authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2024-02-09 10:30:17+01:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2024-02-12 05:25:07+01:00
loga9f738e56b65c8c510da11ec864460f414d82c95
tree2c00e51c9ffbb6ffdb57ebf362653a6419a12673
parentc6b3db8910dc250a32aef49a2d5951bd0c24e5db

x86_64: implement c abi for bool vectors

7 files changed, 8835 insertions(+), 33 deletions(-)

lib/std/mem.zig+1
......@@ -635,6 +635,7 @@ test "lessThan" {
635635const backend_can_use_eql_bytes = switch (builtin.zig_backend) {
636636 // The SPIR-V backend does not support the optimized path yet.
637637 .stage2_spirv64 => false,
638 .stage2_x86_64 => !std.Target.x86.featureSetHas(builtin.cpu.features, .avx2),
638639 else => true,
639640};
640641
src/arch/x86_64/CodeGen.zig+293-32
......@@ -221,6 +221,8 @@ pub const MCValue = union(enum) {
221221 /// The address of an offset from a frame index
222222 /// Payload is a frame address.
223223 lea_frame: FrameAddr,
224 /// Supports integer_per_element abi
225 elementwise_regs_then_frame: packed struct { regs: u3 = 0, frame_off: i29 = 0, frame_index: FrameIndex },
224226 /// This indicates that we have already allocated a frame index for this instruction,
225227 /// but it has not been spilled there yet in the current control flow.
226228 /// Payload is a frame index.
......@@ -300,6 +302,7 @@ pub const MCValue = union(enum) {
300302 .lea_got,
301303 .lea_tlv,
302304 .lea_frame,
305 .elementwise_regs_then_frame,
303306 .reserved_frame,
304307 .air_ref,
305308 => unreachable, // not in memory
......@@ -332,6 +335,7 @@ pub const MCValue = union(enum) {
332335 .load_tlv,
333336 .load_frame,
334337 .load_symbol,
338 .elementwise_regs_then_frame,
335339 .reserved_frame,
336340 .air_ref,
337341 => unreachable, // not dereferenceable
......@@ -352,6 +356,7 @@ pub const MCValue = union(enum) {
352356 .unreach,
353357 .dead,
354358 .undef,
359 .elementwise_regs_then_frame,
355360 .reserved_frame,
356361 .air_ref,
357362 => unreachable, // not valid
......@@ -403,8 +408,8 @@ pub const MCValue = union(enum) {
403408 .load_tlv,
404409 .lea_tlv,
405410 .lea_frame,
411 .elementwise_regs_then_frame,
406412 .reserved_frame,
407 .air_ref,
408413 .lea_symbol,
409414 => unreachable,
410415 .memory => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr| .{
......@@ -441,6 +446,7 @@ pub const MCValue = union(enum) {
441446 } },
442447 };
443448 },
449 .air_ref => |ref| (try function.resolveInst(ref)).mem(function, size),
444450 };
445451 }
446452
......@@ -470,6 +476,7 @@ pub const MCValue = union(enum) {
470476 .load_tlv => |pl| try writer.print("[tlv:{d}]", .{pl}),
471477 .lea_tlv => |pl| try writer.print("tlv:{d}", .{pl}),
472478 .load_frame => |pl| try writer.print("[{} + 0x{x}]", .{ pl.index, pl.off }),
479 .elementwise_regs_then_frame => |pl| try writer.print("elementwise:{d}:[{} + 0x{x}]", .{ pl.regs, pl.frame_index, pl.frame_off }),
473480 .lea_frame => |pl| try writer.print("{} + 0x{x}", .{ pl.index, pl.off }),
474481 .reserved_frame => |pl| try writer.print("(dead:{})", .{pl}),
475482 .air_ref => |pl| try writer.print("(air:0x{x})", .{@intFromEnum(pl)}),
......@@ -502,6 +509,7 @@ const InstTracking = struct {
502509 .lea_symbol,
503510 => result,
504511 .dead,
512 .elementwise_regs_then_frame,
505513 .reserved_frame,
506514 .air_ref,
507515 => unreachable,
......@@ -569,6 +577,7 @@ const InstTracking = struct {
569577 .register_offset,
570578 .register_overflow,
571579 .indirect,
580 .elementwise_regs_then_frame,
572581 .reserved_frame,
573582 .air_ref,
574583 => unreachable,
......@@ -614,6 +623,7 @@ const InstTracking = struct {
614623 .register_offset,
615624 .register_overflow,
616625 .indirect,
626 .elementwise_regs_then_frame,
617627 .air_ref,
618628 => unreachable,
619629 }
......@@ -1757,7 +1767,7 @@ fn gen(self: *Self) InnerError!void {
17571767 .{},
17581768 );
17591769
1760 try self.performReloc(skip_sse_reloc);
1770 self.performReloc(skip_sse_reloc);
17611771 },
17621772 .Win64 => return self.fail("TODO implement gen var arg function for Win64", .{}),
17631773 else => unreachable,
......@@ -2223,14 +2233,14 @@ fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
22232233 );
22242234
22252235 exitlude_jump_reloc.* = try self.asmJmpReloc(undefined);
2226 try self.performReloc(skip_reloc);
2236 self.performReloc(skip_reloc);
22272237
22282238 data_off += @intCast(tag_name.len + 1);
22292239 }
22302240
22312241 try self.airTrap();
22322242
2233 for (exitlude_jump_relocs) |reloc| try self.performReloc(reloc);
2243 for (exitlude_jump_relocs) |reloc| self.performReloc(reloc);
22342244 try self.asmOpOnly(.{ ._, .ret });
22352245 },
22362246 else => return self.fail(
......@@ -3360,7 +3370,7 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
33603370 .resurrect = true,
33613371 .close_scope = true,
33623372 });
3363 try self.performReloc(signed_div_floor_state.reloc);
3373 self.performReloc(signed_div_floor_state.reloc);
33643374 const dst_mcv = try self.genCall(
33653375 .{ .lib = .{
33663376 .return_type = dst_ty.toIntern(),
......@@ -4097,7 +4107,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
40974107 } },
40984108 }, Immediate.u(0));
40994109 _ = try self.asmJccReloc(.z, overflow_loop);
4100 try self.performReloc(overflow);
4110 self.performReloc(overflow);
41014111 try self.asmMemoryImmediate(.{ ._, .mov }, .{
41024112 .base = .{ .frame = dst_mcv.load_frame.index },
41034113 .mod = .{ .rm = .{
......@@ -4105,9 +4115,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
41054115 .disp = @intCast(tuple_ty.structFieldOffset(1, mod)),
41064116 } },
41074117 }, Immediate.u(1));
4108 try self.performReloc(no_overflow);
4118 self.performReloc(no_overflow);
41094119
4110 try self.performReloc(skip_inner);
4120 self.performReloc(skip_inner);
41114121 if (slow_inc) {
41124122 try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), Immediate.u(1));
41134123 } else {
......@@ -5355,11 +5365,26 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
53555365 else => try self.copyToTmpRegister(index_ty, index_mcv),
53565366 };
53575367 switch (array_mcv) {
5358 .register => |array_reg| try self.asmRegisterRegister(
5359 .{ ._, .bt },
5360 array_reg.to64(),
5361 index_reg.to64(),
5362 ),
5368 .register => |array_reg| switch (array_reg.class()) {
5369 .general_purpose => try self.asmRegisterRegister(
5370 .{ ._, .bt },
5371 array_reg.to64(),
5372 index_reg.to64(),
5373 ),
5374 .sse => {
5375 const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, mod));
5376 try self.genSetMem(.{ .frame = frame_index }, 0, array_ty, array_mcv, .{});
5377 try self.asmMemoryRegister(
5378 .{ ._, .bt },
5379 .{
5380 .base = .{ .frame = frame_index },
5381 .mod = .{ .rm = .{ .size = .qword } },
5382 },
5383 index_reg.to64(),
5384 );
5385 },
5386 else => unreachable,
5387 },
53635388 .load_frame => try self.asmMemoryRegister(
53645389 .{ ._, .bt },
53655390 try array_mcv.mem(self, .qword),
......@@ -6700,7 +6725,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
67006725 try self.asmRegisterImmediate(.{ ._, .cmp }, tmp_regs[0].to32(), Immediate.u(limb_len));
67016726 _ = try self.asmJccReloc(.b, neg_loop);
67026727
6703 try self.performReloc(positive);
6728 self.performReloc(positive);
67046729 break :result dst_mcv;
67056730 },
67066731 },
......@@ -7124,6 +7149,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerErro
71247149 .eflags,
71257150 .register_pair,
71267151 .register_overflow,
7152 .elementwise_regs_then_frame,
71277153 .reserved_frame,
71287154 => unreachable, // not a valid pointer
71297155 .immediate,
......@@ -7326,6 +7352,7 @@ fn store(
73267352 .eflags,
73277353 .register_pair,
73287354 .register_overflow,
7355 .elementwise_regs_then_frame,
73297356 .reserved_frame,
73307357 => unreachable, // not a valid pointer
73317358 .immediate,
......@@ -7826,13 +7853,14 @@ fn genUnOpMir(self: *Self, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: MC
78267853 .register_offset,
78277854 .eflags,
78287855 .register_overflow,
7856 .lea_symbol,
78297857 .lea_direct,
78307858 .lea_got,
78317859 .lea_tlv,
78327860 .lea_frame,
7861 .elementwise_regs_then_frame,
78337862 .reserved_frame,
78347863 .air_ref,
7835 .lea_symbol,
78367864 => unreachable, // unmodifiable destination
78377865 .register => |dst_reg| try self.asmRegister(mir_tag, registerAlias(dst_reg, abi_size)),
78387866 .register_pair => unreachable, // unimplemented
......@@ -8470,7 +8498,7 @@ fn genMulDivBinOp(
84708498 );
84718499 _ = try self.asmJccReloc(.b, inner_loop);
84728500
8473 try self.performReloc(skip_inner);
8501 self.performReloc(skip_inner);
84748502 if (slow_inc) {
84758503 try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), Immediate.u(1));
84768504 } else {
......@@ -8903,6 +8931,7 @@ fn genBinOp(
89038931
89048932 const ordered_air: [2]Air.Inst.Ref = if (lhs_ty.isVector(mod) and
89058933 switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
8934 .Bool => false,
89068935 .Int => switch (air_tag) {
89078936 .cmp_lt, .cmp_gte => true,
89088937 else => false,
......@@ -9212,6 +9241,7 @@ fn genBinOp(
92129241 .load_tlv,
92139242 .lea_tlv,
92149243 .lea_frame,
9244 .elementwise_regs_then_frame,
92159245 .reserved_frame,
92169246 .air_ref,
92179247 => unreachable,
......@@ -9253,6 +9283,16 @@ fn genBinOp(
92539283 }
92549284 },
92559285
9286 .cmp_eq, .cmp_neq => {
9287 assert(lhs_ty.isVector(mod) and lhs_ty.childType(mod).toIntern() == .bool_type);
9288 try self.genBinOpMir(.{ ._, .xor }, lhs_ty, dst_mcv, src_mcv);
9289 switch (air_tag) {
9290 .cmp_eq => try self.genUnOpMir(.{ ._, .not }, lhs_ty, dst_mcv),
9291 .cmp_neq => {},
9292 else => unreachable,
9293 }
9294 },
9295
92569296 else => return self.fail("TODO implement genBinOp for {s} {}", .{
92579297 @tagName(air_tag), lhs_ty.fmt(mod),
92589298 }),
......@@ -10447,6 +10487,7 @@ fn genBinOpMir(
1044710487 .lea_tlv,
1044810488 .lea_frame,
1044910489 .lea_symbol,
10490 .elementwise_regs_then_frame,
1045010491 .reserved_frame,
1045110492 .air_ref,
1045210493 => unreachable, // unmodifiable destination
......@@ -10481,6 +10522,7 @@ fn genBinOpMir(
1048110522 .dead,
1048210523 .undef,
1048310524 .register_overflow,
10525 .elementwise_regs_then_frame,
1048410526 .reserved_frame,
1048510527 => unreachable,
1048610528 .register, .register_pair => try self.asmRegisterRegister(
......@@ -10639,6 +10681,7 @@ fn genBinOpMir(
1063910681 .dead,
1064010682 .undef,
1064110683 .register_overflow,
10684 .elementwise_regs_then_frame,
1064210685 .reserved_frame,
1064310686 .air_ref,
1064410687 => unreachable,
......@@ -10733,6 +10776,7 @@ fn genBinOpMir(
1073310776 .dead,
1073410777 .undef,
1073510778 .register_overflow,
10779 .elementwise_regs_then_frame,
1073610780 .reserved_frame,
1073710781 .air_ref,
1073810782 => unreachable,
......@@ -10868,6 +10912,7 @@ fn genIntMulComplexOpMir(self: *Self, dst_ty: Type, dst_mcv: MCValue, src_mcv: M
1086810912 .lea_got,
1086910913 .lea_tlv,
1087010914 .lea_frame,
10915 .elementwise_regs_then_frame,
1087110916 .reserved_frame,
1087210917 .air_ref,
1087310918 => unreachable, // unmodifiable destination
......@@ -10887,6 +10932,7 @@ fn genIntMulComplexOpMir(self: *Self, dst_ty: Type, dst_mcv: MCValue, src_mcv: M
1088710932 .undef,
1088810933 .register_pair,
1088910934 .register_overflow,
10935 .elementwise_regs_then_frame,
1089010936 .reserved_frame,
1089110937 .air_ref,
1089210938 => unreachable,
......@@ -10996,6 +11042,92 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
1099611042 try self.genCopy(arg_ty, dst_mcv, src_mcv, .{});
1099711043 break :dst dst_mcv;
1099811044 },
11045 .elementwise_regs_then_frame => |regs_frame_addr| dst: {
11046 try self.spillEflagsIfOccupied();
11047
11048 const fn_info = mod.typeToFunc(self.fn_type).?;
11049 const cc = abi.resolveCallingConvention(fn_info.cc, self.target.*);
11050 const param_int_regs = abi.getCAbiIntParamRegs(cc);
11051 var prev_reg: Register = undefined;
11052 for (
11053 param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
11054 0..,
11055 ) |dst_reg, elem_index| {
11056 assert(self.register_manager.isRegFree(dst_reg));
11057 if (elem_index > 0) {
11058 try self.asmRegisterImmediate(
11059 .{ ._l, .sh },
11060 dst_reg.to8(),
11061 Immediate.u(elem_index),
11062 );
11063 try self.asmRegisterRegister(
11064 .{ ._, .@"or" },
11065 dst_reg.to8(),
11066 prev_reg.to8(),
11067 );
11068 }
11069 prev_reg = dst_reg;
11070 }
11071
11072 const prev_lock = if (regs_frame_addr.regs > 0)
11073 self.register_manager.lockRegAssumeUnused(prev_reg)
11074 else
11075 null;
11076 defer if (prev_lock) |lock| self.register_manager.unlockReg(lock);
11077
11078 const dst_mcv = try self.allocRegOrMem(inst, false);
11079 if (regs_frame_addr.regs > 0) try self.asmMemoryRegister(
11080 .{ ._, .mov },
11081 try dst_mcv.mem(self, .byte),
11082 prev_reg.to8(),
11083 );
11084 try self.genInlineMemset(
11085 dst_mcv.address().offset(@intFromBool(regs_frame_addr.regs > 0)),
11086 .{ .immediate = 0 },
11087 .{ .immediate = arg_ty.abiSize(mod) - @intFromBool(regs_frame_addr.regs > 0) },
11088 .{},
11089 );
11090
11091 const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
11092 const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
11093 defer self.register_manager.unlockReg(index_lock);
11094
11095 try self.asmRegisterImmediate(
11096 .{ ._, .mov },
11097 index_reg.to32(),
11098 Immediate.u(regs_frame_addr.regs),
11099 );
11100 const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
11101 try self.asmMemoryImmediate(.{ ._, .cmp }, .{
11102 .base = .{ .frame = regs_frame_addr.frame_index },
11103 .mod = .{ .rm = .{
11104 .size = .byte,
11105 .index = index_reg.to64(),
11106 .scale = .@"8",
11107 .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
11108 } },
11109 }, Immediate.u(0));
11110 const unset = try self.asmJccReloc(.e, undefined);
11111 try self.asmMemoryRegister(
11112 .{ ._s, .bt },
11113 try dst_mcv.mem(self, .dword),
11114 index_reg.to32(),
11115 );
11116 self.performReloc(unset);
11117 if (self.hasFeature(.slow_incdec)) {
11118 try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), Immediate.u(1));
11119 } else {
11120 try self.asmRegister(.{ ._, .inc }, index_reg.to32());
11121 }
11122 try self.asmRegisterImmediate(
11123 .{ ._, .cmp },
11124 index_reg.to32(),
11125 Immediate.u(arg_ty.vectorLen(mod)),
11126 );
11127 _ = try self.asmJccReloc(.b, loop);
11128
11129 break :dst dst_mcv;
11130 },
1099911131 else => return self.fail("TODO implement arg for {}", .{src_mcv}),
1100011132 };
1100111133
......@@ -11018,7 +11150,7 @@ fn genArgDbgInfo(self: Self, ty: Type, name: [:0]const u8, mcv: MCValue) !void {
1101811150 regs[0].dwarfNum(), regs[1].dwarfNum(),
1101911151 } },
1102011152 // TODO use a frame index
11021 .load_frame => return,
11153 .load_frame, .elementwise_regs_then_frame => return,
1102211154 //.stack_offset => |off| .{
1102311155 // .stack = .{
1102411156 // // TODO handle -fomit-frame-pointer
......@@ -11254,6 +11386,61 @@ fn genCall(self: *Self, info: union(enum) {
1125411386 try self.genCopy(arg_ty, dst_arg, src_arg, .{});
1125511387 try self.freeValue(src_arg);
1125611388 },
11389 .elementwise_regs_then_frame => |regs_frame_addr| {
11390 const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
11391 const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
11392 defer self.register_manager.unlockReg(index_lock);
11393
11394 const src_mem: Memory = if (src_arg.isMemory()) try src_arg.mem(self, .dword) else .{
11395 .base = .{ .reg = try self.copyToTmpRegister(
11396 Type.usize,
11397 switch (src_arg) {
11398 else => src_arg,
11399 .air_ref => |src_ref| try self.resolveInst(src_ref),
11400 }.address(),
11401 ) },
11402 .mod = .{ .rm = .{ .size = .dword } },
11403 };
11404 const src_lock = switch (src_mem.base) {
11405 .reg => |src_reg| self.register_manager.lockReg(src_reg),
11406 else => null,
11407 };
11408 defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
11409
11410 try self.asmRegisterImmediate(
11411 .{ ._, .mov },
11412 index_reg.to32(),
11413 Immediate.u(regs_frame_addr.regs),
11414 );
11415 const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
11416 try self.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32());
11417 try self.asmSetccMemory(.c, .{
11418 .base = .{ .frame = regs_frame_addr.frame_index },
11419 .mod = .{ .rm = .{
11420 .size = .byte,
11421 .index = index_reg.to64(),
11422 .scale = .@"8",
11423 .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
11424 } },
11425 });
11426 if (self.hasFeature(.slow_incdec)) {
11427 try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), Immediate.u(1));
11428 } else {
11429 try self.asmRegister(.{ ._, .inc }, index_reg.to32());
11430 }
11431 try self.asmRegisterImmediate(
11432 .{ ._, .cmp },
11433 index_reg.to32(),
11434 Immediate.u(arg_ty.vectorLen(mod)),
11435 );
11436 _ = try self.asmJccReloc(.b, loop);
11437
11438 const param_int_regs = abi.getCAbiIntParamRegs(resolved_cc);
11439 for (param_int_regs[param_int_regs.len - regs_frame_addr.regs ..]) |dst_reg| {
11440 try self.register_manager.getReg(dst_reg, null);
11441 try reg_locks.append(self.register_manager.lockReg(dst_reg));
11442 }
11443 },
1125711444 else => unreachable,
1125811445 };
1125911446
......@@ -11295,6 +11482,37 @@ fn genCall(self: *Self, info: union(enum) {
1129511482 .indirect => |reg_off| try self.genSetReg(reg_off.reg, Type.usize, .{
1129611483 .lea_frame = .{ .index = frame_index, .off = -reg_off.off },
1129711484 }, .{}),
11485 .elementwise_regs_then_frame => |regs_frame_addr| {
11486 const src_mem: Memory = if (src_arg.isMemory()) try src_arg.mem(self, .dword) else .{
11487 .base = .{ .reg = try self.copyToTmpRegister(
11488 Type.usize,
11489 switch (src_arg) {
11490 else => src_arg,
11491 .air_ref => |src_ref| try self.resolveInst(src_ref),
11492 }.address(),
11493 ) },
11494 .mod = .{ .rm = .{ .size = .dword } },
11495 };
11496 const src_lock = switch (src_mem.base) {
11497 .reg => |src_reg| self.register_manager.lockReg(src_reg),
11498 else => null,
11499 };
11500 defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
11501
11502 const param_int_regs = abi.getCAbiIntParamRegs(resolved_cc);
11503 for (
11504 param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
11505 0..,
11506 ) |dst_reg, elem_index| {
11507 try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
11508 try self.asmMemoryImmediate(
11509 .{ ._, .bt },
11510 src_mem,
11511 Immediate.u(elem_index),
11512 );
11513 try self.asmSetccRegister(.c, dst_reg.to8());
11514 }
11515 },
1129811516 else => unreachable,
1129911517 };
1130011518
......@@ -11581,6 +11799,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
1158111799 .lea_tlv,
1158211800 .lea_frame,
1158311801 .lea_symbol,
11802 .elementwise_regs_then_frame,
1158411803 .reserved_frame,
1158511804 .air_ref,
1158611805 => unreachable,
......@@ -11641,6 +11860,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
1164111860 .lea_got,
1164211861 .lea_tlv,
1164311862 .lea_frame,
11863 .elementwise_regs_then_frame,
1164411864 .reserved_frame,
1164511865 .air_ref,
1164611866 => unreachable,
......@@ -11925,7 +12145,7 @@ fn genTry(
1192512145 .close_scope = true,
1192612146 });
1192712147
11928 try self.performReloc(reloc);
12148 self.performReloc(reloc);
1192912149
1193012150 for (liveness_cond_br.then_deaths) |death| try self.processDeath(death);
1193112151
......@@ -12039,7 +12259,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
1203912259 .close_scope = true,
1204012260 });
1204112261
12042 try self.performReloc(reloc);
12262 self.performReloc(reloc);
1204312263
1204412264 for (liveness_cond_br.else_deaths) |death| try self.processDeath(death);
1204512265 try self.genBody(else_body);
......@@ -12086,6 +12306,7 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
1208612306 .lea_tlv,
1208712307 .lea_frame,
1208812308 .lea_symbol,
12309 .elementwise_regs_then_frame,
1208912310 .reserved_frame,
1209012311 .air_ref,
1209112312 => unreachable,
......@@ -12422,7 +12643,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
1242212643 .resurrect = true,
1242312644 .close_scope = true,
1242412645 });
12425 for (block_data.value.relocs.items) |reloc| try self.performReloc(reloc);
12646 for (block_data.value.relocs.items) |reloc| self.performReloc(reloc);
1242612647 }
1242712648
1242812649 if (std.debug.runtime_safety) assert(self.inst_tracking.getIndex(inst).? == inst_tracking_i);
......@@ -12482,7 +12703,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
1248212703
1248312704 for (liveness.deaths[case_i]) |operand| try self.processDeath(operand);
1248412705
12485 for (relocs[0 .. relocs.len - 1]) |reloc| try self.performReloc(reloc);
12706 for (relocs[0 .. relocs.len - 1]) |reloc| self.performReloc(reloc);
1248612707 try self.genBody(case_body);
1248712708 try self.restoreState(state, &.{}, .{
1248812709 .emit_instructions = false,
......@@ -12491,7 +12712,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
1249112712 .close_scope = true,
1249212713 });
1249312714
12494 try self.performReloc(relocs[relocs.len - 1]);
12715 self.performReloc(relocs[relocs.len - 1]);
1249512716 }
1249612717
1249712718 if (switch_br.data.else_body_len > 0) {
......@@ -12514,7 +12735,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
1251412735 self.finishAirBookkeeping();
1251512736}
1251612737
12517fn performReloc(self: *Self, reloc: Mir.Inst.Index) !void {
12738fn performReloc(self: *Self, reloc: Mir.Inst.Index) void {
1251812739 const next_inst: u32 = @intCast(self.mir_instructions.len);
1251912740 switch (self.mir_instructions.items(.tag)[reloc]) {
1252012741 .j, .jmp => {},
......@@ -12863,7 +13084,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
1286313084 if (!anon and label_gop.value_ptr.pending_relocs.items.len == 0)
1286413085 return self.fail("redefined label: '{s}'", .{label_name});
1286513086 for (label_gop.value_ptr.pending_relocs.items) |pending_reloc|
12866 try self.performReloc(pending_reloc);
13087 self.performReloc(pending_reloc);
1286713088 if (anon)
1286813089 label_gop.value_ptr.pending_relocs.clearRetainingCapacity()
1286913090 else
......@@ -13380,7 +13601,13 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
1338013601 else => {},
1338113602 },
1338213603 .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
13383 .Bool => {},
13604 .Bool => switch (ty.vectorLen(mod)) {
13605 33...64 => return .{ .move = if (self.hasFeature(.avx))
13606 .{ .v_q, .mov }
13607 else
13608 .{ ._q, .mov } },
13609 else => {},
13610 },
1338413611 .Int => switch (ty.childType(mod).intInfo(mod).bits) {
1338513612 8 => switch (ty.vectorLen(mod)) {
1338613613 1 => if (self.hasFeature(.avx)) return .{ .vex_insert_extract = .{
......@@ -13618,6 +13845,7 @@ fn genCopy(self: *Self, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: Copy
1361813845 .lea_tlv,
1361913846 .lea_frame,
1362013847 .lea_symbol,
13848 .elementwise_regs_then_frame,
1362113849 .reserved_frame,
1362213850 .air_ref,
1362313851 => unreachable, // unmodifiable destination
......@@ -13628,6 +13856,7 @@ fn genCopy(self: *Self, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: Copy
1362813856 .dead,
1362913857 .undef,
1363013858 .register_overflow,
13859 .elementwise_regs_then_frame,
1363113860 .reserved_frame,
1363213861 => unreachable,
1363313862 .immediate,
......@@ -13725,6 +13954,7 @@ fn genSetReg(
1372513954 .unreach,
1372613955 .dead,
1372713956 .register_overflow,
13957 .elementwise_regs_then_frame,
1372813958 .reserved_frame,
1372913959 => unreachable,
1373013960 .undef => if (opts.safety) switch (dst_reg.class()) {
......@@ -14034,7 +14264,12 @@ fn genSetMem(
1403414264 .reloc => |base_symbol| .{ .lea_symbol = .{ .sym = base_symbol.sym_index, .off = disp } },
1403514265 };
1403614266 switch (src_mcv) {
14037 .none, .unreach, .dead, .reserved_frame => unreachable,
14267 .none,
14268 .unreach,
14269 .dead,
14270 .elementwise_regs_then_frame,
14271 .reserved_frame,
14272 => unreachable,
1403814273 .undef => if (opts.safety) try self.genInlineMemset(
1403914274 dst_ptr_mcv,
1404014275 src_mcv,
......@@ -15233,7 +15468,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
1523315468 );
1523415469 try self.genInlineMemcpy(second_elem_ptr_mcv, ptr, len_mcv);
1523515470
15236 try self.performReloc(skip_reloc);
15471 self.performReloc(skip_reloc);
1523715472 },
1523815473 .One => {
1523915474 const elem_ptr_ty = try mod.singleMutPtrType(elem_ty);
......@@ -16402,7 +16637,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
1640216637 try self.genCopy(Type.c_uint, gp_offset, .{ .register = offset_reg }, .{});
1640316638 const done_reloc = try self.asmJmpReloc(undefined);
1640416639
16405 try self.performReloc(mem_reloc);
16640 self.performReloc(mem_reloc);
1640616641 try self.genSetReg(addr_reg, ptr_anyopaque_ty, overflow_arg_area, .{});
1640716642 try self.asmRegisterMemory(.{ ._, .lea }, offset_reg.to64(), .{
1640816643 .base = .{ .reg = addr_reg },
......@@ -16418,7 +16653,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
1641816653 .{},
1641916654 );
1642016655
16421 try self.performReloc(done_reloc);
16656 self.performReloc(done_reloc);
1642216657 if (!unused) try self.genCopy(promote_ty, promote_mcv, .{
1642316658 .indirect = .{ .reg = addr_reg },
1642416659 }, .{});
......@@ -16450,7 +16685,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
1645016685 try self.genCopy(Type.c_uint, fp_offset, .{ .register = offset_reg }, .{});
1645116686 const done_reloc = try self.asmJmpReloc(undefined);
1645216687
16453 try self.performReloc(mem_reloc);
16688 self.performReloc(mem_reloc);
1645416689 try self.genSetReg(addr_reg, ptr_anyopaque_ty, overflow_arg_area, .{});
1645516690 try self.asmRegisterMemory(.{ ._, .lea }, offset_reg.to64(), .{
1645616691 .base = .{ .reg = addr_reg },
......@@ -16466,7 +16701,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
1646616701 .{},
1646716702 );
1646816703
16469 try self.performReloc(done_reloc);
16704 self.performReloc(done_reloc);
1647016705 if (!unused) try self.genCopy(promote_ty, promote_mcv, .{
1647116706 .indirect = .{ .reg = addr_reg },
1647216707 }, .{});
......@@ -16771,7 +17006,7 @@ fn resolveCallingConventionValues(
1677117006 };
1677217007 ret_tracking_i += 1;
1677317008 },
16774 .none => unreachable,
17009 .none, .integer_per_element => unreachable,
1677517010 };
1677617011 result.return_value = switch (ret_tracking_i) {
1677717012 else => unreachable,
......@@ -16846,6 +17081,32 @@ fn resolveCallingConventionValues(
1684617081 else => unreachable,
1684717082 },
1684817083 .none => unreachable,
17084 .integer_per_element => {
17085 const param_int_regs_len: u32 =
17086 @intCast(abi.getCAbiIntParamRegs(resolved_cc).len);
17087 const remaining_param_int_regs: u3 =
17088 @intCast(param_int_regs_len - param_int_reg_i);
17089 param_int_reg_i = param_int_regs_len;
17090
17091 const frame_elem_align = 8;
17092 const frame_elems_len = ty.vectorLen(mod) - remaining_param_int_regs;
17093 const frame_elem_size = mem.alignForward(
17094 u64,
17095 ty.childType(mod).abiSize(mod),
17096 frame_elem_align,
17097 );
17098 const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size);
17099
17100 result.stack_byte_count =
17101 mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
17102 arg_mcv[arg_mcv_i] = .{ .elementwise_regs_then_frame = .{
17103 .regs = remaining_param_int_regs,
17104 .frame_off = @intCast(result.stack_byte_count),
17105 .frame_index = stack_frame_base,
17106 } };
17107 arg_mcv_i += 1;
17108 result.stack_byte_count += frame_size;
17109 },
1684917110 } else {
1685017111 arg.* = switch (arg_mcv_i) {
1685117112 else => unreachable,
src/arch/x86_64/abi.zig+26
......@@ -10,6 +10,7 @@ pub const Class = enum {
1010 win_i128,
1111 float,
1212 float_combine,
13 integer_per_element,
1314};
1415
1516pub fn classifyWindows(ty: Type, mod: *Module) Class {
......@@ -161,6 +162,31 @@ pub fn classifySystemV(ty: Type, mod: *Module, ctx: Context) [8]Class {
161162 .Vector => {
162163 const elem_ty = ty.childType(mod);
163164 const bits = elem_ty.bitSize(mod) * ty.arrayLen(mod);
165 if (elem_ty.toIntern() == .bool_type) {
166 if (bits <= 32) return .{
167 .integer, .none, .none, .none,
168 .none, .none, .none, .none,
169 };
170 if (bits <= 64) return .{
171 .sse, .none, .none, .none,
172 .none, .none, .none, .none,
173 };
174 if (ctx == .arg) {
175 if (bits <= 128) return .{
176 .integer_per_element, .none, .none, .none,
177 .none, .none, .none, .none,
178 };
179 if (bits <= 256 and std.Target.x86.featureSetHas(target.cpu.features, .avx)) return .{
180 .integer_per_element, .none, .none, .none,
181 .none, .none, .none, .none,
182 };
183 if (bits <= 512 and std.Target.x86.featureSetHas(target.cpu.features, .avx512f)) return .{
184 .integer_per_element, .none, .none, .none,
185 .none, .none, .none, .none,
186 };
187 }
188 return memory_class;
189 }
164190 if (bits <= 64) return .{
165191 .sse, .none, .none, .none,
166192 .none, .none, .none, .none,
src/codegen/llvm.zig+6
......@@ -11139,6 +11139,9 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E
1113911139 .memory => unreachable, // handled above
1114011140 .win_i128 => unreachable, // windows only
1114111141 .none => break,
11142 .integer_per_element => {
11143 @panic("TODO");
11144 },
1114211145 }
1114311146 }
1114411147 const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer});
......@@ -11417,6 +11420,9 @@ const ParamTypeIterator = struct {
1141711420 .memory => unreachable, // handled above
1141811421 .win_i128 => unreachable, // windows only
1141911422 .none => break,
11423 .integer_per_element => {
11424 @panic("TODO");
11425 },
1142011426 }
1142111427 }
1142211428 const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer});
test/behavior/vector.zig-1
......@@ -485,7 +485,6 @@ test "initialize vector which is a struct field" {
485485
486486test "vector comparison operators" {
487487 if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
488 if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
489488 if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
490489 if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
491490 if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/c_abi/cfuncs.c+4251
......@@ -236,6 +236,2156 @@ struct SplitStructMixed zig_ret_split_struct_mixed();
236236
237237struct BigStruct zig_big_struct_both(struct BigStruct);
238238
239#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32)
240
241typedef bool Vector2Bool __attribute__((ext_vector_type(2)));
242typedef bool Vector4Bool __attribute__((ext_vector_type(4)));
243typedef bool Vector8Bool __attribute__((ext_vector_type(8)));
244typedef bool Vector16Bool __attribute__((ext_vector_type(16)));
245typedef bool Vector32Bool __attribute__((ext_vector_type(32)));
246typedef bool Vector64Bool __attribute__((ext_vector_type(64)));
247typedef bool Vector128Bool __attribute__((ext_vector_type(128)));
248typedef bool Vector256Bool __attribute__((ext_vector_type(256)));
249typedef bool Vector512Bool __attribute__((ext_vector_type(512)));
250
251void c_vector_2_bool(Vector2Bool vec) {
252 assert_or_panic(vec[0] == true);
253 assert_or_panic(vec[1] == true);
254}
255
256void c_vector_4_bool(Vector4Bool vec) {
257 assert_or_panic(vec[0] == true);
258 assert_or_panic(vec[1] == true);
259 assert_or_panic(vec[2] == false);
260 assert_or_panic(vec[3] == true);
261}
262
263void c_vector_8_bool(Vector8Bool vec) {
264 assert_or_panic(vec[0] == true);
265 assert_or_panic(vec[1] == false);
266 assert_or_panic(vec[2] == true);
267 assert_or_panic(vec[3] == true);
268 assert_or_panic(vec[4] == true);
269 assert_or_panic(vec[5] == true);
270 assert_or_panic(vec[6] == false);
271 assert_or_panic(vec[7] == true);
272}
273
274void c_vector_16_bool(Vector16Bool vec) {
275 assert_or_panic(vec[0] == true);
276 assert_or_panic(vec[1] == false);
277 assert_or_panic(vec[2] == false);
278 assert_or_panic(vec[3] == false);
279 assert_or_panic(vec[4] == true);
280 assert_or_panic(vec[5] == false);
281 assert_or_panic(vec[6] == true);
282 assert_or_panic(vec[7] == true);
283 assert_or_panic(vec[8] == true);
284 assert_or_panic(vec[9] == true);
285 assert_or_panic(vec[10] == true);
286 assert_or_panic(vec[11] == true);
287 assert_or_panic(vec[12] == false);
288 assert_or_panic(vec[13] == false);
289 assert_or_panic(vec[14] == false);
290 assert_or_panic(vec[15] == false);
291}
292
293void c_vector_32_bool(Vector32Bool vec) {
294 assert_or_panic(vec[0] == true);
295 assert_or_panic(vec[1] == false);
296 assert_or_panic(vec[2] == true);
297 assert_or_panic(vec[3] == true);
298 assert_or_panic(vec[4] == false);
299 assert_or_panic(vec[5] == false);
300 assert_or_panic(vec[6] == true);
301 assert_or_panic(vec[7] == false);
302 assert_or_panic(vec[8] == true);
303 assert_or_panic(vec[9] == false);
304 assert_or_panic(vec[10] == true);
305 assert_or_panic(vec[11] == true);
306 assert_or_panic(vec[12] == true);
307 assert_or_panic(vec[13] == false);
308 assert_or_panic(vec[14] == false);
309 assert_or_panic(vec[15] == true);
310 assert_or_panic(vec[16] == false);
311 assert_or_panic(vec[17] == true);
312 assert_or_panic(vec[18] == false);
313 assert_or_panic(vec[19] == true);
314 assert_or_panic(vec[20] == true);
315 assert_or_panic(vec[21] == true);
316 assert_or_panic(vec[22] == true);
317 assert_or_panic(vec[23] == true);
318 assert_or_panic(vec[24] == false);
319 assert_or_panic(vec[25] == true);
320 assert_or_panic(vec[26] == true);
321 assert_or_panic(vec[27] == true);
322 assert_or_panic(vec[28] == false);
323 assert_or_panic(vec[29] == true);
324 assert_or_panic(vec[30] == true);
325 assert_or_panic(vec[31] == false);
326}
327
328void c_vector_64_bool(Vector64Bool vec) {
329 assert_or_panic(vec[0] == true);
330 assert_or_panic(vec[1] == true);
331 assert_or_panic(vec[2] == true);
332 assert_or_panic(vec[3] == false);
333 assert_or_panic(vec[4] == true);
334 assert_or_panic(vec[5] == false);
335 assert_or_panic(vec[6] == false);
336 assert_or_panic(vec[7] == false);
337 assert_or_panic(vec[8] == true);
338 assert_or_panic(vec[9] == false);
339 assert_or_panic(vec[10] == false);
340 assert_or_panic(vec[11] == false);
341 assert_or_panic(vec[12] == false);
342 assert_or_panic(vec[13] == true);
343 assert_or_panic(vec[14] == true);
344 assert_or_panic(vec[15] == true);
345 assert_or_panic(vec[16] == true);
346 assert_or_panic(vec[17] == false);
347 assert_or_panic(vec[18] == false);
348 assert_or_panic(vec[19] == true);
349 assert_or_panic(vec[20] == false);
350 assert_or_panic(vec[21] == true);
351 assert_or_panic(vec[22] == false);
352 assert_or_panic(vec[23] == true);
353 assert_or_panic(vec[24] == true);
354 assert_or_panic(vec[25] == true);
355 assert_or_panic(vec[26] == true);
356 assert_or_panic(vec[27] == true);
357 assert_or_panic(vec[28] == true);
358 assert_or_panic(vec[29] == true);
359 assert_or_panic(vec[30] == false);
360 assert_or_panic(vec[31] == false);
361 assert_or_panic(vec[32] == true);
362 assert_or_panic(vec[33] == true);
363 assert_or_panic(vec[34] == false);
364 assert_or_panic(vec[35] == true);
365 assert_or_panic(vec[36] == false);
366 assert_or_panic(vec[37] == false);
367 assert_or_panic(vec[38] == true);
368 assert_or_panic(vec[39] == true);
369 assert_or_panic(vec[40] == true);
370 assert_or_panic(vec[41] == false);
371 assert_or_panic(vec[42] == false);
372 assert_or_panic(vec[43] == true);
373 assert_or_panic(vec[44] == true);
374 assert_or_panic(vec[45] == false);
375 assert_or_panic(vec[46] == true);
376 assert_or_panic(vec[47] == false);
377 assert_or_panic(vec[48] == true);
378 assert_or_panic(vec[49] == false);
379 assert_or_panic(vec[50] == false);
380 assert_or_panic(vec[51] == true);
381 assert_or_panic(vec[52] == false);
382 assert_or_panic(vec[53] == true);
383 assert_or_panic(vec[54] == true);
384 assert_or_panic(vec[55] == true);
385 assert_or_panic(vec[56] == true);
386 assert_or_panic(vec[57] == true);
387 assert_or_panic(vec[58] == false);
388 assert_or_panic(vec[59] == false);
389 assert_or_panic(vec[60] == true);
390 assert_or_panic(vec[61] == false);
391 assert_or_panic(vec[62] == true);
392 assert_or_panic(vec[63] == false);
393}
394
395void c_vector_128_bool(Vector128Bool vec) {
396 assert_or_panic(vec[0] == false);
397 assert_or_panic(vec[1] == false);
398 assert_or_panic(vec[2] == false);
399 assert_or_panic(vec[3] == false);
400 assert_or_panic(vec[4] == false);
401 assert_or_panic(vec[5] == true);
402 assert_or_panic(vec[6] == true);
403 assert_or_panic(vec[7] == false);
404 assert_or_panic(vec[8] == true);
405 assert_or_panic(vec[9] == true);
406 assert_or_panic(vec[10] == false);
407 assert_or_panic(vec[11] == true);
408 assert_or_panic(vec[12] == true);
409 assert_or_panic(vec[13] == false);
410 assert_or_panic(vec[14] == true);
411 assert_or_panic(vec[15] == true);
412 assert_or_panic(vec[16] == true);
413 assert_or_panic(vec[17] == false);
414 assert_or_panic(vec[18] == false);
415 assert_or_panic(vec[19] == false);
416 assert_or_panic(vec[20] == false);
417 assert_or_panic(vec[21] == true);
418 assert_or_panic(vec[22] == true);
419 assert_or_panic(vec[23] == false);
420 assert_or_panic(vec[24] == false);
421 assert_or_panic(vec[25] == false);
422 assert_or_panic(vec[26] == true);
423 assert_or_panic(vec[27] == true);
424 assert_or_panic(vec[28] == false);
425 assert_or_panic(vec[29] == true);
426 assert_or_panic(vec[30] == false);
427 assert_or_panic(vec[31] == false);
428 assert_or_panic(vec[32] == true);
429 assert_or_panic(vec[33] == false);
430 assert_or_panic(vec[34] == false);
431 assert_or_panic(vec[35] == true);
432 assert_or_panic(vec[36] == true);
433 assert_or_panic(vec[37] == true);
434 assert_or_panic(vec[38] == true);
435 assert_or_panic(vec[39] == true);
436 assert_or_panic(vec[40] == false);
437 assert_or_panic(vec[41] == true);
438 assert_or_panic(vec[42] == true);
439 assert_or_panic(vec[43] == true);
440 assert_or_panic(vec[44] == false);
441 assert_or_panic(vec[45] == false);
442 assert_or_panic(vec[46] == false);
443 assert_or_panic(vec[47] == false);
444 assert_or_panic(vec[48] == true);
445 assert_or_panic(vec[49] == true);
446 assert_or_panic(vec[50] == false);
447 assert_or_panic(vec[51] == true);
448 assert_or_panic(vec[52] == true);
449 assert_or_panic(vec[53] == true);
450 assert_or_panic(vec[54] == true);
451 assert_or_panic(vec[55] == true);
452 assert_or_panic(vec[56] == false);
453 assert_or_panic(vec[57] == true);
454 assert_or_panic(vec[58] == true);
455 assert_or_panic(vec[59] == false);
456 assert_or_panic(vec[60] == true);
457 assert_or_panic(vec[61] == false);
458 assert_or_panic(vec[62] == false);
459 assert_or_panic(vec[63] == true);
460 assert_or_panic(vec[64] == true);
461 assert_or_panic(vec[65] == false);
462 assert_or_panic(vec[66] == true);
463 assert_or_panic(vec[67] == true);
464 assert_or_panic(vec[68] == false);
465 assert_or_panic(vec[69] == true);
466 assert_or_panic(vec[70] == false);
467 assert_or_panic(vec[71] == false);
468 assert_or_panic(vec[72] == true);
469 assert_or_panic(vec[73] == true);
470 assert_or_panic(vec[74] == false);
471 assert_or_panic(vec[75] == true);
472 assert_or_panic(vec[76] == true);
473 assert_or_panic(vec[77] == true);
474 assert_or_panic(vec[78] == false);
475 assert_or_panic(vec[79] == true);
476 assert_or_panic(vec[80] == false);
477 assert_or_panic(vec[81] == false);
478 assert_or_panic(vec[82] == false);
479 assert_or_panic(vec[83] == false);
480 assert_or_panic(vec[84] == true);
481 assert_or_panic(vec[85] == false);
482 assert_or_panic(vec[86] == false);
483 assert_or_panic(vec[87] == false);
484 assert_or_panic(vec[88] == true);
485 assert_or_panic(vec[89] == true);
486 assert_or_panic(vec[90] == false);
487 assert_or_panic(vec[91] == false);
488 assert_or_panic(vec[92] == true);
489 assert_or_panic(vec[93] == true);
490 assert_or_panic(vec[94] == true);
491 assert_or_panic(vec[95] == true);
492 assert_or_panic(vec[96] == false);
493 assert_or_panic(vec[97] == false);
494 assert_or_panic(vec[98] == false);
495 assert_or_panic(vec[99] == false);
496 assert_or_panic(vec[100] == false);
497 assert_or_panic(vec[101] == true);
498 assert_or_panic(vec[102] == false);
499 assert_or_panic(vec[103] == false);
500 assert_or_panic(vec[104] == false);
501 assert_or_panic(vec[105] == false);
502 assert_or_panic(vec[106] == true);
503 assert_or_panic(vec[107] == true);
504 assert_or_panic(vec[108] == true);
505 assert_or_panic(vec[109] == true);
506 assert_or_panic(vec[110] == true);
507 assert_or_panic(vec[111] == false);
508 assert_or_panic(vec[112] == false);
509 assert_or_panic(vec[113] == true);
510 assert_or_panic(vec[114] == false);
511 assert_or_panic(vec[115] == true);
512 assert_or_panic(vec[116] == false);
513 assert_or_panic(vec[117] == false);
514 assert_or_panic(vec[118] == true);
515 assert_or_panic(vec[119] == false);
516 assert_or_panic(vec[120] == true);
517 assert_or_panic(vec[121] == false);
518 assert_or_panic(vec[122] == true);
519 assert_or_panic(vec[123] == true);
520 assert_or_panic(vec[124] == true);
521 assert_or_panic(vec[125] == true);
522 assert_or_panic(vec[126] == true);
523 assert_or_panic(vec[127] == true);
524}
525
526void c_vector_256_bool(Vector256Bool vec) {
527 assert_or_panic(vec[0] == false);
528 assert_or_panic(vec[1] == true);
529 assert_or_panic(vec[2] == true);
530 assert_or_panic(vec[3] == false);
531 assert_or_panic(vec[4] == false);
532 assert_or_panic(vec[5] == true);
533 assert_or_panic(vec[6] == true);
534 assert_or_panic(vec[7] == true);
535 assert_or_panic(vec[8] == false);
536 assert_or_panic(vec[9] == true);
537 assert_or_panic(vec[10] == true);
538 assert_or_panic(vec[11] == true);
539 assert_or_panic(vec[12] == false);
540 assert_or_panic(vec[13] == true);
541 assert_or_panic(vec[14] == false);
542 assert_or_panic(vec[15] == true);
543 assert_or_panic(vec[16] == false);
544 assert_or_panic(vec[17] == false);
545 assert_or_panic(vec[18] == true);
546 assert_or_panic(vec[19] == true);
547 assert_or_panic(vec[20] == false);
548 assert_or_panic(vec[21] == true);
549 assert_or_panic(vec[22] == false);
550 assert_or_panic(vec[23] == false);
551 assert_or_panic(vec[24] == false);
552 assert_or_panic(vec[25] == true);
553 assert_or_panic(vec[26] == true);
554 assert_or_panic(vec[27] == false);
555 assert_or_panic(vec[28] == false);
556 assert_or_panic(vec[29] == true);
557 assert_or_panic(vec[30] == true);
558 assert_or_panic(vec[31] == false);
559 assert_or_panic(vec[32] == true);
560 assert_or_panic(vec[33] == false);
561 assert_or_panic(vec[34] == false);
562 assert_or_panic(vec[35] == true);
563 assert_or_panic(vec[36] == false);
564 assert_or_panic(vec[37] == true);
565 assert_or_panic(vec[38] == false);
566 assert_or_panic(vec[39] == true);
567 assert_or_panic(vec[40] == true);
568 assert_or_panic(vec[41] == true);
569 assert_or_panic(vec[42] == true);
570 assert_or_panic(vec[43] == false);
571 assert_or_panic(vec[44] == false);
572 assert_or_panic(vec[45] == true);
573 assert_or_panic(vec[46] == false);
574 assert_or_panic(vec[47] == false);
575 assert_or_panic(vec[48] == false);
576 assert_or_panic(vec[49] == false);
577 assert_or_panic(vec[50] == false);
578 assert_or_panic(vec[51] == false);
579 assert_or_panic(vec[52] == true);
580 assert_or_panic(vec[53] == true);
581 assert_or_panic(vec[54] == true);
582 assert_or_panic(vec[55] == true);
583 assert_or_panic(vec[56] == true);
584 assert_or_panic(vec[57] == true);
585 assert_or_panic(vec[58] == false);
586 assert_or_panic(vec[59] == true);
587 assert_or_panic(vec[60] == true);
588 assert_or_panic(vec[61] == false);
589 assert_or_panic(vec[62] == false);
590 assert_or_panic(vec[63] == true);
591 assert_or_panic(vec[64] == false);
592 assert_or_panic(vec[65] == false);
593 assert_or_panic(vec[66] == false);
594 assert_or_panic(vec[67] == false);
595 assert_or_panic(vec[68] == false);
596 assert_or_panic(vec[69] == false);
597 assert_or_panic(vec[70] == true);
598 assert_or_panic(vec[71] == true);
599 assert_or_panic(vec[72] == true);
600 assert_or_panic(vec[73] == false);
601 assert_or_panic(vec[74] == false);
602 assert_or_panic(vec[75] == false);
603 assert_or_panic(vec[76] == true);
604 assert_or_panic(vec[77] == false);
605 assert_or_panic(vec[78] == true);
606 assert_or_panic(vec[79] == true);
607 assert_or_panic(vec[80] == false);
608 assert_or_panic(vec[81] == false);
609 assert_or_panic(vec[82] == true);
610 assert_or_panic(vec[83] == true);
611 assert_or_panic(vec[84] == false);
612 assert_or_panic(vec[85] == true);
613 assert_or_panic(vec[86] == true);
614 assert_or_panic(vec[87] == true);
615 assert_or_panic(vec[88] == true);
616 assert_or_panic(vec[89] == true);
617 assert_or_panic(vec[90] == true);
618 assert_or_panic(vec[91] == true);
619 assert_or_panic(vec[92] == false);
620 assert_or_panic(vec[93] == true);
621 assert_or_panic(vec[94] == true);
622 assert_or_panic(vec[95] == false);
623 assert_or_panic(vec[96] == false);
624 assert_or_panic(vec[97] == true);
625 assert_or_panic(vec[98] == true);
626 assert_or_panic(vec[99] == false);
627 assert_or_panic(vec[100] == true);
628 assert_or_panic(vec[101] == false);
629 assert_or_panic(vec[102] == false);
630 assert_or_panic(vec[103] == true);
631 assert_or_panic(vec[104] == false);
632 assert_or_panic(vec[105] == true);
633 assert_or_panic(vec[106] == true);
634 assert_or_panic(vec[107] == true);
635 assert_or_panic(vec[108] == true);
636 assert_or_panic(vec[109] == true);
637 assert_or_panic(vec[110] == false);
638 assert_or_panic(vec[111] == false);
639 assert_or_panic(vec[112] == false);
640 assert_or_panic(vec[113] == false);
641 assert_or_panic(vec[114] == true);
642 assert_or_panic(vec[115] == true);
643 assert_or_panic(vec[116] == false);
644 assert_or_panic(vec[117] == true);
645 assert_or_panic(vec[118] == false);
646 assert_or_panic(vec[119] == false);
647 assert_or_panic(vec[120] == true);
648 assert_or_panic(vec[121] == false);
649 assert_or_panic(vec[122] == false);
650 assert_or_panic(vec[123] == true);
651 assert_or_panic(vec[124] == false);
652 assert_or_panic(vec[125] == true);
653 assert_or_panic(vec[126] == true);
654 assert_or_panic(vec[127] == true);
655 assert_or_panic(vec[128] == true);
656 assert_or_panic(vec[129] == false);
657 assert_or_panic(vec[130] == true);
658 assert_or_panic(vec[131] == true);
659 assert_or_panic(vec[132] == false);
660 assert_or_panic(vec[133] == false);
661 assert_or_panic(vec[134] == true);
662 assert_or_panic(vec[135] == false);
663 assert_or_panic(vec[136] == false);
664 assert_or_panic(vec[137] == true);
665 assert_or_panic(vec[138] == false);
666 assert_or_panic(vec[139] == true);
667 assert_or_panic(vec[140] == false);
668 assert_or_panic(vec[141] == true);
669 assert_or_panic(vec[142] == true);
670 assert_or_panic(vec[143] == true);
671 assert_or_panic(vec[144] == true);
672 assert_or_panic(vec[145] == false);
673 assert_or_panic(vec[146] == true);
674 assert_or_panic(vec[147] == false);
675 assert_or_panic(vec[148] == false);
676 assert_or_panic(vec[149] == false);
677 assert_or_panic(vec[150] == true);
678 assert_or_panic(vec[151] == true);
679 assert_or_panic(vec[152] == true);
680 assert_or_panic(vec[153] == true);
681 assert_or_panic(vec[154] == true);
682 assert_or_panic(vec[155] == false);
683 assert_or_panic(vec[156] == true);
684 assert_or_panic(vec[157] == false);
685 assert_or_panic(vec[158] == false);
686 assert_or_panic(vec[159] == false);
687 assert_or_panic(vec[160] == true);
688 assert_or_panic(vec[161] == true);
689 assert_or_panic(vec[162] == false);
690 assert_or_panic(vec[163] == true);
691 assert_or_panic(vec[164] == true);
692 assert_or_panic(vec[165] == false);
693 assert_or_panic(vec[166] == false);
694 assert_or_panic(vec[167] == false);
695 assert_or_panic(vec[168] == false);
696 assert_or_panic(vec[169] == true);
697 assert_or_panic(vec[170] == false);
698 assert_or_panic(vec[171] == true);
699 assert_or_panic(vec[172] == false);
700 assert_or_panic(vec[173] == false);
701 assert_or_panic(vec[174] == false);
702 assert_or_panic(vec[175] == false);
703 assert_or_panic(vec[176] == true);
704 assert_or_panic(vec[177] == true);
705 assert_or_panic(vec[178] == true);
706 assert_or_panic(vec[179] == false);
707 assert_or_panic(vec[180] == true);
708 assert_or_panic(vec[181] == false);
709 assert_or_panic(vec[182] == true);
710 assert_or_panic(vec[183] == true);
711 assert_or_panic(vec[184] == false);
712 assert_or_panic(vec[185] == false);
713 assert_or_panic(vec[186] == true);
714 assert_or_panic(vec[187] == false);
715 assert_or_panic(vec[188] == false);
716 assert_or_panic(vec[189] == false);
717 assert_or_panic(vec[190] == false);
718 assert_or_panic(vec[191] == true);
719 assert_or_panic(vec[192] == true);
720 assert_or_panic(vec[193] == true);
721 assert_or_panic(vec[194] == true);
722 assert_or_panic(vec[195] == true);
723 assert_or_panic(vec[196] == true);
724 assert_or_panic(vec[197] == true);
725 assert_or_panic(vec[198] == false);
726 assert_or_panic(vec[199] == true);
727 assert_or_panic(vec[200] == false);
728 assert_or_panic(vec[201] == false);
729 assert_or_panic(vec[202] == true);
730 assert_or_panic(vec[203] == false);
731 assert_or_panic(vec[204] == true);
732 assert_or_panic(vec[205] == true);
733 assert_or_panic(vec[206] == true);
734 assert_or_panic(vec[207] == false);
735 assert_or_panic(vec[208] == false);
736 assert_or_panic(vec[209] == true);
737 assert_or_panic(vec[210] == true);
738 assert_or_panic(vec[211] == true);
739 assert_or_panic(vec[212] == false);
740 assert_or_panic(vec[213] == true);
741 assert_or_panic(vec[214] == true);
742 assert_or_panic(vec[215] == true);
743 assert_or_panic(vec[216] == true);
744 assert_or_panic(vec[217] == true);
745 assert_or_panic(vec[218] == false);
746 assert_or_panic(vec[219] == false);
747 assert_or_panic(vec[220] == false);
748 assert_or_panic(vec[221] == false);
749 assert_or_panic(vec[222] == false);
750 assert_or_panic(vec[223] == true);
751 assert_or_panic(vec[224] == true);
752 assert_or_panic(vec[225] == false);
753 assert_or_panic(vec[226] == true);
754 assert_or_panic(vec[227] == false);
755 assert_or_panic(vec[228] == false);
756 assert_or_panic(vec[229] == true);
757 assert_or_panic(vec[230] == false);
758 assert_or_panic(vec[231] == true);
759 assert_or_panic(vec[232] == false);
760 assert_or_panic(vec[233] == false);
761 assert_or_panic(vec[234] == false);
762 assert_or_panic(vec[235] == true);
763 assert_or_panic(vec[236] == false);
764 assert_or_panic(vec[237] == false);
765 assert_or_panic(vec[238] == false);
766 assert_or_panic(vec[239] == true);
767 assert_or_panic(vec[240] == true);
768 assert_or_panic(vec[241] == true);
769 assert_or_panic(vec[242] == true);
770 assert_or_panic(vec[243] == true);
771 assert_or_panic(vec[244] == true);
772 assert_or_panic(vec[245] == false);
773 assert_or_panic(vec[246] == false);
774 assert_or_panic(vec[247] == true);
775 assert_or_panic(vec[248] == false);
776 assert_or_panic(vec[249] == true);
777 assert_or_panic(vec[250] == true);
778 assert_or_panic(vec[251] == false);
779 assert_or_panic(vec[252] == true);
780 assert_or_panic(vec[253] == true);
781 assert_or_panic(vec[254] == true);
782 assert_or_panic(vec[255] == false);
783}
784
785void c_vector_512_bool(Vector512Bool vec) {
786 assert_or_panic(vec[0] == true);
787 assert_or_panic(vec[1] == true);
788 assert_or_panic(vec[2] == true);
789 assert_or_panic(vec[3] == true);
790 assert_or_panic(vec[4] == true);
791 assert_or_panic(vec[5] == false);
792 assert_or_panic(vec[6] == false);
793 assert_or_panic(vec[7] == true);
794 assert_or_panic(vec[8] == true);
795 assert_or_panic(vec[9] == true);
796 assert_or_panic(vec[10] == true);
797 assert_or_panic(vec[11] == false);
798 assert_or_panic(vec[12] == true);
799 assert_or_panic(vec[13] == true);
800 assert_or_panic(vec[14] == false);
801 assert_or_panic(vec[15] == false);
802 assert_or_panic(vec[16] == false);
803 assert_or_panic(vec[17] == true);
804 assert_or_panic(vec[18] == true);
805 assert_or_panic(vec[19] == true);
806 assert_or_panic(vec[20] == true);
807 assert_or_panic(vec[21] == true);
808 assert_or_panic(vec[22] == false);
809 assert_or_panic(vec[23] == false);
810 assert_or_panic(vec[24] == true);
811 assert_or_panic(vec[25] == true);
812 assert_or_panic(vec[26] == false);
813 assert_or_panic(vec[27] == false);
814 assert_or_panic(vec[28] == false);
815 assert_or_panic(vec[29] == false);
816 assert_or_panic(vec[30] == false);
817 assert_or_panic(vec[31] == true);
818 assert_or_panic(vec[32] == true);
819 assert_or_panic(vec[33] == false);
820 assert_or_panic(vec[34] == true);
821 assert_or_panic(vec[35] == true);
822 assert_or_panic(vec[36] == true);
823 assert_or_panic(vec[37] == true);
824 assert_or_panic(vec[38] == true);
825 assert_or_panic(vec[39] == true);
826 assert_or_panic(vec[40] == false);
827 assert_or_panic(vec[41] == true);
828 assert_or_panic(vec[42] == true);
829 assert_or_panic(vec[43] == false);
830 assert_or_panic(vec[44] == false);
831 assert_or_panic(vec[45] == false);
832 assert_or_panic(vec[46] == true);
833 assert_or_panic(vec[47] == true);
834 assert_or_panic(vec[48] == false);
835 assert_or_panic(vec[49] == true);
836 assert_or_panic(vec[50] == false);
837 assert_or_panic(vec[51] == true);
838 assert_or_panic(vec[52] == true);
839 assert_or_panic(vec[53] == false);
840 assert_or_panic(vec[54] == true);
841 assert_or_panic(vec[55] == false);
842 assert_or_panic(vec[56] == false);
843 assert_or_panic(vec[57] == true);
844 assert_or_panic(vec[58] == true);
845 assert_or_panic(vec[59] == false);
846 assert_or_panic(vec[60] == true);
847 assert_or_panic(vec[61] == true);
848 assert_or_panic(vec[62] == false);
849 assert_or_panic(vec[63] == true);
850 assert_or_panic(vec[64] == false);
851 assert_or_panic(vec[65] == true);
852 assert_or_panic(vec[66] == true);
853 assert_or_panic(vec[67] == true);
854 assert_or_panic(vec[68] == true);
855 assert_or_panic(vec[69] == true);
856 assert_or_panic(vec[70] == true);
857 assert_or_panic(vec[71] == true);
858 assert_or_panic(vec[72] == true);
859 assert_or_panic(vec[73] == true);
860 assert_or_panic(vec[74] == false);
861 assert_or_panic(vec[75] == true);
862 assert_or_panic(vec[76] == false);
863 assert_or_panic(vec[77] == true);
864 assert_or_panic(vec[78] == false);
865 assert_or_panic(vec[79] == false);
866 assert_or_panic(vec[80] == false);
867 assert_or_panic(vec[81] == true);
868 assert_or_panic(vec[82] == false);
869 assert_or_panic(vec[83] == true);
870 assert_or_panic(vec[84] == true);
871 assert_or_panic(vec[85] == false);
872 assert_or_panic(vec[86] == true);
873 assert_or_panic(vec[87] == true);
874 assert_or_panic(vec[88] == true);
875 assert_or_panic(vec[89] == false);
876 assert_or_panic(vec[90] == true);
877 assert_or_panic(vec[91] == true);
878 assert_or_panic(vec[92] == false);
879 assert_or_panic(vec[93] == true);
880 assert_or_panic(vec[94] == false);
881 assert_or_panic(vec[95] == true);
882 assert_or_panic(vec[96] == true);
883 assert_or_panic(vec[97] == false);
884 assert_or_panic(vec[98] == false);
885 assert_or_panic(vec[99] == false);
886 assert_or_panic(vec[100] == true);
887 assert_or_panic(vec[101] == true);
888 assert_or_panic(vec[102] == false);
889 assert_or_panic(vec[103] == true);
890 assert_or_panic(vec[104] == false);
891 assert_or_panic(vec[105] == false);
892 assert_or_panic(vec[106] == true);
893 assert_or_panic(vec[107] == false);
894 assert_or_panic(vec[108] == false);
895 assert_or_panic(vec[109] == true);
896 assert_or_panic(vec[110] == false);
897 assert_or_panic(vec[111] == false);
898 assert_or_panic(vec[112] == false);
899 assert_or_panic(vec[113] == false);
900 assert_or_panic(vec[114] == false);
901 assert_or_panic(vec[115] == true);
902 assert_or_panic(vec[116] == true);
903 assert_or_panic(vec[117] == false);
904 assert_or_panic(vec[118] == false);
905 assert_or_panic(vec[119] == false);
906 assert_or_panic(vec[120] == false);
907 assert_or_panic(vec[121] == true);
908 assert_or_panic(vec[122] == false);
909 assert_or_panic(vec[123] == false);
910 assert_or_panic(vec[124] == true);
911 assert_or_panic(vec[125] == true);
912 assert_or_panic(vec[126] == false);
913 assert_or_panic(vec[127] == true);
914 assert_or_panic(vec[128] == false);
915 assert_or_panic(vec[129] == true);
916 assert_or_panic(vec[130] == true);
917 assert_or_panic(vec[131] == false);
918 assert_or_panic(vec[132] == true);
919 assert_or_panic(vec[133] == false);
920 assert_or_panic(vec[134] == false);
921 assert_or_panic(vec[135] == false);
922 assert_or_panic(vec[136] == false);
923 assert_or_panic(vec[137] == true);
924 assert_or_panic(vec[138] == true);
925 assert_or_panic(vec[139] == false);
926 assert_or_panic(vec[140] == false);
927 assert_or_panic(vec[141] == false);
928 assert_or_panic(vec[142] == true);
929 assert_or_panic(vec[143] == true);
930 assert_or_panic(vec[144] == false);
931 assert_or_panic(vec[145] == false);
932 assert_or_panic(vec[146] == true);
933 assert_or_panic(vec[147] == true);
934 assert_or_panic(vec[148] == true);
935 assert_or_panic(vec[149] == true);
936 assert_or_panic(vec[150] == true);
937 assert_or_panic(vec[151] == true);
938 assert_or_panic(vec[152] == true);
939 assert_or_panic(vec[153] == false);
940 assert_or_panic(vec[154] == true);
941 assert_or_panic(vec[155] == false);
942 assert_or_panic(vec[156] == false);
943 assert_or_panic(vec[157] == true);
944 assert_or_panic(vec[158] == false);
945 assert_or_panic(vec[159] == true);
946 assert_or_panic(vec[160] == false);
947 assert_or_panic(vec[161] == true);
948 assert_or_panic(vec[162] == true);
949 assert_or_panic(vec[163] == true);
950 assert_or_panic(vec[164] == true);
951 assert_or_panic(vec[165] == true);
952 assert_or_panic(vec[166] == true);
953 assert_or_panic(vec[167] == true);
954 assert_or_panic(vec[168] == true);
955 assert_or_panic(vec[169] == false);
956 assert_or_panic(vec[170] == true);
957 assert_or_panic(vec[171] == true);
958 assert_or_panic(vec[172] == false);
959 assert_or_panic(vec[173] == true);
960 assert_or_panic(vec[174] == true);
961 assert_or_panic(vec[175] == false);
962 assert_or_panic(vec[176] == false);
963 assert_or_panic(vec[177] == false);
964 assert_or_panic(vec[178] == true);
965 assert_or_panic(vec[179] == false);
966 assert_or_panic(vec[180] == false);
967 assert_or_panic(vec[181] == true);
968 assert_or_panic(vec[182] == true);
969 assert_or_panic(vec[183] == true);
970 assert_or_panic(vec[184] == true);
971 assert_or_panic(vec[185] == true);
972 assert_or_panic(vec[186] == true);
973 assert_or_panic(vec[187] == true);
974 assert_or_panic(vec[188] == true);
975 assert_or_panic(vec[189] == true);
976 assert_or_panic(vec[190] == false);
977 assert_or_panic(vec[191] == true);
978 assert_or_panic(vec[192] == true);
979 assert_or_panic(vec[193] == false);
980 assert_or_panic(vec[194] == false);
981 assert_or_panic(vec[195] == true);
982 assert_or_panic(vec[196] == true);
983 assert_or_panic(vec[197] == false);
984 assert_or_panic(vec[198] == true);
985 assert_or_panic(vec[199] == true);
986 assert_or_panic(vec[200] == false);
987 assert_or_panic(vec[201] == true);
988 assert_or_panic(vec[202] == true);
989 assert_or_panic(vec[203] == false);
990 assert_or_panic(vec[204] == true);
991 assert_or_panic(vec[205] == true);
992 assert_or_panic(vec[206] == true);
993 assert_or_panic(vec[207] == true);
994 assert_or_panic(vec[208] == false);
995 assert_or_panic(vec[209] == true);
996 assert_or_panic(vec[210] == false);
997 assert_or_panic(vec[211] == true);
998 assert_or_panic(vec[212] == true);
999 assert_or_panic(vec[213] == false);
1000 assert_or_panic(vec[214] == true);
1001 assert_or_panic(vec[215] == false);
1002 assert_or_panic(vec[216] == true);
1003 assert_or_panic(vec[217] == false);
1004 assert_or_panic(vec[218] == true);
1005 assert_or_panic(vec[219] == false);
1006 assert_or_panic(vec[220] == false);
1007 assert_or_panic(vec[221] == true);
1008 assert_or_panic(vec[222] == false);
1009 assert_or_panic(vec[223] == false);
1010 assert_or_panic(vec[224] == false);
1011 assert_or_panic(vec[225] == true);
1012 assert_or_panic(vec[226] == true);
1013 assert_or_panic(vec[227] == false);
1014 assert_or_panic(vec[228] == false);
1015 assert_or_panic(vec[229] == false);
1016 assert_or_panic(vec[230] == true);
1017 assert_or_panic(vec[231] == false);
1018 assert_or_panic(vec[232] == true);
1019 assert_or_panic(vec[233] == false);
1020 assert_or_panic(vec[234] == false);
1021 assert_or_panic(vec[235] == false);
1022 assert_or_panic(vec[236] == true);
1023 assert_or_panic(vec[237] == true);
1024 assert_or_panic(vec[238] == false);
1025 assert_or_panic(vec[239] == false);
1026 assert_or_panic(vec[240] == false);
1027 assert_or_panic(vec[241] == false);
1028 assert_or_panic(vec[242] == false);
1029 assert_or_panic(vec[243] == true);
1030 assert_or_panic(vec[244] == true);
1031 assert_or_panic(vec[245] == false);
1032 assert_or_panic(vec[246] == true);
1033 assert_or_panic(vec[247] == false);
1034 assert_or_panic(vec[248] == false);
1035 assert_or_panic(vec[249] == true);
1036 assert_or_panic(vec[250] == false);
1037 assert_or_panic(vec[251] == false);
1038 assert_or_panic(vec[252] == false);
1039 assert_or_panic(vec[253] == true);
1040 assert_or_panic(vec[254] == false);
1041 assert_or_panic(vec[255] == false);
1042 assert_or_panic(vec[256] == false);
1043 assert_or_panic(vec[257] == false);
1044 assert_or_panic(vec[258] == true);
1045 assert_or_panic(vec[259] == true);
1046 assert_or_panic(vec[260] == true);
1047 assert_or_panic(vec[261] == true);
1048 assert_or_panic(vec[262] == false);
1049 assert_or_panic(vec[263] == true);
1050 assert_or_panic(vec[264] == false);
1051 assert_or_panic(vec[265] == false);
1052 assert_or_panic(vec[266] == false);
1053 assert_or_panic(vec[267] == true);
1054 assert_or_panic(vec[268] == false);
1055 assert_or_panic(vec[269] == false);
1056 assert_or_panic(vec[270] == true);
1057 assert_or_panic(vec[271] == true);
1058 assert_or_panic(vec[272] == false);
1059 assert_or_panic(vec[273] == false);
1060 assert_or_panic(vec[274] == false);
1061 assert_or_panic(vec[275] == false);
1062 assert_or_panic(vec[276] == false);
1063 assert_or_panic(vec[277] == true);
1064 assert_or_panic(vec[278] == false);
1065 assert_or_panic(vec[279] == true);
1066 assert_or_panic(vec[280] == true);
1067 assert_or_panic(vec[281] == true);
1068 assert_or_panic(vec[282] == true);
1069 assert_or_panic(vec[283] == true);
1070 assert_or_panic(vec[284] == false);
1071 assert_or_panic(vec[285] == false);
1072 assert_or_panic(vec[286] == false);
1073 assert_or_panic(vec[287] == false);
1074 assert_or_panic(vec[288] == false);
1075 assert_or_panic(vec[289] == false);
1076 assert_or_panic(vec[290] == false);
1077 assert_or_panic(vec[291] == false);
1078 assert_or_panic(vec[292] == false);
1079 assert_or_panic(vec[293] == true);
1080 assert_or_panic(vec[294] == true);
1081 assert_or_panic(vec[295] == true);
1082 assert_or_panic(vec[296] == true);
1083 assert_or_panic(vec[297] == true);
1084 assert_or_panic(vec[298] == true);
1085 assert_or_panic(vec[299] == false);
1086 assert_or_panic(vec[300] == true);
1087 assert_or_panic(vec[301] == false);
1088 assert_or_panic(vec[302] == true);
1089 assert_or_panic(vec[303] == true);
1090 assert_or_panic(vec[304] == true);
1091 assert_or_panic(vec[305] == false);
1092 assert_or_panic(vec[306] == false);
1093 assert_or_panic(vec[307] == true);
1094 assert_or_panic(vec[308] == true);
1095 assert_or_panic(vec[309] == true);
1096 assert_or_panic(vec[310] == false);
1097 assert_or_panic(vec[311] == true);
1098 assert_or_panic(vec[312] == true);
1099 assert_or_panic(vec[313] == true);
1100 assert_or_panic(vec[314] == false);
1101 assert_or_panic(vec[315] == true);
1102 assert_or_panic(vec[316] == true);
1103 assert_or_panic(vec[317] == true);
1104 assert_or_panic(vec[318] == false);
1105 assert_or_panic(vec[319] == true);
1106 assert_or_panic(vec[320] == true);
1107 assert_or_panic(vec[321] == false);
1108 assert_or_panic(vec[322] == false);
1109 assert_or_panic(vec[323] == true);
1110 assert_or_panic(vec[324] == false);
1111 assert_or_panic(vec[325] == false);
1112 assert_or_panic(vec[326] == false);
1113 assert_or_panic(vec[327] == false);
1114 assert_or_panic(vec[328] == true);
1115 assert_or_panic(vec[329] == false);
1116 assert_or_panic(vec[330] == true);
1117 assert_or_panic(vec[331] == true);
1118 assert_or_panic(vec[332] == true);
1119 assert_or_panic(vec[333] == true);
1120 assert_or_panic(vec[334] == false);
1121 assert_or_panic(vec[335] == false);
1122 assert_or_panic(vec[336] == true);
1123 assert_or_panic(vec[337] == false);
1124 assert_or_panic(vec[338] == true);
1125 assert_or_panic(vec[339] == false);
1126 assert_or_panic(vec[340] == false);
1127 assert_or_panic(vec[341] == false);
1128 assert_or_panic(vec[342] == true);
1129 assert_or_panic(vec[343] == false);
1130 assert_or_panic(vec[344] == true);
1131 assert_or_panic(vec[345] == false);
1132 assert_or_panic(vec[346] == false);
1133 assert_or_panic(vec[347] == true);
1134 assert_or_panic(vec[348] == true);
1135 assert_or_panic(vec[349] == true);
1136 assert_or_panic(vec[350] == true);
1137 assert_or_panic(vec[351] == false);
1138 assert_or_panic(vec[352] == false);
1139 assert_or_panic(vec[353] == false);
1140 assert_or_panic(vec[354] == true);
1141 assert_or_panic(vec[355] == true);
1142 assert_or_panic(vec[356] == false);
1143 assert_or_panic(vec[357] == true);
1144 assert_or_panic(vec[358] == false);
1145 assert_or_panic(vec[359] == false);
1146 assert_or_panic(vec[360] == true);
1147 assert_or_panic(vec[361] == false);
1148 assert_or_panic(vec[362] == true);
1149 assert_or_panic(vec[363] == false);
1150 assert_or_panic(vec[364] == true);
1151 assert_or_panic(vec[365] == true);
1152 assert_or_panic(vec[366] == false);
1153 assert_or_panic(vec[367] == false);
1154 assert_or_panic(vec[368] == true);
1155 assert_or_panic(vec[369] == true);
1156 assert_or_panic(vec[370] == true);
1157 assert_or_panic(vec[371] == true);
1158 assert_or_panic(vec[372] == false);
1159 assert_or_panic(vec[373] == false);
1160 assert_or_panic(vec[374] == true);
1161 assert_or_panic(vec[375] == false);
1162 assert_or_panic(vec[376] == true);
1163 assert_or_panic(vec[377] == true);
1164 assert_or_panic(vec[378] == false);
1165 assert_or_panic(vec[379] == true);
1166 assert_or_panic(vec[380] == true);
1167 assert_or_panic(vec[381] == false);
1168 assert_or_panic(vec[382] == true);
1169 assert_or_panic(vec[383] == true);
1170 assert_or_panic(vec[384] == true);
1171 assert_or_panic(vec[385] == false);
1172 assert_or_panic(vec[386] == true);
1173 assert_or_panic(vec[387] == true);
1174 assert_or_panic(vec[388] == true);
1175 assert_or_panic(vec[389] == false);
1176 assert_or_panic(vec[390] == false);
1177 assert_or_panic(vec[391] == true);
1178 assert_or_panic(vec[392] == false);
1179 assert_or_panic(vec[393] == true);
1180 assert_or_panic(vec[394] == true);
1181 assert_or_panic(vec[395] == true);
1182 assert_or_panic(vec[396] == false);
1183 assert_or_panic(vec[397] == false);
1184 assert_or_panic(vec[398] == false);
1185 assert_or_panic(vec[399] == false);
1186 assert_or_panic(vec[400] == false);
1187 assert_or_panic(vec[401] == true);
1188 assert_or_panic(vec[402] == false);
1189 assert_or_panic(vec[403] == false);
1190 assert_or_panic(vec[404] == false);
1191 assert_or_panic(vec[405] == false);
1192 assert_or_panic(vec[406] == true);
1193 assert_or_panic(vec[407] == false);
1194 assert_or_panic(vec[408] == false);
1195 assert_or_panic(vec[409] == true);
1196 assert_or_panic(vec[410] == true);
1197 assert_or_panic(vec[411] == false);
1198 assert_or_panic(vec[412] == false);
1199 assert_or_panic(vec[413] == false);
1200 assert_or_panic(vec[414] == false);
1201 assert_or_panic(vec[415] == true);
1202 assert_or_panic(vec[416] == true);
1203 assert_or_panic(vec[417] == true);
1204 assert_or_panic(vec[418] == true);
1205 assert_or_panic(vec[419] == true);
1206 assert_or_panic(vec[420] == false);
1207 assert_or_panic(vec[421] == false);
1208 assert_or_panic(vec[422] == false);
1209 assert_or_panic(vec[423] == true);
1210 assert_or_panic(vec[424] == false);
1211 assert_or_panic(vec[425] == false);
1212 assert_or_panic(vec[426] == false);
1213 assert_or_panic(vec[427] == false);
1214 assert_or_panic(vec[428] == true);
1215 assert_or_panic(vec[429] == false);
1216 assert_or_panic(vec[430] == true);
1217 assert_or_panic(vec[431] == false);
1218 assert_or_panic(vec[432] == true);
1219 assert_or_panic(vec[433] == true);
1220 assert_or_panic(vec[434] == true);
1221 assert_or_panic(vec[435] == true);
1222 assert_or_panic(vec[436] == false);
1223 assert_or_panic(vec[437] == false);
1224 assert_or_panic(vec[438] == false);
1225 assert_or_panic(vec[439] == false);
1226 assert_or_panic(vec[440] == false);
1227 assert_or_panic(vec[441] == true);
1228 assert_or_panic(vec[442] == true);
1229 assert_or_panic(vec[443] == true);
1230 assert_or_panic(vec[444] == true);
1231 assert_or_panic(vec[445] == true);
1232 assert_or_panic(vec[446] == true);
1233 assert_or_panic(vec[447] == true);
1234 assert_or_panic(vec[448] == true);
1235 assert_or_panic(vec[449] == true);
1236 assert_or_panic(vec[450] == false);
1237 assert_or_panic(vec[451] == false);
1238 assert_or_panic(vec[452] == true);
1239 assert_or_panic(vec[453] == false);
1240 assert_or_panic(vec[454] == true);
1241 assert_or_panic(vec[455] == false);
1242 assert_or_panic(vec[456] == false);
1243 assert_or_panic(vec[457] == true);
1244 assert_or_panic(vec[458] == false);
1245 assert_or_panic(vec[459] == false);
1246 assert_or_panic(vec[460] == true);
1247 assert_or_panic(vec[461] == true);
1248 assert_or_panic(vec[462] == true);
1249 assert_or_panic(vec[463] == true);
1250 assert_or_panic(vec[464] == true);
1251 assert_or_panic(vec[465] == true);
1252 assert_or_panic(vec[466] == false);
1253 assert_or_panic(vec[467] == true);
1254 assert_or_panic(vec[468] == false);
1255 assert_or_panic(vec[469] == false);
1256 assert_or_panic(vec[470] == false);
1257 assert_or_panic(vec[471] == true);
1258 assert_or_panic(vec[472] == true);
1259 assert_or_panic(vec[473] == false);
1260 assert_or_panic(vec[474] == true);
1261 assert_or_panic(vec[475] == true);
1262 assert_or_panic(vec[476] == false);
1263 assert_or_panic(vec[477] == false);
1264 assert_or_panic(vec[478] == true);
1265 assert_or_panic(vec[479] == true);
1266 assert_or_panic(vec[480] == false);
1267 assert_or_panic(vec[481] == false);
1268 assert_or_panic(vec[482] == true);
1269 assert_or_panic(vec[483] == true);
1270 assert_or_panic(vec[484] == false);
1271 assert_or_panic(vec[485] == true);
1272 assert_or_panic(vec[486] == false);
1273 assert_or_panic(vec[487] == true);
1274 assert_or_panic(vec[488] == true);
1275 assert_or_panic(vec[489] == true);
1276 assert_or_panic(vec[490] == true);
1277 assert_or_panic(vec[491] == true);
1278 assert_or_panic(vec[492] == true);
1279 assert_or_panic(vec[493] == true);
1280 assert_or_panic(vec[494] == true);
1281 assert_or_panic(vec[495] == true);
1282 assert_or_panic(vec[496] == false);
1283 assert_or_panic(vec[497] == true);
1284 assert_or_panic(vec[498] == true);
1285 assert_or_panic(vec[499] == true);
1286 assert_or_panic(vec[500] == false);
1287 assert_or_panic(vec[501] == false);
1288 assert_or_panic(vec[502] == true);
1289 assert_or_panic(vec[503] == false);
1290 assert_or_panic(vec[504] == false);
1291 assert_or_panic(vec[505] == false);
1292 assert_or_panic(vec[506] == true);
1293 assert_or_panic(vec[507] == true);
1294 assert_or_panic(vec[508] == false);
1295 assert_or_panic(vec[509] == true);
1296 assert_or_panic(vec[510] == false);
1297 assert_or_panic(vec[511] == true);
1298}
1299
1300Vector2Bool c_ret_vector_2_bool(void) {
1301 return (Vector2Bool){
1302 true,
1303 false,
1304 };
1305}
1306
1307Vector4Bool c_ret_vector_4_bool(void) {
1308 return (Vector4Bool){
1309 true,
1310 false,
1311 true,
1312 false,
1313 };
1314}
1315
1316Vector8Bool c_ret_vector_8_bool(void) {
1317 return (Vector8Bool){
1318 false,
1319 true,
1320 false,
1321 false,
1322 true,
1323 false,
1324 false,
1325 true,
1326 };
1327}
1328
1329Vector16Bool c_ret_vector_16_bool(void) {
1330 return (Vector16Bool){
1331 true,
1332 true,
1333 false,
1334 false,
1335 false,
1336 false,
1337 true,
1338 false,
1339 true,
1340 false,
1341 false,
1342 true,
1343 true,
1344 false,
1345 true,
1346 true,
1347 };
1348}
1349
1350Vector32Bool c_ret_vector_32_bool(void) {
1351 return (Vector32Bool){
1352 true,
1353 false,
1354 true,
1355 true,
1356 true,
1357 false,
1358 true,
1359 false,
1360 true,
1361 true,
1362 true,
1363 false,
1364 true,
1365 true,
1366 false,
1367 false,
1368 true,
1369 false,
1370 false,
1371 false,
1372 false,
1373 true,
1374 true,
1375 true,
1376 false,
1377 true,
1378 false,
1379 false,
1380 true,
1381 false,
1382 false,
1383 false,
1384 };
1385}
1386
1387Vector64Bool c_ret_vector_64_bool(void) {
1388 return (Vector64Bool){
1389 false,
1390 true,
1391 false,
1392 true,
1393 true,
1394 true,
1395 false,
1396 true,
1397 true,
1398 true,
1399 true,
1400 true,
1401 true,
1402 false,
1403 true,
1404 true,
1405 true,
1406 false,
1407 false,
1408 false,
1409 true,
1410 true,
1411 false,
1412 true,
1413 false,
1414 true,
1415 false,
1416 true,
1417 false,
1418 true,
1419 false,
1420 true,
1421 false,
1422 false,
1423 true,
1424 true,
1425 false,
1426 false,
1427 false,
1428 true,
1429 true,
1430 true,
1431 true,
1432 false,
1433 false,
1434 false,
1435 true,
1436 true,
1437 false,
1438 false,
1439 true,
1440 false,
1441 false,
1442 false,
1443 false,
1444 true,
1445 false,
1446 false,
1447 false,
1448 true,
1449 true,
1450 true,
1451 true,
1452 true,
1453 };
1454}
1455
1456Vector128Bool c_ret_vector_128_bool(void) {
1457 return (Vector128Bool){
1458 false,
1459 true,
1460 true,
1461 false,
1462 true,
1463 false,
1464 false,
1465 true,
1466 true,
1467 false,
1468 true,
1469 false,
1470 false,
1471 false,
1472 true,
1473 false,
1474 true,
1475 false,
1476 false,
1477 true,
1478 false,
1479 true,
1480 false,
1481 false,
1482 false,
1483 true,
1484 true,
1485 true,
1486 false,
1487 false,
1488 false,
1489 false,
1490 true,
1491 true,
1492 true,
1493 false,
1494 true,
1495 true,
1496 false,
1497 false,
1498 false,
1499 false,
1500 true,
1501 true,
1502 true,
1503 false,
1504 false,
1505 false,
1506 false,
1507 true,
1508 false,
1509 false,
1510 true,
1511 false,
1512 false,
1513 false,
1514 false,
1515 false,
1516 true,
1517 true,
1518 true,
1519 false,
1520 true,
1521 true,
1522 false,
1523 false,
1524 false,
1525 false,
1526 false,
1527 false,
1528 false,
1529 false,
1530 true,
1531 true,
1532 true,
1533 true,
1534 true,
1535 false,
1536 false,
1537 false,
1538 false,
1539 false,
1540 false,
1541 true,
1542 false,
1543 true,
1544 false,
1545 true,
1546 false,
1547 true,
1548 false,
1549 true,
1550 true,
1551 true,
1552 true,
1553 false,
1554 false,
1555 true,
1556 false,
1557 false,
1558 true,
1559 true,
1560 true,
1561 true,
1562 false,
1563 true,
1564 true,
1565 true,
1566 false,
1567 false,
1568 true,
1569 false,
1570 false,
1571 true,
1572 true,
1573 false,
1574 true,
1575 false,
1576 true,
1577 true,
1578 true,
1579 true,
1580 true,
1581 false,
1582 false,
1583 true,
1584 false,
1585 true,
1586 };
1587}
1588
1589Vector256Bool c_ret_vector_256_bool(void) {
1590 return (Vector256Bool){
1591 true,
1592 false,
1593 true,
1594 true,
1595 false,
1596 false,
1597 false,
1598 false,
1599 false,
1600 true,
1601 false,
1602 true,
1603 false,
1604 true,
1605 false,
1606 false,
1607 true,
1608 true,
1609 true,
1610 false,
1611 false,
1612 false,
1613 true,
1614 false,
1615 true,
1616 false,
1617 false,
1618 true,
1619 true,
1620 true,
1621 false,
1622 false,
1623 true,
1624 true,
1625 true,
1626 false,
1627 true,
1628 true,
1629 true,
1630 false,
1631 true,
1632 false,
1633 true,
1634 true,
1635 false,
1636 true,
1637 false,
1638 true,
1639 true,
1640 false,
1641 false,
1642 true,
1643 true,
1644 false,
1645 false,
1646 true,
1647 false,
1648 true,
1649 true,
1650 true,
1651 false,
1652 true,
1653 true,
1654 false,
1655 true,
1656 true,
1657 false,
1658 true,
1659 false,
1660 true,
1661 true,
1662 true,
1663 false,
1664 true,
1665 true,
1666 false,
1667 true,
1668 true,
1669 true,
1670 true,
1671 false,
1672 true,
1673 false,
1674 true,
1675 true,
1676 true,
1677 false,
1678 true,
1679 false,
1680 true,
1681 false,
1682 false,
1683 true,
1684 false,
1685 false,
1686 false,
1687 true,
1688 true,
1689 false,
1690 false,
1691 false,
1692 true,
1693 true,
1694 true,
1695 false,
1696 false,
1697 false,
1698 true,
1699 false,
1700 true,
1701 true,
1702 true,
1703 true,
1704 true,
1705 true,
1706 true,
1707 true,
1708 false,
1709 true,
1710 false,
1711 true,
1712 false,
1713 false,
1714 true,
1715 true,
1716 false,
1717 true,
1718 false,
1719 false,
1720 false,
1721 false,
1722 true,
1723 false,
1724 false,
1725 true,
1726 false,
1727 false,
1728 false,
1729 false,
1730 false,
1731 false,
1732 true,
1733 false,
1734 true,
1735 false,
1736 true,
1737 true,
1738 true,
1739 false,
1740 true,
1741 true,
1742 false,
1743 true,
1744 true,
1745 false,
1746 true,
1747 true,
1748 true,
1749 true,
1750 true,
1751 true,
1752 true,
1753 false,
1754 false,
1755 false,
1756 true,
1757 false,
1758 false,
1759 true,
1760 false,
1761 true,
1762 true,
1763 true,
1764 false,
1765 false,
1766 true,
1767 true,
1768 true,
1769 true,
1770 false,
1771 true,
1772 true,
1773 false,
1774 true,
1775 false,
1776 false,
1777 false,
1778 true,
1779 true,
1780 true,
1781 true,
1782 true,
1783 true,
1784 true,
1785 true,
1786 false,
1787 false,
1788 true,
1789 false,
1790 false,
1791 false,
1792 true,
1793 true,
1794 true,
1795 true,
1796 true,
1797 true,
1798 false,
1799 false,
1800 false,
1801 true,
1802 true,
1803 true,
1804 false,
1805 true,
1806 false,
1807 true,
1808 false,
1809 true,
1810 false,
1811 true,
1812 true,
1813 true,
1814 false,
1815 true,
1816 false,
1817 true,
1818 false,
1819 true,
1820 false,
1821 true,
1822 false,
1823 false,
1824 true,
1825 false,
1826 true,
1827 true,
1828 false,
1829 false,
1830 true,
1831 false,
1832 false,
1833 false,
1834 true,
1835 true,
1836 false,
1837 false,
1838 false,
1839 false,
1840 false,
1841 true,
1842 false,
1843 true,
1844 false,
1845 false,
1846 false,
1847 };
1848}
1849
1850Vector512Bool c_ret_vector_512_bool(void) {
1851 return (Vector512Bool){
1852 false,
1853 true,
1854 false,
1855 false,
1856 false,
1857 true,
1858 false,
1859 false,
1860 false,
1861 true,
1862 false,
1863 false,
1864 false,
1865 true,
1866 false,
1867 true,
1868 false,
1869 false,
1870 false,
1871 false,
1872 false,
1873 false,
1874 true,
1875 true,
1876 false,
1877 false,
1878 false,
1879 false,
1880 true,
1881 true,
1882 false,
1883 true,
1884 false,
1885 true,
1886 true,
1887 true,
1888 false,
1889 false,
1890 true,
1891 true,
1892 false,
1893 false,
1894 false,
1895 false,
1896 false,
1897 true,
1898 false,
1899 true,
1900 true,
1901 false,
1902 true,
1903 true,
1904 true,
1905 true,
1906 false,
1907 false,
1908 false,
1909 true,
1910 true,
1911 false,
1912 false,
1913 false,
1914 false,
1915 true,
1916 true,
1917 true,
1918 true,
1919 true,
1920 false,
1921 false,
1922 false,
1923 false,
1924 false,
1925 true,
1926 false,
1927 true,
1928 false,
1929 false,
1930 true,
1931 true,
1932 false,
1933 false,
1934 false,
1935 true,
1936 false,
1937 true,
1938 true,
1939 true,
1940 false,
1941 true,
1942 false,
1943 false,
1944 true,
1945 true,
1946 false,
1947 true,
1948 true,
1949 false,
1950 true,
1951 false,
1952 true,
1953 true,
1954 false,
1955 true,
1956 true,
1957 false,
1958 false,
1959 false,
1960 true,
1961 false,
1962 false,
1963 false,
1964 true,
1965 true,
1966 true,
1967 false,
1968 true,
1969 false,
1970 true,
1971 false,
1972 true,
1973 true,
1974 false,
1975 true,
1976 false,
1977 true,
1978 true,
1979 true,
1980 false,
1981 true,
1982 false,
1983 false,
1984 false,
1985 false,
1986 false,
1987 false,
1988 true,
1989 false,
1990 true,
1991 false,
1992 true,
1993 true,
1994 false,
1995 true,
1996 false,
1997 false,
1998 true,
1999 false,
2000 false,
2001 true,
2002 false,
2003 true,
2004 false,
2005 true,
2006 false,
2007 false,
2008 true,
2009 false,
2010 true,
2011 true,
2012 true,
2013 false,
2014 false,
2015 true,
2016 false,
2017 false,
2018 false,
2019 true,
2020 true,
2021 true,
2022 false,
2023 true,
2024 false,
2025 false,
2026 false,
2027 false,
2028 false,
2029 true,
2030 true,
2031 false,
2032 false,
2033 true,
2034 false,
2035 false,
2036 false,
2037 false,
2038 false,
2039 true,
2040 true,
2041 false,
2042 false,
2043 false,
2044 false,
2045 false,
2046 false,
2047 true,
2048 true,
2049 false,
2050 true,
2051 true,
2052 true,
2053 true,
2054 true,
2055 true,
2056 false,
2057 false,
2058 false,
2059 false,
2060 true,
2061 false,
2062 true,
2063 true,
2064 true,
2065 true,
2066 false,
2067 false,
2068 false,
2069 true,
2070 true,
2071 false,
2072 true,
2073 true,
2074 false,
2075 false,
2076 false,
2077 true,
2078 true,
2079 true,
2080 true,
2081 false,
2082 true,
2083 false,
2084 true,
2085 true,
2086 true,
2087 true,
2088 false,
2089 true,
2090 false,
2091 true,
2092 false,
2093 true,
2094 false,
2095 false,
2096 false,
2097 true,
2098 true,
2099 false,
2100 true,
2101 false,
2102 false,
2103 false,
2104 true,
2105 true,
2106 true,
2107 true,
2108 true,
2109 false,
2110 true,
2111 true,
2112 true,
2113 true,
2114 false,
2115 true,
2116 false,
2117 false,
2118 true,
2119 false,
2120 true,
2121 false,
2122 false,
2123 true,
2124 true,
2125 false,
2126 true,
2127 false,
2128 false,
2129 true,
2130 false,
2131 false,
2132 true,
2133 true,
2134 true,
2135 false,
2136 false,
2137 true,
2138 true,
2139 true,
2140 false,
2141 false,
2142 false,
2143 false,
2144 false,
2145 false,
2146 true,
2147 false,
2148 true,
2149 false,
2150 true,
2151 true,
2152 false,
2153 false,
2154 false,
2155 false,
2156 true,
2157 true,
2158 true,
2159 true,
2160 true,
2161 false,
2162 true,
2163 true,
2164 true,
2165 true,
2166 true,
2167 false,
2168 true,
2169 true,
2170 true,
2171 false,
2172 true,
2173 false,
2174 true,
2175 true,
2176 true,
2177 false,
2178 false,
2179 true,
2180 true,
2181 true,
2182 false,
2183 false,
2184 true,
2185 true,
2186 false,
2187 true,
2188 true,
2189 true,
2190 true,
2191 true,
2192 true,
2193 false,
2194 true,
2195 false,
2196 true,
2197 false,
2198 false,
2199 false,
2200 false,
2201 true,
2202 true,
2203 true,
2204 true,
2205 false,
2206 true,
2207 false,
2208 true,
2209 true,
2210 false,
2211 true,
2212 false,
2213 false,
2214 true,
2215 false,
2216 false,
2217 false,
2218 false,
2219 false,
2220 false,
2221 false,
2222 true,
2223 false,
2224 true,
2225 true,
2226 false,
2227 false,
2228 true,
2229 false,
2230 false,
2231 true,
2232 false,
2233 false,
2234 true,
2235 false,
2236 false,
2237 false,
2238 false,
2239 true,
2240 true,
2241 true,
2242 true,
2243 true,
2244 true,
2245 true,
2246 false,
2247 true,
2248 true,
2249 false,
2250 false,
2251 false,
2252 true,
2253 false,
2254 true,
2255 true,
2256 false,
2257 true,
2258 true,
2259 true,
2260 true,
2261 false,
2262 false,
2263 false,
2264 true,
2265 true,
2266 false,
2267 true,
2268 false,
2269 true,
2270 false,
2271 false,
2272 false,
2273 false,
2274 true,
2275 true,
2276 true,
2277 false,
2278 true,
2279 false,
2280 false,
2281 false,
2282 true,
2283 true,
2284 false,
2285 true,
2286 false,
2287 false,
2288 true,
2289 true,
2290 true,
2291 true,
2292 true,
2293 true,
2294 false,
2295 false,
2296 false,
2297 true,
2298 true,
2299 true,
2300 false,
2301 false,
2302 false,
2303 false,
2304 false,
2305 false,
2306 false,
2307 false,
2308 false,
2309 false,
2310 false,
2311 true,
2312 false,
2313 false,
2314 false,
2315 true,
2316 false,
2317 false,
2318 false,
2319 false,
2320 true,
2321 true,
2322 true,
2323 true,
2324 true,
2325 false,
2326 false,
2327 true,
2328 true,
2329 true,
2330 false,
2331 true,
2332 true,
2333 true,
2334 false,
2335 true,
2336 false,
2337 true,
2338 false,
2339 true,
2340 false,
2341 true,
2342 true,
2343 true,
2344 true,
2345 false,
2346 true,
2347 true,
2348 false,
2349 true,
2350 false,
2351 false,
2352 false,
2353 false,
2354 false,
2355 false,
2356 false,
2357 false,
2358 false,
2359 true,
2360 true,
2361 false,
2362 true,
2363 false,
2364 };
2365}
2366
2367void zig_vector_2_bool(Vector2Bool vec);
2368void zig_vector_4_bool(Vector4Bool vec);
2369void zig_vector_8_bool(Vector8Bool vec);
2370void zig_vector_16_bool(Vector16Bool vec);
2371void zig_vector_32_bool(Vector32Bool vec);
2372void zig_vector_64_bool(Vector64Bool vec);
2373void zig_vector_128_bool(Vector128Bool vec);
2374void zig_vector_256_bool(Vector256Bool vec);
2375void zig_vector_512_bool(Vector512Bool vec);
2376
2377Vector2Bool zig_ret_vector_2_bool(void);
2378Vector4Bool zig_ret_vector_4_bool(void);
2379Vector8Bool zig_ret_vector_8_bool(void);
2380Vector16Bool zig_ret_vector_16_bool(void);
2381Vector32Bool zig_ret_vector_32_bool(void);
2382Vector64Bool zig_ret_vector_64_bool(void);
2383Vector128Bool zig_ret_vector_128_bool(void);
2384Vector256Bool zig_ret_vector_256_bool(void);
2385Vector512Bool zig_ret_vector_512_bool(void);
2386
2387#endif
2388
2392389typedef struct Vector3 {
2402390 float x;
2412391 float y;
......@@ -450,6 +2600,2107 @@ void run_c_tests(void) {
4502600 assert_or_panic(zig_ret_i32() == -1);
4512601 assert_or_panic(zig_ret_i64() == -1);
4522602 }
2603
2604#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32)
2605 {
2606 zig_vector_2_bool((Vector2Bool){
2607 false,
2608 true,
2609 });
2610
2611 Vector2Bool vec = zig_ret_vector_2_bool();
2612 assert_or_panic(vec[0] == false);
2613 assert_or_panic(vec[1] == false);
2614 }
2615 {
2616 zig_vector_4_bool((Vector4Bool){
2617 false,
2618 false,
2619 false,
2620 false,
2621 });
2622
2623 Vector4Bool vec = zig_ret_vector_4_bool();
2624 assert_or_panic(vec[0] == false);
2625 assert_or_panic(vec[1] == true);
2626 assert_or_panic(vec[2] == true);
2627 assert_or_panic(vec[3] == true);
2628 }
2629 {
2630 zig_vector_8_bool((Vector8Bool){
2631 true,
2632 true,
2633 false,
2634 true,
2635 false,
2636 true,
2637 true,
2638 false,
2639 });
2640
2641 Vector8Bool vec = zig_ret_vector_8_bool();
2642 assert_or_panic(vec[0] == false);
2643 assert_or_panic(vec[1] == false);
2644 assert_or_panic(vec[2] == false);
2645 assert_or_panic(vec[3] == false);
2646 assert_or_panic(vec[4] == true);
2647 assert_or_panic(vec[5] == false);
2648 assert_or_panic(vec[6] == false);
2649 assert_or_panic(vec[7] == false);
2650 }
2651 {
2652 zig_vector_16_bool((Vector16Bool){
2653 true,
2654 false,
2655 true,
2656 true,
2657 true,
2658 false,
2659 false,
2660 false,
2661 true,
2662 true,
2663 true,
2664 true,
2665 false,
2666 false,
2667 false,
2668 true,
2669 });
2670
2671 Vector16Bool vec = zig_ret_vector_16_bool();
2672 assert_or_panic(vec[0] == false);
2673 assert_or_panic(vec[1] == true);
2674 assert_or_panic(vec[2] == false);
2675 assert_or_panic(vec[3] == false);
2676 assert_or_panic(vec[4] == false);
2677 assert_or_panic(vec[5] == true);
2678 assert_or_panic(vec[6] == false);
2679 assert_or_panic(vec[7] == false);
2680 assert_or_panic(vec[8] == true);
2681 assert_or_panic(vec[9] == false);
2682 assert_or_panic(vec[10] == false);
2683 assert_or_panic(vec[11] == false);
2684 assert_or_panic(vec[12] == false);
2685 assert_or_panic(vec[13] == true);
2686 assert_or_panic(vec[14] == false);
2687 assert_or_panic(vec[15] == false);
2688 }
2689 {
2690 zig_vector_32_bool((Vector32Bool){
2691 false,
2692 false,
2693 false,
2694 true,
2695 true,
2696 false,
2697 false,
2698 true,
2699 false,
2700 true,
2701 true,
2702 true,
2703 false,
2704 false,
2705 true,
2706 true,
2707 true,
2708 true,
2709 true,
2710 false,
2711 true,
2712 true,
2713 true,
2714 false,
2715 false,
2716 true,
2717 true,
2718 false,
2719 true,
2720 true,
2721 false,
2722 true,
2723 });
2724
2725 Vector32Bool vec = zig_ret_vector_32_bool();
2726 assert_or_panic(vec[0] == false);
2727 assert_or_panic(vec[1] == true);
2728 assert_or_panic(vec[2] == false);
2729 assert_or_panic(vec[3] == false);
2730 assert_or_panic(vec[4] == true);
2731 assert_or_panic(vec[5] == false);
2732 assert_or_panic(vec[6] == true);
2733 assert_or_panic(vec[7] == true);
2734 assert_or_panic(vec[8] == true);
2735 assert_or_panic(vec[9] == true);
2736 assert_or_panic(vec[10] == true);
2737 assert_or_panic(vec[11] == true);
2738 assert_or_panic(vec[12] == false);
2739 assert_or_panic(vec[13] == false);
2740 assert_or_panic(vec[14] == false);
2741 assert_or_panic(vec[15] == false);
2742 assert_or_panic(vec[16] == false);
2743 assert_or_panic(vec[17] == false);
2744 assert_or_panic(vec[18] == true);
2745 assert_or_panic(vec[19] == true);
2746 assert_or_panic(vec[20] == true);
2747 assert_or_panic(vec[21] == false);
2748 assert_or_panic(vec[22] == true);
2749 assert_or_panic(vec[23] == false);
2750 assert_or_panic(vec[24] == true);
2751 assert_or_panic(vec[25] == false);
2752 assert_or_panic(vec[26] == false);
2753 assert_or_panic(vec[27] == true);
2754 assert_or_panic(vec[28] == false);
2755 assert_or_panic(vec[29] == false);
2756 assert_or_panic(vec[30] == true);
2757 assert_or_panic(vec[31] == true);
2758 }
2759 {
2760 zig_vector_64_bool((Vector64Bool){
2761 true,
2762 true,
2763 false,
2764 true,
2765 false,
2766 true,
2767 false,
2768 false,
2769 true,
2770 true,
2771 true,
2772 true,
2773 true,
2774 true,
2775 true,
2776 false,
2777 false,
2778 true,
2779 true,
2780 false,
2781 true,
2782 true,
2783 true,
2784 true,
2785 false,
2786 false,
2787 true,
2788 false,
2789 false,
2790 true,
2791 false,
2792 true,
2793 false,
2794 true,
2795 true,
2796 false,
2797 true,
2798 true,
2799 false,
2800 false,
2801 true,
2802 true,
2803 true,
2804 true,
2805 true,
2806 false,
2807 true,
2808 false,
2809 false,
2810 false,
2811 false,
2812 false,
2813 true,
2814 false,
2815 false,
2816 true,
2817 true,
2818 false,
2819 false,
2820 false,
2821 true,
2822 true,
2823 true,
2824 true,
2825 });
2826
2827 Vector64Bool vec = zig_ret_vector_64_bool();
2828 assert_or_panic(vec[0] == true);
2829 assert_or_panic(vec[1] == false);
2830 assert_or_panic(vec[2] == true);
2831 assert_or_panic(vec[3] == false);
2832 assert_or_panic(vec[4] == false);
2833 assert_or_panic(vec[5] == true);
2834 assert_or_panic(vec[6] == false);
2835 assert_or_panic(vec[7] == true);
2836 assert_or_panic(vec[8] == true);
2837 assert_or_panic(vec[9] == false);
2838 assert_or_panic(vec[10] == true);
2839 assert_or_panic(vec[11] == false);
2840 assert_or_panic(vec[12] == true);
2841 assert_or_panic(vec[13] == false);
2842 assert_or_panic(vec[14] == false);
2843 assert_or_panic(vec[15] == true);
2844 assert_or_panic(vec[16] == false);
2845 assert_or_panic(vec[17] == false);
2846 assert_or_panic(vec[18] == true);
2847 assert_or_panic(vec[19] == true);
2848 assert_or_panic(vec[20] == false);
2849 assert_or_panic(vec[21] == false);
2850 assert_or_panic(vec[22] == true);
2851 assert_or_panic(vec[23] == false);
2852 assert_or_panic(vec[24] == false);
2853 assert_or_panic(vec[25] == true);
2854 assert_or_panic(vec[26] == true);
2855 assert_or_panic(vec[27] == true);
2856 assert_or_panic(vec[28] == true);
2857 assert_or_panic(vec[29] == true);
2858 assert_or_panic(vec[30] == false);
2859 assert_or_panic(vec[31] == false);
2860 assert_or_panic(vec[32] == true);
2861 assert_or_panic(vec[33] == true);
2862 assert_or_panic(vec[34] == true);
2863 assert_or_panic(vec[35] == true);
2864 assert_or_panic(vec[36] == false);
2865 assert_or_panic(vec[37] == true);
2866 assert_or_panic(vec[38] == false);
2867 assert_or_panic(vec[39] == true);
2868 assert_or_panic(vec[40] == true);
2869 assert_or_panic(vec[41] == true);
2870 assert_or_panic(vec[42] == true);
2871 assert_or_panic(vec[43] == true);
2872 assert_or_panic(vec[44] == false);
2873 assert_or_panic(vec[45] == false);
2874 assert_or_panic(vec[46] == false);
2875 assert_or_panic(vec[47] == true);
2876 assert_or_panic(vec[48] == true);
2877 assert_or_panic(vec[49] == true);
2878 assert_or_panic(vec[50] == false);
2879 assert_or_panic(vec[51] == true);
2880 assert_or_panic(vec[52] == true);
2881 assert_or_panic(vec[53] == true);
2882 assert_or_panic(vec[54] == false);
2883 assert_or_panic(vec[55] == false);
2884 assert_or_panic(vec[56] == false);
2885 assert_or_panic(vec[57] == true);
2886 assert_or_panic(vec[58] == false);
2887 assert_or_panic(vec[59] == false);
2888 assert_or_panic(vec[60] == true);
2889 assert_or_panic(vec[61] == false);
2890 assert_or_panic(vec[62] == true);
2891 assert_or_panic(vec[63] == false);
2892 }
2893 {
2894 zig_vector_128_bool((Vector128Bool){
2895 true,
2896 true,
2897 false,
2898 true,
2899 true,
2900 false,
2901 false,
2902 true,
2903 true,
2904 true,
2905 true,
2906 true,
2907 false,
2908 false,
2909 false,
2910 true,
2911 false,
2912 true,
2913 false,
2914 false,
2915 true,
2916 false,
2917 true,
2918 false,
2919 false,
2920 false,
2921 true,
2922 false,
2923 true,
2924 true,
2925 false,
2926 true,
2927 false,
2928 true,
2929 true,
2930 false,
2931 false,
2932 false,
2933 false,
2934 true,
2935 true,
2936 false,
2937 true,
2938 false,
2939 false,
2940 true,
2941 false,
2942 false,
2943 true,
2944 true,
2945 false,
2946 false,
2947 true,
2948 false,
2949 false,
2950 true,
2951 true,
2952 true,
2953 true,
2954 true,
2955 true,
2956 true,
2957 true,
2958 false,
2959 false,
2960 true,
2961 false,
2962 true,
2963 true,
2964 true,
2965 true,
2966 false,
2967 false,
2968 false,
2969 true,
2970 true,
2971 false,
2972 true,
2973 true,
2974 true,
2975 true,
2976 false,
2977 true,
2978 true,
2979 true,
2980 true,
2981 true,
2982 true,
2983 false,
2984 true,
2985 true,
2986 true,
2987 true,
2988 true,
2989 true,
2990 false,
2991 false,
2992 false,
2993 true,
2994 true,
2995 true,
2996 true,
2997 true,
2998 true,
2999 true,
3000 false,
3001 false,
3002 false,
3003 false,
3004 false,
3005 true,
3006 true,
3007 true,
3008 false,
3009 false,
3010 false,
3011 false,
3012 false,
3013 true,
3014 false,
3015 false,
3016 false,
3017 false,
3018 true,
3019 true,
3020 false,
3021 true,
3022 false,
3023 });
3024
3025 Vector128Bool vec = zig_ret_vector_128_bool();
3026 assert_or_panic(vec[0] == true);
3027 assert_or_panic(vec[1] == true);
3028 assert_or_panic(vec[2] == false);
3029 assert_or_panic(vec[3] == false);
3030 assert_or_panic(vec[4] == false);
3031 assert_or_panic(vec[5] == true);
3032 assert_or_panic(vec[6] == true);
3033 assert_or_panic(vec[7] == false);
3034 assert_or_panic(vec[8] == false);
3035 assert_or_panic(vec[9] == true);
3036 assert_or_panic(vec[10] == false);
3037 assert_or_panic(vec[11] == false);
3038 assert_or_panic(vec[12] == false);
3039 assert_or_panic(vec[13] == true);
3040 assert_or_panic(vec[14] == false);
3041 assert_or_panic(vec[15] == true);
3042 assert_or_panic(vec[16] == true);
3043 assert_or_panic(vec[17] == false);
3044 assert_or_panic(vec[18] == false);
3045 assert_or_panic(vec[19] == true);
3046 assert_or_panic(vec[20] == true);
3047 assert_or_panic(vec[21] == true);
3048 assert_or_panic(vec[22] == true);
3049 assert_or_panic(vec[23] == true);
3050 assert_or_panic(vec[24] == false);
3051 assert_or_panic(vec[25] == false);
3052 assert_or_panic(vec[26] == true);
3053 assert_or_panic(vec[27] == true);
3054 assert_or_panic(vec[28] == true);
3055 assert_or_panic(vec[29] == false);
3056 assert_or_panic(vec[30] == false);
3057 assert_or_panic(vec[31] == true);
3058 assert_or_panic(vec[32] == true);
3059 assert_or_panic(vec[33] == false);
3060 assert_or_panic(vec[34] == true);
3061 assert_or_panic(vec[35] == true);
3062 assert_or_panic(vec[36] == true);
3063 assert_or_panic(vec[37] == false);
3064 assert_or_panic(vec[38] == true);
3065 assert_or_panic(vec[39] == true);
3066 assert_or_panic(vec[40] == true);
3067 assert_or_panic(vec[41] == false);
3068 assert_or_panic(vec[42] == true);
3069 assert_or_panic(vec[43] == true);
3070 assert_or_panic(vec[44] == false);
3071 assert_or_panic(vec[45] == false);
3072 assert_or_panic(vec[46] == false);
3073 assert_or_panic(vec[47] == true);
3074 assert_or_panic(vec[48] == false);
3075 assert_or_panic(vec[49] == false);
3076 assert_or_panic(vec[50] == false);
3077 assert_or_panic(vec[51] == false);
3078 assert_or_panic(vec[52] == true);
3079 assert_or_panic(vec[53] == false);
3080 assert_or_panic(vec[54] == true);
3081 assert_or_panic(vec[55] == false);
3082 assert_or_panic(vec[56] == true);
3083 assert_or_panic(vec[57] == false);
3084 assert_or_panic(vec[58] == false);
3085 assert_or_panic(vec[59] == true);
3086 assert_or_panic(vec[60] == true);
3087 assert_or_panic(vec[61] == true);
3088 assert_or_panic(vec[62] == true);
3089 assert_or_panic(vec[63] == true);
3090 assert_or_panic(vec[64] == false);
3091 assert_or_panic(vec[65] == false);
3092 assert_or_panic(vec[66] == false);
3093 assert_or_panic(vec[67] == true);
3094 assert_or_panic(vec[68] == true);
3095 assert_or_panic(vec[69] == false);
3096 assert_or_panic(vec[70] == true);
3097 assert_or_panic(vec[71] == true);
3098 assert_or_panic(vec[72] == false);
3099 assert_or_panic(vec[73] == true);
3100 assert_or_panic(vec[74] == true);
3101 assert_or_panic(vec[75] == false);
3102 assert_or_panic(vec[76] == false);
3103 assert_or_panic(vec[77] == true);
3104 assert_or_panic(vec[78] == false);
3105 assert_or_panic(vec[79] == true);
3106 assert_or_panic(vec[80] == false);
3107 assert_or_panic(vec[81] == false);
3108 assert_or_panic(vec[82] == true);
3109 assert_or_panic(vec[83] == true);
3110 assert_or_panic(vec[84] == false);
3111 assert_or_panic(vec[85] == true);
3112 assert_or_panic(vec[86] == false);
3113 assert_or_panic(vec[87] == false);
3114 assert_or_panic(vec[88] == true);
3115 assert_or_panic(vec[89] == true);
3116 assert_or_panic(vec[90] == true);
3117 assert_or_panic(vec[91] == true);
3118 assert_or_panic(vec[92] == true);
3119 assert_or_panic(vec[93] == false);
3120 assert_or_panic(vec[94] == false);
3121 assert_or_panic(vec[95] == true);
3122 assert_or_panic(vec[96] == false);
3123 assert_or_panic(vec[97] == false);
3124 assert_or_panic(vec[98] == true);
3125 assert_or_panic(vec[99] == true);
3126 assert_or_panic(vec[100] == true);
3127 assert_or_panic(vec[101] == true);
3128 assert_or_panic(vec[102] == true);
3129 assert_or_panic(vec[103] == true);
3130 assert_or_panic(vec[104] == true);
3131 assert_or_panic(vec[105] == false);
3132 assert_or_panic(vec[106] == false);
3133 assert_or_panic(vec[107] == true);
3134 assert_or_panic(vec[108] == false);
3135 assert_or_panic(vec[109] == false);
3136 assert_or_panic(vec[110] == true);
3137 assert_or_panic(vec[111] == false);
3138 assert_or_panic(vec[112] == false);
3139 assert_or_panic(vec[113] == true);
3140 assert_or_panic(vec[114] == false);
3141 assert_or_panic(vec[115] == false);
3142 assert_or_panic(vec[116] == false);
3143 assert_or_panic(vec[117] == false);
3144 assert_or_panic(vec[118] == false);
3145 assert_or_panic(vec[119] == false);
3146 assert_or_panic(vec[120] == true);
3147 assert_or_panic(vec[121] == true);
3148 assert_or_panic(vec[122] == true);
3149 assert_or_panic(vec[123] == false);
3150 assert_or_panic(vec[124] == true);
3151 assert_or_panic(vec[125] == false);
3152 assert_or_panic(vec[126] == false);
3153 assert_or_panic(vec[127] == true);
3154 }
3155 {
3156 zig_vector_256_bool((Vector256Bool){
3157 false,
3158 false,
3159 false,
3160 false,
3161 true,
3162 true,
3163 false,
3164 false,
3165 false,
3166 true,
3167 true,
3168 false,
3169 true,
3170 false,
3171 false,
3172 false,
3173 false,
3174 true,
3175 true,
3176 true,
3177 false,
3178 true,
3179 true,
3180 false,
3181 true,
3182 false,
3183 false,
3184 true,
3185 true,
3186 true,
3187 false,
3188 true,
3189 false,
3190 true,
3191 false,
3192 false,
3193 false,
3194 true,
3195 false,
3196 false,
3197 true,
3198 true,
3199 false,
3200 true,
3201 true,
3202 false,
3203 true,
3204 false,
3205 true,
3206 false,
3207 true,
3208 false,
3209 true,
3210 true,
3211 true,
3212 false,
3213 false,
3214 true,
3215 true,
3216 false,
3217 false,
3218 true,
3219 true,
3220 false,
3221 false,
3222 false,
3223 true,
3224 true,
3225 false,
3226 true,
3227 false,
3228 true,
3229 false,
3230 true,
3231 false,
3232 false,
3233 true,
3234 false,
3235 false,
3236 false,
3237 false,
3238 false,
3239 true,
3240 false,
3241 false,
3242 false,
3243 true,
3244 true,
3245 true,
3246 false,
3247 true,
3248 false,
3249 true,
3250 false,
3251 true,
3252 true,
3253 true,
3254 true,
3255 false,
3256 true,
3257 false,
3258 true,
3259 true,
3260 false,
3261 false,
3262 true,
3263 false,
3264 true,
3265 false,
3266 false,
3267 false,
3268 false,
3269 false,
3270 false,
3271 false,
3272 false,
3273 false,
3274 false,
3275 false,
3276 false,
3277 false,
3278 false,
3279 true,
3280 true,
3281 false,
3282 false,
3283 false,
3284 true,
3285 true,
3286 true,
3287 true,
3288 false,
3289 false,
3290 false,
3291 true,
3292 true,
3293 false,
3294 false,
3295 true,
3296 true,
3297 true,
3298 true,
3299 true,
3300 false,
3301 true,
3302 true,
3303 true,
3304 false,
3305 false,
3306 false,
3307 false,
3308 false,
3309 false,
3310 false,
3311 true,
3312 false,
3313 false,
3314 false,
3315 true,
3316 true,
3317 false,
3318 true,
3319 false,
3320 false,
3321 false,
3322 true,
3323 false,
3324 true,
3325 false,
3326 false,
3327 false,
3328 false,
3329 true,
3330 true,
3331 true,
3332 true,
3333 true,
3334 true,
3335 false,
3336 true,
3337 true,
3338 false,
3339 true,
3340 false,
3341 true,
3342 false,
3343 true,
3344 false,
3345 true,
3346 false,
3347 false,
3348 false,
3349 false,
3350 true,
3351 true,
3352 true,
3353 false,
3354 false,
3355 true,
3356 false,
3357 false,
3358 true,
3359 true,
3360 false,
3361 true,
3362 false,
3363 true,
3364 false,
3365 false,
3366 false,
3367 true,
3368 true,
3369 false,
3370 false,
3371 false,
3372 true,
3373 false,
3374 true,
3375 true,
3376 true,
3377 false,
3378 true,
3379 false,
3380 true,
3381 false,
3382 false,
3383 false,
3384 true,
3385 true,
3386 false,
3387 false,
3388 false,
3389 false,
3390 false,
3391 true,
3392 false,
3393 false,
3394 false,
3395 true,
3396 false,
3397 true,
3398 true,
3399 true,
3400 false,
3401 false,
3402 true,
3403 false,
3404 false,
3405 false,
3406 true,
3407 false,
3408 false,
3409 true,
3410 true,
3411 true,
3412 true,
3413 });
3414
3415 Vector256Bool vec = zig_ret_vector_256_bool();
3416 assert_or_panic(vec[0] == true);
3417 assert_or_panic(vec[1] == true);
3418 assert_or_panic(vec[2] == true);
3419 assert_or_panic(vec[3] == false);
3420 assert_or_panic(vec[4] == true);
3421 assert_or_panic(vec[5] == false);
3422 assert_or_panic(vec[6] == false);
3423 assert_or_panic(vec[7] == true);
3424 assert_or_panic(vec[8] == false);
3425 assert_or_panic(vec[9] == false);
3426 assert_or_panic(vec[10] == false);
3427 assert_or_panic(vec[11] == false);
3428 assert_or_panic(vec[12] == false);
3429 assert_or_panic(vec[13] == false);
3430 assert_or_panic(vec[14] == false);
3431 assert_or_panic(vec[15] == false);
3432 assert_or_panic(vec[16] == true);
3433 assert_or_panic(vec[17] == false);
3434 assert_or_panic(vec[18] == true);
3435 assert_or_panic(vec[19] == false);
3436 assert_or_panic(vec[20] == false);
3437 assert_or_panic(vec[21] == true);
3438 assert_or_panic(vec[22] == true);
3439 assert_or_panic(vec[23] == false);
3440 assert_or_panic(vec[24] == false);
3441 assert_or_panic(vec[25] == true);
3442 assert_or_panic(vec[26] == true);
3443 assert_or_panic(vec[27] == false);
3444 assert_or_panic(vec[28] == true);
3445 assert_or_panic(vec[29] == true);
3446 assert_or_panic(vec[30] == true);
3447 assert_or_panic(vec[31] == false);
3448 assert_or_panic(vec[32] == true);
3449 assert_or_panic(vec[33] == false);
3450 assert_or_panic(vec[34] == true);
3451 assert_or_panic(vec[35] == false);
3452 assert_or_panic(vec[36] == true);
3453 assert_or_panic(vec[37] == false);
3454 assert_or_panic(vec[38] == true);
3455 assert_or_panic(vec[39] == false);
3456 assert_or_panic(vec[40] == false);
3457 assert_or_panic(vec[41] == false);
3458 assert_or_panic(vec[42] == true);
3459 assert_or_panic(vec[43] == true);
3460 assert_or_panic(vec[44] == true);
3461 assert_or_panic(vec[45] == false);
3462 assert_or_panic(vec[46] == false);
3463 assert_or_panic(vec[47] == false);
3464 assert_or_panic(vec[48] == true);
3465 assert_or_panic(vec[49] == false);
3466 assert_or_panic(vec[50] == true);
3467 assert_or_panic(vec[51] == false);
3468 assert_or_panic(vec[52] == true);
3469 assert_or_panic(vec[53] == false);
3470 assert_or_panic(vec[54] == true);
3471 assert_or_panic(vec[55] == true);
3472 assert_or_panic(vec[56] == false);
3473 assert_or_panic(vec[57] == false);
3474 assert_or_panic(vec[58] == false);
3475 assert_or_panic(vec[59] == true);
3476 assert_or_panic(vec[60] == true);
3477 assert_or_panic(vec[61] == true);
3478 assert_or_panic(vec[62] == false);
3479 assert_or_panic(vec[63] == true);
3480 assert_or_panic(vec[64] == false);
3481 assert_or_panic(vec[65] == true);
3482 assert_or_panic(vec[66] == false);
3483 assert_or_panic(vec[67] == true);
3484 assert_or_panic(vec[68] == true);
3485 assert_or_panic(vec[69] == false);
3486 assert_or_panic(vec[70] == true);
3487 assert_or_panic(vec[71] == false);
3488 assert_or_panic(vec[72] == true);
3489 assert_or_panic(vec[73] == true);
3490 assert_or_panic(vec[74] == false);
3491 assert_or_panic(vec[75] == false);
3492 assert_or_panic(vec[76] == false);
3493 assert_or_panic(vec[77] == false);
3494 assert_or_panic(vec[78] == false);
3495 assert_or_panic(vec[79] == false);
3496 assert_or_panic(vec[80] == false);
3497 assert_or_panic(vec[81] == false);
3498 assert_or_panic(vec[82] == false);
3499 assert_or_panic(vec[83] == true);
3500 assert_or_panic(vec[84] == false);
3501 assert_or_panic(vec[85] == false);
3502 assert_or_panic(vec[86] == false);
3503 assert_or_panic(vec[87] == true);
3504 assert_or_panic(vec[88] == false);
3505 assert_or_panic(vec[89] == true);
3506 assert_or_panic(vec[90] == true);
3507 assert_or_panic(vec[91] == false);
3508 assert_or_panic(vec[92] == false);
3509 assert_or_panic(vec[93] == true);
3510 assert_or_panic(vec[94] == true);
3511 assert_or_panic(vec[95] == false);
3512 assert_or_panic(vec[96] == false);
3513 assert_or_panic(vec[97] == true);
3514 assert_or_panic(vec[98] == false);
3515 assert_or_panic(vec[99] == false);
3516 assert_or_panic(vec[100] == false);
3517 assert_or_panic(vec[101] == false);
3518 assert_or_panic(vec[102] == false);
3519 assert_or_panic(vec[103] == false);
3520 assert_or_panic(vec[104] == false);
3521 assert_or_panic(vec[105] == true);
3522 assert_or_panic(vec[106] == true);
3523 assert_or_panic(vec[107] == false);
3524 assert_or_panic(vec[108] == true);
3525 assert_or_panic(vec[109] == false);
3526 assert_or_panic(vec[110] == true);
3527 assert_or_panic(vec[111] == true);
3528 assert_or_panic(vec[112] == false);
3529 assert_or_panic(vec[113] == false);
3530 assert_or_panic(vec[114] == false);
3531 assert_or_panic(vec[115] == false);
3532 assert_or_panic(vec[116] == false);
3533 assert_or_panic(vec[117] == false);
3534 assert_or_panic(vec[118] == false);
3535 assert_or_panic(vec[119] == true);
3536 assert_or_panic(vec[120] == true);
3537 assert_or_panic(vec[121] == true);
3538 assert_or_panic(vec[122] == false);
3539 assert_or_panic(vec[123] == true);
3540 assert_or_panic(vec[124] == true);
3541 assert_or_panic(vec[125] == false);
3542 assert_or_panic(vec[126] == false);
3543 assert_or_panic(vec[127] == true);
3544 assert_or_panic(vec[128] == true);
3545 assert_or_panic(vec[129] == true);
3546 assert_or_panic(vec[130] == true);
3547 assert_or_panic(vec[131] == true);
3548 assert_or_panic(vec[132] == false);
3549 assert_or_panic(vec[133] == true);
3550 assert_or_panic(vec[134] == true);
3551 assert_or_panic(vec[135] == false);
3552 assert_or_panic(vec[136] == false);
3553 assert_or_panic(vec[137] == true);
3554 assert_or_panic(vec[138] == true);
3555 assert_or_panic(vec[139] == false);
3556 assert_or_panic(vec[140] == true);
3557 assert_or_panic(vec[141] == false);
3558 assert_or_panic(vec[142] == true);
3559 assert_or_panic(vec[143] == false);
3560 assert_or_panic(vec[144] == true);
3561 assert_or_panic(vec[145] == true);
3562 assert_or_panic(vec[146] == true);
3563 assert_or_panic(vec[147] == true);
3564 assert_or_panic(vec[148] == false);
3565 assert_or_panic(vec[149] == false);
3566 assert_or_panic(vec[150] == false);
3567 assert_or_panic(vec[151] == true);
3568 assert_or_panic(vec[152] == false);
3569 assert_or_panic(vec[153] == true);
3570 assert_or_panic(vec[154] == false);
3571 assert_or_panic(vec[155] == true);
3572 assert_or_panic(vec[156] == true);
3573 assert_or_panic(vec[157] == false);
3574 assert_or_panic(vec[158] == true);
3575 assert_or_panic(vec[159] == true);
3576 assert_or_panic(vec[160] == true);
3577 assert_or_panic(vec[161] == true);
3578 assert_or_panic(vec[162] == true);
3579 assert_or_panic(vec[163] == false);
3580 assert_or_panic(vec[164] == false);
3581 assert_or_panic(vec[165] == true);
3582 assert_or_panic(vec[166] == false);
3583 assert_or_panic(vec[167] == true);
3584 assert_or_panic(vec[168] == true);
3585 assert_or_panic(vec[169] == true);
3586 assert_or_panic(vec[170] == true);
3587 assert_or_panic(vec[171] == false);
3588 assert_or_panic(vec[172] == true);
3589 assert_or_panic(vec[173] == true);
3590 assert_or_panic(vec[174] == true);
3591 assert_or_panic(vec[175] == true);
3592 assert_or_panic(vec[176] == true);
3593 assert_or_panic(vec[177] == true);
3594 assert_or_panic(vec[178] == true);
3595 assert_or_panic(vec[179] == false);
3596 assert_or_panic(vec[180] == true);
3597 assert_or_panic(vec[181] == false);
3598 assert_or_panic(vec[182] == false);
3599 assert_or_panic(vec[183] == false);
3600 assert_or_panic(vec[184] == true);
3601 assert_or_panic(vec[185] == false);
3602 assert_or_panic(vec[186] == true);
3603 assert_or_panic(vec[187] == true);
3604 assert_or_panic(vec[188] == false);
3605 assert_or_panic(vec[189] == true);
3606 assert_or_panic(vec[190] == false);
3607 assert_or_panic(vec[191] == true);
3608 assert_or_panic(vec[192] == false);
3609 assert_or_panic(vec[193] == true);
3610 assert_or_panic(vec[194] == false);
3611 assert_or_panic(vec[195] == false);
3612 assert_or_panic(vec[196] == true);
3613 assert_or_panic(vec[197] == true);
3614 assert_or_panic(vec[198] == true);
3615 assert_or_panic(vec[199] == true);
3616 assert_or_panic(vec[200] == true);
3617 assert_or_panic(vec[201] == true);
3618 assert_or_panic(vec[202] == true);
3619 assert_or_panic(vec[203] == false);
3620 assert_or_panic(vec[204] == true);
3621 assert_or_panic(vec[205] == false);
3622 assert_or_panic(vec[206] == false);
3623 assert_or_panic(vec[207] == true);
3624 assert_or_panic(vec[208] == true);
3625 assert_or_panic(vec[209] == false);
3626 assert_or_panic(vec[210] == false);
3627 assert_or_panic(vec[211] == false);
3628 assert_or_panic(vec[212] == true);
3629 assert_or_panic(vec[213] == true);
3630 assert_or_panic(vec[214] == true);
3631 assert_or_panic(vec[215] == false);
3632 assert_or_panic(vec[216] == false);
3633 assert_or_panic(vec[217] == true);
3634 assert_or_panic(vec[218] == true);
3635 assert_or_panic(vec[219] == true);
3636 assert_or_panic(vec[220] == true);
3637 assert_or_panic(vec[221] == false);
3638 assert_or_panic(vec[222] == true);
3639 assert_or_panic(vec[223] == false);
3640 assert_or_panic(vec[224] == true);
3641 assert_or_panic(vec[225] == true);
3642 assert_or_panic(vec[226] == true);
3643 assert_or_panic(vec[227] == false);
3644 assert_or_panic(vec[228] == false);
3645 assert_or_panic(vec[229] == false);
3646 assert_or_panic(vec[230] == false);
3647 assert_or_panic(vec[231] == false);
3648 assert_or_panic(vec[232] == true);
3649 assert_or_panic(vec[233] == true);
3650 assert_or_panic(vec[234] == false);
3651 assert_or_panic(vec[235] == false);
3652 assert_or_panic(vec[236] == false);
3653 assert_or_panic(vec[237] == true);
3654 assert_or_panic(vec[238] == true);
3655 assert_or_panic(vec[239] == false);
3656 assert_or_panic(vec[240] == true);
3657 assert_or_panic(vec[241] == true);
3658 assert_or_panic(vec[242] == true);
3659 assert_or_panic(vec[243] == false);
3660 assert_or_panic(vec[244] == true);
3661 assert_or_panic(vec[245] == true);
3662 assert_or_panic(vec[246] == false);
3663 assert_or_panic(vec[247] == true);
3664 assert_or_panic(vec[248] == false);
3665 assert_or_panic(vec[249] == false);
3666 assert_or_panic(vec[250] == true);
3667 assert_or_panic(vec[251] == true);
3668 assert_or_panic(vec[252] == false);
3669 assert_or_panic(vec[253] == true);
3670 assert_or_panic(vec[254] == false);
3671 assert_or_panic(vec[255] == true);
3672 }
3673 {
3674 zig_vector_512_bool((Vector512Bool){
3675 false,
3676 true,
3677 true,
3678 false,
3679 true,
3680 false,
3681 true,
3682 false,
3683 false,
3684 false,
3685 false,
3686 false,
3687 true,
3688 false,
3689 true,
3690 false,
3691 false,
3692 false,
3693 true,
3694 true,
3695 true,
3696 true,
3697 false,
3698 false,
3699 false,
3700 true,
3701 true,
3702 false,
3703 true,
3704 true,
3705 false,
3706 false,
3707 true,
3708 true,
3709 false,
3710 false,
3711 false,
3712 false,
3713 false,
3714 false,
3715 false,
3716 true,
3717 true,
3718 true,
3719 false,
3720 true,
3721 true,
3722 true,
3723 true,
3724 true,
3725 false,
3726 true,
3727 true,
3728 true,
3729 false,
3730 true,
3731 false,
3732 false,
3733 true,
3734 false,
3735 true,
3736 true,
3737 false,
3738 false,
3739 false,
3740 true,
3741 true,
3742 true,
3743 true,
3744 false,
3745 false,
3746 true,
3747 true,
3748 false,
3749 true,
3750 true,
3751 false,
3752 false,
3753 true,
3754 false,
3755 false,
3756 false,
3757 true,
3758 true,
3759 true,
3760 false,
3761 false,
3762 true,
3763 false,
3764 true,
3765 false,
3766 false,
3767 true,
3768 false,
3769 false,
3770 true,
3771 true,
3772 false,
3773 false,
3774 false,
3775 false,
3776 true,
3777 false,
3778 false,
3779 false,
3780 false,
3781 false,
3782 false,
3783 true,
3784 true,
3785 true,
3786 true,
3787 true,
3788 false,
3789 false,
3790 false,
3791 false,
3792 true,
3793 true,
3794 false,
3795 true,
3796 true,
3797 false,
3798 false,
3799 true,
3800 false,
3801 false,
3802 false,
3803 false,
3804 true,
3805 true,
3806 true,
3807 true,
3808 false,
3809 false,
3810 false,
3811 false,
3812 true,
3813 false,
3814 false,
3815 false,
3816 false,
3817 true,
3818 true,
3819 false,
3820 true,
3821 false,
3822 true,
3823 false,
3824 false,
3825 true,
3826 true,
3827 false,
3828 true,
3829 true,
3830 false,
3831 false,
3832 false,
3833 true,
3834 false,
3835 false,
3836 false,
3837 false,
3838 true,
3839 true,
3840 false,
3841 false,
3842 true,
3843 false,
3844 true,
3845 true,
3846 false,
3847 false,
3848 false,
3849 false,
3850 false,
3851 false,
3852 true,
3853 false,
3854 false,
3855 false,
3856 false,
3857 false,
3858 false,
3859 true,
3860 false,
3861 false,
3862 false,
3863 false,
3864 true,
3865 false,
3866 false,
3867 false,
3868 false,
3869 false,
3870 false,
3871 true,
3872 true,
3873 true,
3874 false,
3875 true,
3876 true,
3877 false,
3878 false,
3879 false,
3880 false,
3881 false,
3882 true,
3883 true,
3884 false,
3885 false,
3886 false,
3887 true,
3888 false,
3889 false,
3890 true,
3891 true,
3892 true,
3893 false,
3894 false,
3895 true,
3896 false,
3897 true,
3898 true,
3899 true,
3900 true,
3901 false,
3902 true,
3903 false,
3904 false,
3905 false,
3906 true,
3907 false,
3908 false,
3909 false,
3910 false,
3911 false,
3912 false,
3913 false,
3914 true,
3915 false,
3916 false,
3917 false,
3918 true,
3919 true,
3920 true,
3921 true,
3922 false,
3923 true,
3924 true,
3925 false,
3926 false,
3927 false,
3928 true,
3929 false,
3930 false,
3931 true,
3932 true,
3933 false,
3934 true,
3935 false,
3936 true,
3937 true,
3938 false,
3939 false,
3940 false,
3941 false,
3942 true,
3943 false,
3944 true,
3945 true,
3946 false,
3947 false,
3948 true,
3949 true,
3950 true,
3951 false,
3952 true,
3953 false,
3954 false,
3955 true,
3956 true,
3957 false,
3958 true,
3959 false,
3960 true,
3961 true,
3962 true,
3963 true,
3964 true,
3965 true,
3966 true,
3967 true,
3968 true,
3969 true,
3970 false,
3971 true,
3972 false,
3973 true,
3974 false,
3975 true,
3976 true,
3977 false,
3978 true,
3979 false,
3980 true,
3981 false,
3982 true,
3983 true,
3984 false,
3985 true,
3986 true,
3987 true,
3988 false,
3989 false,
3990 false,
3991 false,
3992 true,
3993 true,
3994 true,
3995 true,
3996 true,
3997 true,
3998 true,
3999 true,
4000 true,
4001 false,
4002 true,
4003 false,
4004 false,
4005 true,
4006 false,
4007 false,
4008 false,
4009 false,
4010 false,
4011 false,
4012 false,
4013 false,
4014 false,
4015 false,
4016 false,
4017 true,
4018 true,
4019 false,
4020 false,
4021 false,
4022 false,
4023 false,
4024 true,
4025 true,
4026 true,
4027 true,
4028 false,
4029 false,
4030 false,
4031 false,
4032 true,
4033 true,
4034 false,
4035 false,
4036 false,
4037 true,
4038 true,
4039 false,
4040 false,
4041 false,
4042 false,
4043 false,
4044 true,
4045 true,
4046 false,
4047 true,
4048 true,
4049 false,
4050 true,
4051 true,
4052 false,
4053 true,
4054 true,
4055 false,
4056 true,
4057 true,
4058 false,
4059 true,
4060 false,
4061 true,
4062 true,
4063 true,
4064 true,
4065 false,
4066 false,
4067 false,
4068 true,
4069 true,
4070 true,
4071 true,
4072 false,
4073 true,
4074 true,
4075 true,
4076 false,
4077 false,
4078 true,
4079 false,
4080 false,
4081 false,
4082 true,
4083 true,
4084 true,
4085 false,
4086 true,
4087 false,
4088 false,
4089 false,
4090 true,
4091 false,
4092 false,
4093 true,
4094 true,
4095 true,
4096 true,
4097 false,
4098 true,
4099 true,
4100 false,
4101 false,
4102 false,
4103 true,
4104 false,
4105 true,
4106 true,
4107 false,
4108 false,
4109 false,
4110 false,
4111 true,
4112 false,
4113 true,
4114 false,
4115 false,
4116 false,
4117 false,
4118 true,
4119 false,
4120 false,
4121 true,
4122 true,
4123 true,
4124 false,
4125 true,
4126 true,
4127 false,
4128 true,
4129 false,
4130 true,
4131 false,
4132 false,
4133 false,
4134 true,
4135 false,
4136 false,
4137 false,
4138 true,
4139 true,
4140 true,
4141 true,
4142 true,
4143 false,
4144 false,
4145 false,
4146 false,
4147 false,
4148 false,
4149 true,
4150 true,
4151 true,
4152 true,
4153 true,
4154 false,
4155 true,
4156 true,
4157 false,
4158 true,
4159 false,
4160 true,
4161 false,
4162 true,
4163 false,
4164 false,
4165 false,
4166 true,
4167 false,
4168 false,
4169 false,
4170 true,
4171 true,
4172 false,
4173 false,
4174 true,
4175 false,
4176 true,
4177 false,
4178 false,
4179 false,
4180 true,
4181 true,
4182 true,
4183 true,
4184 false,
4185 false,
4186 true,
4187 });
4188
4189 Vector512Bool vec = zig_ret_vector_512_bool();
4190 assert_or_panic(vec[0] == true);
4191 assert_or_panic(vec[1] == true);
4192 assert_or_panic(vec[2] == true);
4193 assert_or_panic(vec[3] == true);
4194 assert_or_panic(vec[4] == false);
4195 assert_or_panic(vec[5] == true);
4196 assert_or_panic(vec[6] == false);
4197 assert_or_panic(vec[7] == true);
4198 assert_or_panic(vec[8] == true);
4199 assert_or_panic(vec[9] == true);
4200 assert_or_panic(vec[10] == false);
4201 assert_or_panic(vec[11] == true);
4202 assert_or_panic(vec[12] == false);
4203 assert_or_panic(vec[13] == false);
4204 assert_or_panic(vec[14] == false);
4205 assert_or_panic(vec[15] == true);
4206 assert_or_panic(vec[16] == true);
4207 assert_or_panic(vec[17] == false);
4208 assert_or_panic(vec[18] == false);
4209 assert_or_panic(vec[19] == false);
4210 assert_or_panic(vec[20] == true);
4211 assert_or_panic(vec[21] == true);
4212 assert_or_panic(vec[22] == false);
4213 assert_or_panic(vec[23] == false);
4214 assert_or_panic(vec[24] == false);
4215 assert_or_panic(vec[25] == false);
4216 assert_or_panic(vec[26] == true);
4217 assert_or_panic(vec[27] == false);
4218 assert_or_panic(vec[28] == false);
4219 assert_or_panic(vec[29] == false);
4220 assert_or_panic(vec[30] == true);
4221 assert_or_panic(vec[31] == true);
4222 assert_or_panic(vec[32] == true);
4223 assert_or_panic(vec[33] == true);
4224 assert_or_panic(vec[34] == false);
4225 assert_or_panic(vec[35] == false);
4226 assert_or_panic(vec[36] == false);
4227 assert_or_panic(vec[37] == true);
4228 assert_or_panic(vec[38] == true);
4229 assert_or_panic(vec[39] == true);
4230 assert_or_panic(vec[40] == false);
4231 assert_or_panic(vec[41] == false);
4232 assert_or_panic(vec[42] == true);
4233 assert_or_panic(vec[43] == false);
4234 assert_or_panic(vec[44] == false);
4235 assert_or_panic(vec[45] == true);
4236 assert_or_panic(vec[46] == false);
4237 assert_or_panic(vec[47] == false);
4238 assert_or_panic(vec[48] == true);
4239 assert_or_panic(vec[49] == true);
4240 assert_or_panic(vec[50] == true);
4241 assert_or_panic(vec[51] == true);
4242 assert_or_panic(vec[52] == false);
4243 assert_or_panic(vec[53] == false);
4244 assert_or_panic(vec[54] == false);
4245 assert_or_panic(vec[55] == true);
4246 assert_or_panic(vec[56] == false);
4247 assert_or_panic(vec[57] == true);
4248 assert_or_panic(vec[58] == false);
4249 assert_or_panic(vec[59] == true);
4250 assert_or_panic(vec[60] == true);
4251 assert_or_panic(vec[61] == false);
4252 assert_or_panic(vec[62] == false);
4253 assert_or_panic(vec[63] == true);
4254 assert_or_panic(vec[64] == true);
4255 assert_or_panic(vec[65] == false);
4256 assert_or_panic(vec[66] == true);
4257 assert_or_panic(vec[67] == false);
4258 assert_or_panic(vec[68] == false);
4259 assert_or_panic(vec[69] == false);
4260 assert_or_panic(vec[70] == true);
4261 assert_or_panic(vec[71] == true);
4262 assert_or_panic(vec[72] == true);
4263 assert_or_panic(vec[73] == true);
4264 assert_or_panic(vec[74] == true);
4265 assert_or_panic(vec[75] == false);
4266 assert_or_panic(vec[76] == true);
4267 assert_or_panic(vec[77] == false);
4268 assert_or_panic(vec[78] == true);
4269 assert_or_panic(vec[79] == true);
4270 assert_or_panic(vec[80] == true);
4271 assert_or_panic(vec[81] == true);
4272 assert_or_panic(vec[82] == true);
4273 assert_or_panic(vec[83] == false);
4274 assert_or_panic(vec[84] == true);
4275 assert_or_panic(vec[85] == true);
4276 assert_or_panic(vec[86] == false);
4277 assert_or_panic(vec[87] == true);
4278 assert_or_panic(vec[88] == false);
4279 assert_or_panic(vec[89] == false);
4280 assert_or_panic(vec[90] == true);
4281 assert_or_panic(vec[91] == false);
4282 assert_or_panic(vec[92] == true);
4283 assert_or_panic(vec[93] == false);
4284 assert_or_panic(vec[94] == false);
4285 assert_or_panic(vec[95] == false);
4286 assert_or_panic(vec[96] == true);
4287 assert_or_panic(vec[97] == true);
4288 assert_or_panic(vec[98] == false);
4289 assert_or_panic(vec[99] == true);
4290 assert_or_panic(vec[100] == true);
4291 assert_or_panic(vec[101] == false);
4292 assert_or_panic(vec[102] == true);
4293 assert_or_panic(vec[103] == false);
4294 assert_or_panic(vec[104] == true);
4295 assert_or_panic(vec[105] == false);
4296 assert_or_panic(vec[106] == true);
4297 assert_or_panic(vec[107] == false);
4298 assert_or_panic(vec[108] == false);
4299 assert_or_panic(vec[109] == true);
4300 assert_or_panic(vec[110] == false);
4301 assert_or_panic(vec[111] == false);
4302 assert_or_panic(vec[112] == true);
4303 assert_or_panic(vec[113] == false);
4304 assert_or_panic(vec[114] == true);
4305 assert_or_panic(vec[115] == false);
4306 assert_or_panic(vec[116] == true);
4307 assert_or_panic(vec[117] == false);
4308 assert_or_panic(vec[118] == false);
4309 assert_or_panic(vec[119] == true);
4310 assert_or_panic(vec[120] == true);
4311 assert_or_panic(vec[121] == true);
4312 assert_or_panic(vec[122] == false);
4313 assert_or_panic(vec[123] == true);
4314 assert_or_panic(vec[124] == false);
4315 assert_or_panic(vec[125] == false);
4316 assert_or_panic(vec[126] == true);
4317 assert_or_panic(vec[127] == true);
4318 assert_or_panic(vec[128] == false);
4319 assert_or_panic(vec[129] == true);
4320 assert_or_panic(vec[130] == true);
4321 assert_or_panic(vec[131] == false);
4322 assert_or_panic(vec[132] == true);
4323 assert_or_panic(vec[133] == true);
4324 assert_or_panic(vec[134] == false);
4325 assert_or_panic(vec[135] == true);
4326 assert_or_panic(vec[136] == true);
4327 assert_or_panic(vec[137] == false);
4328 assert_or_panic(vec[138] == false);
4329 assert_or_panic(vec[139] == false);
4330 assert_or_panic(vec[140] == true);
4331 assert_or_panic(vec[141] == false);
4332 assert_or_panic(vec[142] == true);
4333 assert_or_panic(vec[143] == false);
4334 assert_or_panic(vec[144] == false);
4335 assert_or_panic(vec[145] == false);
4336 assert_or_panic(vec[146] == true);
4337 assert_or_panic(vec[147] == false);
4338 assert_or_panic(vec[148] == true);
4339 assert_or_panic(vec[149] == false);
4340 assert_or_panic(vec[150] == false);
4341 assert_or_panic(vec[151] == true);
4342 assert_or_panic(vec[152] == false);
4343 assert_or_panic(vec[153] == true);
4344 assert_or_panic(vec[154] == true);
4345 assert_or_panic(vec[155] == false);
4346 assert_or_panic(vec[156] == true);
4347 assert_or_panic(vec[157] == true);
4348 assert_or_panic(vec[158] == false);
4349 assert_or_panic(vec[159] == true);
4350 assert_or_panic(vec[160] == true);
4351 assert_or_panic(vec[161] == false);
4352 assert_or_panic(vec[162] == false);
4353 assert_or_panic(vec[163] == false);
4354 assert_or_panic(vec[164] == true);
4355 assert_or_panic(vec[165] == false);
4356 assert_or_panic(vec[166] == true);
4357 assert_or_panic(vec[167] == true);
4358 assert_or_panic(vec[168] == true);
4359 assert_or_panic(vec[169] == true);
4360 assert_or_panic(vec[170] == false);
4361 assert_or_panic(vec[171] == true);
4362 assert_or_panic(vec[172] == false);
4363 assert_or_panic(vec[173] == false);
4364 assert_or_panic(vec[174] == true);
4365 assert_or_panic(vec[175] == true);
4366 assert_or_panic(vec[176] == true);
4367 assert_or_panic(vec[177] == false);
4368 assert_or_panic(vec[178] == false);
4369 assert_or_panic(vec[179] == false);
4370 assert_or_panic(vec[180] == true);
4371 assert_or_panic(vec[181] == false);
4372 assert_or_panic(vec[182] == false);
4373 assert_or_panic(vec[183] == true);
4374 assert_or_panic(vec[184] == true);
4375 assert_or_panic(vec[185] == false);
4376 assert_or_panic(vec[186] == true);
4377 assert_or_panic(vec[187] == false);
4378 assert_or_panic(vec[188] == true);
4379 assert_or_panic(vec[189] == true);
4380 assert_or_panic(vec[190] == true);
4381 assert_or_panic(vec[191] == true);
4382 assert_or_panic(vec[192] == true);
4383 assert_or_panic(vec[193] == true);
4384 assert_or_panic(vec[194] == true);
4385 assert_or_panic(vec[195] == false);
4386 assert_or_panic(vec[196] == false);
4387 assert_or_panic(vec[197] == false);
4388 assert_or_panic(vec[198] == false);
4389 assert_or_panic(vec[199] == false);
4390 assert_or_panic(vec[200] == true);
4391 assert_or_panic(vec[201] == false);
4392 assert_or_panic(vec[202] == true);
4393 assert_or_panic(vec[203] == false);
4394 assert_or_panic(vec[204] == true);
4395 assert_or_panic(vec[205] == true);
4396 assert_or_panic(vec[206] == false);
4397 assert_or_panic(vec[207] == false);
4398 assert_or_panic(vec[208] == false);
4399 assert_or_panic(vec[209] == true);
4400 assert_or_panic(vec[210] == true);
4401 assert_or_panic(vec[211] == true);
4402 assert_or_panic(vec[212] == false);
4403 assert_or_panic(vec[213] == false);
4404 assert_or_panic(vec[214] == true);
4405 assert_or_panic(vec[215] == true);
4406 assert_or_panic(vec[216] == true);
4407 assert_or_panic(vec[217] == false);
4408 assert_or_panic(vec[218] == false);
4409 assert_or_panic(vec[219] == true);
4410 assert_or_panic(vec[220] == false);
4411 assert_or_panic(vec[221] == true);
4412 assert_or_panic(vec[222] == true);
4413 assert_or_panic(vec[223] == false);
4414 assert_or_panic(vec[224] == true);
4415 assert_or_panic(vec[225] == false);
4416 assert_or_panic(vec[226] == false);
4417 assert_or_panic(vec[227] == true);
4418 assert_or_panic(vec[228] == false);
4419 assert_or_panic(vec[229] == false);
4420 assert_or_panic(vec[230] == true);
4421 assert_or_panic(vec[231] == true);
4422 assert_or_panic(vec[232] == false);
4423 assert_or_panic(vec[233] == true);
4424 assert_or_panic(vec[234] == true);
4425 assert_or_panic(vec[235] == true);
4426 assert_or_panic(vec[236] == true);
4427 assert_or_panic(vec[237] == true);
4428 assert_or_panic(vec[238] == false);
4429 assert_or_panic(vec[239] == true);
4430 assert_or_panic(vec[240] == false);
4431 assert_or_panic(vec[241] == false);
4432 assert_or_panic(vec[242] == true);
4433 assert_or_panic(vec[243] == false);
4434 assert_or_panic(vec[244] == true);
4435 assert_or_panic(vec[245] == false);
4436 assert_or_panic(vec[246] == true);
4437 assert_or_panic(vec[247] == false);
4438 assert_or_panic(vec[248] == true);
4439 assert_or_panic(vec[249] == true);
4440 assert_or_panic(vec[250] == true);
4441 assert_or_panic(vec[251] == true);
4442 assert_or_panic(vec[252] == true);
4443 assert_or_panic(vec[253] == false);
4444 assert_or_panic(vec[254] == false);
4445 assert_or_panic(vec[255] == false);
4446 assert_or_panic(vec[256] == false);
4447 assert_or_panic(vec[257] == false);
4448 assert_or_panic(vec[258] == false);
4449 assert_or_panic(vec[259] == true);
4450 assert_or_panic(vec[260] == true);
4451 assert_or_panic(vec[261] == true);
4452 assert_or_panic(vec[262] == true);
4453 assert_or_panic(vec[263] == false);
4454 assert_or_panic(vec[264] == false);
4455 assert_or_panic(vec[265] == false);
4456 assert_or_panic(vec[266] == true);
4457 assert_or_panic(vec[267] == false);
4458 assert_or_panic(vec[268] == true);
4459 assert_or_panic(vec[269] == false);
4460 assert_or_panic(vec[270] == true);
4461 assert_or_panic(vec[271] == true);
4462 assert_or_panic(vec[272] == true);
4463 assert_or_panic(vec[273] == true);
4464 assert_or_panic(vec[274] == true);
4465 assert_or_panic(vec[275] == true);
4466 assert_or_panic(vec[276] == false);
4467 assert_or_panic(vec[277] == false);
4468 assert_or_panic(vec[278] == true);
4469 assert_or_panic(vec[279] == true);
4470 assert_or_panic(vec[280] == false);
4471 assert_or_panic(vec[281] == false);
4472 assert_or_panic(vec[282] == false);
4473 assert_or_panic(vec[283] == false);
4474 assert_or_panic(vec[284] == true);
4475 assert_or_panic(vec[285] == true);
4476 assert_or_panic(vec[286] == true);
4477 assert_or_panic(vec[287] == false);
4478 assert_or_panic(vec[288] == false);
4479 assert_or_panic(vec[289] == false);
4480 assert_or_panic(vec[290] == true);
4481 assert_or_panic(vec[291] == false);
4482 assert_or_panic(vec[292] == true);
4483 assert_or_panic(vec[293] == true);
4484 assert_or_panic(vec[294] == false);
4485 assert_or_panic(vec[295] == true);
4486 assert_or_panic(vec[296] == true);
4487 assert_or_panic(vec[297] == true);
4488 assert_or_panic(vec[298] == false);
4489 assert_or_panic(vec[299] == true);
4490 assert_or_panic(vec[300] == true);
4491 assert_or_panic(vec[301] == false);
4492 assert_or_panic(vec[302] == false);
4493 assert_or_panic(vec[303] == true);
4494 assert_or_panic(vec[304] == false);
4495 assert_or_panic(vec[305] == false);
4496 assert_or_panic(vec[306] == true);
4497 assert_or_panic(vec[307] == true);
4498 assert_or_panic(vec[308] == true);
4499 assert_or_panic(vec[309] == true);
4500 assert_or_panic(vec[310] == false);
4501 assert_or_panic(vec[311] == false);
4502 assert_or_panic(vec[312] == false);
4503 assert_or_panic(vec[313] == false);
4504 assert_or_panic(vec[314] == false);
4505 assert_or_panic(vec[315] == true);
4506 assert_or_panic(vec[316] == false);
4507 assert_or_panic(vec[317] == false);
4508 assert_or_panic(vec[318] == true);
4509 assert_or_panic(vec[319] == false);
4510 assert_or_panic(vec[320] == false);
4511 assert_or_panic(vec[321] == true);
4512 assert_or_panic(vec[322] == true);
4513 assert_or_panic(vec[323] == true);
4514 assert_or_panic(vec[324] == true);
4515 assert_or_panic(vec[325] == false);
4516 assert_or_panic(vec[326] == false);
4517 assert_or_panic(vec[327] == false);
4518 assert_or_panic(vec[328] == true);
4519 assert_or_panic(vec[329] == true);
4520 assert_or_panic(vec[330] == false);
4521 assert_or_panic(vec[331] == true);
4522 assert_or_panic(vec[332] == true);
4523 assert_or_panic(vec[333] == false);
4524 assert_or_panic(vec[334] == false);
4525 assert_or_panic(vec[335] == true);
4526 assert_or_panic(vec[336] == true);
4527 assert_or_panic(vec[337] == false);
4528 assert_or_panic(vec[338] == true);
4529 assert_or_panic(vec[339] == true);
4530 assert_or_panic(vec[340] == true);
4531 assert_or_panic(vec[341] == false);
4532 assert_or_panic(vec[342] == false);
4533 assert_or_panic(vec[343] == false);
4534 assert_or_panic(vec[344] == true);
4535 assert_or_panic(vec[345] == true);
4536 assert_or_panic(vec[346] == false);
4537 assert_or_panic(vec[347] == true);
4538 assert_or_panic(vec[348] == false);
4539 assert_or_panic(vec[349] == true);
4540 assert_or_panic(vec[350] == false);
4541 assert_or_panic(vec[351] == false);
4542 assert_or_panic(vec[352] == true);
4543 assert_or_panic(vec[353] == false);
4544 assert_or_panic(vec[354] == true);
4545 assert_or_panic(vec[355] == false);
4546 assert_or_panic(vec[356] == false);
4547 assert_or_panic(vec[357] == false);
4548 assert_or_panic(vec[358] == false);
4549 assert_or_panic(vec[359] == false);
4550 assert_or_panic(vec[360] == true);
4551 assert_or_panic(vec[361] == true);
4552 assert_or_panic(vec[362] == false);
4553 assert_or_panic(vec[363] == false);
4554 assert_or_panic(vec[364] == false);
4555 assert_or_panic(vec[365] == false);
4556 assert_or_panic(vec[366] == true);
4557 assert_or_panic(vec[367] == false);
4558 assert_or_panic(vec[368] == true);
4559 assert_or_panic(vec[369] == false);
4560 assert_or_panic(vec[370] == true);
4561 assert_or_panic(vec[371] == true);
4562 assert_or_panic(vec[372] == false);
4563 assert_or_panic(vec[373] == true);
4564 assert_or_panic(vec[374] == true);
4565 assert_or_panic(vec[375] == true);
4566 assert_or_panic(vec[376] == true);
4567 assert_or_panic(vec[377] == true);
4568 assert_or_panic(vec[378] == false);
4569 assert_or_panic(vec[379] == true);
4570 assert_or_panic(vec[380] == false);
4571 assert_or_panic(vec[381] == true);
4572 assert_or_panic(vec[382] == true);
4573 assert_or_panic(vec[383] == true);
4574 assert_or_panic(vec[384] == true);
4575 assert_or_panic(vec[385] == true);
4576 assert_or_panic(vec[386] == false);
4577 assert_or_panic(vec[387] == true);
4578 assert_or_panic(vec[388] == true);
4579 assert_or_panic(vec[389] == false);
4580 assert_or_panic(vec[390] == true);
4581 assert_or_panic(vec[391] == false);
4582 assert_or_panic(vec[392] == true);
4583 assert_or_panic(vec[393] == false);
4584 assert_or_panic(vec[394] == true);
4585 assert_or_panic(vec[395] == false);
4586 assert_or_panic(vec[396] == true);
4587 assert_or_panic(vec[397] == false);
4588 assert_or_panic(vec[398] == false);
4589 assert_or_panic(vec[399] == true);
4590 assert_or_panic(vec[400] == true);
4591 assert_or_panic(vec[401] == true);
4592 assert_or_panic(vec[402] == true);
4593 assert_or_panic(vec[403] == false);
4594 assert_or_panic(vec[404] == false);
4595 assert_or_panic(vec[405] == true);
4596 assert_or_panic(vec[406] == false);
4597 assert_or_panic(vec[407] == false);
4598 assert_or_panic(vec[408] == false);
4599 assert_or_panic(vec[409] == true);
4600 assert_or_panic(vec[410] == false);
4601 assert_or_panic(vec[411] == true);
4602 assert_or_panic(vec[412] == true);
4603 assert_or_panic(vec[413] == false);
4604 assert_or_panic(vec[414] == true);
4605 assert_or_panic(vec[415] == true);
4606 assert_or_panic(vec[416] == false);
4607 assert_or_panic(vec[417] == true);
4608 assert_or_panic(vec[418] == true);
4609 assert_or_panic(vec[419] == false);
4610 assert_or_panic(vec[420] == false);
4611 assert_or_panic(vec[421] == true);
4612 assert_or_panic(vec[422] == false);
4613 assert_or_panic(vec[423] == false);
4614 assert_or_panic(vec[424] == true);
4615 assert_or_panic(vec[425] == false);
4616 assert_or_panic(vec[426] == true);
4617 assert_or_panic(vec[427] == false);
4618 assert_or_panic(vec[428] == false);
4619 assert_or_panic(vec[429] == true);
4620 assert_or_panic(vec[430] == false);
4621 assert_or_panic(vec[431] == true);
4622 assert_or_panic(vec[432] == true);
4623 assert_or_panic(vec[433] == false);
4624 assert_or_panic(vec[434] == true);
4625 assert_or_panic(vec[435] == false);
4626 assert_or_panic(vec[436] == true);
4627 assert_or_panic(vec[437] == false);
4628 assert_or_panic(vec[438] == true);
4629 assert_or_panic(vec[439] == false);
4630 assert_or_panic(vec[440] == false);
4631 assert_or_panic(vec[441] == true);
4632 assert_or_panic(vec[442] == true);
4633 assert_or_panic(vec[443] == false);
4634 assert_or_panic(vec[444] == true);
4635 assert_or_panic(vec[445] == true);
4636 assert_or_panic(vec[446] == false);
4637 assert_or_panic(vec[447] == true);
4638 assert_or_panic(vec[448] == true);
4639 assert_or_panic(vec[449] == false);
4640 assert_or_panic(vec[450] == false);
4641 assert_or_panic(vec[451] == false);
4642 assert_or_panic(vec[452] == false);
4643 assert_or_panic(vec[453] == false);
4644 assert_or_panic(vec[454] == true);
4645 assert_or_panic(vec[455] == false);
4646 assert_or_panic(vec[456] == false);
4647 assert_or_panic(vec[457] == true);
4648 assert_or_panic(vec[458] == false);
4649 assert_or_panic(vec[459] == true);
4650 assert_or_panic(vec[460] == false);
4651 assert_or_panic(vec[461] == false);
4652 assert_or_panic(vec[462] == false);
4653 assert_or_panic(vec[463] == true);
4654 assert_or_panic(vec[464] == false);
4655 assert_or_panic(vec[465] == true);
4656 assert_or_panic(vec[466] == false);
4657 assert_or_panic(vec[467] == false);
4658 assert_or_panic(vec[468] == false);
4659 assert_or_panic(vec[469] == false);
4660 assert_or_panic(vec[470] == true);
4661 assert_or_panic(vec[471] == true);
4662 assert_or_panic(vec[472] == false);
4663 assert_or_panic(vec[473] == true);
4664 assert_or_panic(vec[474] == true);
4665 assert_or_panic(vec[475] == false);
4666 assert_or_panic(vec[476] == false);
4667 assert_or_panic(vec[477] == true);
4668 assert_or_panic(vec[478] == true);
4669 assert_or_panic(vec[479] == true);
4670 assert_or_panic(vec[480] == false);
4671 assert_or_panic(vec[481] == false);
4672 assert_or_panic(vec[482] == true);
4673 assert_or_panic(vec[483] == false);
4674 assert_or_panic(vec[484] == false);
4675 assert_or_panic(vec[485] == false);
4676 assert_or_panic(vec[486] == true);
4677 assert_or_panic(vec[487] == true);
4678 assert_or_panic(vec[488] == false);
4679 assert_or_panic(vec[489] == false);
4680 assert_or_panic(vec[490] == false);
4681 assert_or_panic(vec[491] == false);
4682 assert_or_panic(vec[492] == false);
4683 assert_or_panic(vec[493] == true);
4684 assert_or_panic(vec[494] == true);
4685 assert_or_panic(vec[495] == true);
4686 assert_or_panic(vec[496] == true);
4687 assert_or_panic(vec[497] == false);
4688 assert_or_panic(vec[498] == false);
4689 assert_or_panic(vec[499] == false);
4690 assert_or_panic(vec[500] == true);
4691 assert_or_panic(vec[501] == false);
4692 assert_or_panic(vec[502] == true);
4693 assert_or_panic(vec[503] == true);
4694 assert_or_panic(vec[504] == true);
4695 assert_or_panic(vec[505] == true);
4696 assert_or_panic(vec[506] == false);
4697 assert_or_panic(vec[507] == false);
4698 assert_or_panic(vec[508] == true);
4699 assert_or_panic(vec[509] == true);
4700 assert_or_panic(vec[510] == false);
4701 assert_or_panic(vec[511] == false);
4702 }
4703#endif
4534704}
4544705
4554706void c_u8(uint8_t x) {
test/c_abi/main.zig+4258
......@@ -890,6 +890,4264 @@ test "big simd vector" {
890890 try expect(x[7] == 16);
891891}
892892
893const Vector2Bool = @Vector(2, bool);
894const Vector4Bool = @Vector(4, bool);
895const Vector8Bool = @Vector(8, bool);
896const Vector16Bool = @Vector(16, bool);
897const Vector32Bool = @Vector(32, bool);
898const Vector64Bool = @Vector(64, bool);
899const Vector128Bool = @Vector(128, bool);
900const Vector256Bool = @Vector(256, bool);
901const Vector512Bool = @Vector(512, bool);
902
903extern fn c_vector_2_bool(Vector2Bool) void;
904extern fn c_vector_4_bool(Vector4Bool) void;
905extern fn c_vector_8_bool(Vector8Bool) void;
906extern fn c_vector_16_bool(Vector16Bool) void;
907extern fn c_vector_32_bool(Vector32Bool) void;
908extern fn c_vector_64_bool(Vector64Bool) void;
909extern fn c_vector_128_bool(Vector128Bool) void;
910extern fn c_vector_256_bool(Vector256Bool) void;
911extern fn c_vector_512_bool(Vector512Bool) void;
912
913extern fn c_ret_vector_2_bool() Vector2Bool;
914extern fn c_ret_vector_4_bool() Vector4Bool;
915extern fn c_ret_vector_8_bool() Vector8Bool;
916extern fn c_ret_vector_16_bool() Vector16Bool;
917extern fn c_ret_vector_32_bool() Vector32Bool;
918extern fn c_ret_vector_64_bool() Vector64Bool;
919extern fn c_ret_vector_128_bool() Vector128Bool;
920extern fn c_ret_vector_256_bool() Vector256Bool;
921extern fn c_ret_vector_512_bool() Vector512Bool;
922
923test "bool simd vector" {
924 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch != .powerpc) return error.SkipZigTest;
925
926 {
927 c_vector_2_bool(.{
928 true,
929 true,
930 });
931
932 const vec = c_ret_vector_2_bool();
933 try expect(vec[0] == true);
934 try expect(vec[1] == false);
935 }
936 {
937 c_vector_4_bool(.{
938 true,
939 true,
940 false,
941 true,
942 });
943
944 const vec = c_ret_vector_4_bool();
945 try expect(vec[0] == true);
946 try expect(vec[1] == false);
947 try expect(vec[2] == true);
948 try expect(vec[3] == false);
949 }
950 {
951 c_vector_8_bool(.{
952 true,
953 false,
954 true,
955 true,
956 true,
957 true,
958 false,
959 true,
960 });
961
962 const vec = c_ret_vector_8_bool();
963 try expect(vec[0] == false);
964 try expect(vec[1] == true);
965 try expect(vec[2] == false);
966 try expect(vec[3] == false);
967 try expect(vec[4] == true);
968 try expect(vec[5] == false);
969 try expect(vec[6] == false);
970 try expect(vec[7] == true);
971 }
972 {
973 c_vector_16_bool(.{
974 true,
975 false,
976 false,
977 false,
978 true,
979 false,
980 true,
981 true,
982 true,
983 true,
984 true,
985 true,
986 false,
987 false,
988 false,
989 false,
990 });
991
992 const vec = c_ret_vector_16_bool();
993 try expect(vec[0] == true);
994 try expect(vec[1] == true);
995 try expect(vec[2] == false);
996 try expect(vec[3] == false);
997 try expect(vec[4] == false);
998 try expect(vec[5] == false);
999 try expect(vec[6] == true);
1000 try expect(vec[7] == false);
1001 try expect(vec[8] == true);
1002 try expect(vec[9] == false);
1003 try expect(vec[10] == false);
1004 try expect(vec[11] == true);
1005 try expect(vec[12] == true);
1006 try expect(vec[13] == false);
1007 try expect(vec[14] == true);
1008 try expect(vec[15] == true);
1009 }
1010 {
1011 c_vector_32_bool(.{
1012 true,
1013 false,
1014 true,
1015 true,
1016 false,
1017 false,
1018 true,
1019 false,
1020 true,
1021 false,
1022 true,
1023 true,
1024 true,
1025 false,
1026 false,
1027 true,
1028 false,
1029 true,
1030 false,
1031 true,
1032 true,
1033 true,
1034 true,
1035 true,
1036 false,
1037 true,
1038 true,
1039 true,
1040 false,
1041 true,
1042 true,
1043 false,
1044 });
1045
1046 const vec = c_ret_vector_32_bool();
1047 try expect(vec[0] == true);
1048 try expect(vec[1] == false);
1049 try expect(vec[2] == true);
1050 try expect(vec[3] == true);
1051 try expect(vec[4] == true);
1052 try expect(vec[5] == false);
1053 try expect(vec[6] == true);
1054 try expect(vec[7] == false);
1055 try expect(vec[8] == true);
1056 try expect(vec[9] == true);
1057 try expect(vec[10] == true);
1058 try expect(vec[11] == false);
1059 try expect(vec[12] == true);
1060 try expect(vec[13] == true);
1061 try expect(vec[14] == false);
1062 try expect(vec[15] == false);
1063 try expect(vec[16] == true);
1064 try expect(vec[17] == false);
1065 try expect(vec[18] == false);
1066 try expect(vec[19] == false);
1067 try expect(vec[20] == false);
1068 try expect(vec[21] == true);
1069 try expect(vec[22] == true);
1070 try expect(vec[23] == true);
1071 try expect(vec[24] == false);
1072 try expect(vec[25] == true);
1073 try expect(vec[26] == false);
1074 try expect(vec[27] == false);
1075 try expect(vec[28] == true);
1076 try expect(vec[29] == false);
1077 try expect(vec[30] == false);
1078 try expect(vec[31] == false);
1079 }
1080 {
1081 c_vector_64_bool(.{
1082 true,
1083 true,
1084 true,
1085 false,
1086 true,
1087 false,
1088 false,
1089 false,
1090 true,
1091 false,
1092 false,
1093 false,
1094 false,
1095 true,
1096 true,
1097 true,
1098 true,
1099 false,
1100 false,
1101 true,
1102 false,
1103 true,
1104 false,
1105 true,
1106 true,
1107 true,
1108 true,
1109 true,
1110 true,
1111 true,
1112 false,
1113 false,
1114 true,
1115 true,
1116 false,
1117 true,
1118 false,
1119 false,
1120 true,
1121 true,
1122 true,
1123 false,
1124 false,
1125 true,
1126 true,
1127 false,
1128 true,
1129 false,
1130 true,
1131 false,
1132 false,
1133 true,
1134 false,
1135 true,
1136 true,
1137 true,
1138 true,
1139 true,
1140 false,
1141 false,
1142 true,
1143 false,
1144 true,
1145 false,
1146 });
1147
1148 const vec = c_ret_vector_64_bool();
1149 try expect(vec[0] == false);
1150 try expect(vec[1] == true);
1151 try expect(vec[2] == false);
1152 try expect(vec[3] == true);
1153 try expect(vec[4] == true);
1154 try expect(vec[5] == true);
1155 try expect(vec[6] == false);
1156 try expect(vec[7] == true);
1157 try expect(vec[8] == true);
1158 try expect(vec[9] == true);
1159 try expect(vec[10] == true);
1160 try expect(vec[11] == true);
1161 try expect(vec[12] == true);
1162 try expect(vec[13] == false);
1163 try expect(vec[14] == true);
1164 try expect(vec[15] == true);
1165 try expect(vec[16] == true);
1166 try expect(vec[17] == false);
1167 try expect(vec[18] == false);
1168 try expect(vec[19] == false);
1169 try expect(vec[20] == true);
1170 try expect(vec[21] == true);
1171 try expect(vec[22] == false);
1172 try expect(vec[23] == true);
1173 try expect(vec[24] == false);
1174 try expect(vec[25] == true);
1175 try expect(vec[26] == false);
1176 try expect(vec[27] == true);
1177 try expect(vec[28] == false);
1178 try expect(vec[29] == true);
1179 try expect(vec[30] == false);
1180 try expect(vec[31] == true);
1181 try expect(vec[32] == false);
1182 try expect(vec[33] == false);
1183 try expect(vec[34] == true);
1184 try expect(vec[35] == true);
1185 try expect(vec[36] == false);
1186 try expect(vec[37] == false);
1187 try expect(vec[38] == false);
1188 try expect(vec[39] == true);
1189 try expect(vec[40] == true);
1190 try expect(vec[41] == true);
1191 try expect(vec[42] == true);
1192 try expect(vec[43] == false);
1193 try expect(vec[44] == false);
1194 try expect(vec[45] == false);
1195 try expect(vec[46] == true);
1196 try expect(vec[47] == true);
1197 try expect(vec[48] == false);
1198 try expect(vec[49] == false);
1199 try expect(vec[50] == true);
1200 try expect(vec[51] == false);
1201 try expect(vec[52] == false);
1202 try expect(vec[53] == false);
1203 try expect(vec[54] == false);
1204 try expect(vec[55] == true);
1205 try expect(vec[56] == false);
1206 try expect(vec[57] == false);
1207 try expect(vec[58] == false);
1208 try expect(vec[59] == true);
1209 try expect(vec[60] == true);
1210 try expect(vec[61] == true);
1211 try expect(vec[62] == true);
1212 try expect(vec[63] == true);
1213 }
1214 {
1215 c_vector_128_bool(.{
1216 false,
1217 false,
1218 false,
1219 false,
1220 false,
1221 true,
1222 true,
1223 false,
1224 true,
1225 true,
1226 false,
1227 true,
1228 true,
1229 false,
1230 true,
1231 true,
1232 true,
1233 false,
1234 false,
1235 false,
1236 false,
1237 true,
1238 true,
1239 false,
1240 false,
1241 false,
1242 true,
1243 true,
1244 false,
1245 true,
1246 false,
1247 false,
1248 true,
1249 false,
1250 false,
1251 true,
1252 true,
1253 true,
1254 true,
1255 true,
1256 false,
1257 true,
1258 true,
1259 true,
1260 false,
1261 false,
1262 false,
1263 false,
1264 true,
1265 true,
1266 false,
1267 true,
1268 true,
1269 true,
1270 true,
1271 true,
1272 false,
1273 true,
1274 true,
1275 false,
1276 true,
1277 false,
1278 false,
1279 true,
1280 true,
1281 false,
1282 true,
1283 true,
1284 false,
1285 true,
1286 false,
1287 false,
1288 true,
1289 true,
1290 false,
1291 true,
1292 true,
1293 true,
1294 false,
1295 true,
1296 false,
1297 false,
1298 false,
1299 false,
1300 true,
1301 false,
1302 false,
1303 false,
1304 true,
1305 true,
1306 false,
1307 false,
1308 true,
1309 true,
1310 true,
1311 true,
1312 false,
1313 false,
1314 false,
1315 false,
1316 false,
1317 true,
1318 false,
1319 false,
1320 false,
1321 false,
1322 true,
1323 true,
1324 true,
1325 true,
1326 true,
1327 false,
1328 false,
1329 true,
1330 false,
1331 true,
1332 false,
1333 false,
1334 true,
1335 false,
1336 true,
1337 false,
1338 true,
1339 true,
1340 true,
1341 true,
1342 true,
1343 true,
1344 });
1345
1346 const vec = c_ret_vector_128_bool();
1347 try expect(vec[0] == false);
1348 try expect(vec[1] == true);
1349 try expect(vec[2] == true);
1350 try expect(vec[3] == false);
1351 try expect(vec[4] == true);
1352 try expect(vec[5] == false);
1353 try expect(vec[6] == false);
1354 try expect(vec[7] == true);
1355 try expect(vec[8] == true);
1356 try expect(vec[9] == false);
1357 try expect(vec[10] == true);
1358 try expect(vec[11] == false);
1359 try expect(vec[12] == false);
1360 try expect(vec[13] == false);
1361 try expect(vec[14] == true);
1362 try expect(vec[15] == false);
1363 try expect(vec[16] == true);
1364 try expect(vec[17] == false);
1365 try expect(vec[18] == false);
1366 try expect(vec[19] == true);
1367 try expect(vec[20] == false);
1368 try expect(vec[21] == true);
1369 try expect(vec[22] == false);
1370 try expect(vec[23] == false);
1371 try expect(vec[24] == false);
1372 try expect(vec[25] == true);
1373 try expect(vec[26] == true);
1374 try expect(vec[27] == true);
1375 try expect(vec[28] == false);
1376 try expect(vec[29] == false);
1377 try expect(vec[30] == false);
1378 try expect(vec[31] == false);
1379 try expect(vec[32] == true);
1380 try expect(vec[33] == true);
1381 try expect(vec[34] == true);
1382 try expect(vec[35] == false);
1383 try expect(vec[36] == true);
1384 try expect(vec[37] == true);
1385 try expect(vec[38] == false);
1386 try expect(vec[39] == false);
1387 try expect(vec[40] == false);
1388 try expect(vec[41] == false);
1389 try expect(vec[42] == true);
1390 try expect(vec[43] == true);
1391 try expect(vec[44] == true);
1392 try expect(vec[45] == false);
1393 try expect(vec[46] == false);
1394 try expect(vec[47] == false);
1395 try expect(vec[48] == false);
1396 try expect(vec[49] == true);
1397 try expect(vec[50] == false);
1398 try expect(vec[51] == false);
1399 try expect(vec[52] == true);
1400 try expect(vec[53] == false);
1401 try expect(vec[54] == false);
1402 try expect(vec[55] == false);
1403 try expect(vec[56] == false);
1404 try expect(vec[57] == false);
1405 try expect(vec[58] == true);
1406 try expect(vec[59] == true);
1407 try expect(vec[60] == true);
1408 try expect(vec[61] == false);
1409 try expect(vec[62] == true);
1410 try expect(vec[63] == true);
1411 try expect(vec[64] == false);
1412 try expect(vec[65] == false);
1413 try expect(vec[66] == false);
1414 try expect(vec[67] == false);
1415 try expect(vec[68] == false);
1416 try expect(vec[69] == false);
1417 try expect(vec[70] == false);
1418 try expect(vec[71] == false);
1419 try expect(vec[72] == true);
1420 try expect(vec[73] == true);
1421 try expect(vec[74] == true);
1422 try expect(vec[75] == true);
1423 try expect(vec[76] == true);
1424 try expect(vec[77] == false);
1425 try expect(vec[78] == false);
1426 try expect(vec[79] == false);
1427 try expect(vec[80] == false);
1428 try expect(vec[81] == false);
1429 try expect(vec[82] == false);
1430 try expect(vec[83] == true);
1431 try expect(vec[84] == false);
1432 try expect(vec[85] == true);
1433 try expect(vec[86] == false);
1434 try expect(vec[87] == true);
1435 try expect(vec[88] == false);
1436 try expect(vec[89] == true);
1437 try expect(vec[90] == false);
1438 try expect(vec[91] == true);
1439 try expect(vec[92] == true);
1440 try expect(vec[93] == true);
1441 try expect(vec[94] == true);
1442 try expect(vec[95] == false);
1443 try expect(vec[96] == false);
1444 try expect(vec[97] == true);
1445 try expect(vec[98] == false);
1446 try expect(vec[99] == false);
1447 try expect(vec[100] == true);
1448 try expect(vec[101] == true);
1449 try expect(vec[102] == true);
1450 try expect(vec[103] == true);
1451 try expect(vec[104] == false);
1452 try expect(vec[105] == true);
1453 try expect(vec[106] == true);
1454 try expect(vec[107] == true);
1455 try expect(vec[108] == false);
1456 try expect(vec[109] == false);
1457 try expect(vec[110] == true);
1458 try expect(vec[111] == false);
1459 try expect(vec[112] == false);
1460 try expect(vec[113] == true);
1461 try expect(vec[114] == true);
1462 try expect(vec[115] == false);
1463 try expect(vec[116] == true);
1464 try expect(vec[117] == false);
1465 try expect(vec[118] == true);
1466 try expect(vec[119] == true);
1467 try expect(vec[120] == true);
1468 try expect(vec[121] == true);
1469 try expect(vec[122] == true);
1470 try expect(vec[123] == false);
1471 try expect(vec[124] == false);
1472 try expect(vec[125] == true);
1473 try expect(vec[126] == false);
1474 try expect(vec[127] == true);
1475 }
1476 {
1477 c_vector_256_bool(.{
1478 false,
1479 true,
1480 true,
1481 false,
1482 false,
1483 true,
1484 true,
1485 true,
1486 false,
1487 true,
1488 true,
1489 true,
1490 false,
1491 true,
1492 false,
1493 true,
1494 false,
1495 false,
1496 true,
1497 true,
1498 false,
1499 true,
1500 false,
1501 false,
1502 false,
1503 true,
1504 true,
1505 false,
1506 false,
1507 true,
1508 true,
1509 false,
1510 true,
1511 false,
1512 false,
1513 true,
1514 false,
1515 true,
1516 false,
1517 true,
1518 true,
1519 true,
1520 true,
1521 false,
1522 false,
1523 true,
1524 false,
1525 false,
1526 false,
1527 false,
1528 false,
1529 false,
1530 true,
1531 true,
1532 true,
1533 true,
1534 true,
1535 true,
1536 false,
1537 true,
1538 true,
1539 false,
1540 false,
1541 true,
1542 false,
1543 false,
1544 false,
1545 false,
1546 false,
1547 false,
1548 true,
1549 true,
1550 true,
1551 false,
1552 false,
1553 false,
1554 true,
1555 false,
1556 true,
1557 true,
1558 false,
1559 false,
1560 true,
1561 true,
1562 false,
1563 true,
1564 true,
1565 true,
1566 true,
1567 true,
1568 true,
1569 true,
1570 false,
1571 true,
1572 true,
1573 false,
1574 false,
1575 true,
1576 true,
1577 false,
1578 true,
1579 false,
1580 false,
1581 true,
1582 false,
1583 true,
1584 true,
1585 true,
1586 true,
1587 true,
1588 false,
1589 false,
1590 false,
1591 false,
1592 true,
1593 true,
1594 false,
1595 true,
1596 false,
1597 false,
1598 true,
1599 false,
1600 false,
1601 true,
1602 false,
1603 true,
1604 true,
1605 true,
1606 true,
1607 false,
1608 true,
1609 true,
1610 false,
1611 false,
1612 true,
1613 false,
1614 false,
1615 true,
1616 false,
1617 true,
1618 false,
1619 true,
1620 true,
1621 true,
1622 true,
1623 false,
1624 true,
1625 false,
1626 false,
1627 false,
1628 true,
1629 true,
1630 true,
1631 true,
1632 true,
1633 false,
1634 true,
1635 false,
1636 false,
1637 false,
1638 true,
1639 true,
1640 false,
1641 true,
1642 true,
1643 false,
1644 false,
1645 false,
1646 false,
1647 true,
1648 false,
1649 true,
1650 false,
1651 false,
1652 false,
1653 false,
1654 true,
1655 true,
1656 true,
1657 false,
1658 true,
1659 false,
1660 true,
1661 true,
1662 false,
1663 false,
1664 true,
1665 false,
1666 false,
1667 false,
1668 false,
1669 true,
1670 true,
1671 true,
1672 true,
1673 true,
1674 true,
1675 true,
1676 false,
1677 true,
1678 false,
1679 false,
1680 true,
1681 false,
1682 true,
1683 true,
1684 true,
1685 false,
1686 false,
1687 true,
1688 true,
1689 true,
1690 false,
1691 true,
1692 true,
1693 true,
1694 true,
1695 true,
1696 false,
1697 false,
1698 false,
1699 false,
1700 false,
1701 true,
1702 true,
1703 false,
1704 true,
1705 false,
1706 false,
1707 true,
1708 false,
1709 true,
1710 false,
1711 false,
1712 false,
1713 true,
1714 false,
1715 false,
1716 false,
1717 true,
1718 true,
1719 true,
1720 true,
1721 true,
1722 true,
1723 false,
1724 false,
1725 true,
1726 false,
1727 true,
1728 true,
1729 false,
1730 true,
1731 true,
1732 true,
1733 false,
1734 });
1735
1736 const vec = c_ret_vector_256_bool();
1737 try expect(vec[0] == true);
1738 try expect(vec[1] == false);
1739 try expect(vec[2] == true);
1740 try expect(vec[3] == true);
1741 try expect(vec[4] == false);
1742 try expect(vec[5] == false);
1743 try expect(vec[6] == false);
1744 try expect(vec[7] == false);
1745 try expect(vec[8] == false);
1746 try expect(vec[9] == true);
1747 try expect(vec[10] == false);
1748 try expect(vec[11] == true);
1749 try expect(vec[12] == false);
1750 try expect(vec[13] == true);
1751 try expect(vec[14] == false);
1752 try expect(vec[15] == false);
1753 try expect(vec[16] == true);
1754 try expect(vec[17] == true);
1755 try expect(vec[18] == true);
1756 try expect(vec[19] == false);
1757 try expect(vec[20] == false);
1758 try expect(vec[21] == false);
1759 try expect(vec[22] == true);
1760 try expect(vec[23] == false);
1761 try expect(vec[24] == true);
1762 try expect(vec[25] == false);
1763 try expect(vec[26] == false);
1764 try expect(vec[27] == true);
1765 try expect(vec[28] == true);
1766 try expect(vec[29] == true);
1767 try expect(vec[30] == false);
1768 try expect(vec[31] == false);
1769 try expect(vec[32] == true);
1770 try expect(vec[33] == true);
1771 try expect(vec[34] == true);
1772 try expect(vec[35] == false);
1773 try expect(vec[36] == true);
1774 try expect(vec[37] == true);
1775 try expect(vec[38] == true);
1776 try expect(vec[39] == false);
1777 try expect(vec[40] == true);
1778 try expect(vec[41] == false);
1779 try expect(vec[42] == true);
1780 try expect(vec[43] == true);
1781 try expect(vec[44] == false);
1782 try expect(vec[45] == true);
1783 try expect(vec[46] == false);
1784 try expect(vec[47] == true);
1785 try expect(vec[48] == true);
1786 try expect(vec[49] == false);
1787 try expect(vec[50] == false);
1788 try expect(vec[51] == true);
1789 try expect(vec[52] == true);
1790 try expect(vec[53] == false);
1791 try expect(vec[54] == false);
1792 try expect(vec[55] == true);
1793 try expect(vec[56] == false);
1794 try expect(vec[57] == true);
1795 try expect(vec[58] == true);
1796 try expect(vec[59] == true);
1797 try expect(vec[60] == false);
1798 try expect(vec[61] == true);
1799 try expect(vec[62] == true);
1800 try expect(vec[63] == false);
1801 try expect(vec[64] == true);
1802 try expect(vec[65] == true);
1803 try expect(vec[66] == false);
1804 try expect(vec[67] == true);
1805 try expect(vec[68] == false);
1806 try expect(vec[69] == true);
1807 try expect(vec[70] == true);
1808 try expect(vec[71] == true);
1809 try expect(vec[72] == false);
1810 try expect(vec[73] == true);
1811 try expect(vec[74] == true);
1812 try expect(vec[75] == false);
1813 try expect(vec[76] == true);
1814 try expect(vec[77] == true);
1815 try expect(vec[78] == true);
1816 try expect(vec[79] == true);
1817 try expect(vec[80] == false);
1818 try expect(vec[81] == true);
1819 try expect(vec[82] == false);
1820 try expect(vec[83] == true);
1821 try expect(vec[84] == true);
1822 try expect(vec[85] == true);
1823 try expect(vec[86] == false);
1824 try expect(vec[87] == true);
1825 try expect(vec[88] == false);
1826 try expect(vec[89] == true);
1827 try expect(vec[90] == false);
1828 try expect(vec[91] == false);
1829 try expect(vec[92] == true);
1830 try expect(vec[93] == false);
1831 try expect(vec[94] == false);
1832 try expect(vec[95] == false);
1833 try expect(vec[96] == true);
1834 try expect(vec[97] == true);
1835 try expect(vec[98] == false);
1836 try expect(vec[99] == false);
1837 try expect(vec[100] == false);
1838 try expect(vec[101] == true);
1839 try expect(vec[102] == true);
1840 try expect(vec[103] == true);
1841 try expect(vec[104] == false);
1842 try expect(vec[105] == false);
1843 try expect(vec[106] == false);
1844 try expect(vec[107] == true);
1845 try expect(vec[108] == false);
1846 try expect(vec[109] == true);
1847 try expect(vec[110] == true);
1848 try expect(vec[111] == true);
1849 try expect(vec[112] == true);
1850 try expect(vec[113] == true);
1851 try expect(vec[114] == true);
1852 try expect(vec[115] == true);
1853 try expect(vec[116] == true);
1854 try expect(vec[117] == false);
1855 try expect(vec[118] == true);
1856 try expect(vec[119] == false);
1857 try expect(vec[120] == true);
1858 try expect(vec[121] == false);
1859 try expect(vec[122] == false);
1860 try expect(vec[123] == true);
1861 try expect(vec[124] == true);
1862 try expect(vec[125] == false);
1863 try expect(vec[126] == true);
1864 try expect(vec[127] == false);
1865 try expect(vec[128] == false);
1866 try expect(vec[129] == false);
1867 try expect(vec[130] == false);
1868 try expect(vec[131] == true);
1869 try expect(vec[132] == false);
1870 try expect(vec[133] == false);
1871 try expect(vec[134] == true);
1872 try expect(vec[135] == false);
1873 try expect(vec[136] == false);
1874 try expect(vec[137] == false);
1875 try expect(vec[138] == false);
1876 try expect(vec[139] == false);
1877 try expect(vec[140] == false);
1878 try expect(vec[141] == true);
1879 try expect(vec[142] == false);
1880 try expect(vec[143] == true);
1881 try expect(vec[144] == false);
1882 try expect(vec[145] == true);
1883 try expect(vec[146] == true);
1884 try expect(vec[147] == true);
1885 try expect(vec[148] == false);
1886 try expect(vec[149] == true);
1887 try expect(vec[150] == true);
1888 try expect(vec[151] == false);
1889 try expect(vec[152] == true);
1890 try expect(vec[153] == true);
1891 try expect(vec[154] == false);
1892 try expect(vec[155] == true);
1893 try expect(vec[156] == true);
1894 try expect(vec[157] == true);
1895 try expect(vec[158] == true);
1896 try expect(vec[159] == true);
1897 try expect(vec[160] == true);
1898 try expect(vec[161] == true);
1899 try expect(vec[162] == false);
1900 try expect(vec[163] == false);
1901 try expect(vec[164] == false);
1902 try expect(vec[165] == true);
1903 try expect(vec[166] == false);
1904 try expect(vec[167] == false);
1905 try expect(vec[168] == true);
1906 try expect(vec[169] == false);
1907 try expect(vec[170] == true);
1908 try expect(vec[171] == true);
1909 try expect(vec[172] == true);
1910 try expect(vec[173] == false);
1911 try expect(vec[174] == false);
1912 try expect(vec[175] == true);
1913 try expect(vec[176] == true);
1914 try expect(vec[177] == true);
1915 try expect(vec[178] == true);
1916 try expect(vec[179] == false);
1917 try expect(vec[180] == true);
1918 try expect(vec[181] == true);
1919 try expect(vec[182] == false);
1920 try expect(vec[183] == true);
1921 try expect(vec[184] == false);
1922 try expect(vec[185] == false);
1923 try expect(vec[186] == false);
1924 try expect(vec[187] == true);
1925 try expect(vec[188] == true);
1926 try expect(vec[189] == true);
1927 try expect(vec[190] == true);
1928 try expect(vec[191] == true);
1929 try expect(vec[192] == true);
1930 try expect(vec[193] == true);
1931 try expect(vec[194] == true);
1932 try expect(vec[195] == false);
1933 try expect(vec[196] == false);
1934 try expect(vec[197] == true);
1935 try expect(vec[198] == false);
1936 try expect(vec[199] == false);
1937 try expect(vec[200] == false);
1938 try expect(vec[201] == true);
1939 try expect(vec[202] == true);
1940 try expect(vec[203] == true);
1941 try expect(vec[204] == true);
1942 try expect(vec[205] == true);
1943 try expect(vec[206] == true);
1944 try expect(vec[207] == false);
1945 try expect(vec[208] == false);
1946 try expect(vec[209] == false);
1947 try expect(vec[210] == true);
1948 try expect(vec[211] == true);
1949 try expect(vec[212] == true);
1950 try expect(vec[213] == false);
1951 try expect(vec[214] == true);
1952 try expect(vec[215] == false);
1953 try expect(vec[216] == true);
1954 try expect(vec[217] == false);
1955 try expect(vec[218] == true);
1956 try expect(vec[219] == false);
1957 try expect(vec[220] == true);
1958 try expect(vec[221] == true);
1959 try expect(vec[222] == true);
1960 try expect(vec[223] == false);
1961 try expect(vec[224] == true);
1962 try expect(vec[225] == false);
1963 try expect(vec[226] == true);
1964 try expect(vec[227] == false);
1965 try expect(vec[228] == true);
1966 try expect(vec[229] == false);
1967 try expect(vec[230] == true);
1968 try expect(vec[231] == false);
1969 try expect(vec[232] == false);
1970 try expect(vec[233] == true);
1971 try expect(vec[234] == false);
1972 try expect(vec[235] == true);
1973 try expect(vec[236] == true);
1974 try expect(vec[237] == false);
1975 try expect(vec[238] == false);
1976 try expect(vec[239] == true);
1977 try expect(vec[240] == false);
1978 try expect(vec[241] == false);
1979 try expect(vec[242] == false);
1980 try expect(vec[243] == true);
1981 try expect(vec[244] == true);
1982 try expect(vec[245] == false);
1983 try expect(vec[246] == false);
1984 try expect(vec[247] == false);
1985 try expect(vec[248] == false);
1986 try expect(vec[249] == false);
1987 try expect(vec[250] == true);
1988 try expect(vec[251] == false);
1989 try expect(vec[252] == true);
1990 try expect(vec[253] == false);
1991 try expect(vec[254] == false);
1992 try expect(vec[255] == false);
1993 }
1994 {
1995 c_vector_512_bool(.{
1996 true,
1997 true,
1998 true,
1999 true,
2000 true,
2001 false,
2002 false,
2003 true,
2004 true,
2005 true,
2006 true,
2007 false,
2008 true,
2009 true,
2010 false,
2011 false,
2012 false,
2013 true,
2014 true,
2015 true,
2016 true,
2017 true,
2018 false,
2019 false,
2020 true,
2021 true,
2022 false,
2023 false,
2024 false,
2025 false,
2026 false,
2027 true,
2028 true,
2029 false,
2030 true,
2031 true,
2032 true,
2033 true,
2034 true,
2035 true,
2036 false,
2037 true,
2038 true,
2039 false,
2040 false,
2041 false,
2042 true,
2043 true,
2044 false,
2045 true,
2046 false,
2047 true,
2048 true,
2049 false,
2050 true,
2051 false,
2052 false,
2053 true,
2054 true,
2055 false,
2056 true,
2057 true,
2058 false,
2059 true,
2060 false,
2061 true,
2062 true,
2063 true,
2064 true,
2065 true,
2066 true,
2067 true,
2068 true,
2069 true,
2070 false,
2071 true,
2072 false,
2073 true,
2074 false,
2075 false,
2076 false,
2077 true,
2078 false,
2079 true,
2080 true,
2081 false,
2082 true,
2083 true,
2084 true,
2085 false,
2086 true,
2087 true,
2088 false,
2089 true,
2090 false,
2091 true,
2092 true,
2093 false,
2094 false,
2095 false,
2096 true,
2097 true,
2098 false,
2099 true,
2100 false,
2101 false,
2102 true,
2103 false,
2104 false,
2105 true,
2106 false,
2107 false,
2108 false,
2109 false,
2110 false,
2111 true,
2112 true,
2113 false,
2114 false,
2115 false,
2116 false,
2117 true,
2118 false,
2119 false,
2120 true,
2121 true,
2122 false,
2123 true,
2124 false,
2125 true,
2126 true,
2127 false,
2128 true,
2129 false,
2130 false,
2131 false,
2132 false,
2133 true,
2134 true,
2135 false,
2136 false,
2137 false,
2138 true,
2139 true,
2140 false,
2141 false,
2142 true,
2143 true,
2144 true,
2145 true,
2146 true,
2147 true,
2148 true,
2149 false,
2150 true,
2151 false,
2152 false,
2153 true,
2154 false,
2155 true,
2156 false,
2157 true,
2158 true,
2159 true,
2160 true,
2161 true,
2162 true,
2163 true,
2164 true,
2165 false,
2166 true,
2167 true,
2168 false,
2169 true,
2170 true,
2171 false,
2172 false,
2173 false,
2174 true,
2175 false,
2176 false,
2177 true,
2178 true,
2179 true,
2180 true,
2181 true,
2182 true,
2183 true,
2184 true,
2185 true,
2186 false,
2187 true,
2188 true,
2189 false,
2190 false,
2191 true,
2192 true,
2193 false,
2194 true,
2195 true,
2196 false,
2197 true,
2198 true,
2199 false,
2200 true,
2201 true,
2202 true,
2203 true,
2204 false,
2205 true,
2206 false,
2207 true,
2208 true,
2209 false,
2210 true,
2211 false,
2212 true,
2213 false,
2214 true,
2215 false,
2216 false,
2217 true,
2218 false,
2219 false,
2220 false,
2221 true,
2222 true,
2223 false,
2224 false,
2225 false,
2226 true,
2227 false,
2228 true,
2229 false,
2230 false,
2231 false,
2232 true,
2233 true,
2234 false,
2235 false,
2236 false,
2237 false,
2238 false,
2239 true,
2240 true,
2241 false,
2242 true,
2243 false,
2244 false,
2245 true,
2246 false,
2247 false,
2248 false,
2249 true,
2250 false,
2251 false,
2252 false,
2253 false,
2254 true,
2255 true,
2256 true,
2257 true,
2258 false,
2259 true,
2260 false,
2261 false,
2262 false,
2263 true,
2264 false,
2265 false,
2266 true,
2267 true,
2268 false,
2269 false,
2270 false,
2271 false,
2272 false,
2273 true,
2274 false,
2275 true,
2276 true,
2277 true,
2278 true,
2279 true,
2280 false,
2281 false,
2282 false,
2283 false,
2284 false,
2285 false,
2286 false,
2287 false,
2288 false,
2289 true,
2290 true,
2291 true,
2292 true,
2293 true,
2294 true,
2295 false,
2296 true,
2297 false,
2298 true,
2299 true,
2300 true,
2301 false,
2302 false,
2303 true,
2304 true,
2305 true,
2306 false,
2307 true,
2308 true,
2309 true,
2310 false,
2311 true,
2312 true,
2313 true,
2314 false,
2315 true,
2316 true,
2317 false,
2318 false,
2319 true,
2320 false,
2321 false,
2322 false,
2323 false,
2324 true,
2325 false,
2326 true,
2327 true,
2328 true,
2329 true,
2330 false,
2331 false,
2332 true,
2333 false,
2334 true,
2335 false,
2336 false,
2337 false,
2338 true,
2339 false,
2340 true,
2341 false,
2342 false,
2343 true,
2344 true,
2345 true,
2346 true,
2347 false,
2348 false,
2349 false,
2350 true,
2351 true,
2352 false,
2353 true,
2354 false,
2355 false,
2356 true,
2357 false,
2358 true,
2359 false,
2360 true,
2361 true,
2362 false,
2363 false,
2364 true,
2365 true,
2366 true,
2367 true,
2368 false,
2369 false,
2370 true,
2371 false,
2372 true,
2373 true,
2374 false,
2375 true,
2376 true,
2377 false,
2378 true,
2379 true,
2380 true,
2381 false,
2382 true,
2383 true,
2384 true,
2385 false,
2386 false,
2387 true,
2388 false,
2389 true,
2390 true,
2391 true,
2392 false,
2393 false,
2394 false,
2395 false,
2396 false,
2397 true,
2398 false,
2399 false,
2400 false,
2401 false,
2402 true,
2403 false,
2404 false,
2405 true,
2406 true,
2407 false,
2408 false,
2409 false,
2410 false,
2411 true,
2412 true,
2413 true,
2414 true,
2415 true,
2416 false,
2417 false,
2418 false,
2419 true,
2420 false,
2421 false,
2422 false,
2423 false,
2424 true,
2425 false,
2426 true,
2427 false,
2428 true,
2429 true,
2430 true,
2431 true,
2432 false,
2433 false,
2434 false,
2435 false,
2436 false,
2437 true,
2438 true,
2439 true,
2440 true,
2441 true,
2442 true,
2443 true,
2444 true,
2445 true,
2446 false,
2447 false,
2448 true,
2449 false,
2450 true,
2451 false,
2452 false,
2453 true,
2454 false,
2455 false,
2456 true,
2457 true,
2458 true,
2459 true,
2460 true,
2461 true,
2462 false,
2463 true,
2464 false,
2465 false,
2466 false,
2467 true,
2468 true,
2469 false,
2470 true,
2471 true,
2472 false,
2473 false,
2474 true,
2475 true,
2476 false,
2477 false,
2478 true,
2479 true,
2480 false,
2481 true,
2482 false,
2483 true,
2484 true,
2485 true,
2486 true,
2487 true,
2488 true,
2489 true,
2490 true,
2491 true,
2492 false,
2493 true,
2494 true,
2495 true,
2496 false,
2497 false,
2498 true,
2499 false,
2500 false,
2501 false,
2502 true,
2503 true,
2504 false,
2505 true,
2506 false,
2507 true,
2508 });
2509
2510 const vec = c_ret_vector_512_bool();
2511 try expect(vec[0] == false);
2512 try expect(vec[1] == true);
2513 try expect(vec[2] == false);
2514 try expect(vec[3] == false);
2515 try expect(vec[4] == false);
2516 try expect(vec[5] == true);
2517 try expect(vec[6] == false);
2518 try expect(vec[7] == false);
2519 try expect(vec[8] == false);
2520 try expect(vec[9] == true);
2521 try expect(vec[10] == false);
2522 try expect(vec[11] == false);
2523 try expect(vec[12] == false);
2524 try expect(vec[13] == true);
2525 try expect(vec[14] == false);
2526 try expect(vec[15] == true);
2527 try expect(vec[16] == false);
2528 try expect(vec[17] == false);
2529 try expect(vec[18] == false);
2530 try expect(vec[19] == false);
2531 try expect(vec[20] == false);
2532 try expect(vec[21] == false);
2533 try expect(vec[22] == true);
2534 try expect(vec[23] == true);
2535 try expect(vec[24] == false);
2536 try expect(vec[25] == false);
2537 try expect(vec[26] == false);
2538 try expect(vec[27] == false);
2539 try expect(vec[28] == true);
2540 try expect(vec[29] == true);
2541 try expect(vec[30] == false);
2542 try expect(vec[31] == true);
2543 try expect(vec[32] == false);
2544 try expect(vec[33] == true);
2545 try expect(vec[34] == true);
2546 try expect(vec[35] == true);
2547 try expect(vec[36] == false);
2548 try expect(vec[37] == false);
2549 try expect(vec[38] == true);
2550 try expect(vec[39] == true);
2551 try expect(vec[40] == false);
2552 try expect(vec[41] == false);
2553 try expect(vec[42] == false);
2554 try expect(vec[43] == false);
2555 try expect(vec[44] == false);
2556 try expect(vec[45] == true);
2557 try expect(vec[46] == false);
2558 try expect(vec[47] == true);
2559 try expect(vec[48] == true);
2560 try expect(vec[49] == false);
2561 try expect(vec[50] == true);
2562 try expect(vec[51] == true);
2563 try expect(vec[52] == true);
2564 try expect(vec[53] == true);
2565 try expect(vec[54] == false);
2566 try expect(vec[55] == false);
2567 try expect(vec[56] == false);
2568 try expect(vec[57] == true);
2569 try expect(vec[58] == true);
2570 try expect(vec[59] == false);
2571 try expect(vec[60] == false);
2572 try expect(vec[61] == false);
2573 try expect(vec[62] == false);
2574 try expect(vec[63] == true);
2575 try expect(vec[64] == true);
2576 try expect(vec[65] == true);
2577 try expect(vec[66] == true);
2578 try expect(vec[67] == true);
2579 try expect(vec[68] == false);
2580 try expect(vec[69] == false);
2581 try expect(vec[70] == false);
2582 try expect(vec[71] == false);
2583 try expect(vec[72] == false);
2584 try expect(vec[73] == true);
2585 try expect(vec[74] == false);
2586 try expect(vec[75] == true);
2587 try expect(vec[76] == false);
2588 try expect(vec[77] == false);
2589 try expect(vec[78] == true);
2590 try expect(vec[79] == true);
2591 try expect(vec[80] == false);
2592 try expect(vec[81] == false);
2593 try expect(vec[82] == false);
2594 try expect(vec[83] == true);
2595 try expect(vec[84] == false);
2596 try expect(vec[85] == true);
2597 try expect(vec[86] == true);
2598 try expect(vec[87] == true);
2599 try expect(vec[88] == false);
2600 try expect(vec[89] == true);
2601 try expect(vec[90] == false);
2602 try expect(vec[91] == false);
2603 try expect(vec[92] == true);
2604 try expect(vec[93] == true);
2605 try expect(vec[94] == false);
2606 try expect(vec[95] == true);
2607 try expect(vec[96] == true);
2608 try expect(vec[97] == false);
2609 try expect(vec[98] == true);
2610 try expect(vec[99] == false);
2611 try expect(vec[100] == true);
2612 try expect(vec[101] == true);
2613 try expect(vec[102] == false);
2614 try expect(vec[103] == true);
2615 try expect(vec[104] == true);
2616 try expect(vec[105] == false);
2617 try expect(vec[106] == false);
2618 try expect(vec[107] == false);
2619 try expect(vec[108] == true);
2620 try expect(vec[109] == false);
2621 try expect(vec[110] == false);
2622 try expect(vec[111] == false);
2623 try expect(vec[112] == true);
2624 try expect(vec[113] == true);
2625 try expect(vec[114] == true);
2626 try expect(vec[115] == false);
2627 try expect(vec[116] == true);
2628 try expect(vec[117] == false);
2629 try expect(vec[118] == true);
2630 try expect(vec[119] == false);
2631 try expect(vec[120] == true);
2632 try expect(vec[121] == true);
2633 try expect(vec[122] == false);
2634 try expect(vec[123] == true);
2635 try expect(vec[124] == false);
2636 try expect(vec[125] == true);
2637 try expect(vec[126] == true);
2638 try expect(vec[127] == true);
2639 try expect(vec[128] == false);
2640 try expect(vec[129] == true);
2641 try expect(vec[130] == false);
2642 try expect(vec[131] == false);
2643 try expect(vec[132] == false);
2644 try expect(vec[133] == false);
2645 try expect(vec[134] == false);
2646 try expect(vec[135] == false);
2647 try expect(vec[136] == true);
2648 try expect(vec[137] == false);
2649 try expect(vec[138] == true);
2650 try expect(vec[139] == false);
2651 try expect(vec[140] == true);
2652 try expect(vec[141] == true);
2653 try expect(vec[142] == false);
2654 try expect(vec[143] == true);
2655 try expect(vec[144] == false);
2656 try expect(vec[145] == false);
2657 try expect(vec[146] == true);
2658 try expect(vec[147] == false);
2659 try expect(vec[148] == false);
2660 try expect(vec[149] == true);
2661 try expect(vec[150] == false);
2662 try expect(vec[151] == true);
2663 try expect(vec[152] == false);
2664 try expect(vec[153] == true);
2665 try expect(vec[154] == false);
2666 try expect(vec[155] == false);
2667 try expect(vec[156] == true);
2668 try expect(vec[157] == false);
2669 try expect(vec[158] == true);
2670 try expect(vec[159] == true);
2671 try expect(vec[160] == true);
2672 try expect(vec[161] == false);
2673 try expect(vec[162] == false);
2674 try expect(vec[163] == true);
2675 try expect(vec[164] == false);
2676 try expect(vec[165] == false);
2677 try expect(vec[166] == false);
2678 try expect(vec[167] == true);
2679 try expect(vec[168] == true);
2680 try expect(vec[169] == true);
2681 try expect(vec[170] == false);
2682 try expect(vec[171] == true);
2683 try expect(vec[172] == false);
2684 try expect(vec[173] == false);
2685 try expect(vec[174] == false);
2686 try expect(vec[175] == false);
2687 try expect(vec[176] == false);
2688 try expect(vec[177] == true);
2689 try expect(vec[178] == true);
2690 try expect(vec[179] == false);
2691 try expect(vec[180] == false);
2692 try expect(vec[181] == true);
2693 try expect(vec[182] == false);
2694 try expect(vec[183] == false);
2695 try expect(vec[184] == false);
2696 try expect(vec[185] == false);
2697 try expect(vec[186] == false);
2698 try expect(vec[187] == true);
2699 try expect(vec[188] == true);
2700 try expect(vec[189] == false);
2701 try expect(vec[190] == false);
2702 try expect(vec[191] == false);
2703 try expect(vec[192] == false);
2704 try expect(vec[193] == false);
2705 try expect(vec[194] == false);
2706 try expect(vec[195] == true);
2707 try expect(vec[196] == true);
2708 try expect(vec[197] == false);
2709 try expect(vec[198] == true);
2710 try expect(vec[199] == true);
2711 try expect(vec[200] == true);
2712 try expect(vec[201] == true);
2713 try expect(vec[202] == true);
2714 try expect(vec[203] == true);
2715 try expect(vec[204] == false);
2716 try expect(vec[205] == false);
2717 try expect(vec[206] == false);
2718 try expect(vec[207] == false);
2719 try expect(vec[208] == true);
2720 try expect(vec[209] == false);
2721 try expect(vec[210] == true);
2722 try expect(vec[211] == true);
2723 try expect(vec[212] == true);
2724 try expect(vec[213] == true);
2725 try expect(vec[214] == false);
2726 try expect(vec[215] == false);
2727 try expect(vec[216] == false);
2728 try expect(vec[217] == true);
2729 try expect(vec[218] == true);
2730 try expect(vec[219] == false);
2731 try expect(vec[220] == true);
2732 try expect(vec[221] == true);
2733 try expect(vec[222] == false);
2734 try expect(vec[223] == false);
2735 try expect(vec[224] == false);
2736 try expect(vec[225] == true);
2737 try expect(vec[226] == true);
2738 try expect(vec[227] == true);
2739 try expect(vec[228] == true);
2740 try expect(vec[229] == false);
2741 try expect(vec[230] == true);
2742 try expect(vec[231] == false);
2743 try expect(vec[232] == true);
2744 try expect(vec[233] == true);
2745 try expect(vec[234] == true);
2746 try expect(vec[235] == true);
2747 try expect(vec[236] == false);
2748 try expect(vec[237] == true);
2749 try expect(vec[238] == false);
2750 try expect(vec[239] == true);
2751 try expect(vec[240] == false);
2752 try expect(vec[241] == true);
2753 try expect(vec[242] == false);
2754 try expect(vec[243] == false);
2755 try expect(vec[244] == false);
2756 try expect(vec[245] == true);
2757 try expect(vec[246] == true);
2758 try expect(vec[247] == false);
2759 try expect(vec[248] == true);
2760 try expect(vec[249] == false);
2761 try expect(vec[250] == false);
2762 try expect(vec[251] == false);
2763 try expect(vec[252] == true);
2764 try expect(vec[253] == true);
2765 try expect(vec[254] == true);
2766 try expect(vec[255] == true);
2767 try expect(vec[256] == true);
2768 try expect(vec[257] == false);
2769 try expect(vec[258] == true);
2770 try expect(vec[259] == true);
2771 try expect(vec[260] == true);
2772 try expect(vec[261] == true);
2773 try expect(vec[262] == false);
2774 try expect(vec[263] == true);
2775 try expect(vec[264] == false);
2776 try expect(vec[265] == false);
2777 try expect(vec[266] == true);
2778 try expect(vec[267] == false);
2779 try expect(vec[268] == true);
2780 try expect(vec[269] == false);
2781 try expect(vec[270] == false);
2782 try expect(vec[271] == true);
2783 try expect(vec[272] == true);
2784 try expect(vec[273] == false);
2785 try expect(vec[274] == true);
2786 try expect(vec[275] == false);
2787 try expect(vec[276] == false);
2788 try expect(vec[277] == true);
2789 try expect(vec[278] == false);
2790 try expect(vec[279] == false);
2791 try expect(vec[280] == true);
2792 try expect(vec[281] == true);
2793 try expect(vec[282] == true);
2794 try expect(vec[283] == false);
2795 try expect(vec[284] == false);
2796 try expect(vec[285] == true);
2797 try expect(vec[286] == true);
2798 try expect(vec[287] == true);
2799 try expect(vec[288] == false);
2800 try expect(vec[289] == false);
2801 try expect(vec[290] == false);
2802 try expect(vec[291] == false);
2803 try expect(vec[292] == false);
2804 try expect(vec[293] == false);
2805 try expect(vec[294] == true);
2806 try expect(vec[295] == false);
2807 try expect(vec[296] == true);
2808 try expect(vec[297] == false);
2809 try expect(vec[298] == true);
2810 try expect(vec[299] == true);
2811 try expect(vec[300] == false);
2812 try expect(vec[301] == false);
2813 try expect(vec[302] == false);
2814 try expect(vec[303] == false);
2815 try expect(vec[304] == true);
2816 try expect(vec[305] == true);
2817 try expect(vec[306] == true);
2818 try expect(vec[307] == true);
2819 try expect(vec[308] == true);
2820 try expect(vec[309] == false);
2821 try expect(vec[310] == true);
2822 try expect(vec[311] == true);
2823 try expect(vec[312] == true);
2824 try expect(vec[313] == true);
2825 try expect(vec[314] == true);
2826 try expect(vec[315] == false);
2827 try expect(vec[316] == true);
2828 try expect(vec[317] == true);
2829 try expect(vec[318] == true);
2830 try expect(vec[319] == false);
2831 try expect(vec[320] == true);
2832 try expect(vec[321] == false);
2833 try expect(vec[322] == true);
2834 try expect(vec[323] == true);
2835 try expect(vec[324] == true);
2836 try expect(vec[325] == false);
2837 try expect(vec[326] == false);
2838 try expect(vec[327] == true);
2839 try expect(vec[328] == true);
2840 try expect(vec[329] == true);
2841 try expect(vec[330] == false);
2842 try expect(vec[331] == false);
2843 try expect(vec[332] == true);
2844 try expect(vec[333] == true);
2845 try expect(vec[334] == false);
2846 try expect(vec[335] == true);
2847 try expect(vec[336] == true);
2848 try expect(vec[337] == true);
2849 try expect(vec[338] == true);
2850 try expect(vec[339] == true);
2851 try expect(vec[340] == true);
2852 try expect(vec[341] == false);
2853 try expect(vec[342] == true);
2854 try expect(vec[343] == false);
2855 try expect(vec[344] == true);
2856 try expect(vec[345] == false);
2857 try expect(vec[346] == false);
2858 try expect(vec[347] == false);
2859 try expect(vec[348] == false);
2860 try expect(vec[349] == true);
2861 try expect(vec[350] == true);
2862 try expect(vec[351] == true);
2863 try expect(vec[352] == true);
2864 try expect(vec[353] == false);
2865 try expect(vec[354] == true);
2866 try expect(vec[355] == false);
2867 try expect(vec[356] == true);
2868 try expect(vec[357] == true);
2869 try expect(vec[358] == false);
2870 try expect(vec[359] == true);
2871 try expect(vec[360] == false);
2872 try expect(vec[361] == false);
2873 try expect(vec[362] == true);
2874 try expect(vec[363] == false);
2875 try expect(vec[364] == false);
2876 try expect(vec[365] == false);
2877 try expect(vec[366] == false);
2878 try expect(vec[367] == false);
2879 try expect(vec[368] == false);
2880 try expect(vec[369] == false);
2881 try expect(vec[370] == true);
2882 try expect(vec[371] == false);
2883 try expect(vec[372] == true);
2884 try expect(vec[373] == true);
2885 try expect(vec[374] == false);
2886 try expect(vec[375] == false);
2887 try expect(vec[376] == true);
2888 try expect(vec[377] == false);
2889 try expect(vec[378] == false);
2890 try expect(vec[379] == true);
2891 try expect(vec[380] == false);
2892 try expect(vec[381] == false);
2893 try expect(vec[382] == true);
2894 try expect(vec[383] == false);
2895 try expect(vec[384] == false);
2896 try expect(vec[385] == false);
2897 try expect(vec[386] == false);
2898 try expect(vec[387] == true);
2899 try expect(vec[388] == true);
2900 try expect(vec[389] == true);
2901 try expect(vec[390] == true);
2902 try expect(vec[391] == true);
2903 try expect(vec[392] == true);
2904 try expect(vec[393] == true);
2905 try expect(vec[394] == false);
2906 try expect(vec[395] == true);
2907 try expect(vec[396] == true);
2908 try expect(vec[397] == false);
2909 try expect(vec[398] == false);
2910 try expect(vec[399] == false);
2911 try expect(vec[400] == true);
2912 try expect(vec[401] == false);
2913 try expect(vec[402] == true);
2914 try expect(vec[403] == true);
2915 try expect(vec[404] == false);
2916 try expect(vec[405] == true);
2917 try expect(vec[406] == true);
2918 try expect(vec[407] == true);
2919 try expect(vec[408] == true);
2920 try expect(vec[409] == false);
2921 try expect(vec[410] == false);
2922 try expect(vec[411] == false);
2923 try expect(vec[412] == true);
2924 try expect(vec[413] == true);
2925 try expect(vec[414] == false);
2926 try expect(vec[415] == true);
2927 try expect(vec[416] == false);
2928 try expect(vec[417] == true);
2929 try expect(vec[418] == false);
2930 try expect(vec[419] == false);
2931 try expect(vec[420] == false);
2932 try expect(vec[421] == false);
2933 try expect(vec[422] == true);
2934 try expect(vec[423] == true);
2935 try expect(vec[424] == true);
2936 try expect(vec[425] == false);
2937 try expect(vec[426] == true);
2938 try expect(vec[427] == false);
2939 try expect(vec[428] == false);
2940 try expect(vec[429] == false);
2941 try expect(vec[430] == true);
2942 try expect(vec[431] == true);
2943 try expect(vec[432] == false);
2944 try expect(vec[433] == true);
2945 try expect(vec[434] == false);
2946 try expect(vec[435] == false);
2947 try expect(vec[436] == true);
2948 try expect(vec[437] == true);
2949 try expect(vec[438] == true);
2950 try expect(vec[439] == true);
2951 try expect(vec[440] == true);
2952 try expect(vec[441] == true);
2953 try expect(vec[442] == false);
2954 try expect(vec[443] == false);
2955 try expect(vec[444] == false);
2956 try expect(vec[445] == true);
2957 try expect(vec[446] == true);
2958 try expect(vec[447] == true);
2959 try expect(vec[448] == false);
2960 try expect(vec[449] == false);
2961 try expect(vec[450] == false);
2962 try expect(vec[451] == false);
2963 try expect(vec[452] == false);
2964 try expect(vec[453] == false);
2965 try expect(vec[454] == false);
2966 try expect(vec[455] == false);
2967 try expect(vec[456] == false);
2968 try expect(vec[457] == false);
2969 try expect(vec[458] == false);
2970 try expect(vec[459] == true);
2971 try expect(vec[460] == false);
2972 try expect(vec[461] == false);
2973 try expect(vec[462] == false);
2974 try expect(vec[463] == true);
2975 try expect(vec[464] == false);
2976 try expect(vec[465] == false);
2977 try expect(vec[466] == false);
2978 try expect(vec[467] == false);
2979 try expect(vec[468] == true);
2980 try expect(vec[469] == true);
2981 try expect(vec[470] == true);
2982 try expect(vec[471] == true);
2983 try expect(vec[472] == true);
2984 try expect(vec[473] == false);
2985 try expect(vec[474] == false);
2986 try expect(vec[475] == true);
2987 try expect(vec[476] == true);
2988 try expect(vec[477] == true);
2989 try expect(vec[478] == false);
2990 try expect(vec[479] == true);
2991 try expect(vec[480] == true);
2992 try expect(vec[481] == true);
2993 try expect(vec[482] == false);
2994 try expect(vec[483] == true);
2995 try expect(vec[484] == false);
2996 try expect(vec[485] == true);
2997 try expect(vec[486] == false);
2998 try expect(vec[487] == true);
2999 try expect(vec[488] == false);
3000 try expect(vec[489] == true);
3001 try expect(vec[490] == true);
3002 try expect(vec[491] == true);
3003 try expect(vec[492] == true);
3004 try expect(vec[493] == false);
3005 try expect(vec[494] == true);
3006 try expect(vec[495] == true);
3007 try expect(vec[496] == false);
3008 try expect(vec[497] == true);
3009 try expect(vec[498] == false);
3010 try expect(vec[499] == false);
3011 try expect(vec[500] == false);
3012 try expect(vec[501] == false);
3013 try expect(vec[502] == false);
3014 try expect(vec[503] == false);
3015 try expect(vec[504] == false);
3016 try expect(vec[505] == false);
3017 try expect(vec[506] == false);
3018 try expect(vec[507] == true);
3019 try expect(vec[508] == true);
3020 try expect(vec[509] == false);
3021 try expect(vec[510] == true);
3022 try expect(vec[511] == false);
3023 }
3024}
3025
3026comptime {
3027 skip: {
3028 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) break :skip;
3029 if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
3030
3031 _ = struct {
3032 export fn zig_vector_2_bool(vec: Vector2Bool) void {
3033 expect(vec[0] == false) catch @panic("test failure");
3034 expect(vec[1] == true) catch @panic("test failure");
3035 }
3036
3037 export fn zig_vector_4_bool(vec: Vector4Bool) void {
3038 expect(vec[0] == false) catch @panic("test failure");
3039 expect(vec[1] == false) catch @panic("test failure");
3040 expect(vec[2] == false) catch @panic("test failure");
3041 expect(vec[3] == false) catch @panic("test failure");
3042 }
3043
3044 export fn zig_vector_8_bool(vec: Vector8Bool) void {
3045 expect(vec[0] == true) catch @panic("test failure");
3046 expect(vec[1] == true) catch @panic("test failure");
3047 expect(vec[2] == false) catch @panic("test failure");
3048 expect(vec[3] == true) catch @panic("test failure");
3049 expect(vec[4] == false) catch @panic("test failure");
3050 expect(vec[5] == true) catch @panic("test failure");
3051 expect(vec[6] == true) catch @panic("test failure");
3052 expect(vec[7] == false) catch @panic("test failure");
3053 }
3054
3055 export fn zig_vector_16_bool(vec: Vector16Bool) void {
3056 expect(vec[0] == true) catch @panic("test failure");
3057 expect(vec[1] == false) catch @panic("test failure");
3058 expect(vec[2] == true) catch @panic("test failure");
3059 expect(vec[3] == true) catch @panic("test failure");
3060 expect(vec[4] == true) catch @panic("test failure");
3061 expect(vec[5] == false) catch @panic("test failure");
3062 expect(vec[6] == false) catch @panic("test failure");
3063 expect(vec[7] == false) catch @panic("test failure");
3064 expect(vec[8] == true) catch @panic("test failure");
3065 expect(vec[9] == true) catch @panic("test failure");
3066 expect(vec[10] == true) catch @panic("test failure");
3067 expect(vec[11] == true) catch @panic("test failure");
3068 expect(vec[12] == false) catch @panic("test failure");
3069 expect(vec[13] == false) catch @panic("test failure");
3070 expect(vec[14] == false) catch @panic("test failure");
3071 expect(vec[15] == true) catch @panic("test failure");
3072 }
3073
3074 export fn zig_vector_32_bool(vec: Vector32Bool) void {
3075 expect(vec[0] == false) catch @panic("test failure");
3076 expect(vec[1] == false) catch @panic("test failure");
3077 expect(vec[2] == false) catch @panic("test failure");
3078 expect(vec[3] == true) catch @panic("test failure");
3079 expect(vec[4] == true) catch @panic("test failure");
3080 expect(vec[5] == false) catch @panic("test failure");
3081 expect(vec[6] == false) catch @panic("test failure");
3082 expect(vec[7] == true) catch @panic("test failure");
3083 expect(vec[8] == false) catch @panic("test failure");
3084 expect(vec[9] == true) catch @panic("test failure");
3085 expect(vec[10] == true) catch @panic("test failure");
3086 expect(vec[11] == true) catch @panic("test failure");
3087 expect(vec[12] == false) catch @panic("test failure");
3088 expect(vec[13] == false) catch @panic("test failure");
3089 expect(vec[14] == true) catch @panic("test failure");
3090 expect(vec[15] == true) catch @panic("test failure");
3091 expect(vec[16] == true) catch @panic("test failure");
3092 expect(vec[17] == true) catch @panic("test failure");
3093 expect(vec[18] == true) catch @panic("test failure");
3094 expect(vec[19] == false) catch @panic("test failure");
3095 expect(vec[20] == true) catch @panic("test failure");
3096 expect(vec[21] == true) catch @panic("test failure");
3097 expect(vec[22] == true) catch @panic("test failure");
3098 expect(vec[23] == false) catch @panic("test failure");
3099 expect(vec[24] == false) catch @panic("test failure");
3100 expect(vec[25] == true) catch @panic("test failure");
3101 expect(vec[26] == true) catch @panic("test failure");
3102 expect(vec[27] == false) catch @panic("test failure");
3103 expect(vec[28] == true) catch @panic("test failure");
3104 expect(vec[29] == true) catch @panic("test failure");
3105 expect(vec[30] == false) catch @panic("test failure");
3106 expect(vec[31] == true) catch @panic("test failure");
3107 }
3108
3109 export fn zig_vector_64_bool(vec: Vector64Bool) void {
3110 expect(vec[0] == true) catch @panic("test failure");
3111 expect(vec[1] == true) catch @panic("test failure");
3112 expect(vec[2] == false) catch @panic("test failure");
3113 expect(vec[3] == true) catch @panic("test failure");
3114 expect(vec[4] == false) catch @panic("test failure");
3115 expect(vec[5] == true) catch @panic("test failure");
3116 expect(vec[6] == false) catch @panic("test failure");
3117 expect(vec[7] == false) catch @panic("test failure");
3118 expect(vec[8] == true) catch @panic("test failure");
3119 expect(vec[9] == true) catch @panic("test failure");
3120 expect(vec[10] == true) catch @panic("test failure");
3121 expect(vec[11] == true) catch @panic("test failure");
3122 expect(vec[12] == true) catch @panic("test failure");
3123 expect(vec[13] == true) catch @panic("test failure");
3124 expect(vec[14] == true) catch @panic("test failure");
3125 expect(vec[15] == false) catch @panic("test failure");
3126 expect(vec[16] == false) catch @panic("test failure");
3127 expect(vec[17] == true) catch @panic("test failure");
3128 expect(vec[18] == true) catch @panic("test failure");
3129 expect(vec[19] == false) catch @panic("test failure");
3130 expect(vec[20] == true) catch @panic("test failure");
3131 expect(vec[21] == true) catch @panic("test failure");
3132 expect(vec[22] == true) catch @panic("test failure");
3133 expect(vec[23] == true) catch @panic("test failure");
3134 expect(vec[24] == false) catch @panic("test failure");
3135 expect(vec[25] == false) catch @panic("test failure");
3136 expect(vec[26] == true) catch @panic("test failure");
3137 expect(vec[27] == false) catch @panic("test failure");
3138 expect(vec[28] == false) catch @panic("test failure");
3139 expect(vec[29] == true) catch @panic("test failure");
3140 expect(vec[30] == false) catch @panic("test failure");
3141 expect(vec[31] == true) catch @panic("test failure");
3142 expect(vec[32] == false) catch @panic("test failure");
3143 expect(vec[33] == true) catch @panic("test failure");
3144 expect(vec[34] == true) catch @panic("test failure");
3145 expect(vec[35] == false) catch @panic("test failure");
3146 expect(vec[36] == true) catch @panic("test failure");
3147 expect(vec[37] == true) catch @panic("test failure");
3148 expect(vec[38] == false) catch @panic("test failure");
3149 expect(vec[39] == false) catch @panic("test failure");
3150 expect(vec[40] == true) catch @panic("test failure");
3151 expect(vec[41] == true) catch @panic("test failure");
3152 expect(vec[42] == true) catch @panic("test failure");
3153 expect(vec[43] == true) catch @panic("test failure");
3154 expect(vec[44] == true) catch @panic("test failure");
3155 expect(vec[45] == false) catch @panic("test failure");
3156 expect(vec[46] == true) catch @panic("test failure");
3157 expect(vec[47] == false) catch @panic("test failure");
3158 expect(vec[48] == false) catch @panic("test failure");
3159 expect(vec[49] == false) catch @panic("test failure");
3160 expect(vec[50] == false) catch @panic("test failure");
3161 expect(vec[51] == false) catch @panic("test failure");
3162 expect(vec[52] == true) catch @panic("test failure");
3163 expect(vec[53] == false) catch @panic("test failure");
3164 expect(vec[54] == false) catch @panic("test failure");
3165 expect(vec[55] == true) catch @panic("test failure");
3166 expect(vec[56] == true) catch @panic("test failure");
3167 expect(vec[57] == false) catch @panic("test failure");
3168 expect(vec[58] == false) catch @panic("test failure");
3169 expect(vec[59] == false) catch @panic("test failure");
3170 expect(vec[60] == true) catch @panic("test failure");
3171 expect(vec[61] == true) catch @panic("test failure");
3172 expect(vec[62] == true) catch @panic("test failure");
3173 expect(vec[63] == true) catch @panic("test failure");
3174 }
3175
3176 export fn zig_vector_128_bool(vec: Vector128Bool) void {
3177 expect(vec[0] == true) catch @panic("test failure");
3178 expect(vec[1] == true) catch @panic("test failure");
3179 expect(vec[2] == false) catch @panic("test failure");
3180 expect(vec[3] == true) catch @panic("test failure");
3181 expect(vec[4] == true) catch @panic("test failure");
3182 expect(vec[5] == false) catch @panic("test failure");
3183 expect(vec[6] == false) catch @panic("test failure");
3184 expect(vec[7] == true) catch @panic("test failure");
3185 expect(vec[8] == true) catch @panic("test failure");
3186 expect(vec[9] == true) catch @panic("test failure");
3187 expect(vec[10] == true) catch @panic("test failure");
3188 expect(vec[11] == true) catch @panic("test failure");
3189 expect(vec[12] == false) catch @panic("test failure");
3190 expect(vec[13] == false) catch @panic("test failure");
3191 expect(vec[14] == false) catch @panic("test failure");
3192 expect(vec[15] == true) catch @panic("test failure");
3193 expect(vec[16] == false) catch @panic("test failure");
3194 expect(vec[17] == true) catch @panic("test failure");
3195 expect(vec[18] == false) catch @panic("test failure");
3196 expect(vec[19] == false) catch @panic("test failure");
3197 expect(vec[20] == true) catch @panic("test failure");
3198 expect(vec[21] == false) catch @panic("test failure");
3199 expect(vec[22] == true) catch @panic("test failure");
3200 expect(vec[23] == false) catch @panic("test failure");
3201 expect(vec[24] == false) catch @panic("test failure");
3202 expect(vec[25] == false) catch @panic("test failure");
3203 expect(vec[26] == true) catch @panic("test failure");
3204 expect(vec[27] == false) catch @panic("test failure");
3205 expect(vec[28] == true) catch @panic("test failure");
3206 expect(vec[29] == true) catch @panic("test failure");
3207 expect(vec[30] == false) catch @panic("test failure");
3208 expect(vec[31] == true) catch @panic("test failure");
3209 expect(vec[32] == false) catch @panic("test failure");
3210 expect(vec[33] == true) catch @panic("test failure");
3211 expect(vec[34] == true) catch @panic("test failure");
3212 expect(vec[35] == false) catch @panic("test failure");
3213 expect(vec[36] == false) catch @panic("test failure");
3214 expect(vec[37] == false) catch @panic("test failure");
3215 expect(vec[38] == false) catch @panic("test failure");
3216 expect(vec[39] == true) catch @panic("test failure");
3217 expect(vec[40] == true) catch @panic("test failure");
3218 expect(vec[41] == false) catch @panic("test failure");
3219 expect(vec[42] == true) catch @panic("test failure");
3220 expect(vec[43] == false) catch @panic("test failure");
3221 expect(vec[44] == false) catch @panic("test failure");
3222 expect(vec[45] == true) catch @panic("test failure");
3223 expect(vec[46] == false) catch @panic("test failure");
3224 expect(vec[47] == false) catch @panic("test failure");
3225 expect(vec[48] == true) catch @panic("test failure");
3226 expect(vec[49] == true) catch @panic("test failure");
3227 expect(vec[50] == false) catch @panic("test failure");
3228 expect(vec[51] == false) catch @panic("test failure");
3229 expect(vec[52] == true) catch @panic("test failure");
3230 expect(vec[53] == false) catch @panic("test failure");
3231 expect(vec[54] == false) catch @panic("test failure");
3232 expect(vec[55] == true) catch @panic("test failure");
3233 expect(vec[56] == true) catch @panic("test failure");
3234 expect(vec[57] == true) catch @panic("test failure");
3235 expect(vec[58] == true) catch @panic("test failure");
3236 expect(vec[59] == true) catch @panic("test failure");
3237 expect(vec[60] == true) catch @panic("test failure");
3238 expect(vec[61] == true) catch @panic("test failure");
3239 expect(vec[62] == true) catch @panic("test failure");
3240 expect(vec[63] == false) catch @panic("test failure");
3241 expect(vec[64] == false) catch @panic("test failure");
3242 expect(vec[65] == true) catch @panic("test failure");
3243 expect(vec[66] == false) catch @panic("test failure");
3244 expect(vec[67] == true) catch @panic("test failure");
3245 expect(vec[68] == true) catch @panic("test failure");
3246 expect(vec[69] == true) catch @panic("test failure");
3247 expect(vec[70] == true) catch @panic("test failure");
3248 expect(vec[71] == false) catch @panic("test failure");
3249 expect(vec[72] == false) catch @panic("test failure");
3250 expect(vec[73] == false) catch @panic("test failure");
3251 expect(vec[74] == true) catch @panic("test failure");
3252 expect(vec[75] == true) catch @panic("test failure");
3253 expect(vec[76] == false) catch @panic("test failure");
3254 expect(vec[77] == true) catch @panic("test failure");
3255 expect(vec[78] == true) catch @panic("test failure");
3256 expect(vec[79] == true) catch @panic("test failure");
3257 expect(vec[80] == true) catch @panic("test failure");
3258 expect(vec[81] == false) catch @panic("test failure");
3259 expect(vec[82] == true) catch @panic("test failure");
3260 expect(vec[83] == true) catch @panic("test failure");
3261 expect(vec[84] == true) catch @panic("test failure");
3262 expect(vec[85] == true) catch @panic("test failure");
3263 expect(vec[86] == true) catch @panic("test failure");
3264 expect(vec[87] == true) catch @panic("test failure");
3265 expect(vec[88] == false) catch @panic("test failure");
3266 expect(vec[89] == true) catch @panic("test failure");
3267 expect(vec[90] == true) catch @panic("test failure");
3268 expect(vec[91] == true) catch @panic("test failure");
3269 expect(vec[92] == true) catch @panic("test failure");
3270 expect(vec[93] == true) catch @panic("test failure");
3271 expect(vec[94] == true) catch @panic("test failure");
3272 expect(vec[95] == false) catch @panic("test failure");
3273 expect(vec[96] == false) catch @panic("test failure");
3274 expect(vec[97] == false) catch @panic("test failure");
3275 expect(vec[98] == true) catch @panic("test failure");
3276 expect(vec[99] == true) catch @panic("test failure");
3277 expect(vec[100] == true) catch @panic("test failure");
3278 expect(vec[101] == true) catch @panic("test failure");
3279 expect(vec[102] == true) catch @panic("test failure");
3280 expect(vec[103] == true) catch @panic("test failure");
3281 expect(vec[104] == true) catch @panic("test failure");
3282 expect(vec[105] == false) catch @panic("test failure");
3283 expect(vec[106] == false) catch @panic("test failure");
3284 expect(vec[107] == false) catch @panic("test failure");
3285 expect(vec[108] == false) catch @panic("test failure");
3286 expect(vec[109] == false) catch @panic("test failure");
3287 expect(vec[110] == true) catch @panic("test failure");
3288 expect(vec[111] == true) catch @panic("test failure");
3289 expect(vec[112] == true) catch @panic("test failure");
3290 expect(vec[113] == false) catch @panic("test failure");
3291 expect(vec[114] == false) catch @panic("test failure");
3292 expect(vec[115] == false) catch @panic("test failure");
3293 expect(vec[116] == false) catch @panic("test failure");
3294 expect(vec[117] == false) catch @panic("test failure");
3295 expect(vec[118] == true) catch @panic("test failure");
3296 expect(vec[119] == false) catch @panic("test failure");
3297 expect(vec[120] == false) catch @panic("test failure");
3298 expect(vec[121] == false) catch @panic("test failure");
3299 expect(vec[122] == false) catch @panic("test failure");
3300 expect(vec[123] == true) catch @panic("test failure");
3301 expect(vec[124] == true) catch @panic("test failure");
3302 expect(vec[125] == false) catch @panic("test failure");
3303 expect(vec[126] == true) catch @panic("test failure");
3304 expect(vec[127] == false) catch @panic("test failure");
3305 }
3306
3307 export fn zig_vector_256_bool(vec: Vector256Bool) void {
3308 expect(vec[0] == false) catch @panic("test failure");
3309 expect(vec[1] == false) catch @panic("test failure");
3310 expect(vec[2] == false) catch @panic("test failure");
3311 expect(vec[3] == false) catch @panic("test failure");
3312 expect(vec[4] == true) catch @panic("test failure");
3313 expect(vec[5] == true) catch @panic("test failure");
3314 expect(vec[6] == false) catch @panic("test failure");
3315 expect(vec[7] == false) catch @panic("test failure");
3316 expect(vec[8] == false) catch @panic("test failure");
3317 expect(vec[9] == true) catch @panic("test failure");
3318 expect(vec[10] == true) catch @panic("test failure");
3319 expect(vec[11] == false) catch @panic("test failure");
3320 expect(vec[12] == true) catch @panic("test failure");
3321 expect(vec[13] == false) catch @panic("test failure");
3322 expect(vec[14] == false) catch @panic("test failure");
3323 expect(vec[15] == false) catch @panic("test failure");
3324 expect(vec[16] == false) catch @panic("test failure");
3325 expect(vec[17] == true) catch @panic("test failure");
3326 expect(vec[18] == true) catch @panic("test failure");
3327 expect(vec[19] == true) catch @panic("test failure");
3328 expect(vec[20] == false) catch @panic("test failure");
3329 expect(vec[21] == true) catch @panic("test failure");
3330 expect(vec[22] == true) catch @panic("test failure");
3331 expect(vec[23] == false) catch @panic("test failure");
3332 expect(vec[24] == true) catch @panic("test failure");
3333 expect(vec[25] == false) catch @panic("test failure");
3334 expect(vec[26] == false) catch @panic("test failure");
3335 expect(vec[27] == true) catch @panic("test failure");
3336 expect(vec[28] == true) catch @panic("test failure");
3337 expect(vec[29] == true) catch @panic("test failure");
3338 expect(vec[30] == false) catch @panic("test failure");
3339 expect(vec[31] == true) catch @panic("test failure");
3340 expect(vec[32] == false) catch @panic("test failure");
3341 expect(vec[33] == true) catch @panic("test failure");
3342 expect(vec[34] == false) catch @panic("test failure");
3343 expect(vec[35] == false) catch @panic("test failure");
3344 expect(vec[36] == false) catch @panic("test failure");
3345 expect(vec[37] == true) catch @panic("test failure");
3346 expect(vec[38] == false) catch @panic("test failure");
3347 expect(vec[39] == false) catch @panic("test failure");
3348 expect(vec[40] == true) catch @panic("test failure");
3349 expect(vec[41] == true) catch @panic("test failure");
3350 expect(vec[42] == false) catch @panic("test failure");
3351 expect(vec[43] == true) catch @panic("test failure");
3352 expect(vec[44] == true) catch @panic("test failure");
3353 expect(vec[45] == false) catch @panic("test failure");
3354 expect(vec[46] == true) catch @panic("test failure");
3355 expect(vec[47] == false) catch @panic("test failure");
3356 expect(vec[48] == true) catch @panic("test failure");
3357 expect(vec[49] == false) catch @panic("test failure");
3358 expect(vec[50] == true) catch @panic("test failure");
3359 expect(vec[51] == false) catch @panic("test failure");
3360 expect(vec[52] == true) catch @panic("test failure");
3361 expect(vec[53] == true) catch @panic("test failure");
3362 expect(vec[54] == true) catch @panic("test failure");
3363 expect(vec[55] == false) catch @panic("test failure");
3364 expect(vec[56] == false) catch @panic("test failure");
3365 expect(vec[57] == true) catch @panic("test failure");
3366 expect(vec[58] == true) catch @panic("test failure");
3367 expect(vec[59] == false) catch @panic("test failure");
3368 expect(vec[60] == false) catch @panic("test failure");
3369 expect(vec[61] == true) catch @panic("test failure");
3370 expect(vec[62] == true) catch @panic("test failure");
3371 expect(vec[63] == false) catch @panic("test failure");
3372 expect(vec[64] == false) catch @panic("test failure");
3373 expect(vec[65] == false) catch @panic("test failure");
3374 expect(vec[66] == true) catch @panic("test failure");
3375 expect(vec[67] == true) catch @panic("test failure");
3376 expect(vec[68] == false) catch @panic("test failure");
3377 expect(vec[69] == true) catch @panic("test failure");
3378 expect(vec[70] == false) catch @panic("test failure");
3379 expect(vec[71] == true) catch @panic("test failure");
3380 expect(vec[72] == false) catch @panic("test failure");
3381 expect(vec[73] == true) catch @panic("test failure");
3382 expect(vec[74] == false) catch @panic("test failure");
3383 expect(vec[75] == false) catch @panic("test failure");
3384 expect(vec[76] == true) catch @panic("test failure");
3385 expect(vec[77] == false) catch @panic("test failure");
3386 expect(vec[78] == false) catch @panic("test failure");
3387 expect(vec[79] == false) catch @panic("test failure");
3388 expect(vec[80] == false) catch @panic("test failure");
3389 expect(vec[81] == false) catch @panic("test failure");
3390 expect(vec[82] == true) catch @panic("test failure");
3391 expect(vec[83] == false) catch @panic("test failure");
3392 expect(vec[84] == false) catch @panic("test failure");
3393 expect(vec[85] == false) catch @panic("test failure");
3394 expect(vec[86] == true) catch @panic("test failure");
3395 expect(vec[87] == true) catch @panic("test failure");
3396 expect(vec[88] == true) catch @panic("test failure");
3397 expect(vec[89] == false) catch @panic("test failure");
3398 expect(vec[90] == true) catch @panic("test failure");
3399 expect(vec[91] == false) catch @panic("test failure");
3400 expect(vec[92] == true) catch @panic("test failure");
3401 expect(vec[93] == false) catch @panic("test failure");
3402 expect(vec[94] == true) catch @panic("test failure");
3403 expect(vec[95] == true) catch @panic("test failure");
3404 expect(vec[96] == true) catch @panic("test failure");
3405 expect(vec[97] == true) catch @panic("test failure");
3406 expect(vec[98] == false) catch @panic("test failure");
3407 expect(vec[99] == true) catch @panic("test failure");
3408 expect(vec[100] == false) catch @panic("test failure");
3409 expect(vec[101] == true) catch @panic("test failure");
3410 expect(vec[102] == true) catch @panic("test failure");
3411 expect(vec[103] == false) catch @panic("test failure");
3412 expect(vec[104] == false) catch @panic("test failure");
3413 expect(vec[105] == true) catch @panic("test failure");
3414 expect(vec[106] == false) catch @panic("test failure");
3415 expect(vec[107] == true) catch @panic("test failure");
3416 expect(vec[108] == false) catch @panic("test failure");
3417 expect(vec[109] == false) catch @panic("test failure");
3418 expect(vec[110] == false) catch @panic("test failure");
3419 expect(vec[111] == false) catch @panic("test failure");
3420 expect(vec[112] == false) catch @panic("test failure");
3421 expect(vec[113] == false) catch @panic("test failure");
3422 expect(vec[114] == false) catch @panic("test failure");
3423 expect(vec[115] == false) catch @panic("test failure");
3424 expect(vec[116] == false) catch @panic("test failure");
3425 expect(vec[117] == false) catch @panic("test failure");
3426 expect(vec[118] == false) catch @panic("test failure");
3427 expect(vec[119] == false) catch @panic("test failure");
3428 expect(vec[120] == false) catch @panic("test failure");
3429 expect(vec[121] == false) catch @panic("test failure");
3430 expect(vec[122] == true) catch @panic("test failure");
3431 expect(vec[123] == true) catch @panic("test failure");
3432 expect(vec[124] == false) catch @panic("test failure");
3433 expect(vec[125] == false) catch @panic("test failure");
3434 expect(vec[126] == false) catch @panic("test failure");
3435 expect(vec[127] == true) catch @panic("test failure");
3436 expect(vec[128] == true) catch @panic("test failure");
3437 expect(vec[129] == true) catch @panic("test failure");
3438 expect(vec[130] == true) catch @panic("test failure");
3439 expect(vec[131] == false) catch @panic("test failure");
3440 expect(vec[132] == false) catch @panic("test failure");
3441 expect(vec[133] == false) catch @panic("test failure");
3442 expect(vec[134] == true) catch @panic("test failure");
3443 expect(vec[135] == true) catch @panic("test failure");
3444 expect(vec[136] == false) catch @panic("test failure");
3445 expect(vec[137] == false) catch @panic("test failure");
3446 expect(vec[138] == true) catch @panic("test failure");
3447 expect(vec[139] == true) catch @panic("test failure");
3448 expect(vec[140] == true) catch @panic("test failure");
3449 expect(vec[141] == true) catch @panic("test failure");
3450 expect(vec[142] == true) catch @panic("test failure");
3451 expect(vec[143] == false) catch @panic("test failure");
3452 expect(vec[144] == true) catch @panic("test failure");
3453 expect(vec[145] == true) catch @panic("test failure");
3454 expect(vec[146] == true) catch @panic("test failure");
3455 expect(vec[147] == false) catch @panic("test failure");
3456 expect(vec[148] == false) catch @panic("test failure");
3457 expect(vec[149] == false) catch @panic("test failure");
3458 expect(vec[150] == false) catch @panic("test failure");
3459 expect(vec[151] == false) catch @panic("test failure");
3460 expect(vec[152] == false) catch @panic("test failure");
3461 expect(vec[153] == false) catch @panic("test failure");
3462 expect(vec[154] == true) catch @panic("test failure");
3463 expect(vec[155] == false) catch @panic("test failure");
3464 expect(vec[156] == false) catch @panic("test failure");
3465 expect(vec[157] == false) catch @panic("test failure");
3466 expect(vec[158] == true) catch @panic("test failure");
3467 expect(vec[159] == true) catch @panic("test failure");
3468 expect(vec[160] == false) catch @panic("test failure");
3469 expect(vec[161] == true) catch @panic("test failure");
3470 expect(vec[162] == false) catch @panic("test failure");
3471 expect(vec[163] == false) catch @panic("test failure");
3472 expect(vec[164] == false) catch @panic("test failure");
3473 expect(vec[165] == true) catch @panic("test failure");
3474 expect(vec[166] == false) catch @panic("test failure");
3475 expect(vec[167] == true) catch @panic("test failure");
3476 expect(vec[168] == false) catch @panic("test failure");
3477 expect(vec[169] == false) catch @panic("test failure");
3478 expect(vec[170] == false) catch @panic("test failure");
3479 expect(vec[171] == false) catch @panic("test failure");
3480 expect(vec[172] == true) catch @panic("test failure");
3481 expect(vec[173] == true) catch @panic("test failure");
3482 expect(vec[174] == true) catch @panic("test failure");
3483 expect(vec[175] == true) catch @panic("test failure");
3484 expect(vec[176] == true) catch @panic("test failure");
3485 expect(vec[177] == true) catch @panic("test failure");
3486 expect(vec[178] == false) catch @panic("test failure");
3487 expect(vec[179] == true) catch @panic("test failure");
3488 expect(vec[180] == true) catch @panic("test failure");
3489 expect(vec[181] == false) catch @panic("test failure");
3490 expect(vec[182] == true) catch @panic("test failure");
3491 expect(vec[183] == false) catch @panic("test failure");
3492 expect(vec[184] == true) catch @panic("test failure");
3493 expect(vec[185] == false) catch @panic("test failure");
3494 expect(vec[186] == true) catch @panic("test failure");
3495 expect(vec[187] == false) catch @panic("test failure");
3496 expect(vec[188] == true) catch @panic("test failure");
3497 expect(vec[189] == false) catch @panic("test failure");
3498 expect(vec[190] == false) catch @panic("test failure");
3499 expect(vec[191] == false) catch @panic("test failure");
3500 expect(vec[192] == false) catch @panic("test failure");
3501 expect(vec[193] == true) catch @panic("test failure");
3502 expect(vec[194] == true) catch @panic("test failure");
3503 expect(vec[195] == true) catch @panic("test failure");
3504 expect(vec[196] == false) catch @panic("test failure");
3505 expect(vec[197] == false) catch @panic("test failure");
3506 expect(vec[198] == true) catch @panic("test failure");
3507 expect(vec[199] == false) catch @panic("test failure");
3508 expect(vec[200] == false) catch @panic("test failure");
3509 expect(vec[201] == true) catch @panic("test failure");
3510 expect(vec[202] == true) catch @panic("test failure");
3511 expect(vec[203] == false) catch @panic("test failure");
3512 expect(vec[204] == true) catch @panic("test failure");
3513 expect(vec[205] == false) catch @panic("test failure");
3514 expect(vec[206] == true) catch @panic("test failure");
3515 expect(vec[207] == false) catch @panic("test failure");
3516 expect(vec[208] == false) catch @panic("test failure");
3517 expect(vec[209] == false) catch @panic("test failure");
3518 expect(vec[210] == true) catch @panic("test failure");
3519 expect(vec[211] == true) catch @panic("test failure");
3520 expect(vec[212] == false) catch @panic("test failure");
3521 expect(vec[213] == false) catch @panic("test failure");
3522 expect(vec[214] == false) catch @panic("test failure");
3523 expect(vec[215] == true) catch @panic("test failure");
3524 expect(vec[216] == false) catch @panic("test failure");
3525 expect(vec[217] == true) catch @panic("test failure");
3526 expect(vec[218] == true) catch @panic("test failure");
3527 expect(vec[219] == true) catch @panic("test failure");
3528 expect(vec[220] == false) catch @panic("test failure");
3529 expect(vec[221] == true) catch @panic("test failure");
3530 expect(vec[222] == false) catch @panic("test failure");
3531 expect(vec[223] == true) catch @panic("test failure");
3532 expect(vec[224] == false) catch @panic("test failure");
3533 expect(vec[225] == false) catch @panic("test failure");
3534 expect(vec[226] == false) catch @panic("test failure");
3535 expect(vec[227] == true) catch @panic("test failure");
3536 expect(vec[228] == true) catch @panic("test failure");
3537 expect(vec[229] == false) catch @panic("test failure");
3538 expect(vec[230] == false) catch @panic("test failure");
3539 expect(vec[231] == false) catch @panic("test failure");
3540 expect(vec[232] == false) catch @panic("test failure");
3541 expect(vec[233] == false) catch @panic("test failure");
3542 expect(vec[234] == true) catch @panic("test failure");
3543 expect(vec[235] == false) catch @panic("test failure");
3544 expect(vec[236] == false) catch @panic("test failure");
3545 expect(vec[237] == false) catch @panic("test failure");
3546 expect(vec[238] == true) catch @panic("test failure");
3547 expect(vec[239] == false) catch @panic("test failure");
3548 expect(vec[240] == true) catch @panic("test failure");
3549 expect(vec[241] == true) catch @panic("test failure");
3550 expect(vec[242] == true) catch @panic("test failure");
3551 expect(vec[243] == false) catch @panic("test failure");
3552 expect(vec[244] == false) catch @panic("test failure");
3553 expect(vec[245] == true) catch @panic("test failure");
3554 expect(vec[246] == false) catch @panic("test failure");
3555 expect(vec[247] == false) catch @panic("test failure");
3556 expect(vec[248] == false) catch @panic("test failure");
3557 expect(vec[249] == true) catch @panic("test failure");
3558 expect(vec[250] == false) catch @panic("test failure");
3559 expect(vec[251] == false) catch @panic("test failure");
3560 expect(vec[252] == true) catch @panic("test failure");
3561 expect(vec[253] == true) catch @panic("test failure");
3562 expect(vec[254] == true) catch @panic("test failure");
3563 expect(vec[255] == true) catch @panic("test failure");
3564 }
3565
3566 export fn zig_vector_512_bool(vec: Vector512Bool) void {
3567 expect(vec[0] == false) catch @panic("test failure");
3568 expect(vec[1] == true) catch @panic("test failure");
3569 expect(vec[2] == true) catch @panic("test failure");
3570 expect(vec[3] == false) catch @panic("test failure");
3571 expect(vec[4] == true) catch @panic("test failure");
3572 expect(vec[5] == false) catch @panic("test failure");
3573 expect(vec[6] == true) catch @panic("test failure");
3574 expect(vec[7] == false) catch @panic("test failure");
3575 expect(vec[8] == false) catch @panic("test failure");
3576 expect(vec[9] == false) catch @panic("test failure");
3577 expect(vec[10] == false) catch @panic("test failure");
3578 expect(vec[11] == false) catch @panic("test failure");
3579 expect(vec[12] == true) catch @panic("test failure");
3580 expect(vec[13] == false) catch @panic("test failure");
3581 expect(vec[14] == true) catch @panic("test failure");
3582 expect(vec[15] == false) catch @panic("test failure");
3583 expect(vec[16] == false) catch @panic("test failure");
3584 expect(vec[17] == false) catch @panic("test failure");
3585 expect(vec[18] == true) catch @panic("test failure");
3586 expect(vec[19] == true) catch @panic("test failure");
3587 expect(vec[20] == true) catch @panic("test failure");
3588 expect(vec[21] == true) catch @panic("test failure");
3589 expect(vec[22] == false) catch @panic("test failure");
3590 expect(vec[23] == false) catch @panic("test failure");
3591 expect(vec[24] == false) catch @panic("test failure");
3592 expect(vec[25] == true) catch @panic("test failure");
3593 expect(vec[26] == true) catch @panic("test failure");
3594 expect(vec[27] == false) catch @panic("test failure");
3595 expect(vec[28] == true) catch @panic("test failure");
3596 expect(vec[29] == true) catch @panic("test failure");
3597 expect(vec[30] == false) catch @panic("test failure");
3598 expect(vec[31] == false) catch @panic("test failure");
3599 expect(vec[32] == true) catch @panic("test failure");
3600 expect(vec[33] == true) catch @panic("test failure");
3601 expect(vec[34] == false) catch @panic("test failure");
3602 expect(vec[35] == false) catch @panic("test failure");
3603 expect(vec[36] == false) catch @panic("test failure");
3604 expect(vec[37] == false) catch @panic("test failure");
3605 expect(vec[38] == false) catch @panic("test failure");
3606 expect(vec[39] == false) catch @panic("test failure");
3607 expect(vec[40] == false) catch @panic("test failure");
3608 expect(vec[41] == true) catch @panic("test failure");
3609 expect(vec[42] == true) catch @panic("test failure");
3610 expect(vec[43] == true) catch @panic("test failure");
3611 expect(vec[44] == false) catch @panic("test failure");
3612 expect(vec[45] == true) catch @panic("test failure");
3613 expect(vec[46] == true) catch @panic("test failure");
3614 expect(vec[47] == true) catch @panic("test failure");
3615 expect(vec[48] == true) catch @panic("test failure");
3616 expect(vec[49] == true) catch @panic("test failure");
3617 expect(vec[50] == false) catch @panic("test failure");
3618 expect(vec[51] == true) catch @panic("test failure");
3619 expect(vec[52] == true) catch @panic("test failure");
3620 expect(vec[53] == true) catch @panic("test failure");
3621 expect(vec[54] == false) catch @panic("test failure");
3622 expect(vec[55] == true) catch @panic("test failure");
3623 expect(vec[56] == false) catch @panic("test failure");
3624 expect(vec[57] == false) catch @panic("test failure");
3625 expect(vec[58] == true) catch @panic("test failure");
3626 expect(vec[59] == false) catch @panic("test failure");
3627 expect(vec[60] == true) catch @panic("test failure");
3628 expect(vec[61] == true) catch @panic("test failure");
3629 expect(vec[62] == false) catch @panic("test failure");
3630 expect(vec[63] == false) catch @panic("test failure");
3631 expect(vec[64] == false) catch @panic("test failure");
3632 expect(vec[65] == true) catch @panic("test failure");
3633 expect(vec[66] == true) catch @panic("test failure");
3634 expect(vec[67] == true) catch @panic("test failure");
3635 expect(vec[68] == true) catch @panic("test failure");
3636 expect(vec[69] == false) catch @panic("test failure");
3637 expect(vec[70] == false) catch @panic("test failure");
3638 expect(vec[71] == true) catch @panic("test failure");
3639 expect(vec[72] == true) catch @panic("test failure");
3640 expect(vec[73] == false) catch @panic("test failure");
3641 expect(vec[74] == true) catch @panic("test failure");
3642 expect(vec[75] == true) catch @panic("test failure");
3643 expect(vec[76] == false) catch @panic("test failure");
3644 expect(vec[77] == false) catch @panic("test failure");
3645 expect(vec[78] == true) catch @panic("test failure");
3646 expect(vec[79] == false) catch @panic("test failure");
3647 expect(vec[80] == false) catch @panic("test failure");
3648 expect(vec[81] == false) catch @panic("test failure");
3649 expect(vec[82] == true) catch @panic("test failure");
3650 expect(vec[83] == true) catch @panic("test failure");
3651 expect(vec[84] == true) catch @panic("test failure");
3652 expect(vec[85] == false) catch @panic("test failure");
3653 expect(vec[86] == false) catch @panic("test failure");
3654 expect(vec[87] == true) catch @panic("test failure");
3655 expect(vec[88] == false) catch @panic("test failure");
3656 expect(vec[89] == true) catch @panic("test failure");
3657 expect(vec[90] == false) catch @panic("test failure");
3658 expect(vec[91] == false) catch @panic("test failure");
3659 expect(vec[92] == true) catch @panic("test failure");
3660 expect(vec[93] == false) catch @panic("test failure");
3661 expect(vec[94] == false) catch @panic("test failure");
3662 expect(vec[95] == true) catch @panic("test failure");
3663 expect(vec[96] == true) catch @panic("test failure");
3664 expect(vec[97] == false) catch @panic("test failure");
3665 expect(vec[98] == false) catch @panic("test failure");
3666 expect(vec[99] == false) catch @panic("test failure");
3667 expect(vec[100] == false) catch @panic("test failure");
3668 expect(vec[101] == true) catch @panic("test failure");
3669 expect(vec[102] == false) catch @panic("test failure");
3670 expect(vec[103] == false) catch @panic("test failure");
3671 expect(vec[104] == false) catch @panic("test failure");
3672 expect(vec[105] == false) catch @panic("test failure");
3673 expect(vec[106] == false) catch @panic("test failure");
3674 expect(vec[107] == false) catch @panic("test failure");
3675 expect(vec[108] == true) catch @panic("test failure");
3676 expect(vec[109] == true) catch @panic("test failure");
3677 expect(vec[110] == true) catch @panic("test failure");
3678 expect(vec[111] == true) catch @panic("test failure");
3679 expect(vec[112] == true) catch @panic("test failure");
3680 expect(vec[113] == false) catch @panic("test failure");
3681 expect(vec[114] == false) catch @panic("test failure");
3682 expect(vec[115] == false) catch @panic("test failure");
3683 expect(vec[116] == false) catch @panic("test failure");
3684 expect(vec[117] == true) catch @panic("test failure");
3685 expect(vec[118] == true) catch @panic("test failure");
3686 expect(vec[119] == false) catch @panic("test failure");
3687 expect(vec[120] == true) catch @panic("test failure");
3688 expect(vec[121] == true) catch @panic("test failure");
3689 expect(vec[122] == false) catch @panic("test failure");
3690 expect(vec[123] == false) catch @panic("test failure");
3691 expect(vec[124] == true) catch @panic("test failure");
3692 expect(vec[125] == false) catch @panic("test failure");
3693 expect(vec[126] == false) catch @panic("test failure");
3694 expect(vec[127] == false) catch @panic("test failure");
3695 expect(vec[128] == false) catch @panic("test failure");
3696 expect(vec[129] == true) catch @panic("test failure");
3697 expect(vec[130] == true) catch @panic("test failure");
3698 expect(vec[131] == true) catch @panic("test failure");
3699 expect(vec[132] == true) catch @panic("test failure");
3700 expect(vec[133] == false) catch @panic("test failure");
3701 expect(vec[134] == false) catch @panic("test failure");
3702 expect(vec[135] == false) catch @panic("test failure");
3703 expect(vec[136] == false) catch @panic("test failure");
3704 expect(vec[137] == true) catch @panic("test failure");
3705 expect(vec[138] == false) catch @panic("test failure");
3706 expect(vec[139] == false) catch @panic("test failure");
3707 expect(vec[140] == false) catch @panic("test failure");
3708 expect(vec[141] == false) catch @panic("test failure");
3709 expect(vec[142] == true) catch @panic("test failure");
3710 expect(vec[143] == true) catch @panic("test failure");
3711 expect(vec[144] == false) catch @panic("test failure");
3712 expect(vec[145] == true) catch @panic("test failure");
3713 expect(vec[146] == false) catch @panic("test failure");
3714 expect(vec[147] == true) catch @panic("test failure");
3715 expect(vec[148] == false) catch @panic("test failure");
3716 expect(vec[149] == false) catch @panic("test failure");
3717 expect(vec[150] == true) catch @panic("test failure");
3718 expect(vec[151] == true) catch @panic("test failure");
3719 expect(vec[152] == false) catch @panic("test failure");
3720 expect(vec[153] == true) catch @panic("test failure");
3721 expect(vec[154] == true) catch @panic("test failure");
3722 expect(vec[155] == false) catch @panic("test failure");
3723 expect(vec[156] == false) catch @panic("test failure");
3724 expect(vec[157] == false) catch @panic("test failure");
3725 expect(vec[158] == true) catch @panic("test failure");
3726 expect(vec[159] == false) catch @panic("test failure");
3727 expect(vec[160] == false) catch @panic("test failure");
3728 expect(vec[161] == false) catch @panic("test failure");
3729 expect(vec[162] == false) catch @panic("test failure");
3730 expect(vec[163] == true) catch @panic("test failure");
3731 expect(vec[164] == true) catch @panic("test failure");
3732 expect(vec[165] == false) catch @panic("test failure");
3733 expect(vec[166] == false) catch @panic("test failure");
3734 expect(vec[167] == true) catch @panic("test failure");
3735 expect(vec[168] == false) catch @panic("test failure");
3736 expect(vec[169] == true) catch @panic("test failure");
3737 expect(vec[170] == true) catch @panic("test failure");
3738 expect(vec[171] == false) catch @panic("test failure");
3739 expect(vec[172] == false) catch @panic("test failure");
3740 expect(vec[173] == false) catch @panic("test failure");
3741 expect(vec[174] == false) catch @panic("test failure");
3742 expect(vec[175] == false) catch @panic("test failure");
3743 expect(vec[176] == false) catch @panic("test failure");
3744 expect(vec[177] == true) catch @panic("test failure");
3745 expect(vec[178] == false) catch @panic("test failure");
3746 expect(vec[179] == false) catch @panic("test failure");
3747 expect(vec[180] == false) catch @panic("test failure");
3748 expect(vec[181] == false) catch @panic("test failure");
3749 expect(vec[182] == false) catch @panic("test failure");
3750 expect(vec[183] == false) catch @panic("test failure");
3751 expect(vec[184] == true) catch @panic("test failure");
3752 expect(vec[185] == false) catch @panic("test failure");
3753 expect(vec[186] == false) catch @panic("test failure");
3754 expect(vec[187] == false) catch @panic("test failure");
3755 expect(vec[188] == false) catch @panic("test failure");
3756 expect(vec[189] == true) catch @panic("test failure");
3757 expect(vec[190] == false) catch @panic("test failure");
3758 expect(vec[191] == false) catch @panic("test failure");
3759 expect(vec[192] == false) catch @panic("test failure");
3760 expect(vec[193] == false) catch @panic("test failure");
3761 expect(vec[194] == false) catch @panic("test failure");
3762 expect(vec[195] == false) catch @panic("test failure");
3763 expect(vec[196] == true) catch @panic("test failure");
3764 expect(vec[197] == true) catch @panic("test failure");
3765 expect(vec[198] == true) catch @panic("test failure");
3766 expect(vec[199] == false) catch @panic("test failure");
3767 expect(vec[200] == true) catch @panic("test failure");
3768 expect(vec[201] == true) catch @panic("test failure");
3769 expect(vec[202] == false) catch @panic("test failure");
3770 expect(vec[203] == false) catch @panic("test failure");
3771 expect(vec[204] == false) catch @panic("test failure");
3772 expect(vec[205] == false) catch @panic("test failure");
3773 expect(vec[206] == false) catch @panic("test failure");
3774 expect(vec[207] == true) catch @panic("test failure");
3775 expect(vec[208] == true) catch @panic("test failure");
3776 expect(vec[209] == false) catch @panic("test failure");
3777 expect(vec[210] == false) catch @panic("test failure");
3778 expect(vec[211] == false) catch @panic("test failure");
3779 expect(vec[212] == true) catch @panic("test failure");
3780 expect(vec[213] == false) catch @panic("test failure");
3781 expect(vec[214] == false) catch @panic("test failure");
3782 expect(vec[215] == true) catch @panic("test failure");
3783 expect(vec[216] == true) catch @panic("test failure");
3784 expect(vec[217] == true) catch @panic("test failure");
3785 expect(vec[218] == false) catch @panic("test failure");
3786 expect(vec[219] == false) catch @panic("test failure");
3787 expect(vec[220] == true) catch @panic("test failure");
3788 expect(vec[221] == false) catch @panic("test failure");
3789 expect(vec[222] == true) catch @panic("test failure");
3790 expect(vec[223] == true) catch @panic("test failure");
3791 expect(vec[224] == true) catch @panic("test failure");
3792 expect(vec[225] == true) catch @panic("test failure");
3793 expect(vec[226] == false) catch @panic("test failure");
3794 expect(vec[227] == true) catch @panic("test failure");
3795 expect(vec[228] == false) catch @panic("test failure");
3796 expect(vec[229] == false) catch @panic("test failure");
3797 expect(vec[230] == false) catch @panic("test failure");
3798 expect(vec[231] == true) catch @panic("test failure");
3799 expect(vec[232] == false) catch @panic("test failure");
3800 expect(vec[233] == false) catch @panic("test failure");
3801 expect(vec[234] == false) catch @panic("test failure");
3802 expect(vec[235] == false) catch @panic("test failure");
3803 expect(vec[236] == false) catch @panic("test failure");
3804 expect(vec[237] == false) catch @panic("test failure");
3805 expect(vec[238] == false) catch @panic("test failure");
3806 expect(vec[239] == true) catch @panic("test failure");
3807 expect(vec[240] == false) catch @panic("test failure");
3808 expect(vec[241] == false) catch @panic("test failure");
3809 expect(vec[242] == false) catch @panic("test failure");
3810 expect(vec[243] == true) catch @panic("test failure");
3811 expect(vec[244] == true) catch @panic("test failure");
3812 expect(vec[245] == true) catch @panic("test failure");
3813 expect(vec[246] == true) catch @panic("test failure");
3814 expect(vec[247] == false) catch @panic("test failure");
3815 expect(vec[248] == true) catch @panic("test failure");
3816 expect(vec[249] == true) catch @panic("test failure");
3817 expect(vec[250] == false) catch @panic("test failure");
3818 expect(vec[251] == false) catch @panic("test failure");
3819 expect(vec[252] == false) catch @panic("test failure");
3820 expect(vec[253] == true) catch @panic("test failure");
3821 expect(vec[254] == false) catch @panic("test failure");
3822 expect(vec[255] == false) catch @panic("test failure");
3823 expect(vec[256] == true) catch @panic("test failure");
3824 expect(vec[257] == true) catch @panic("test failure");
3825 expect(vec[258] == false) catch @panic("test failure");
3826 expect(vec[259] == true) catch @panic("test failure");
3827 expect(vec[260] == false) catch @panic("test failure");
3828 expect(vec[261] == true) catch @panic("test failure");
3829 expect(vec[262] == true) catch @panic("test failure");
3830 expect(vec[263] == false) catch @panic("test failure");
3831 expect(vec[264] == false) catch @panic("test failure");
3832 expect(vec[265] == false) catch @panic("test failure");
3833 expect(vec[266] == false) catch @panic("test failure");
3834 expect(vec[267] == true) catch @panic("test failure");
3835 expect(vec[268] == false) catch @panic("test failure");
3836 expect(vec[269] == true) catch @panic("test failure");
3837 expect(vec[270] == true) catch @panic("test failure");
3838 expect(vec[271] == false) catch @panic("test failure");
3839 expect(vec[272] == false) catch @panic("test failure");
3840 expect(vec[273] == true) catch @panic("test failure");
3841 expect(vec[274] == true) catch @panic("test failure");
3842 expect(vec[275] == true) catch @panic("test failure");
3843 expect(vec[276] == false) catch @panic("test failure");
3844 expect(vec[277] == true) catch @panic("test failure");
3845 expect(vec[278] == false) catch @panic("test failure");
3846 expect(vec[279] == false) catch @panic("test failure");
3847 expect(vec[280] == true) catch @panic("test failure");
3848 expect(vec[281] == true) catch @panic("test failure");
3849 expect(vec[282] == false) catch @panic("test failure");
3850 expect(vec[283] == true) catch @panic("test failure");
3851 expect(vec[284] == false) catch @panic("test failure");
3852 expect(vec[285] == true) catch @panic("test failure");
3853 expect(vec[286] == true) catch @panic("test failure");
3854 expect(vec[287] == true) catch @panic("test failure");
3855 expect(vec[288] == true) catch @panic("test failure");
3856 expect(vec[289] == true) catch @panic("test failure");
3857 expect(vec[290] == true) catch @panic("test failure");
3858 expect(vec[291] == true) catch @panic("test failure");
3859 expect(vec[292] == true) catch @panic("test failure");
3860 expect(vec[293] == true) catch @panic("test failure");
3861 expect(vec[294] == true) catch @panic("test failure");
3862 expect(vec[295] == false) catch @panic("test failure");
3863 expect(vec[296] == true) catch @panic("test failure");
3864 expect(vec[297] == false) catch @panic("test failure");
3865 expect(vec[298] == true) catch @panic("test failure");
3866 expect(vec[299] == false) catch @panic("test failure");
3867 expect(vec[300] == true) catch @panic("test failure");
3868 expect(vec[301] == true) catch @panic("test failure");
3869 expect(vec[302] == false) catch @panic("test failure");
3870 expect(vec[303] == true) catch @panic("test failure");
3871 expect(vec[304] == false) catch @panic("test failure");
3872 expect(vec[305] == true) catch @panic("test failure");
3873 expect(vec[306] == false) catch @panic("test failure");
3874 expect(vec[307] == true) catch @panic("test failure");
3875 expect(vec[308] == true) catch @panic("test failure");
3876 expect(vec[309] == false) catch @panic("test failure");
3877 expect(vec[310] == true) catch @panic("test failure");
3878 expect(vec[311] == true) catch @panic("test failure");
3879 expect(vec[312] == true) catch @panic("test failure");
3880 expect(vec[313] == false) catch @panic("test failure");
3881 expect(vec[314] == false) catch @panic("test failure");
3882 expect(vec[315] == false) catch @panic("test failure");
3883 expect(vec[316] == false) catch @panic("test failure");
3884 expect(vec[317] == true) catch @panic("test failure");
3885 expect(vec[318] == true) catch @panic("test failure");
3886 expect(vec[319] == true) catch @panic("test failure");
3887 expect(vec[320] == true) catch @panic("test failure");
3888 expect(vec[321] == true) catch @panic("test failure");
3889 expect(vec[322] == true) catch @panic("test failure");
3890 expect(vec[323] == true) catch @panic("test failure");
3891 expect(vec[324] == true) catch @panic("test failure");
3892 expect(vec[325] == true) catch @panic("test failure");
3893 expect(vec[326] == false) catch @panic("test failure");
3894 expect(vec[327] == true) catch @panic("test failure");
3895 expect(vec[328] == false) catch @panic("test failure");
3896 expect(vec[329] == false) catch @panic("test failure");
3897 expect(vec[330] == true) catch @panic("test failure");
3898 expect(vec[331] == false) catch @panic("test failure");
3899 expect(vec[332] == false) catch @panic("test failure");
3900 expect(vec[333] == false) catch @panic("test failure");
3901 expect(vec[334] == false) catch @panic("test failure");
3902 expect(vec[335] == false) catch @panic("test failure");
3903 expect(vec[336] == false) catch @panic("test failure");
3904 expect(vec[337] == false) catch @panic("test failure");
3905 expect(vec[338] == false) catch @panic("test failure");
3906 expect(vec[339] == false) catch @panic("test failure");
3907 expect(vec[340] == false) catch @panic("test failure");
3908 expect(vec[341] == false) catch @panic("test failure");
3909 expect(vec[342] == true) catch @panic("test failure");
3910 expect(vec[343] == true) catch @panic("test failure");
3911 expect(vec[344] == false) catch @panic("test failure");
3912 expect(vec[345] == false) catch @panic("test failure");
3913 expect(vec[346] == false) catch @panic("test failure");
3914 expect(vec[347] == false) catch @panic("test failure");
3915 expect(vec[348] == false) catch @panic("test failure");
3916 expect(vec[349] == true) catch @panic("test failure");
3917 expect(vec[350] == true) catch @panic("test failure");
3918 expect(vec[351] == true) catch @panic("test failure");
3919 expect(vec[352] == true) catch @panic("test failure");
3920 expect(vec[353] == false) catch @panic("test failure");
3921 expect(vec[354] == false) catch @panic("test failure");
3922 expect(vec[355] == false) catch @panic("test failure");
3923 expect(vec[356] == false) catch @panic("test failure");
3924 expect(vec[357] == true) catch @panic("test failure");
3925 expect(vec[358] == true) catch @panic("test failure");
3926 expect(vec[359] == false) catch @panic("test failure");
3927 expect(vec[360] == false) catch @panic("test failure");
3928 expect(vec[361] == false) catch @panic("test failure");
3929 expect(vec[362] == true) catch @panic("test failure");
3930 expect(vec[363] == true) catch @panic("test failure");
3931 expect(vec[364] == false) catch @panic("test failure");
3932 expect(vec[365] == false) catch @panic("test failure");
3933 expect(vec[366] == false) catch @panic("test failure");
3934 expect(vec[367] == false) catch @panic("test failure");
3935 expect(vec[368] == false) catch @panic("test failure");
3936 expect(vec[369] == true) catch @panic("test failure");
3937 expect(vec[370] == true) catch @panic("test failure");
3938 expect(vec[371] == false) catch @panic("test failure");
3939 expect(vec[372] == true) catch @panic("test failure");
3940 expect(vec[373] == true) catch @panic("test failure");
3941 expect(vec[374] == false) catch @panic("test failure");
3942 expect(vec[375] == true) catch @panic("test failure");
3943 expect(vec[376] == true) catch @panic("test failure");
3944 expect(vec[377] == false) catch @panic("test failure");
3945 expect(vec[378] == true) catch @panic("test failure");
3946 expect(vec[379] == true) catch @panic("test failure");
3947 expect(vec[380] == false) catch @panic("test failure");
3948 expect(vec[381] == true) catch @panic("test failure");
3949 expect(vec[382] == true) catch @panic("test failure");
3950 expect(vec[383] == false) catch @panic("test failure");
3951 expect(vec[384] == true) catch @panic("test failure");
3952 expect(vec[385] == false) catch @panic("test failure");
3953 expect(vec[386] == true) catch @panic("test failure");
3954 expect(vec[387] == true) catch @panic("test failure");
3955 expect(vec[388] == true) catch @panic("test failure");
3956 expect(vec[389] == true) catch @panic("test failure");
3957 expect(vec[390] == false) catch @panic("test failure");
3958 expect(vec[391] == false) catch @panic("test failure");
3959 expect(vec[392] == false) catch @panic("test failure");
3960 expect(vec[393] == true) catch @panic("test failure");
3961 expect(vec[394] == true) catch @panic("test failure");
3962 expect(vec[395] == true) catch @panic("test failure");
3963 expect(vec[396] == true) catch @panic("test failure");
3964 expect(vec[397] == false) catch @panic("test failure");
3965 expect(vec[398] == true) catch @panic("test failure");
3966 expect(vec[399] == true) catch @panic("test failure");
3967 expect(vec[400] == true) catch @panic("test failure");
3968 expect(vec[401] == false) catch @panic("test failure");
3969 expect(vec[402] == false) catch @panic("test failure");
3970 expect(vec[403] == true) catch @panic("test failure");
3971 expect(vec[404] == false) catch @panic("test failure");
3972 expect(vec[405] == false) catch @panic("test failure");
3973 expect(vec[406] == false) catch @panic("test failure");
3974 expect(vec[407] == true) catch @panic("test failure");
3975 expect(vec[408] == true) catch @panic("test failure");
3976 expect(vec[409] == true) catch @panic("test failure");
3977 expect(vec[410] == false) catch @panic("test failure");
3978 expect(vec[411] == true) catch @panic("test failure");
3979 expect(vec[412] == false) catch @panic("test failure");
3980 expect(vec[413] == false) catch @panic("test failure");
3981 expect(vec[414] == false) catch @panic("test failure");
3982 expect(vec[415] == true) catch @panic("test failure");
3983 expect(vec[416] == false) catch @panic("test failure");
3984 expect(vec[417] == false) catch @panic("test failure");
3985 expect(vec[418] == true) catch @panic("test failure");
3986 expect(vec[419] == true) catch @panic("test failure");
3987 expect(vec[420] == true) catch @panic("test failure");
3988 expect(vec[421] == true) catch @panic("test failure");
3989 expect(vec[422] == false) catch @panic("test failure");
3990 expect(vec[423] == true) catch @panic("test failure");
3991 expect(vec[424] == true) catch @panic("test failure");
3992 expect(vec[425] == false) catch @panic("test failure");
3993 expect(vec[426] == false) catch @panic("test failure");
3994 expect(vec[427] == false) catch @panic("test failure");
3995 expect(vec[428] == true) catch @panic("test failure");
3996 expect(vec[429] == false) catch @panic("test failure");
3997 expect(vec[430] == true) catch @panic("test failure");
3998 expect(vec[431] == true) catch @panic("test failure");
3999 expect(vec[432] == false) catch @panic("test failure");
4000 expect(vec[433] == false) catch @panic("test failure");
4001 expect(vec[434] == false) catch @panic("test failure");
4002 expect(vec[435] == false) catch @panic("test failure");
4003 expect(vec[436] == true) catch @panic("test failure");
4004 expect(vec[437] == false) catch @panic("test failure");
4005 expect(vec[438] == true) catch @panic("test failure");
4006 expect(vec[439] == false) catch @panic("test failure");
4007 expect(vec[440] == false) catch @panic("test failure");
4008 expect(vec[441] == false) catch @panic("test failure");
4009 expect(vec[442] == false) catch @panic("test failure");
4010 expect(vec[443] == true) catch @panic("test failure");
4011 expect(vec[444] == false) catch @panic("test failure");
4012 expect(vec[445] == false) catch @panic("test failure");
4013 expect(vec[446] == true) catch @panic("test failure");
4014 expect(vec[447] == true) catch @panic("test failure");
4015 expect(vec[448] == true) catch @panic("test failure");
4016 expect(vec[449] == false) catch @panic("test failure");
4017 expect(vec[450] == true) catch @panic("test failure");
4018 expect(vec[451] == true) catch @panic("test failure");
4019 expect(vec[452] == false) catch @panic("test failure");
4020 expect(vec[453] == true) catch @panic("test failure");
4021 expect(vec[454] == false) catch @panic("test failure");
4022 expect(vec[455] == true) catch @panic("test failure");
4023 expect(vec[456] == false) catch @panic("test failure");
4024 expect(vec[457] == false) catch @panic("test failure");
4025 expect(vec[458] == false) catch @panic("test failure");
4026 expect(vec[459] == true) catch @panic("test failure");
4027 expect(vec[460] == false) catch @panic("test failure");
4028 expect(vec[461] == false) catch @panic("test failure");
4029 expect(vec[462] == false) catch @panic("test failure");
4030 expect(vec[463] == true) catch @panic("test failure");
4031 expect(vec[464] == true) catch @panic("test failure");
4032 expect(vec[465] == true) catch @panic("test failure");
4033 expect(vec[466] == true) catch @panic("test failure");
4034 expect(vec[467] == true) catch @panic("test failure");
4035 expect(vec[468] == false) catch @panic("test failure");
4036 expect(vec[469] == false) catch @panic("test failure");
4037 expect(vec[470] == false) catch @panic("test failure");
4038 expect(vec[471] == false) catch @panic("test failure");
4039 expect(vec[472] == false) catch @panic("test failure");
4040 expect(vec[473] == false) catch @panic("test failure");
4041 expect(vec[474] == true) catch @panic("test failure");
4042 expect(vec[475] == true) catch @panic("test failure");
4043 expect(vec[476] == true) catch @panic("test failure");
4044 expect(vec[477] == true) catch @panic("test failure");
4045 expect(vec[478] == true) catch @panic("test failure");
4046 expect(vec[479] == false) catch @panic("test failure");
4047 expect(vec[480] == true) catch @panic("test failure");
4048 expect(vec[481] == true) catch @panic("test failure");
4049 expect(vec[482] == false) catch @panic("test failure");
4050 expect(vec[483] == true) catch @panic("test failure");
4051 expect(vec[484] == false) catch @panic("test failure");
4052 expect(vec[485] == true) catch @panic("test failure");
4053 expect(vec[486] == false) catch @panic("test failure");
4054 expect(vec[487] == true) catch @panic("test failure");
4055 expect(vec[488] == false) catch @panic("test failure");
4056 expect(vec[489] == false) catch @panic("test failure");
4057 expect(vec[490] == false) catch @panic("test failure");
4058 expect(vec[491] == true) catch @panic("test failure");
4059 expect(vec[492] == false) catch @panic("test failure");
4060 expect(vec[493] == false) catch @panic("test failure");
4061 expect(vec[494] == false) catch @panic("test failure");
4062 expect(vec[495] == true) catch @panic("test failure");
4063 expect(vec[496] == true) catch @panic("test failure");
4064 expect(vec[497] == false) catch @panic("test failure");
4065 expect(vec[498] == false) catch @panic("test failure");
4066 expect(vec[499] == true) catch @panic("test failure");
4067 expect(vec[500] == false) catch @panic("test failure");
4068 expect(vec[501] == true) catch @panic("test failure");
4069 expect(vec[502] == false) catch @panic("test failure");
4070 expect(vec[503] == false) catch @panic("test failure");
4071 expect(vec[504] == false) catch @panic("test failure");
4072 expect(vec[505] == true) catch @panic("test failure");
4073 expect(vec[506] == true) catch @panic("test failure");
4074 expect(vec[507] == true) catch @panic("test failure");
4075 expect(vec[508] == true) catch @panic("test failure");
4076 expect(vec[509] == false) catch @panic("test failure");
4077 expect(vec[510] == false) catch @panic("test failure");
4078 expect(vec[511] == true) catch @panic("test failure");
4079 }
4080
4081 export fn zig_ret_vector_2_bool() Vector2Bool {
4082 return .{
4083 false,
4084 false,
4085 };
4086 }
4087
4088 export fn zig_ret_vector_4_bool() Vector4Bool {
4089 return .{
4090 false,
4091 true,
4092 true,
4093 true,
4094 };
4095 }
4096
4097 export fn zig_ret_vector_8_bool() Vector8Bool {
4098 return .{
4099 false,
4100 false,
4101 false,
4102 false,
4103 true,
4104 false,
4105 false,
4106 false,
4107 };
4108 }
4109
4110 export fn zig_ret_vector_16_bool() Vector16Bool {
4111 return .{
4112 false,
4113 true,
4114 false,
4115 false,
4116 false,
4117 true,
4118 false,
4119 false,
4120 true,
4121 false,
4122 false,
4123 false,
4124 false,
4125 true,
4126 false,
4127 false,
4128 };
4129 }
4130
4131 export fn zig_ret_vector_32_bool() Vector32Bool {
4132 return .{
4133 false,
4134 true,
4135 false,
4136 false,
4137 true,
4138 false,
4139 true,
4140 true,
4141 true,
4142 true,
4143 true,
4144 true,
4145 false,
4146 false,
4147 false,
4148 false,
4149 false,
4150 false,
4151 true,
4152 true,
4153 true,
4154 false,
4155 true,
4156 false,
4157 true,
4158 false,
4159 false,
4160 true,
4161 false,
4162 false,
4163 true,
4164 true,
4165 };
4166 }
4167
4168 export fn zig_ret_vector_64_bool() Vector64Bool {
4169 return .{
4170 true,
4171 false,
4172 true,
4173 false,
4174 false,
4175 true,
4176 false,
4177 true,
4178 true,
4179 false,
4180 true,
4181 false,
4182 true,
4183 false,
4184 false,
4185 true,
4186 false,
4187 false,
4188 true,
4189 true,
4190 false,
4191 false,
4192 true,
4193 false,
4194 false,
4195 true,
4196 true,
4197 true,
4198 true,
4199 true,
4200 false,
4201 false,
4202 true,
4203 true,
4204 true,
4205 true,
4206 false,
4207 true,
4208 false,
4209 true,
4210 true,
4211 true,
4212 true,
4213 true,
4214 false,
4215 false,
4216 false,
4217 true,
4218 true,
4219 true,
4220 false,
4221 true,
4222 true,
4223 true,
4224 false,
4225 false,
4226 false,
4227 true,
4228 false,
4229 false,
4230 true,
4231 false,
4232 true,
4233 false,
4234 };
4235 }
4236
4237 export fn zig_ret_vector_128_bool() Vector128Bool {
4238 return .{
4239 true,
4240 true,
4241 false,
4242 false,
4243 false,
4244 true,
4245 true,
4246 false,
4247 false,
4248 true,
4249 false,
4250 false,
4251 false,
4252 true,
4253 false,
4254 true,
4255 true,
4256 false,
4257 false,
4258 true,
4259 true,
4260 true,
4261 true,
4262 true,
4263 false,
4264 false,
4265 true,
4266 true,
4267 true,
4268 false,
4269 false,
4270 true,
4271 true,
4272 false,
4273 true,
4274 true,
4275 true,
4276 false,
4277 true,
4278 true,
4279 true,
4280 false,
4281 true,
4282 true,
4283 false,
4284 false,
4285 false,
4286 true,
4287 false,
4288 false,
4289 false,
4290 false,
4291 true,
4292 false,
4293 true,
4294 false,
4295 true,
4296 false,
4297 false,
4298 true,
4299 true,
4300 true,
4301 true,
4302 true,
4303 false,
4304 false,
4305 false,
4306 true,
4307 true,
4308 false,
4309 true,
4310 true,
4311 false,
4312 true,
4313 true,
4314 false,
4315 false,
4316 true,
4317 false,
4318 true,
4319 false,
4320 false,
4321 true,
4322 true,
4323 false,
4324 true,
4325 false,
4326 false,
4327 true,
4328 true,
4329 true,
4330 true,
4331 true,
4332 false,
4333 false,
4334 true,
4335 false,
4336 false,
4337 true,
4338 true,
4339 true,
4340 true,
4341 true,
4342 true,
4343 true,
4344 false,
4345 false,
4346 true,
4347 false,
4348 false,
4349 true,
4350 false,
4351 false,
4352 true,
4353 false,
4354 false,
4355 false,
4356 false,
4357 false,
4358 false,
4359 true,
4360 true,
4361 true,
4362 false,
4363 true,
4364 false,
4365 false,
4366 true,
4367 };
4368 }
4369
4370 export fn zig_ret_vector_256_bool() Vector256Bool {
4371 return .{
4372 true,
4373 true,
4374 true,
4375 false,
4376 true,
4377 false,
4378 false,
4379 true,
4380 false,
4381 false,
4382 false,
4383 false,
4384 false,
4385 false,
4386 false,
4387 false,
4388 true,
4389 false,
4390 true,
4391 false,
4392 false,
4393 true,
4394 true,
4395 false,
4396 false,
4397 true,
4398 true,
4399 false,
4400 true,
4401 true,
4402 true,
4403 false,
4404 true,
4405 false,
4406 true,
4407 false,
4408 true,
4409 false,
4410 true,
4411 false,
4412 false,
4413 false,
4414 true,
4415 true,
4416 true,
4417 false,
4418 false,
4419 false,
4420 true,
4421 false,
4422 true,
4423 false,
4424 true,
4425 false,
4426 true,
4427 true,
4428 false,
4429 false,
4430 false,
4431 true,
4432 true,
4433 true,
4434 false,
4435 true,
4436 false,
4437 true,
4438 false,
4439 true,
4440 true,
4441 false,
4442 true,
4443 false,
4444 true,
4445 true,
4446 false,
4447 false,
4448 false,
4449 false,
4450 false,
4451 false,
4452 false,
4453 false,
4454 false,
4455 true,
4456 false,
4457 false,
4458 false,
4459 true,
4460 false,
4461 true,
4462 true,
4463 false,
4464 false,
4465 true,
4466 true,
4467 false,
4468 false,
4469 true,
4470 false,
4471 false,
4472 false,
4473 false,
4474 false,
4475 false,
4476 false,
4477 true,
4478 true,
4479 false,
4480 true,
4481 false,
4482 true,
4483 true,
4484 false,
4485 false,
4486 false,
4487 false,
4488 false,
4489 false,
4490 false,
4491 true,
4492 true,
4493 true,
4494 false,
4495 true,
4496 true,
4497 false,
4498 false,
4499 true,
4500 true,
4501 true,
4502 true,
4503 true,
4504 false,
4505 true,
4506 true,
4507 false,
4508 false,
4509 true,
4510 true,
4511 false,
4512 true,
4513 false,
4514 true,
4515 false,
4516 true,
4517 true,
4518 true,
4519 true,
4520 false,
4521 false,
4522 false,
4523 true,
4524 false,
4525 true,
4526 false,
4527 true,
4528 true,
4529 false,
4530 true,
4531 true,
4532 true,
4533 true,
4534 true,
4535 false,
4536 false,
4537 true,
4538 false,
4539 true,
4540 true,
4541 true,
4542 true,
4543 false,
4544 true,
4545 true,
4546 true,
4547 true,
4548 true,
4549 true,
4550 true,
4551 false,
4552 true,
4553 false,
4554 false,
4555 false,
4556 true,
4557 false,
4558 true,
4559 true,
4560 false,
4561 true,
4562 false,
4563 true,
4564 false,
4565 true,
4566 false,
4567 false,
4568 true,
4569 true,
4570 true,
4571 true,
4572 true,
4573 true,
4574 true,
4575 false,
4576 true,
4577 false,
4578 false,
4579 true,
4580 true,
4581 false,
4582 false,
4583 false,
4584 true,
4585 true,
4586 true,
4587 false,
4588 false,
4589 true,
4590 true,
4591 true,
4592 true,
4593 false,
4594 true,
4595 false,
4596 true,
4597 true,
4598 true,
4599 false,
4600 false,
4601 false,
4602 false,
4603 false,
4604 true,
4605 true,
4606 false,
4607 false,
4608 false,
4609 true,
4610 true,
4611 false,
4612 true,
4613 true,
4614 true,
4615 false,
4616 true,
4617 true,
4618 false,
4619 true,
4620 false,
4621 false,
4622 true,
4623 true,
4624 false,
4625 true,
4626 false,
4627 true,
4628 };
4629 }
4630
4631 export fn zig_ret_vector_512_bool() Vector512Bool {
4632 return .{
4633 true,
4634 true,
4635 true,
4636 true,
4637 false,
4638 true,
4639 false,
4640 true,
4641 true,
4642 true,
4643 false,
4644 true,
4645 false,
4646 false,
4647 false,
4648 true,
4649 true,
4650 false,
4651 false,
4652 false,
4653 true,
4654 true,
4655 false,
4656 false,
4657 false,
4658 false,
4659 true,
4660 false,
4661 false,
4662 false,
4663 true,
4664 true,
4665 true,
4666 true,
4667 false,
4668 false,
4669 false,
4670 true,
4671 true,
4672 true,
4673 false,
4674 false,
4675 true,
4676 false,
4677 false,
4678 true,
4679 false,
4680 false,
4681 true,
4682 true,
4683 true,
4684 true,
4685 false,
4686 false,
4687 false,
4688 true,
4689 false,
4690 true,
4691 false,
4692 true,
4693 true,
4694 false,
4695 false,
4696 true,
4697 true,
4698 false,
4699 true,
4700 false,
4701 false,
4702 false,
4703 true,
4704 true,
4705 true,
4706 true,
4707 true,
4708 false,
4709 true,
4710 false,
4711 true,
4712 true,
4713 true,
4714 true,
4715 true,
4716 false,
4717 true,
4718 true,
4719 false,
4720 true,
4721 false,
4722 false,
4723 true,
4724 false,
4725 true,
4726 false,
4727 false,
4728 false,
4729 true,
4730 true,
4731 false,
4732 true,
4733 true,
4734 false,
4735 true,
4736 false,
4737 true,
4738 false,
4739 true,
4740 false,
4741 false,
4742 true,
4743 false,
4744 false,
4745 true,
4746 false,
4747 true,
4748 false,
4749 true,
4750 false,
4751 false,
4752 true,
4753 true,
4754 true,
4755 false,
4756 true,
4757 false,
4758 false,
4759 true,
4760 true,
4761 false,
4762 true,
4763 true,
4764 false,
4765 true,
4766 true,
4767 false,
4768 true,
4769 true,
4770 false,
4771 false,
4772 false,
4773 true,
4774 false,
4775 true,
4776 false,
4777 false,
4778 false,
4779 true,
4780 false,
4781 true,
4782 false,
4783 false,
4784 true,
4785 false,
4786 true,
4787 true,
4788 false,
4789 true,
4790 true,
4791 false,
4792 true,
4793 true,
4794 false,
4795 false,
4796 false,
4797 true,
4798 false,
4799 true,
4800 true,
4801 true,
4802 true,
4803 false,
4804 true,
4805 false,
4806 false,
4807 true,
4808 true,
4809 true,
4810 false,
4811 false,
4812 false,
4813 true,
4814 false,
4815 false,
4816 true,
4817 true,
4818 false,
4819 true,
4820 false,
4821 true,
4822 true,
4823 true,
4824 true,
4825 true,
4826 true,
4827 true,
4828 false,
4829 false,
4830 false,
4831 false,
4832 false,
4833 true,
4834 false,
4835 true,
4836 false,
4837 true,
4838 true,
4839 false,
4840 false,
4841 false,
4842 true,
4843 true,
4844 true,
4845 false,
4846 false,
4847 true,
4848 true,
4849 true,
4850 false,
4851 false,
4852 true,
4853 false,
4854 true,
4855 true,
4856 false,
4857 true,
4858 false,
4859 false,
4860 true,
4861 false,
4862 false,
4863 true,
4864 true,
4865 false,
4866 true,
4867 true,
4868 true,
4869 true,
4870 true,
4871 false,
4872 true,
4873 false,
4874 false,
4875 true,
4876 false,
4877 true,
4878 false,
4879 true,
4880 false,
4881 true,
4882 true,
4883 true,
4884 true,
4885 true,
4886 false,
4887 false,
4888 false,
4889 false,
4890 false,
4891 false,
4892 true,
4893 true,
4894 true,
4895 true,
4896 false,
4897 false,
4898 false,
4899 true,
4900 false,
4901 true,
4902 false,
4903 true,
4904 true,
4905 true,
4906 true,
4907 true,
4908 true,
4909 false,
4910 false,
4911 true,
4912 true,
4913 false,
4914 false,
4915 false,
4916 false,
4917 true,
4918 true,
4919 true,
4920 false,
4921 false,
4922 false,
4923 true,
4924 false,
4925 true,
4926 true,
4927 false,
4928 true,
4929 true,
4930 true,
4931 false,
4932 true,
4933 true,
4934 false,
4935 false,
4936 true,
4937 false,
4938 false,
4939 true,
4940 true,
4941 true,
4942 true,
4943 false,
4944 false,
4945 false,
4946 false,
4947 false,
4948 true,
4949 false,
4950 false,
4951 true,
4952 false,
4953 false,
4954 true,
4955 true,
4956 true,
4957 true,
4958 false,
4959 false,
4960 false,
4961 true,
4962 true,
4963 false,
4964 true,
4965 true,
4966 false,
4967 false,
4968 true,
4969 true,
4970 false,
4971 true,
4972 true,
4973 true,
4974 false,
4975 false,
4976 false,
4977 true,
4978 true,
4979 false,
4980 true,
4981 false,
4982 true,
4983 false,
4984 false,
4985 true,
4986 false,
4987 true,
4988 false,
4989 false,
4990 false,
4991 false,
4992 false,
4993 true,
4994 true,
4995 false,
4996 false,
4997 false,
4998 false,
4999 true,
5000 false,
5001 true,
5002 false,
5003 true,
5004 true,
5005 false,
5006 true,
5007 true,
5008 true,
5009 true,
5010 true,
5011 false,
5012 true,
5013 false,
5014 true,
5015 true,
5016 true,
5017 true,
5018 true,
5019 false,
5020 true,
5021 true,
5022 false,
5023 true,
5024 false,
5025 true,
5026 false,
5027 true,
5028 false,
5029 true,
5030 false,
5031 false,
5032 true,
5033 true,
5034 true,
5035 true,
5036 false,
5037 false,
5038 true,
5039 false,
5040 false,
5041 false,
5042 true,
5043 false,
5044 true,
5045 true,
5046 false,
5047 true,
5048 true,
5049 false,
5050 true,
5051 true,
5052 false,
5053 false,
5054 true,
5055 false,
5056 false,
5057 true,
5058 false,
5059 true,
5060 false,
5061 false,
5062 true,
5063 false,
5064 true,
5065 true,
5066 false,
5067 true,
5068 false,
5069 true,
5070 false,
5071 true,
5072 false,
5073 false,
5074 true,
5075 true,
5076 false,
5077 true,
5078 true,
5079 false,
5080 true,
5081 true,
5082 false,
5083 false,
5084 false,
5085 false,
5086 false,
5087 true,
5088 false,
5089 false,
5090 true,
5091 false,
5092 true,
5093 false,
5094 false,
5095 false,
5096 true,
5097 false,
5098 true,
5099 false,
5100 false,
5101 false,
5102 false,
5103 true,
5104 true,
5105 false,
5106 true,
5107 true,
5108 false,
5109 false,
5110 true,
5111 true,
5112 true,
5113 false,
5114 false,
5115 true,
5116 false,
5117 false,
5118 false,
5119 true,
5120 true,
5121 false,
5122 false,
5123 false,
5124 false,
5125 false,
5126 true,
5127 true,
5128 true,
5129 true,
5130 false,
5131 false,
5132 false,
5133 true,
5134 false,
5135 true,
5136 true,
5137 true,
5138 true,
5139 false,
5140 false,
5141 true,
5142 true,
5143 false,
5144 false,
5145 };
5146 }
5147 };
5148 }
5149}
5150
8935151const Vector2 = extern struct { x: f32, y: f32 };
8945152
8955153extern fn c_ptr_size_float_struct(Vector2) void;