Commit a9f738e56b

Jacob Young <jacobly0@users.noreply.github.com>
2024-02-09 10:30:17
x86_64: implement c abi for bool vectors
master
1 parent c6b3db8
Changed files (7)
lib
std
mem.zig
src
arch
x86_64
abi.zig
CodeGen.zig
codegen
llvm.zig
test
behavior
vector.zig
c_abi
cfuncs.c
main.zig
lib/std/mem.zig
@@ -635,6 +635,7 @@ test "lessThan" {
 const backend_can_use_eql_bytes = switch (builtin.zig_backend) {
     // The SPIR-V backend does not support the optimized path yet.
     .stage2_spirv64 => false,
+    .stage2_x86_64 => !std.Target.x86.featureSetHas(builtin.cpu.features, .avx2),
     else => true,
 };
src/arch/x86_64/abi.zig
@@ -10,6 +10,7 @@ pub const Class = enum {
     win_i128,
     float,
     float_combine,
+    integer_per_element,
 };
 
 pub fn classifyWindows(ty: Type, mod: *Module) Class {
@@ -161,6 +162,31 @@ pub fn classifySystemV(ty: Type, mod: *Module, ctx: Context) [8]Class {
         .Vector => {
             const elem_ty = ty.childType(mod);
             const bits = elem_ty.bitSize(mod) * ty.arrayLen(mod);
+            if (elem_ty.toIntern() == .bool_type) {
+                if (bits <= 32) return .{
+                    .integer, .none, .none, .none,
+                    .none,    .none, .none, .none,
+                };
+                if (bits <= 64) return .{
+                    .sse,  .none, .none, .none,
+                    .none, .none, .none, .none,
+                };
+                if (ctx == .arg) {
+                    if (bits <= 128) return .{
+                        .integer_per_element, .none, .none, .none,
+                        .none,                .none, .none, .none,
+                    };
+                    if (bits <= 256 and std.Target.x86.featureSetHas(target.cpu.features, .avx)) return .{
+                        .integer_per_element, .none, .none, .none,
+                        .none,                .none, .none, .none,
+                    };
+                    if (bits <= 512 and std.Target.x86.featureSetHas(target.cpu.features, .avx512f)) return .{
+                        .integer_per_element, .none, .none, .none,
+                        .none,                .none, .none, .none,
+                    };
+                }
+                return memory_class;
+            }
             if (bits <= 64) return .{
                 .sse,  .none, .none, .none,
                 .none, .none, .none, .none,
src/arch/x86_64/CodeGen.zig
@@ -221,6 +221,8 @@ pub const MCValue = union(enum) {
     /// The address of an offset from a frame index
     /// Payload is a frame address.
     lea_frame: FrameAddr,
+    /// Supports integer_per_element abi
+    elementwise_regs_then_frame: packed struct { regs: u3 = 0, frame_off: i29 = 0, frame_index: FrameIndex },
     /// This indicates that we have already allocated a frame index for this instruction,
     /// but it has not been spilled there yet in the current control flow.
     /// Payload is a frame index.
@@ -300,6 +302,7 @@ pub const MCValue = union(enum) {
             .lea_got,
             .lea_tlv,
             .lea_frame,
+            .elementwise_regs_then_frame,
             .reserved_frame,
             .air_ref,
             => unreachable, // not in memory
@@ -332,6 +335,7 @@ pub const MCValue = union(enum) {
             .load_tlv,
             .load_frame,
             .load_symbol,
+            .elementwise_regs_then_frame,
             .reserved_frame,
             .air_ref,
             => unreachable, // not dereferenceable
@@ -352,6 +356,7 @@ pub const MCValue = union(enum) {
             .unreach,
             .dead,
             .undef,
+            .elementwise_regs_then_frame,
             .reserved_frame,
             .air_ref,
             => unreachable, // not valid
@@ -403,8 +408,8 @@ pub const MCValue = union(enum) {
             .load_tlv,
             .lea_tlv,
             .lea_frame,
+            .elementwise_regs_then_frame,
             .reserved_frame,
-            .air_ref,
             .lea_symbol,
             => unreachable,
             .memory => |addr| if (math.cast(i32, @as(i64, @bitCast(addr)))) |small_addr| .{
@@ -441,6 +446,7 @@ pub const MCValue = union(enum) {
                     } },
                 };
             },
+            .air_ref => |ref| (try function.resolveInst(ref)).mem(function, size),
         };
     }
 
@@ -470,6 +476,7 @@ pub const MCValue = union(enum) {
             .load_tlv => |pl| try writer.print("[tlv:{d}]", .{pl}),
             .lea_tlv => |pl| try writer.print("tlv:{d}", .{pl}),
             .load_frame => |pl| try writer.print("[{} + 0x{x}]", .{ pl.index, pl.off }),
+            .elementwise_regs_then_frame => |pl| try writer.print("elementwise:{d}:[{} + 0x{x}]", .{ pl.regs, pl.frame_index, pl.frame_off }),
             .lea_frame => |pl| try writer.print("{} + 0x{x}", .{ pl.index, pl.off }),
             .reserved_frame => |pl| try writer.print("(dead:{})", .{pl}),
             .air_ref => |pl| try writer.print("(air:0x{x})", .{@intFromEnum(pl)}),
@@ -502,6 +509,7 @@ const InstTracking = struct {
             .lea_symbol,
             => result,
             .dead,
+            .elementwise_regs_then_frame,
             .reserved_frame,
             .air_ref,
             => unreachable,
@@ -569,6 +577,7 @@ const InstTracking = struct {
             .register_offset,
             .register_overflow,
             .indirect,
+            .elementwise_regs_then_frame,
             .reserved_frame,
             .air_ref,
             => unreachable,
@@ -614,6 +623,7 @@ const InstTracking = struct {
             .register_offset,
             .register_overflow,
             .indirect,
+            .elementwise_regs_then_frame,
             .air_ref,
             => unreachable,
         }
@@ -1757,7 +1767,7 @@ fn gen(self: *Self) InnerError!void {
                         .{},
                     );
 
-                try self.performReloc(skip_sse_reloc);
+                self.performReloc(skip_sse_reloc);
             },
             .Win64 => return self.fail("TODO implement gen var arg function for Win64", .{}),
             else => unreachable,
@@ -2223,14 +2233,14 @@ fn genLazy(self: *Self, lazy_sym: link.File.LazySymbol) InnerError!void {
                 );
 
                 exitlude_jump_reloc.* = try self.asmJmpReloc(undefined);
-                try self.performReloc(skip_reloc);
+                self.performReloc(skip_reloc);
 
                 data_off += @intCast(tag_name.len + 1);
             }
 
             try self.airTrap();
 
-            for (exitlude_jump_relocs) |reloc| try self.performReloc(reloc);
+            for (exitlude_jump_relocs) |reloc| self.performReloc(reloc);
             try self.asmOpOnly(.{ ._, .ret });
         },
         else => return self.fail(
@@ -3360,7 +3370,7 @@ fn airMulDivBinOp(self: *Self, inst: Air.Inst.Index) !void {
                             .resurrect = true,
                             .close_scope = true,
                         });
-                        try self.performReloc(signed_div_floor_state.reloc);
+                        self.performReloc(signed_div_floor_state.reloc);
                         const dst_mcv = try self.genCall(
                             .{ .lib = .{
                                 .return_type = dst_ty.toIntern(),
@@ -4097,7 +4107,7 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                     } },
                 }, Immediate.u(0));
                 _ = try self.asmJccReloc(.z, overflow_loop);
-                try self.performReloc(overflow);
+                self.performReloc(overflow);
                 try self.asmMemoryImmediate(.{ ._, .mov }, .{
                     .base = .{ .frame = dst_mcv.load_frame.index },
                     .mod = .{ .rm = .{
@@ -4105,9 +4115,9 @@ fn airMulWithOverflow(self: *Self, inst: Air.Inst.Index) !void {
                         .disp = @intCast(tuple_ty.structFieldOffset(1, mod)),
                     } },
                 }, Immediate.u(1));
-                try self.performReloc(no_overflow);
+                self.performReloc(no_overflow);
 
-                try self.performReloc(skip_inner);
+                self.performReloc(skip_inner);
                 if (slow_inc) {
                     try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), Immediate.u(1));
                 } else {
@@ -5355,11 +5365,26 @@ fn airArrayElemVal(self: *Self, inst: Air.Inst.Index) !void {
                 else => try self.copyToTmpRegister(index_ty, index_mcv),
             };
             switch (array_mcv) {
-                .register => |array_reg| try self.asmRegisterRegister(
-                    .{ ._, .bt },
-                    array_reg.to64(),
-                    index_reg.to64(),
-                ),
+                .register => |array_reg| switch (array_reg.class()) {
+                    .general_purpose => try self.asmRegisterRegister(
+                        .{ ._, .bt },
+                        array_reg.to64(),
+                        index_reg.to64(),
+                    ),
+                    .sse => {
+                        const frame_index = try self.allocFrameIndex(FrameAlloc.initType(array_ty, mod));
+                        try self.genSetMem(.{ .frame = frame_index }, 0, array_ty, array_mcv, .{});
+                        try self.asmMemoryRegister(
+                            .{ ._, .bt },
+                            .{
+                                .base = .{ .frame = frame_index },
+                                .mod = .{ .rm = .{ .size = .qword } },
+                            },
+                            index_reg.to64(),
+                        );
+                    },
+                    else => unreachable,
+                },
                 .load_frame => try self.asmMemoryRegister(
                     .{ ._, .bt },
                     try array_mcv.mem(self, .qword),
@@ -6700,7 +6725,7 @@ fn airAbs(self: *Self, inst: Air.Inst.Index) !void {
                     try self.asmRegisterImmediate(.{ ._, .cmp }, tmp_regs[0].to32(), Immediate.u(limb_len));
                     _ = try self.asmJccReloc(.b, neg_loop);
 
-                    try self.performReloc(positive);
+                    self.performReloc(positive);
                     break :result dst_mcv;
                 },
             },
@@ -7124,6 +7149,7 @@ fn load(self: *Self, dst_mcv: MCValue, ptr_ty: Type, ptr_mcv: MCValue) InnerErro
         .eflags,
         .register_pair,
         .register_overflow,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         => unreachable, // not a valid pointer
         .immediate,
@@ -7326,6 +7352,7 @@ fn store(
         .eflags,
         .register_pair,
         .register_overflow,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         => unreachable, // not a valid pointer
         .immediate,
@@ -7826,13 +7853,14 @@ fn genUnOpMir(self: *Self, mir_tag: Mir.Inst.FixedTag, dst_ty: Type, dst_mcv: MC
         .register_offset,
         .eflags,
         .register_overflow,
+        .lea_symbol,
         .lea_direct,
         .lea_got,
         .lea_tlv,
         .lea_frame,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         .air_ref,
-        .lea_symbol,
         => unreachable, // unmodifiable destination
         .register => |dst_reg| try self.asmRegister(mir_tag, registerAlias(dst_reg, abi_size)),
         .register_pair => unreachable, // unimplemented
@@ -8470,7 +8498,7 @@ fn genMulDivBinOp(
                 );
                 _ = try self.asmJccReloc(.b, inner_loop);
 
-                try self.performReloc(skip_inner);
+                self.performReloc(skip_inner);
                 if (slow_inc) {
                     try self.asmRegisterImmediate(.{ ._, .add }, temp_regs[0].to32(), Immediate.u(1));
                 } else {
@@ -8903,6 +8931,7 @@ fn genBinOp(
 
     const ordered_air: [2]Air.Inst.Ref = if (lhs_ty.isVector(mod) and
         switch (lhs_ty.childType(mod).zigTypeTag(mod)) {
+        .Bool => false,
         .Int => switch (air_tag) {
             .cmp_lt, .cmp_gte => true,
             else => false,
@@ -9212,6 +9241,7 @@ fn genBinOp(
                         .load_tlv,
                         .lea_tlv,
                         .lea_frame,
+                        .elementwise_regs_then_frame,
                         .reserved_frame,
                         .air_ref,
                         => unreachable,
@@ -9253,6 +9283,16 @@ fn genBinOp(
                 }
             },
 
+            .cmp_eq, .cmp_neq => {
+                assert(lhs_ty.isVector(mod) and lhs_ty.childType(mod).toIntern() == .bool_type);
+                try self.genBinOpMir(.{ ._, .xor }, lhs_ty, dst_mcv, src_mcv);
+                switch (air_tag) {
+                    .cmp_eq => try self.genUnOpMir(.{ ._, .not }, lhs_ty, dst_mcv),
+                    .cmp_neq => {},
+                    else => unreachable,
+                }
+            },
+
             else => return self.fail("TODO implement genBinOp for {s} {}", .{
                 @tagName(air_tag), lhs_ty.fmt(mod),
             }),
@@ -10447,6 +10487,7 @@ fn genBinOpMir(
         .lea_tlv,
         .lea_frame,
         .lea_symbol,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         .air_ref,
         => unreachable, // unmodifiable destination
@@ -10481,6 +10522,7 @@ fn genBinOpMir(
                     .dead,
                     .undef,
                     .register_overflow,
+                    .elementwise_regs_then_frame,
                     .reserved_frame,
                     => unreachable,
                     .register, .register_pair => try self.asmRegisterRegister(
@@ -10639,6 +10681,7 @@ fn genBinOpMir(
                 .dead,
                 .undef,
                 .register_overflow,
+                .elementwise_regs_then_frame,
                 .reserved_frame,
                 .air_ref,
                 => unreachable,
@@ -10733,6 +10776,7 @@ fn genBinOpMir(
                     .dead,
                     .undef,
                     .register_overflow,
+                    .elementwise_regs_then_frame,
                     .reserved_frame,
                     .air_ref,
                     => unreachable,
@@ -10868,6 +10912,7 @@ fn genIntMulComplexOpMir(self: *Self, dst_ty: Type, dst_mcv: MCValue, src_mcv: M
         .lea_got,
         .lea_tlv,
         .lea_frame,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         .air_ref,
         => unreachable, // unmodifiable destination
@@ -10887,6 +10932,7 @@ fn genIntMulComplexOpMir(self: *Self, dst_ty: Type, dst_mcv: MCValue, src_mcv: M
                 .undef,
                 .register_pair,
                 .register_overflow,
+                .elementwise_regs_then_frame,
                 .reserved_frame,
                 .air_ref,
                 => unreachable,
@@ -10996,6 +11042,92 @@ fn airArg(self: *Self, inst: Air.Inst.Index) !void {
                 try self.genCopy(arg_ty, dst_mcv, src_mcv, .{});
                 break :dst dst_mcv;
             },
+            .elementwise_regs_then_frame => |regs_frame_addr| dst: {
+                try self.spillEflagsIfOccupied();
+
+                const fn_info = mod.typeToFunc(self.fn_type).?;
+                const cc = abi.resolveCallingConvention(fn_info.cc, self.target.*);
+                const param_int_regs = abi.getCAbiIntParamRegs(cc);
+                var prev_reg: Register = undefined;
+                for (
+                    param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
+                    0..,
+                ) |dst_reg, elem_index| {
+                    assert(self.register_manager.isRegFree(dst_reg));
+                    if (elem_index > 0) {
+                        try self.asmRegisterImmediate(
+                            .{ ._l, .sh },
+                            dst_reg.to8(),
+                            Immediate.u(elem_index),
+                        );
+                        try self.asmRegisterRegister(
+                            .{ ._, .@"or" },
+                            dst_reg.to8(),
+                            prev_reg.to8(),
+                        );
+                    }
+                    prev_reg = dst_reg;
+                }
+
+                const prev_lock = if (regs_frame_addr.regs > 0)
+                    self.register_manager.lockRegAssumeUnused(prev_reg)
+                else
+                    null;
+                defer if (prev_lock) |lock| self.register_manager.unlockReg(lock);
+
+                const dst_mcv = try self.allocRegOrMem(inst, false);
+                if (regs_frame_addr.regs > 0) try self.asmMemoryRegister(
+                    .{ ._, .mov },
+                    try dst_mcv.mem(self, .byte),
+                    prev_reg.to8(),
+                );
+                try self.genInlineMemset(
+                    dst_mcv.address().offset(@intFromBool(regs_frame_addr.regs > 0)),
+                    .{ .immediate = 0 },
+                    .{ .immediate = arg_ty.abiSize(mod) - @intFromBool(regs_frame_addr.regs > 0) },
+                    .{},
+                );
+
+                const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
+                const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
+                defer self.register_manager.unlockReg(index_lock);
+
+                try self.asmRegisterImmediate(
+                    .{ ._, .mov },
+                    index_reg.to32(),
+                    Immediate.u(regs_frame_addr.regs),
+                );
+                const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
+                try self.asmMemoryImmediate(.{ ._, .cmp }, .{
+                    .base = .{ .frame = regs_frame_addr.frame_index },
+                    .mod = .{ .rm = .{
+                        .size = .byte,
+                        .index = index_reg.to64(),
+                        .scale = .@"8",
+                        .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
+                    } },
+                }, Immediate.u(0));
+                const unset = try self.asmJccReloc(.e, undefined);
+                try self.asmMemoryRegister(
+                    .{ ._s, .bt },
+                    try dst_mcv.mem(self, .dword),
+                    index_reg.to32(),
+                );
+                self.performReloc(unset);
+                if (self.hasFeature(.slow_incdec)) {
+                    try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), Immediate.u(1));
+                } else {
+                    try self.asmRegister(.{ ._, .inc }, index_reg.to32());
+                }
+                try self.asmRegisterImmediate(
+                    .{ ._, .cmp },
+                    index_reg.to32(),
+                    Immediate.u(arg_ty.vectorLen(mod)),
+                );
+                _ = try self.asmJccReloc(.b, loop);
+
+                break :dst dst_mcv;
+            },
             else => return self.fail("TODO implement arg for {}", .{src_mcv}),
         };
 
@@ -11018,7 +11150,7 @@ fn genArgDbgInfo(self: Self, ty: Type, name: [:0]const u8, mcv: MCValue) !void {
                     regs[0].dwarfNum(), regs[1].dwarfNum(),
                 } },
                 // TODO use a frame index
-                .load_frame => return,
+                .load_frame, .elementwise_regs_then_frame => return,
                 //.stack_offset => |off| .{
                 //    .stack = .{
                 //        // TODO handle -fomit-frame-pointer
@@ -11254,6 +11386,61 @@ fn genCall(self: *Self, info: union(enum) {
                 try self.genCopy(arg_ty, dst_arg, src_arg, .{});
                 try self.freeValue(src_arg);
             },
+            .elementwise_regs_then_frame => |regs_frame_addr| {
+                const index_reg = try self.register_manager.allocReg(null, abi.RegisterClass.gp);
+                const index_lock = self.register_manager.lockRegAssumeUnused(index_reg);
+                defer self.register_manager.unlockReg(index_lock);
+
+                const src_mem: Memory = if (src_arg.isMemory()) try src_arg.mem(self, .dword) else .{
+                    .base = .{ .reg = try self.copyToTmpRegister(
+                        Type.usize,
+                        switch (src_arg) {
+                            else => src_arg,
+                            .air_ref => |src_ref| try self.resolveInst(src_ref),
+                        }.address(),
+                    ) },
+                    .mod = .{ .rm = .{ .size = .dword } },
+                };
+                const src_lock = switch (src_mem.base) {
+                    .reg => |src_reg| self.register_manager.lockReg(src_reg),
+                    else => null,
+                };
+                defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
+
+                try self.asmRegisterImmediate(
+                    .{ ._, .mov },
+                    index_reg.to32(),
+                    Immediate.u(regs_frame_addr.regs),
+                );
+                const loop: Mir.Inst.Index = @intCast(self.mir_instructions.len);
+                try self.asmMemoryRegister(.{ ._, .bt }, src_mem, index_reg.to32());
+                try self.asmSetccMemory(.c, .{
+                    .base = .{ .frame = regs_frame_addr.frame_index },
+                    .mod = .{ .rm = .{
+                        .size = .byte,
+                        .index = index_reg.to64(),
+                        .scale = .@"8",
+                        .disp = regs_frame_addr.frame_off - @as(u6, regs_frame_addr.regs) * 8,
+                    } },
+                });
+                if (self.hasFeature(.slow_incdec)) {
+                    try self.asmRegisterImmediate(.{ ._, .add }, index_reg.to32(), Immediate.u(1));
+                } else {
+                    try self.asmRegister(.{ ._, .inc }, index_reg.to32());
+                }
+                try self.asmRegisterImmediate(
+                    .{ ._, .cmp },
+                    index_reg.to32(),
+                    Immediate.u(arg_ty.vectorLen(mod)),
+                );
+                _ = try self.asmJccReloc(.b, loop);
+
+                const param_int_regs = abi.getCAbiIntParamRegs(resolved_cc);
+                for (param_int_regs[param_int_regs.len - regs_frame_addr.regs ..]) |dst_reg| {
+                    try self.register_manager.getReg(dst_reg, null);
+                    try reg_locks.append(self.register_manager.lockReg(dst_reg));
+                }
+            },
             else => unreachable,
         };
 
@@ -11295,6 +11482,37 @@ fn genCall(self: *Self, info: union(enum) {
             .indirect => |reg_off| try self.genSetReg(reg_off.reg, Type.usize, .{
                 .lea_frame = .{ .index = frame_index, .off = -reg_off.off },
             }, .{}),
+            .elementwise_regs_then_frame => |regs_frame_addr| {
+                const src_mem: Memory = if (src_arg.isMemory()) try src_arg.mem(self, .dword) else .{
+                    .base = .{ .reg = try self.copyToTmpRegister(
+                        Type.usize,
+                        switch (src_arg) {
+                            else => src_arg,
+                            .air_ref => |src_ref| try self.resolveInst(src_ref),
+                        }.address(),
+                    ) },
+                    .mod = .{ .rm = .{ .size = .dword } },
+                };
+                const src_lock = switch (src_mem.base) {
+                    .reg => |src_reg| self.register_manager.lockReg(src_reg),
+                    else => null,
+                };
+                defer if (src_lock) |lock| self.register_manager.unlockReg(lock);
+
+                const param_int_regs = abi.getCAbiIntParamRegs(resolved_cc);
+                for (
+                    param_int_regs[param_int_regs.len - regs_frame_addr.regs ..],
+                    0..,
+                ) |dst_reg, elem_index| {
+                    try self.asmRegisterRegister(.{ ._, .xor }, dst_reg.to32(), dst_reg.to32());
+                    try self.asmMemoryImmediate(
+                        .{ ._, .bt },
+                        src_mem,
+                        Immediate.u(elem_index),
+                    );
+                    try self.asmSetccRegister(.c, dst_reg.to8());
+                }
+            },
             else => unreachable,
         };
 
@@ -11581,6 +11799,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
                                     .lea_tlv,
                                     .lea_frame,
                                     .lea_symbol,
+                                    .elementwise_regs_then_frame,
                                     .reserved_frame,
                                     .air_ref,
                                     => unreachable,
@@ -11641,6 +11860,7 @@ fn airCmp(self: *Self, inst: Air.Inst.Index, op: math.CompareOperator) !void {
                                     .lea_got,
                                     .lea_tlv,
                                     .lea_frame,
+                                    .elementwise_regs_then_frame,
                                     .reserved_frame,
                                     .air_ref,
                                     => unreachable,
@@ -11925,7 +12145,7 @@ fn genTry(
         .close_scope = true,
     });
 
-    try self.performReloc(reloc);
+    self.performReloc(reloc);
 
     for (liveness_cond_br.then_deaths) |death| try self.processDeath(death);
 
@@ -12039,7 +12259,7 @@ fn airCondBr(self: *Self, inst: Air.Inst.Index) !void {
         .close_scope = true,
     });
 
-    try self.performReloc(reloc);
+    self.performReloc(reloc);
 
     for (liveness_cond_br.else_deaths) |death| try self.processDeath(death);
     try self.genBody(else_body);
@@ -12086,6 +12306,7 @@ fn isNull(self: *Self, inst: Air.Inst.Index, opt_ty: Type, opt_mcv: MCValue) !MC
         .lea_tlv,
         .lea_frame,
         .lea_symbol,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         .air_ref,
         => unreachable,
@@ -12422,7 +12643,7 @@ fn airBlock(self: *Self, inst: Air.Inst.Index) !void {
             .resurrect = true,
             .close_scope = true,
         });
-        for (block_data.value.relocs.items) |reloc| try self.performReloc(reloc);
+        for (block_data.value.relocs.items) |reloc| self.performReloc(reloc);
     }
 
     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 {
 
         for (liveness.deaths[case_i]) |operand| try self.processDeath(operand);
 
-        for (relocs[0 .. relocs.len - 1]) |reloc| try self.performReloc(reloc);
+        for (relocs[0 .. relocs.len - 1]) |reloc| self.performReloc(reloc);
         try self.genBody(case_body);
         try self.restoreState(state, &.{}, .{
             .emit_instructions = false,
@@ -12491,7 +12712,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
             .close_scope = true,
         });
 
-        try self.performReloc(relocs[relocs.len - 1]);
+        self.performReloc(relocs[relocs.len - 1]);
     }
 
     if (switch_br.data.else_body_len > 0) {
@@ -12514,7 +12735,7 @@ fn airSwitchBr(self: *Self, inst: Air.Inst.Index) !void {
     self.finishAirBookkeeping();
 }
 
-fn performReloc(self: *Self, reloc: Mir.Inst.Index) !void {
+fn performReloc(self: *Self, reloc: Mir.Inst.Index) void {
     const next_inst: u32 = @intCast(self.mir_instructions.len);
     switch (self.mir_instructions.items(.tag)[reloc]) {
         .j, .jmp => {},
@@ -12863,7 +13084,7 @@ fn airAsm(self: *Self, inst: Air.Inst.Index) !void {
                 if (!anon and label_gop.value_ptr.pending_relocs.items.len == 0)
                     return self.fail("redefined label: '{s}'", .{label_name});
                 for (label_gop.value_ptr.pending_relocs.items) |pending_reloc|
-                    try self.performReloc(pending_reloc);
+                    self.performReloc(pending_reloc);
                 if (anon)
                     label_gop.value_ptr.pending_relocs.clearRetainingCapacity()
                 else
@@ -13380,7 +13601,13 @@ fn moveStrategy(self: *Self, ty: Type, class: Register.Class, aligned: bool) !Mo
                 else => {},
             },
             .Vector => switch (ty.childType(mod).zigTypeTag(mod)) {
-                .Bool => {},
+                .Bool => switch (ty.vectorLen(mod)) {
+                    33...64 => return .{ .move = if (self.hasFeature(.avx))
+                        .{ .v_q, .mov }
+                    else
+                        .{ ._q, .mov } },
+                    else => {},
+                },
                 .Int => switch (ty.childType(mod).intInfo(mod).bits) {
                     8 => switch (ty.vectorLen(mod)) {
                         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
         .lea_tlv,
         .lea_frame,
         .lea_symbol,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         .air_ref,
         => unreachable, // unmodifiable destination
@@ -13628,6 +13856,7 @@ fn genCopy(self: *Self, ty: Type, dst_mcv: MCValue, src_mcv: MCValue, opts: Copy
             .dead,
             .undef,
             .register_overflow,
+            .elementwise_regs_then_frame,
             .reserved_frame,
             => unreachable,
             .immediate,
@@ -13725,6 +13954,7 @@ fn genSetReg(
         .unreach,
         .dead,
         .register_overflow,
+        .elementwise_regs_then_frame,
         .reserved_frame,
         => unreachable,
         .undef => if (opts.safety) switch (dst_reg.class()) {
@@ -14034,7 +14264,12 @@ fn genSetMem(
         .reloc => |base_symbol| .{ .lea_symbol = .{ .sym = base_symbol.sym_index, .off = disp } },
     };
     switch (src_mcv) {
-        .none, .unreach, .dead, .reserved_frame => unreachable,
+        .none,
+        .unreach,
+        .dead,
+        .elementwise_regs_then_frame,
+        .reserved_frame,
+        => unreachable,
         .undef => if (opts.safety) try self.genInlineMemset(
             dst_ptr_mcv,
             src_mcv,
@@ -15233,7 +15468,7 @@ fn airMemset(self: *Self, inst: Air.Inst.Index, safety: bool) !void {
                 );
                 try self.genInlineMemcpy(second_elem_ptr_mcv, ptr, len_mcv);
 
-                try self.performReloc(skip_reloc);
+                self.performReloc(skip_reloc);
             },
             .One => {
                 const elem_ptr_ty = try mod.singleMutPtrType(elem_ty);
@@ -16402,7 +16637,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
                     try self.genCopy(Type.c_uint, gp_offset, .{ .register = offset_reg }, .{});
                     const done_reloc = try self.asmJmpReloc(undefined);
 
-                    try self.performReloc(mem_reloc);
+                    self.performReloc(mem_reloc);
                     try self.genSetReg(addr_reg, ptr_anyopaque_ty, overflow_arg_area, .{});
                     try self.asmRegisterMemory(.{ ._, .lea }, offset_reg.to64(), .{
                         .base = .{ .reg = addr_reg },
@@ -16418,7 +16653,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
                         .{},
                     );
 
-                    try self.performReloc(done_reloc);
+                    self.performReloc(done_reloc);
                     if (!unused) try self.genCopy(promote_ty, promote_mcv, .{
                         .indirect = .{ .reg = addr_reg },
                     }, .{});
@@ -16450,7 +16685,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
                     try self.genCopy(Type.c_uint, fp_offset, .{ .register = offset_reg }, .{});
                     const done_reloc = try self.asmJmpReloc(undefined);
 
-                    try self.performReloc(mem_reloc);
+                    self.performReloc(mem_reloc);
                     try self.genSetReg(addr_reg, ptr_anyopaque_ty, overflow_arg_area, .{});
                     try self.asmRegisterMemory(.{ ._, .lea }, offset_reg.to64(), .{
                         .base = .{ .reg = addr_reg },
@@ -16466,7 +16701,7 @@ fn airVaArg(self: *Self, inst: Air.Inst.Index) !void {
                         .{},
                     );
 
-                    try self.performReloc(done_reloc);
+                    self.performReloc(done_reloc);
                     if (!unused) try self.genCopy(promote_ty, promote_mcv, .{
                         .indirect = .{ .reg = addr_reg },
                     }, .{});
@@ -16771,7 +17006,7 @@ fn resolveCallingConventionValues(
                         };
                         ret_tracking_i += 1;
                     },
-                    .none => unreachable,
+                    .none, .integer_per_element => unreachable,
                 };
                 result.return_value = switch (ret_tracking_i) {
                     else => unreachable,
@@ -16846,6 +17081,32 @@ fn resolveCallingConventionValues(
                         else => unreachable,
                     },
                     .none => unreachable,
+                    .integer_per_element => {
+                        const param_int_regs_len: u32 =
+                            @intCast(abi.getCAbiIntParamRegs(resolved_cc).len);
+                        const remaining_param_int_regs: u3 =
+                            @intCast(param_int_regs_len - param_int_reg_i);
+                        param_int_reg_i = param_int_regs_len;
+
+                        const frame_elem_align = 8;
+                        const frame_elems_len = ty.vectorLen(mod) - remaining_param_int_regs;
+                        const frame_elem_size = mem.alignForward(
+                            u64,
+                            ty.childType(mod).abiSize(mod),
+                            frame_elem_align,
+                        );
+                        const frame_size: u31 = @intCast(frame_elems_len * frame_elem_size);
+
+                        result.stack_byte_count =
+                            mem.alignForward(u31, result.stack_byte_count, frame_elem_align);
+                        arg_mcv[arg_mcv_i] = .{ .elementwise_regs_then_frame = .{
+                            .regs = remaining_param_int_regs,
+                            .frame_off = @intCast(result.stack_byte_count),
+                            .frame_index = stack_frame_base,
+                        } };
+                        arg_mcv_i += 1;
+                        result.stack_byte_count += frame_size;
+                    },
                 } else {
                     arg.* = switch (arg_mcv_i) {
                         else => unreachable,
src/codegen/llvm.zig
@@ -11139,6 +11139,9 @@ fn lowerSystemVFnRetTy(o: *Object, fn_info: InternPool.Key.FuncType) Allocator.E
             .memory => unreachable, // handled above
             .win_i128 => unreachable, // windows only
             .none => break,
+            .integer_per_element => {
+                @panic("TODO");
+            },
         }
     }
     const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer});
@@ -11417,6 +11420,9 @@ const ParamTypeIterator = struct {
                 .memory => unreachable, // handled above
                 .win_i128 => unreachable, // windows only
                 .none => break,
+                .integer_per_element => {
+                    @panic("TODO");
+                },
             }
         }
         const first_non_integer = std.mem.indexOfNone(x86_64_abi.Class, &classes, &.{.integer});
test/behavior/vector.zig
@@ -485,7 +485,6 @@ test "initialize vector which is a struct field" {
 
 test "vector comparison operators" {
     if (builtin.zig_backend == .stage2_wasm) return error.SkipZigTest; // TODO
-    if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_aarch64) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_arm) return error.SkipZigTest; // TODO
     if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO
test/c_abi/cfuncs.c
@@ -236,6 +236,2156 @@ struct SplitStructMixed zig_ret_split_struct_mixed();
 
 struct BigStruct zig_big_struct_both(struct BigStruct);
 
+#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32)
+
+typedef bool Vector2Bool __attribute__((ext_vector_type(2)));
+typedef bool Vector4Bool __attribute__((ext_vector_type(4)));
+typedef bool Vector8Bool __attribute__((ext_vector_type(8)));
+typedef bool Vector16Bool __attribute__((ext_vector_type(16)));
+typedef bool Vector32Bool __attribute__((ext_vector_type(32)));
+typedef bool Vector64Bool __attribute__((ext_vector_type(64)));
+typedef bool Vector128Bool __attribute__((ext_vector_type(128)));
+typedef bool Vector256Bool __attribute__((ext_vector_type(256)));
+typedef bool Vector512Bool __attribute__((ext_vector_type(512)));
+
+void c_vector_2_bool(Vector2Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == true);
+}
+
+void c_vector_4_bool(Vector4Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == true);
+    assert_or_panic(vec[2] == false);
+    assert_or_panic(vec[3] == true);
+}
+
+void c_vector_8_bool(Vector8Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == false);
+    assert_or_panic(vec[2] == true);
+    assert_or_panic(vec[3] == true);
+    assert_or_panic(vec[4] == true);
+    assert_or_panic(vec[5] == true);
+    assert_or_panic(vec[6] == false);
+    assert_or_panic(vec[7] == true);
+}
+
+void c_vector_16_bool(Vector16Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == false);
+    assert_or_panic(vec[2] == false);
+    assert_or_panic(vec[3] == false);
+    assert_or_panic(vec[4] == true);
+    assert_or_panic(vec[5] == false);
+    assert_or_panic(vec[6] == true);
+    assert_or_panic(vec[7] == true);
+    assert_or_panic(vec[8] == true);
+    assert_or_panic(vec[9] == true);
+    assert_or_panic(vec[10] == true);
+    assert_or_panic(vec[11] == true);
+    assert_or_panic(vec[12] == false);
+    assert_or_panic(vec[13] == false);
+    assert_or_panic(vec[14] == false);
+    assert_or_panic(vec[15] == false);
+}
+
+void c_vector_32_bool(Vector32Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == false);
+    assert_or_panic(vec[2] == true);
+    assert_or_panic(vec[3] == true);
+    assert_or_panic(vec[4] == false);
+    assert_or_panic(vec[5] == false);
+    assert_or_panic(vec[6] == true);
+    assert_or_panic(vec[7] == false);
+    assert_or_panic(vec[8] == true);
+    assert_or_panic(vec[9] == false);
+    assert_or_panic(vec[10] == true);
+    assert_or_panic(vec[11] == true);
+    assert_or_panic(vec[12] == true);
+    assert_or_panic(vec[13] == false);
+    assert_or_panic(vec[14] == false);
+    assert_or_panic(vec[15] == true);
+    assert_or_panic(vec[16] == false);
+    assert_or_panic(vec[17] == true);
+    assert_or_panic(vec[18] == false);
+    assert_or_panic(vec[19] == true);
+    assert_or_panic(vec[20] == true);
+    assert_or_panic(vec[21] == true);
+    assert_or_panic(vec[22] == true);
+    assert_or_panic(vec[23] == true);
+    assert_or_panic(vec[24] == false);
+    assert_or_panic(vec[25] == true);
+    assert_or_panic(vec[26] == true);
+    assert_or_panic(vec[27] == true);
+    assert_or_panic(vec[28] == false);
+    assert_or_panic(vec[29] == true);
+    assert_or_panic(vec[30] == true);
+    assert_or_panic(vec[31] == false);
+}
+
+void c_vector_64_bool(Vector64Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == true);
+    assert_or_panic(vec[2] == true);
+    assert_or_panic(vec[3] == false);
+    assert_or_panic(vec[4] == true);
+    assert_or_panic(vec[5] == false);
+    assert_or_panic(vec[6] == false);
+    assert_or_panic(vec[7] == false);
+    assert_or_panic(vec[8] == true);
+    assert_or_panic(vec[9] == false);
+    assert_or_panic(vec[10] == false);
+    assert_or_panic(vec[11] == false);
+    assert_or_panic(vec[12] == false);
+    assert_or_panic(vec[13] == true);
+    assert_or_panic(vec[14] == true);
+    assert_or_panic(vec[15] == true);
+    assert_or_panic(vec[16] == true);
+    assert_or_panic(vec[17] == false);
+    assert_or_panic(vec[18] == false);
+    assert_or_panic(vec[19] == true);
+    assert_or_panic(vec[20] == false);
+    assert_or_panic(vec[21] == true);
+    assert_or_panic(vec[22] == false);
+    assert_or_panic(vec[23] == true);
+    assert_or_panic(vec[24] == true);
+    assert_or_panic(vec[25] == true);
+    assert_or_panic(vec[26] == true);
+    assert_or_panic(vec[27] == true);
+    assert_or_panic(vec[28] == true);
+    assert_or_panic(vec[29] == true);
+    assert_or_panic(vec[30] == false);
+    assert_or_panic(vec[31] == false);
+    assert_or_panic(vec[32] == true);
+    assert_or_panic(vec[33] == true);
+    assert_or_panic(vec[34] == false);
+    assert_or_panic(vec[35] == true);
+    assert_or_panic(vec[36] == false);
+    assert_or_panic(vec[37] == false);
+    assert_or_panic(vec[38] == true);
+    assert_or_panic(vec[39] == true);
+    assert_or_panic(vec[40] == true);
+    assert_or_panic(vec[41] == false);
+    assert_or_panic(vec[42] == false);
+    assert_or_panic(vec[43] == true);
+    assert_or_panic(vec[44] == true);
+    assert_or_panic(vec[45] == false);
+    assert_or_panic(vec[46] == true);
+    assert_or_panic(vec[47] == false);
+    assert_or_panic(vec[48] == true);
+    assert_or_panic(vec[49] == false);
+    assert_or_panic(vec[50] == false);
+    assert_or_panic(vec[51] == true);
+    assert_or_panic(vec[52] == false);
+    assert_or_panic(vec[53] == true);
+    assert_or_panic(vec[54] == true);
+    assert_or_panic(vec[55] == true);
+    assert_or_panic(vec[56] == true);
+    assert_or_panic(vec[57] == true);
+    assert_or_panic(vec[58] == false);
+    assert_or_panic(vec[59] == false);
+    assert_or_panic(vec[60] == true);
+    assert_or_panic(vec[61] == false);
+    assert_or_panic(vec[62] == true);
+    assert_or_panic(vec[63] == false);
+}
+
+void c_vector_128_bool(Vector128Bool vec) {
+    assert_or_panic(vec[0] == false);
+    assert_or_panic(vec[1] == false);
+    assert_or_panic(vec[2] == false);
+    assert_or_panic(vec[3] == false);
+    assert_or_panic(vec[4] == false);
+    assert_or_panic(vec[5] == true);
+    assert_or_panic(vec[6] == true);
+    assert_or_panic(vec[7] == false);
+    assert_or_panic(vec[8] == true);
+    assert_or_panic(vec[9] == true);
+    assert_or_panic(vec[10] == false);
+    assert_or_panic(vec[11] == true);
+    assert_or_panic(vec[12] == true);
+    assert_or_panic(vec[13] == false);
+    assert_or_panic(vec[14] == true);
+    assert_or_panic(vec[15] == true);
+    assert_or_panic(vec[16] == true);
+    assert_or_panic(vec[17] == false);
+    assert_or_panic(vec[18] == false);
+    assert_or_panic(vec[19] == false);
+    assert_or_panic(vec[20] == false);
+    assert_or_panic(vec[21] == true);
+    assert_or_panic(vec[22] == true);
+    assert_or_panic(vec[23] == false);
+    assert_or_panic(vec[24] == false);
+    assert_or_panic(vec[25] == false);
+    assert_or_panic(vec[26] == true);
+    assert_or_panic(vec[27] == true);
+    assert_or_panic(vec[28] == false);
+    assert_or_panic(vec[29] == true);
+    assert_or_panic(vec[30] == false);
+    assert_or_panic(vec[31] == false);
+    assert_or_panic(vec[32] == true);
+    assert_or_panic(vec[33] == false);
+    assert_or_panic(vec[34] == false);
+    assert_or_panic(vec[35] == true);
+    assert_or_panic(vec[36] == true);
+    assert_or_panic(vec[37] == true);
+    assert_or_panic(vec[38] == true);
+    assert_or_panic(vec[39] == true);
+    assert_or_panic(vec[40] == false);
+    assert_or_panic(vec[41] == true);
+    assert_or_panic(vec[42] == true);
+    assert_or_panic(vec[43] == true);
+    assert_or_panic(vec[44] == false);
+    assert_or_panic(vec[45] == false);
+    assert_or_panic(vec[46] == false);
+    assert_or_panic(vec[47] == false);
+    assert_or_panic(vec[48] == true);
+    assert_or_panic(vec[49] == true);
+    assert_or_panic(vec[50] == false);
+    assert_or_panic(vec[51] == true);
+    assert_or_panic(vec[52] == true);
+    assert_or_panic(vec[53] == true);
+    assert_or_panic(vec[54] == true);
+    assert_or_panic(vec[55] == true);
+    assert_or_panic(vec[56] == false);
+    assert_or_panic(vec[57] == true);
+    assert_or_panic(vec[58] == true);
+    assert_or_panic(vec[59] == false);
+    assert_or_panic(vec[60] == true);
+    assert_or_panic(vec[61] == false);
+    assert_or_panic(vec[62] == false);
+    assert_or_panic(vec[63] == true);
+    assert_or_panic(vec[64] == true);
+    assert_or_panic(vec[65] == false);
+    assert_or_panic(vec[66] == true);
+    assert_or_panic(vec[67] == true);
+    assert_or_panic(vec[68] == false);
+    assert_or_panic(vec[69] == true);
+    assert_or_panic(vec[70] == false);
+    assert_or_panic(vec[71] == false);
+    assert_or_panic(vec[72] == true);
+    assert_or_panic(vec[73] == true);
+    assert_or_panic(vec[74] == false);
+    assert_or_panic(vec[75] == true);
+    assert_or_panic(vec[76] == true);
+    assert_or_panic(vec[77] == true);
+    assert_or_panic(vec[78] == false);
+    assert_or_panic(vec[79] == true);
+    assert_or_panic(vec[80] == false);
+    assert_or_panic(vec[81] == false);
+    assert_or_panic(vec[82] == false);
+    assert_or_panic(vec[83] == false);
+    assert_or_panic(vec[84] == true);
+    assert_or_panic(vec[85] == false);
+    assert_or_panic(vec[86] == false);
+    assert_or_panic(vec[87] == false);
+    assert_or_panic(vec[88] == true);
+    assert_or_panic(vec[89] == true);
+    assert_or_panic(vec[90] == false);
+    assert_or_panic(vec[91] == false);
+    assert_or_panic(vec[92] == true);
+    assert_or_panic(vec[93] == true);
+    assert_or_panic(vec[94] == true);
+    assert_or_panic(vec[95] == true);
+    assert_or_panic(vec[96] == false);
+    assert_or_panic(vec[97] == false);
+    assert_or_panic(vec[98] == false);
+    assert_or_panic(vec[99] == false);
+    assert_or_panic(vec[100] == false);
+    assert_or_panic(vec[101] == true);
+    assert_or_panic(vec[102] == false);
+    assert_or_panic(vec[103] == false);
+    assert_or_panic(vec[104] == false);
+    assert_or_panic(vec[105] == false);
+    assert_or_panic(vec[106] == true);
+    assert_or_panic(vec[107] == true);
+    assert_or_panic(vec[108] == true);
+    assert_or_panic(vec[109] == true);
+    assert_or_panic(vec[110] == true);
+    assert_or_panic(vec[111] == false);
+    assert_or_panic(vec[112] == false);
+    assert_or_panic(vec[113] == true);
+    assert_or_panic(vec[114] == false);
+    assert_or_panic(vec[115] == true);
+    assert_or_panic(vec[116] == false);
+    assert_or_panic(vec[117] == false);
+    assert_or_panic(vec[118] == true);
+    assert_or_panic(vec[119] == false);
+    assert_or_panic(vec[120] == true);
+    assert_or_panic(vec[121] == false);
+    assert_or_panic(vec[122] == true);
+    assert_or_panic(vec[123] == true);
+    assert_or_panic(vec[124] == true);
+    assert_or_panic(vec[125] == true);
+    assert_or_panic(vec[126] == true);
+    assert_or_panic(vec[127] == true);
+}
+
+void c_vector_256_bool(Vector256Bool vec) {
+    assert_or_panic(vec[0] == false);
+    assert_or_panic(vec[1] == true);
+    assert_or_panic(vec[2] == true);
+    assert_or_panic(vec[3] == false);
+    assert_or_panic(vec[4] == false);
+    assert_or_panic(vec[5] == true);
+    assert_or_panic(vec[6] == true);
+    assert_or_panic(vec[7] == true);
+    assert_or_panic(vec[8] == false);
+    assert_or_panic(vec[9] == true);
+    assert_or_panic(vec[10] == true);
+    assert_or_panic(vec[11] == true);
+    assert_or_panic(vec[12] == false);
+    assert_or_panic(vec[13] == true);
+    assert_or_panic(vec[14] == false);
+    assert_or_panic(vec[15] == true);
+    assert_or_panic(vec[16] == false);
+    assert_or_panic(vec[17] == false);
+    assert_or_panic(vec[18] == true);
+    assert_or_panic(vec[19] == true);
+    assert_or_panic(vec[20] == false);
+    assert_or_panic(vec[21] == true);
+    assert_or_panic(vec[22] == false);
+    assert_or_panic(vec[23] == false);
+    assert_or_panic(vec[24] == false);
+    assert_or_panic(vec[25] == true);
+    assert_or_panic(vec[26] == true);
+    assert_or_panic(vec[27] == false);
+    assert_or_panic(vec[28] == false);
+    assert_or_panic(vec[29] == true);
+    assert_or_panic(vec[30] == true);
+    assert_or_panic(vec[31] == false);
+    assert_or_panic(vec[32] == true);
+    assert_or_panic(vec[33] == false);
+    assert_or_panic(vec[34] == false);
+    assert_or_panic(vec[35] == true);
+    assert_or_panic(vec[36] == false);
+    assert_or_panic(vec[37] == true);
+    assert_or_panic(vec[38] == false);
+    assert_or_panic(vec[39] == true);
+    assert_or_panic(vec[40] == true);
+    assert_or_panic(vec[41] == true);
+    assert_or_panic(vec[42] == true);
+    assert_or_panic(vec[43] == false);
+    assert_or_panic(vec[44] == false);
+    assert_or_panic(vec[45] == true);
+    assert_or_panic(vec[46] == false);
+    assert_or_panic(vec[47] == false);
+    assert_or_panic(vec[48] == false);
+    assert_or_panic(vec[49] == false);
+    assert_or_panic(vec[50] == false);
+    assert_or_panic(vec[51] == false);
+    assert_or_panic(vec[52] == true);
+    assert_or_panic(vec[53] == true);
+    assert_or_panic(vec[54] == true);
+    assert_or_panic(vec[55] == true);
+    assert_or_panic(vec[56] == true);
+    assert_or_panic(vec[57] == true);
+    assert_or_panic(vec[58] == false);
+    assert_or_panic(vec[59] == true);
+    assert_or_panic(vec[60] == true);
+    assert_or_panic(vec[61] == false);
+    assert_or_panic(vec[62] == false);
+    assert_or_panic(vec[63] == true);
+    assert_or_panic(vec[64] == false);
+    assert_or_panic(vec[65] == false);
+    assert_or_panic(vec[66] == false);
+    assert_or_panic(vec[67] == false);
+    assert_or_panic(vec[68] == false);
+    assert_or_panic(vec[69] == false);
+    assert_or_panic(vec[70] == true);
+    assert_or_panic(vec[71] == true);
+    assert_or_panic(vec[72] == true);
+    assert_or_panic(vec[73] == false);
+    assert_or_panic(vec[74] == false);
+    assert_or_panic(vec[75] == false);
+    assert_or_panic(vec[76] == true);
+    assert_or_panic(vec[77] == false);
+    assert_or_panic(vec[78] == true);
+    assert_or_panic(vec[79] == true);
+    assert_or_panic(vec[80] == false);
+    assert_or_panic(vec[81] == false);
+    assert_or_panic(vec[82] == true);
+    assert_or_panic(vec[83] == true);
+    assert_or_panic(vec[84] == false);
+    assert_or_panic(vec[85] == true);
+    assert_or_panic(vec[86] == true);
+    assert_or_panic(vec[87] == true);
+    assert_or_panic(vec[88] == true);
+    assert_or_panic(vec[89] == true);
+    assert_or_panic(vec[90] == true);
+    assert_or_panic(vec[91] == true);
+    assert_or_panic(vec[92] == false);
+    assert_or_panic(vec[93] == true);
+    assert_or_panic(vec[94] == true);
+    assert_or_panic(vec[95] == false);
+    assert_or_panic(vec[96] == false);
+    assert_or_panic(vec[97] == true);
+    assert_or_panic(vec[98] == true);
+    assert_or_panic(vec[99] == false);
+    assert_or_panic(vec[100] == true);
+    assert_or_panic(vec[101] == false);
+    assert_or_panic(vec[102] == false);
+    assert_or_panic(vec[103] == true);
+    assert_or_panic(vec[104] == false);
+    assert_or_panic(vec[105] == true);
+    assert_or_panic(vec[106] == true);
+    assert_or_panic(vec[107] == true);
+    assert_or_panic(vec[108] == true);
+    assert_or_panic(vec[109] == true);
+    assert_or_panic(vec[110] == false);
+    assert_or_panic(vec[111] == false);
+    assert_or_panic(vec[112] == false);
+    assert_or_panic(vec[113] == false);
+    assert_or_panic(vec[114] == true);
+    assert_or_panic(vec[115] == true);
+    assert_or_panic(vec[116] == false);
+    assert_or_panic(vec[117] == true);
+    assert_or_panic(vec[118] == false);
+    assert_or_panic(vec[119] == false);
+    assert_or_panic(vec[120] == true);
+    assert_or_panic(vec[121] == false);
+    assert_or_panic(vec[122] == false);
+    assert_or_panic(vec[123] == true);
+    assert_or_panic(vec[124] == false);
+    assert_or_panic(vec[125] == true);
+    assert_or_panic(vec[126] == true);
+    assert_or_panic(vec[127] == true);
+    assert_or_panic(vec[128] == true);
+    assert_or_panic(vec[129] == false);
+    assert_or_panic(vec[130] == true);
+    assert_or_panic(vec[131] == true);
+    assert_or_panic(vec[132] == false);
+    assert_or_panic(vec[133] == false);
+    assert_or_panic(vec[134] == true);
+    assert_or_panic(vec[135] == false);
+    assert_or_panic(vec[136] == false);
+    assert_or_panic(vec[137] == true);
+    assert_or_panic(vec[138] == false);
+    assert_or_panic(vec[139] == true);
+    assert_or_panic(vec[140] == false);
+    assert_or_panic(vec[141] == true);
+    assert_or_panic(vec[142] == true);
+    assert_or_panic(vec[143] == true);
+    assert_or_panic(vec[144] == true);
+    assert_or_panic(vec[145] == false);
+    assert_or_panic(vec[146] == true);
+    assert_or_panic(vec[147] == false);
+    assert_or_panic(vec[148] == false);
+    assert_or_panic(vec[149] == false);
+    assert_or_panic(vec[150] == true);
+    assert_or_panic(vec[151] == true);
+    assert_or_panic(vec[152] == true);
+    assert_or_panic(vec[153] == true);
+    assert_or_panic(vec[154] == true);
+    assert_or_panic(vec[155] == false);
+    assert_or_panic(vec[156] == true);
+    assert_or_panic(vec[157] == false);
+    assert_or_panic(vec[158] == false);
+    assert_or_panic(vec[159] == false);
+    assert_or_panic(vec[160] == true);
+    assert_or_panic(vec[161] == true);
+    assert_or_panic(vec[162] == false);
+    assert_or_panic(vec[163] == true);
+    assert_or_panic(vec[164] == true);
+    assert_or_panic(vec[165] == false);
+    assert_or_panic(vec[166] == false);
+    assert_or_panic(vec[167] == false);
+    assert_or_panic(vec[168] == false);
+    assert_or_panic(vec[169] == true);
+    assert_or_panic(vec[170] == false);
+    assert_or_panic(vec[171] == true);
+    assert_or_panic(vec[172] == false);
+    assert_or_panic(vec[173] == false);
+    assert_or_panic(vec[174] == false);
+    assert_or_panic(vec[175] == false);
+    assert_or_panic(vec[176] == true);
+    assert_or_panic(vec[177] == true);
+    assert_or_panic(vec[178] == true);
+    assert_or_panic(vec[179] == false);
+    assert_or_panic(vec[180] == true);
+    assert_or_panic(vec[181] == false);
+    assert_or_panic(vec[182] == true);
+    assert_or_panic(vec[183] == true);
+    assert_or_panic(vec[184] == false);
+    assert_or_panic(vec[185] == false);
+    assert_or_panic(vec[186] == true);
+    assert_or_panic(vec[187] == false);
+    assert_or_panic(vec[188] == false);
+    assert_or_panic(vec[189] == false);
+    assert_or_panic(vec[190] == false);
+    assert_or_panic(vec[191] == true);
+    assert_or_panic(vec[192] == true);
+    assert_or_panic(vec[193] == true);
+    assert_or_panic(vec[194] == true);
+    assert_or_panic(vec[195] == true);
+    assert_or_panic(vec[196] == true);
+    assert_or_panic(vec[197] == true);
+    assert_or_panic(vec[198] == false);
+    assert_or_panic(vec[199] == true);
+    assert_or_panic(vec[200] == false);
+    assert_or_panic(vec[201] == false);
+    assert_or_panic(vec[202] == true);
+    assert_or_panic(vec[203] == false);
+    assert_or_panic(vec[204] == true);
+    assert_or_panic(vec[205] == true);
+    assert_or_panic(vec[206] == true);
+    assert_or_panic(vec[207] == false);
+    assert_or_panic(vec[208] == false);
+    assert_or_panic(vec[209] == true);
+    assert_or_panic(vec[210] == true);
+    assert_or_panic(vec[211] == true);
+    assert_or_panic(vec[212] == false);
+    assert_or_panic(vec[213] == true);
+    assert_or_panic(vec[214] == true);
+    assert_or_panic(vec[215] == true);
+    assert_or_panic(vec[216] == true);
+    assert_or_panic(vec[217] == true);
+    assert_or_panic(vec[218] == false);
+    assert_or_panic(vec[219] == false);
+    assert_or_panic(vec[220] == false);
+    assert_or_panic(vec[221] == false);
+    assert_or_panic(vec[222] == false);
+    assert_or_panic(vec[223] == true);
+    assert_or_panic(vec[224] == true);
+    assert_or_panic(vec[225] == false);
+    assert_or_panic(vec[226] == true);
+    assert_or_panic(vec[227] == false);
+    assert_or_panic(vec[228] == false);
+    assert_or_panic(vec[229] == true);
+    assert_or_panic(vec[230] == false);
+    assert_or_panic(vec[231] == true);
+    assert_or_panic(vec[232] == false);
+    assert_or_panic(vec[233] == false);
+    assert_or_panic(vec[234] == false);
+    assert_or_panic(vec[235] == true);
+    assert_or_panic(vec[236] == false);
+    assert_or_panic(vec[237] == false);
+    assert_or_panic(vec[238] == false);
+    assert_or_panic(vec[239] == true);
+    assert_or_panic(vec[240] == true);
+    assert_or_panic(vec[241] == true);
+    assert_or_panic(vec[242] == true);
+    assert_or_panic(vec[243] == true);
+    assert_or_panic(vec[244] == true);
+    assert_or_panic(vec[245] == false);
+    assert_or_panic(vec[246] == false);
+    assert_or_panic(vec[247] == true);
+    assert_or_panic(vec[248] == false);
+    assert_or_panic(vec[249] == true);
+    assert_or_panic(vec[250] == true);
+    assert_or_panic(vec[251] == false);
+    assert_or_panic(vec[252] == true);
+    assert_or_panic(vec[253] == true);
+    assert_or_panic(vec[254] == true);
+    assert_or_panic(vec[255] == false);
+}
+
+void c_vector_512_bool(Vector512Bool vec) {
+    assert_or_panic(vec[0] == true);
+    assert_or_panic(vec[1] == true);
+    assert_or_panic(vec[2] == true);
+    assert_or_panic(vec[3] == true);
+    assert_or_panic(vec[4] == true);
+    assert_or_panic(vec[5] == false);
+    assert_or_panic(vec[6] == false);
+    assert_or_panic(vec[7] == true);
+    assert_or_panic(vec[8] == true);
+    assert_or_panic(vec[9] == true);
+    assert_or_panic(vec[10] == true);
+    assert_or_panic(vec[11] == false);
+    assert_or_panic(vec[12] == true);
+    assert_or_panic(vec[13] == true);
+    assert_or_panic(vec[14] == false);
+    assert_or_panic(vec[15] == false);
+    assert_or_panic(vec[16] == false);
+    assert_or_panic(vec[17] == true);
+    assert_or_panic(vec[18] == true);
+    assert_or_panic(vec[19] == true);
+    assert_or_panic(vec[20] == true);
+    assert_or_panic(vec[21] == true);
+    assert_or_panic(vec[22] == false);
+    assert_or_panic(vec[23] == false);
+    assert_or_panic(vec[24] == true);
+    assert_or_panic(vec[25] == true);
+    assert_or_panic(vec[26] == false);
+    assert_or_panic(vec[27] == false);
+    assert_or_panic(vec[28] == false);
+    assert_or_panic(vec[29] == false);
+    assert_or_panic(vec[30] == false);
+    assert_or_panic(vec[31] == true);
+    assert_or_panic(vec[32] == true);
+    assert_or_panic(vec[33] == false);
+    assert_or_panic(vec[34] == true);
+    assert_or_panic(vec[35] == true);
+    assert_or_panic(vec[36] == true);
+    assert_or_panic(vec[37] == true);
+    assert_or_panic(vec[38] == true);
+    assert_or_panic(vec[39] == true);
+    assert_or_panic(vec[40] == false);
+    assert_or_panic(vec[41] == true);
+    assert_or_panic(vec[42] == true);
+    assert_or_panic(vec[43] == false);
+    assert_or_panic(vec[44] == false);
+    assert_or_panic(vec[45] == false);
+    assert_or_panic(vec[46] == true);
+    assert_or_panic(vec[47] == true);
+    assert_or_panic(vec[48] == false);
+    assert_or_panic(vec[49] == true);
+    assert_or_panic(vec[50] == false);
+    assert_or_panic(vec[51] == true);
+    assert_or_panic(vec[52] == true);
+    assert_or_panic(vec[53] == false);
+    assert_or_panic(vec[54] == true);
+    assert_or_panic(vec[55] == false);
+    assert_or_panic(vec[56] == false);
+    assert_or_panic(vec[57] == true);
+    assert_or_panic(vec[58] == true);
+    assert_or_panic(vec[59] == false);
+    assert_or_panic(vec[60] == true);
+    assert_or_panic(vec[61] == true);
+    assert_or_panic(vec[62] == false);
+    assert_or_panic(vec[63] == true);
+    assert_or_panic(vec[64] == false);
+    assert_or_panic(vec[65] == true);
+    assert_or_panic(vec[66] == true);
+    assert_or_panic(vec[67] == true);
+    assert_or_panic(vec[68] == true);
+    assert_or_panic(vec[69] == true);
+    assert_or_panic(vec[70] == true);
+    assert_or_panic(vec[71] == true);
+    assert_or_panic(vec[72] == true);
+    assert_or_panic(vec[73] == true);
+    assert_or_panic(vec[74] == false);
+    assert_or_panic(vec[75] == true);
+    assert_or_panic(vec[76] == false);
+    assert_or_panic(vec[77] == true);
+    assert_or_panic(vec[78] == false);
+    assert_or_panic(vec[79] == false);
+    assert_or_panic(vec[80] == false);
+    assert_or_panic(vec[81] == true);
+    assert_or_panic(vec[82] == false);
+    assert_or_panic(vec[83] == true);
+    assert_or_panic(vec[84] == true);
+    assert_or_panic(vec[85] == false);
+    assert_or_panic(vec[86] == true);
+    assert_or_panic(vec[87] == true);
+    assert_or_panic(vec[88] == true);
+    assert_or_panic(vec[89] == false);
+    assert_or_panic(vec[90] == true);
+    assert_or_panic(vec[91] == true);
+    assert_or_panic(vec[92] == false);
+    assert_or_panic(vec[93] == true);
+    assert_or_panic(vec[94] == false);
+    assert_or_panic(vec[95] == true);
+    assert_or_panic(vec[96] == true);
+    assert_or_panic(vec[97] == false);
+    assert_or_panic(vec[98] == false);
+    assert_or_panic(vec[99] == false);
+    assert_or_panic(vec[100] == true);
+    assert_or_panic(vec[101] == true);
+    assert_or_panic(vec[102] == false);
+    assert_or_panic(vec[103] == true);
+    assert_or_panic(vec[104] == false);
+    assert_or_panic(vec[105] == false);
+    assert_or_panic(vec[106] == true);
+    assert_or_panic(vec[107] == false);
+    assert_or_panic(vec[108] == false);
+    assert_or_panic(vec[109] == true);
+    assert_or_panic(vec[110] == false);
+    assert_or_panic(vec[111] == false);
+    assert_or_panic(vec[112] == false);
+    assert_or_panic(vec[113] == false);
+    assert_or_panic(vec[114] == false);
+    assert_or_panic(vec[115] == true);
+    assert_or_panic(vec[116] == true);
+    assert_or_panic(vec[117] == false);
+    assert_or_panic(vec[118] == false);
+    assert_or_panic(vec[119] == false);
+    assert_or_panic(vec[120] == false);
+    assert_or_panic(vec[121] == true);
+    assert_or_panic(vec[122] == false);
+    assert_or_panic(vec[123] == false);
+    assert_or_panic(vec[124] == true);
+    assert_or_panic(vec[125] == true);
+    assert_or_panic(vec[126] == false);
+    assert_or_panic(vec[127] == true);
+    assert_or_panic(vec[128] == false);
+    assert_or_panic(vec[129] == true);
+    assert_or_panic(vec[130] == true);
+    assert_or_panic(vec[131] == false);
+    assert_or_panic(vec[132] == true);
+    assert_or_panic(vec[133] == false);
+    assert_or_panic(vec[134] == false);
+    assert_or_panic(vec[135] == false);
+    assert_or_panic(vec[136] == false);
+    assert_or_panic(vec[137] == true);
+    assert_or_panic(vec[138] == true);
+    assert_or_panic(vec[139] == false);
+    assert_or_panic(vec[140] == false);
+    assert_or_panic(vec[141] == false);
+    assert_or_panic(vec[142] == true);
+    assert_or_panic(vec[143] == true);
+    assert_or_panic(vec[144] == false);
+    assert_or_panic(vec[145] == false);
+    assert_or_panic(vec[146] == true);
+    assert_or_panic(vec[147] == true);
+    assert_or_panic(vec[148] == true);
+    assert_or_panic(vec[149] == true);
+    assert_or_panic(vec[150] == true);
+    assert_or_panic(vec[151] == true);
+    assert_or_panic(vec[152] == true);
+    assert_or_panic(vec[153] == false);
+    assert_or_panic(vec[154] == true);
+    assert_or_panic(vec[155] == false);
+    assert_or_panic(vec[156] == false);
+    assert_or_panic(vec[157] == true);
+    assert_or_panic(vec[158] == false);
+    assert_or_panic(vec[159] == true);
+    assert_or_panic(vec[160] == false);
+    assert_or_panic(vec[161] == true);
+    assert_or_panic(vec[162] == true);
+    assert_or_panic(vec[163] == true);
+    assert_or_panic(vec[164] == true);
+    assert_or_panic(vec[165] == true);
+    assert_or_panic(vec[166] == true);
+    assert_or_panic(vec[167] == true);
+    assert_or_panic(vec[168] == true);
+    assert_or_panic(vec[169] == false);
+    assert_or_panic(vec[170] == true);
+    assert_or_panic(vec[171] == true);
+    assert_or_panic(vec[172] == false);
+    assert_or_panic(vec[173] == true);
+    assert_or_panic(vec[174] == true);
+    assert_or_panic(vec[175] == false);
+    assert_or_panic(vec[176] == false);
+    assert_or_panic(vec[177] == false);
+    assert_or_panic(vec[178] == true);
+    assert_or_panic(vec[179] == false);
+    assert_or_panic(vec[180] == false);
+    assert_or_panic(vec[181] == true);
+    assert_or_panic(vec[182] == true);
+    assert_or_panic(vec[183] == true);
+    assert_or_panic(vec[184] == true);
+    assert_or_panic(vec[185] == true);
+    assert_or_panic(vec[186] == true);
+    assert_or_panic(vec[187] == true);
+    assert_or_panic(vec[188] == true);
+    assert_or_panic(vec[189] == true);
+    assert_or_panic(vec[190] == false);
+    assert_or_panic(vec[191] == true);
+    assert_or_panic(vec[192] == true);
+    assert_or_panic(vec[193] == false);
+    assert_or_panic(vec[194] == false);
+    assert_or_panic(vec[195] == true);
+    assert_or_panic(vec[196] == true);
+    assert_or_panic(vec[197] == false);
+    assert_or_panic(vec[198] == true);
+    assert_or_panic(vec[199] == true);
+    assert_or_panic(vec[200] == false);
+    assert_or_panic(vec[201] == true);
+    assert_or_panic(vec[202] == true);
+    assert_or_panic(vec[203] == false);
+    assert_or_panic(vec[204] == true);
+    assert_or_panic(vec[205] == true);
+    assert_or_panic(vec[206] == true);
+    assert_or_panic(vec[207] == true);
+    assert_or_panic(vec[208] == false);
+    assert_or_panic(vec[209] == true);
+    assert_or_panic(vec[210] == false);
+    assert_or_panic(vec[211] == true);
+    assert_or_panic(vec[212] == true);
+    assert_or_panic(vec[213] == false);
+    assert_or_panic(vec[214] == true);
+    assert_or_panic(vec[215] == false);
+    assert_or_panic(vec[216] == true);
+    assert_or_panic(vec[217] == false);
+    assert_or_panic(vec[218] == true);
+    assert_or_panic(vec[219] == false);
+    assert_or_panic(vec[220] == false);
+    assert_or_panic(vec[221] == true);
+    assert_or_panic(vec[222] == false);
+    assert_or_panic(vec[223] == false);
+    assert_or_panic(vec[224] == false);
+    assert_or_panic(vec[225] == true);
+    assert_or_panic(vec[226] == true);
+    assert_or_panic(vec[227] == false);
+    assert_or_panic(vec[228] == false);
+    assert_or_panic(vec[229] == false);
+    assert_or_panic(vec[230] == true);
+    assert_or_panic(vec[231] == false);
+    assert_or_panic(vec[232] == true);
+    assert_or_panic(vec[233] == false);
+    assert_or_panic(vec[234] == false);
+    assert_or_panic(vec[235] == false);
+    assert_or_panic(vec[236] == true);
+    assert_or_panic(vec[237] == true);
+    assert_or_panic(vec[238] == false);
+    assert_or_panic(vec[239] == false);
+    assert_or_panic(vec[240] == false);
+    assert_or_panic(vec[241] == false);
+    assert_or_panic(vec[242] == false);
+    assert_or_panic(vec[243] == true);
+    assert_or_panic(vec[244] == true);
+    assert_or_panic(vec[245] == false);
+    assert_or_panic(vec[246] == true);
+    assert_or_panic(vec[247] == false);
+    assert_or_panic(vec[248] == false);
+    assert_or_panic(vec[249] == true);
+    assert_or_panic(vec[250] == false);
+    assert_or_panic(vec[251] == false);
+    assert_or_panic(vec[252] == false);
+    assert_or_panic(vec[253] == true);
+    assert_or_panic(vec[254] == false);
+    assert_or_panic(vec[255] == false);
+    assert_or_panic(vec[256] == false);
+    assert_or_panic(vec[257] == false);
+    assert_or_panic(vec[258] == true);
+    assert_or_panic(vec[259] == true);
+    assert_or_panic(vec[260] == true);
+    assert_or_panic(vec[261] == true);
+    assert_or_panic(vec[262] == false);
+    assert_or_panic(vec[263] == true);
+    assert_or_panic(vec[264] == false);
+    assert_or_panic(vec[265] == false);
+    assert_or_panic(vec[266] == false);
+    assert_or_panic(vec[267] == true);
+    assert_or_panic(vec[268] == false);
+    assert_or_panic(vec[269] == false);
+    assert_or_panic(vec[270] == true);
+    assert_or_panic(vec[271] == true);
+    assert_or_panic(vec[272] == false);
+    assert_or_panic(vec[273] == false);
+    assert_or_panic(vec[274] == false);
+    assert_or_panic(vec[275] == false);
+    assert_or_panic(vec[276] == false);
+    assert_or_panic(vec[277] == true);
+    assert_or_panic(vec[278] == false);
+    assert_or_panic(vec[279] == true);
+    assert_or_panic(vec[280] == true);
+    assert_or_panic(vec[281] == true);
+    assert_or_panic(vec[282] == true);
+    assert_or_panic(vec[283] == true);
+    assert_or_panic(vec[284] == false);
+    assert_or_panic(vec[285] == false);
+    assert_or_panic(vec[286] == false);
+    assert_or_panic(vec[287] == false);
+    assert_or_panic(vec[288] == false);
+    assert_or_panic(vec[289] == false);
+    assert_or_panic(vec[290] == false);
+    assert_or_panic(vec[291] == false);
+    assert_or_panic(vec[292] == false);
+    assert_or_panic(vec[293] == true);
+    assert_or_panic(vec[294] == true);
+    assert_or_panic(vec[295] == true);
+    assert_or_panic(vec[296] == true);
+    assert_or_panic(vec[297] == true);
+    assert_or_panic(vec[298] == true);
+    assert_or_panic(vec[299] == false);
+    assert_or_panic(vec[300] == true);
+    assert_or_panic(vec[301] == false);
+    assert_or_panic(vec[302] == true);
+    assert_or_panic(vec[303] == true);
+    assert_or_panic(vec[304] == true);
+    assert_or_panic(vec[305] == false);
+    assert_or_panic(vec[306] == false);
+    assert_or_panic(vec[307] == true);
+    assert_or_panic(vec[308] == true);
+    assert_or_panic(vec[309] == true);
+    assert_or_panic(vec[310] == false);
+    assert_or_panic(vec[311] == true);
+    assert_or_panic(vec[312] == true);
+    assert_or_panic(vec[313] == true);
+    assert_or_panic(vec[314] == false);
+    assert_or_panic(vec[315] == true);
+    assert_or_panic(vec[316] == true);
+    assert_or_panic(vec[317] == true);
+    assert_or_panic(vec[318] == false);
+    assert_or_panic(vec[319] == true);
+    assert_or_panic(vec[320] == true);
+    assert_or_panic(vec[321] == false);
+    assert_or_panic(vec[322] == false);
+    assert_or_panic(vec[323] == true);
+    assert_or_panic(vec[324] == false);
+    assert_or_panic(vec[325] == false);
+    assert_or_panic(vec[326] == false);
+    assert_or_panic(vec[327] == false);
+    assert_or_panic(vec[328] == true);
+    assert_or_panic(vec[329] == false);
+    assert_or_panic(vec[330] == true);
+    assert_or_panic(vec[331] == true);
+    assert_or_panic(vec[332] == true);
+    assert_or_panic(vec[333] == true);
+    assert_or_panic(vec[334] == false);
+    assert_or_panic(vec[335] == false);
+    assert_or_panic(vec[336] == true);
+    assert_or_panic(vec[337] == false);
+    assert_or_panic(vec[338] == true);
+    assert_or_panic(vec[339] == false);
+    assert_or_panic(vec[340] == false);
+    assert_or_panic(vec[341] == false);
+    assert_or_panic(vec[342] == true);
+    assert_or_panic(vec[343] == false);
+    assert_or_panic(vec[344] == true);
+    assert_or_panic(vec[345] == false);
+    assert_or_panic(vec[346] == false);
+    assert_or_panic(vec[347] == true);
+    assert_or_panic(vec[348] == true);
+    assert_or_panic(vec[349] == true);
+    assert_or_panic(vec[350] == true);
+    assert_or_panic(vec[351] == false);
+    assert_or_panic(vec[352] == false);
+    assert_or_panic(vec[353] == false);
+    assert_or_panic(vec[354] == true);
+    assert_or_panic(vec[355] == true);
+    assert_or_panic(vec[356] == false);
+    assert_or_panic(vec[357] == true);
+    assert_or_panic(vec[358] == false);
+    assert_or_panic(vec[359] == false);
+    assert_or_panic(vec[360] == true);
+    assert_or_panic(vec[361] == false);
+    assert_or_panic(vec[362] == true);
+    assert_or_panic(vec[363] == false);
+    assert_or_panic(vec[364] == true);
+    assert_or_panic(vec[365] == true);
+    assert_or_panic(vec[366] == false);
+    assert_or_panic(vec[367] == false);
+    assert_or_panic(vec[368] == true);
+    assert_or_panic(vec[369] == true);
+    assert_or_panic(vec[370] == true);
+    assert_or_panic(vec[371] == true);
+    assert_or_panic(vec[372] == false);
+    assert_or_panic(vec[373] == false);
+    assert_or_panic(vec[374] == true);
+    assert_or_panic(vec[375] == false);
+    assert_or_panic(vec[376] == true);
+    assert_or_panic(vec[377] == true);
+    assert_or_panic(vec[378] == false);
+    assert_or_panic(vec[379] == true);
+    assert_or_panic(vec[380] == true);
+    assert_or_panic(vec[381] == false);
+    assert_or_panic(vec[382] == true);
+    assert_or_panic(vec[383] == true);
+    assert_or_panic(vec[384] == true);
+    assert_or_panic(vec[385] == false);
+    assert_or_panic(vec[386] == true);
+    assert_or_panic(vec[387] == true);
+    assert_or_panic(vec[388] == true);
+    assert_or_panic(vec[389] == false);
+    assert_or_panic(vec[390] == false);
+    assert_or_panic(vec[391] == true);
+    assert_or_panic(vec[392] == false);
+    assert_or_panic(vec[393] == true);
+    assert_or_panic(vec[394] == true);
+    assert_or_panic(vec[395] == true);
+    assert_or_panic(vec[396] == false);
+    assert_or_panic(vec[397] == false);
+    assert_or_panic(vec[398] == false);
+    assert_or_panic(vec[399] == false);
+    assert_or_panic(vec[400] == false);
+    assert_or_panic(vec[401] == true);
+    assert_or_panic(vec[402] == false);
+    assert_or_panic(vec[403] == false);
+    assert_or_panic(vec[404] == false);
+    assert_or_panic(vec[405] == false);
+    assert_or_panic(vec[406] == true);
+    assert_or_panic(vec[407] == false);
+    assert_or_panic(vec[408] == false);
+    assert_or_panic(vec[409] == true);
+    assert_or_panic(vec[410] == true);
+    assert_or_panic(vec[411] == false);
+    assert_or_panic(vec[412] == false);
+    assert_or_panic(vec[413] == false);
+    assert_or_panic(vec[414] == false);
+    assert_or_panic(vec[415] == true);
+    assert_or_panic(vec[416] == true);
+    assert_or_panic(vec[417] == true);
+    assert_or_panic(vec[418] == true);
+    assert_or_panic(vec[419] == true);
+    assert_or_panic(vec[420] == false);
+    assert_or_panic(vec[421] == false);
+    assert_or_panic(vec[422] == false);
+    assert_or_panic(vec[423] == true);
+    assert_or_panic(vec[424] == false);
+    assert_or_panic(vec[425] == false);
+    assert_or_panic(vec[426] == false);
+    assert_or_panic(vec[427] == false);
+    assert_or_panic(vec[428] == true);
+    assert_or_panic(vec[429] == false);
+    assert_or_panic(vec[430] == true);
+    assert_or_panic(vec[431] == false);
+    assert_or_panic(vec[432] == true);
+    assert_or_panic(vec[433] == true);
+    assert_or_panic(vec[434] == true);
+    assert_or_panic(vec[435] == true);
+    assert_or_panic(vec[436] == false);
+    assert_or_panic(vec[437] == false);
+    assert_or_panic(vec[438] == false);
+    assert_or_panic(vec[439] == false);
+    assert_or_panic(vec[440] == false);
+    assert_or_panic(vec[441] == true);
+    assert_or_panic(vec[442] == true);
+    assert_or_panic(vec[443] == true);
+    assert_or_panic(vec[444] == true);
+    assert_or_panic(vec[445] == true);
+    assert_or_panic(vec[446] == true);
+    assert_or_panic(vec[447] == true);
+    assert_or_panic(vec[448] == true);
+    assert_or_panic(vec[449] == true);
+    assert_or_panic(vec[450] == false);
+    assert_or_panic(vec[451] == false);
+    assert_or_panic(vec[452] == true);
+    assert_or_panic(vec[453] == false);
+    assert_or_panic(vec[454] == true);
+    assert_or_panic(vec[455] == false);
+    assert_or_panic(vec[456] == false);
+    assert_or_panic(vec[457] == true);
+    assert_or_panic(vec[458] == false);
+    assert_or_panic(vec[459] == false);
+    assert_or_panic(vec[460] == true);
+    assert_or_panic(vec[461] == true);
+    assert_or_panic(vec[462] == true);
+    assert_or_panic(vec[463] == true);
+    assert_or_panic(vec[464] == true);
+    assert_or_panic(vec[465] == true);
+    assert_or_panic(vec[466] == false);
+    assert_or_panic(vec[467] == true);
+    assert_or_panic(vec[468] == false);
+    assert_or_panic(vec[469] == false);
+    assert_or_panic(vec[470] == false);
+    assert_or_panic(vec[471] == true);
+    assert_or_panic(vec[472] == true);
+    assert_or_panic(vec[473] == false);
+    assert_or_panic(vec[474] == true);
+    assert_or_panic(vec[475] == true);
+    assert_or_panic(vec[476] == false);
+    assert_or_panic(vec[477] == false);
+    assert_or_panic(vec[478] == true);
+    assert_or_panic(vec[479] == true);
+    assert_or_panic(vec[480] == false);
+    assert_or_panic(vec[481] == false);
+    assert_or_panic(vec[482] == true);
+    assert_or_panic(vec[483] == true);
+    assert_or_panic(vec[484] == false);
+    assert_or_panic(vec[485] == true);
+    assert_or_panic(vec[486] == false);
+    assert_or_panic(vec[487] == true);
+    assert_or_panic(vec[488] == true);
+    assert_or_panic(vec[489] == true);
+    assert_or_panic(vec[490] == true);
+    assert_or_panic(vec[491] == true);
+    assert_or_panic(vec[492] == true);
+    assert_or_panic(vec[493] == true);
+    assert_or_panic(vec[494] == true);
+    assert_or_panic(vec[495] == true);
+    assert_or_panic(vec[496] == false);
+    assert_or_panic(vec[497] == true);
+    assert_or_panic(vec[498] == true);
+    assert_or_panic(vec[499] == true);
+    assert_or_panic(vec[500] == false);
+    assert_or_panic(vec[501] == false);
+    assert_or_panic(vec[502] == true);
+    assert_or_panic(vec[503] == false);
+    assert_or_panic(vec[504] == false);
+    assert_or_panic(vec[505] == false);
+    assert_or_panic(vec[506] == true);
+    assert_or_panic(vec[507] == true);
+    assert_or_panic(vec[508] == false);
+    assert_or_panic(vec[509] == true);
+    assert_or_panic(vec[510] == false);
+    assert_or_panic(vec[511] == true);
+}
+
+Vector2Bool c_ret_vector_2_bool(void) {
+    return (Vector2Bool){
+        true,
+        false,
+    };
+}
+
+Vector4Bool c_ret_vector_4_bool(void) {
+    return (Vector4Bool){
+        true,
+        false,
+        true,
+        false,
+    };
+}
+
+Vector8Bool c_ret_vector_8_bool(void) {
+    return (Vector8Bool){
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+    };
+}
+
+Vector16Bool c_ret_vector_16_bool(void) {
+    return (Vector16Bool){
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+    };
+}
+
+Vector32Bool c_ret_vector_32_bool(void) {
+    return (Vector32Bool){
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+    };
+}
+
+Vector64Bool c_ret_vector_64_bool(void) {
+    return (Vector64Bool){
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+    };
+}
+
+Vector128Bool c_ret_vector_128_bool(void) {
+    return (Vector128Bool){
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+    };
+}
+
+Vector256Bool c_ret_vector_256_bool(void) {
+    return (Vector256Bool){
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+    };
+}
+
+Vector512Bool c_ret_vector_512_bool(void) {
+    return (Vector512Bool){
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        true,
+        true,
+        true,
+        false,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        false,
+        true,
+        true,
+        true,
+        true,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        false,
+        true,
+        true,
+        false,
+        true,
+        false,
+    };
+}
+
+void zig_vector_2_bool(Vector2Bool vec);
+void zig_vector_4_bool(Vector4Bool vec);
+void zig_vector_8_bool(Vector8Bool vec);
+void zig_vector_16_bool(Vector16Bool vec);
+void zig_vector_32_bool(Vector32Bool vec);
+void zig_vector_64_bool(Vector64Bool vec);
+void zig_vector_128_bool(Vector128Bool vec);
+void zig_vector_256_bool(Vector256Bool vec);
+void zig_vector_512_bool(Vector512Bool vec);
+
+Vector2Bool zig_ret_vector_2_bool(void);
+Vector4Bool zig_ret_vector_4_bool(void);
+Vector8Bool zig_ret_vector_8_bool(void);
+Vector16Bool zig_ret_vector_16_bool(void);
+Vector32Bool zig_ret_vector_32_bool(void);
+Vector64Bool zig_ret_vector_64_bool(void);
+Vector128Bool zig_ret_vector_128_bool(void);
+Vector256Bool zig_ret_vector_256_bool(void);
+Vector512Bool zig_ret_vector_512_bool(void);
+
+#endif
+
 typedef struct Vector3 {
     float x;
     float y;
@@ -450,6 +2600,2107 @@ void run_c_tests(void) {
         assert_or_panic(zig_ret_i32() == -1);
         assert_or_panic(zig_ret_i64() == -1);
     }
+
+#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32)
+    {
+        zig_vector_2_bool((Vector2Bool){
+            false,
+            true,
+        });
+
+        Vector2Bool vec = zig_ret_vector_2_bool();
+        assert_or_panic(vec[0] == false);
+        assert_or_panic(vec[1] == false);
+    }
+    {
+        zig_vector_4_bool((Vector4Bool){
+            false,
+            false,
+            false,
+            false,
+        });
+
+        Vector4Bool vec = zig_ret_vector_4_bool();
+        assert_or_panic(vec[0] == false);
+        assert_or_panic(vec[1] == true);
+        assert_or_panic(vec[2] == true);
+        assert_or_panic(vec[3] == true);
+    }
+    {
+        zig_vector_8_bool((Vector8Bool){
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+        });
+
+        Vector8Bool vec = zig_ret_vector_8_bool();
+        assert_or_panic(vec[0] == false);
+        assert_or_panic(vec[1] == false);
+        assert_or_panic(vec[2] == false);
+        assert_or_panic(vec[3] == false);
+        assert_or_panic(vec[4] == true);
+        assert_or_panic(vec[5] == false);
+        assert_or_panic(vec[6] == false);
+        assert_or_panic(vec[7] == false);
+    }
+    {
+        zig_vector_16_bool((Vector16Bool){
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+        });
+
+        Vector16Bool vec = zig_ret_vector_16_bool();
+        assert_or_panic(vec[0] == false);
+        assert_or_panic(vec[1] == true);
+        assert_or_panic(vec[2] == false);
+        assert_or_panic(vec[3] == false);
+        assert_or_panic(vec[4] == false);
+        assert_or_panic(vec[5] == true);
+        assert_or_panic(vec[6] == false);
+        assert_or_panic(vec[7] == false);
+        assert_or_panic(vec[8] == true);
+        assert_or_panic(vec[9] == false);
+        assert_or_panic(vec[10] == false);
+        assert_or_panic(vec[11] == false);
+        assert_or_panic(vec[12] == false);
+        assert_or_panic(vec[13] == true);
+        assert_or_panic(vec[14] == false);
+        assert_or_panic(vec[15] == false);
+    }
+    {
+        zig_vector_32_bool((Vector32Bool){
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+        });
+
+        Vector32Bool vec = zig_ret_vector_32_bool();
+        assert_or_panic(vec[0] == false);
+        assert_or_panic(vec[1] == true);
+        assert_or_panic(vec[2] == false);
+        assert_or_panic(vec[3] == false);
+        assert_or_panic(vec[4] == true);
+        assert_or_panic(vec[5] == false);
+        assert_or_panic(vec[6] == true);
+        assert_or_panic(vec[7] == true);
+        assert_or_panic(vec[8] == true);
+        assert_or_panic(vec[9] == true);
+        assert_or_panic(vec[10] == true);
+        assert_or_panic(vec[11] == true);
+        assert_or_panic(vec[12] == false);
+        assert_or_panic(vec[13] == false);
+        assert_or_panic(vec[14] == false);
+        assert_or_panic(vec[15] == false);
+        assert_or_panic(vec[16] == false);
+        assert_or_panic(vec[17] == false);
+        assert_or_panic(vec[18] == true);
+        assert_or_panic(vec[19] == true);
+        assert_or_panic(vec[20] == true);
+        assert_or_panic(vec[21] == false);
+        assert_or_panic(vec[22] == true);
+        assert_or_panic(vec[23] == false);
+        assert_or_panic(vec[24] == true);
+        assert_or_panic(vec[25] == false);
+        assert_or_panic(vec[26] == false);
+        assert_or_panic(vec[27] == true);
+        assert_or_panic(vec[28] == false);
+        assert_or_panic(vec[29] == false);
+        assert_or_panic(vec[30] == true);
+        assert_or_panic(vec[31] == true);
+    }
+    {
+        zig_vector_64_bool((Vector64Bool){
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+        });
+
+        Vector64Bool vec = zig_ret_vector_64_bool();
+        assert_or_panic(vec[0] == true);
+        assert_or_panic(vec[1] == false);
+        assert_or_panic(vec[2] == true);
+        assert_or_panic(vec[3] == false);
+        assert_or_panic(vec[4] == false);
+        assert_or_panic(vec[5] == true);
+        assert_or_panic(vec[6] == false);
+        assert_or_panic(vec[7] == true);
+        assert_or_panic(vec[8] == true);
+        assert_or_panic(vec[9] == false);
+        assert_or_panic(vec[10] == true);
+        assert_or_panic(vec[11] == false);
+        assert_or_panic(vec[12] == true);
+        assert_or_panic(vec[13] == false);
+        assert_or_panic(vec[14] == false);
+        assert_or_panic(vec[15] == true);
+        assert_or_panic(vec[16] == false);
+        assert_or_panic(vec[17] == false);
+        assert_or_panic(vec[18] == true);
+        assert_or_panic(vec[19] == true);
+        assert_or_panic(vec[20] == false);
+        assert_or_panic(vec[21] == false);
+        assert_or_panic(vec[22] == true);
+        assert_or_panic(vec[23] == false);
+        assert_or_panic(vec[24] == false);
+        assert_or_panic(vec[25] == true);
+        assert_or_panic(vec[26] == true);
+        assert_or_panic(vec[27] == true);
+        assert_or_panic(vec[28] == true);
+        assert_or_panic(vec[29] == true);
+        assert_or_panic(vec[30] == false);
+        assert_or_panic(vec[31] == false);
+        assert_or_panic(vec[32] == true);
+        assert_or_panic(vec[33] == true);
+        assert_or_panic(vec[34] == true);
+        assert_or_panic(vec[35] == true);
+        assert_or_panic(vec[36] == false);
+        assert_or_panic(vec[37] == true);
+        assert_or_panic(vec[38] == false);
+        assert_or_panic(vec[39] == true);
+        assert_or_panic(vec[40] == true);
+        assert_or_panic(vec[41] == true);
+        assert_or_panic(vec[42] == true);
+        assert_or_panic(vec[43] == true);
+        assert_or_panic(vec[44] == false);
+        assert_or_panic(vec[45] == false);
+        assert_or_panic(vec[46] == false);
+        assert_or_panic(vec[47] == true);
+        assert_or_panic(vec[48] == true);
+        assert_or_panic(vec[49] == true);
+        assert_or_panic(vec[50] == false);
+        assert_or_panic(vec[51] == true);
+        assert_or_panic(vec[52] == true);
+        assert_or_panic(vec[53] == true);
+        assert_or_panic(vec[54] == false);
+        assert_or_panic(vec[55] == false);
+        assert_or_panic(vec[56] == false);
+        assert_or_panic(vec[57] == true);
+        assert_or_panic(vec[58] == false);
+        assert_or_panic(vec[59] == false);
+        assert_or_panic(vec[60] == true);
+        assert_or_panic(vec[61] == false);
+        assert_or_panic(vec[62] == true);
+        assert_or_panic(vec[63] == false);
+    }
+    {
+        zig_vector_128_bool((Vector128Bool){
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+        });
+
+        Vector128Bool vec = zig_ret_vector_128_bool();
+        assert_or_panic(vec[0] == true);
+        assert_or_panic(vec[1] == true);
+        assert_or_panic(vec[2] == false);
+        assert_or_panic(vec[3] == false);
+        assert_or_panic(vec[4] == false);
+        assert_or_panic(vec[5] == true);
+        assert_or_panic(vec[6] == true);
+        assert_or_panic(vec[7] == false);
+        assert_or_panic(vec[8] == false);
+        assert_or_panic(vec[9] == true);
+        assert_or_panic(vec[10] == false);
+        assert_or_panic(vec[11] == false);
+        assert_or_panic(vec[12] == false);
+        assert_or_panic(vec[13] == true);
+        assert_or_panic(vec[14] == false);
+        assert_or_panic(vec[15] == true);
+        assert_or_panic(vec[16] == true);
+        assert_or_panic(vec[17] == false);
+        assert_or_panic(vec[18] == false);
+        assert_or_panic(vec[19] == true);
+        assert_or_panic(vec[20] == true);
+        assert_or_panic(vec[21] == true);
+        assert_or_panic(vec[22] == true);
+        assert_or_panic(vec[23] == true);
+        assert_or_panic(vec[24] == false);
+        assert_or_panic(vec[25] == false);
+        assert_or_panic(vec[26] == true);
+        assert_or_panic(vec[27] == true);
+        assert_or_panic(vec[28] == true);
+        assert_or_panic(vec[29] == false);
+        assert_or_panic(vec[30] == false);
+        assert_or_panic(vec[31] == true);
+        assert_or_panic(vec[32] == true);
+        assert_or_panic(vec[33] == false);
+        assert_or_panic(vec[34] == true);
+        assert_or_panic(vec[35] == true);
+        assert_or_panic(vec[36] == true);
+        assert_or_panic(vec[37] == false);
+        assert_or_panic(vec[38] == true);
+        assert_or_panic(vec[39] == true);
+        assert_or_panic(vec[40] == true);
+        assert_or_panic(vec[41] == false);
+        assert_or_panic(vec[42] == true);
+        assert_or_panic(vec[43] == true);
+        assert_or_panic(vec[44] == false);
+        assert_or_panic(vec[45] == false);
+        assert_or_panic(vec[46] == false);
+        assert_or_panic(vec[47] == true);
+        assert_or_panic(vec[48] == false);
+        assert_or_panic(vec[49] == false);
+        assert_or_panic(vec[50] == false);
+        assert_or_panic(vec[51] == false);
+        assert_or_panic(vec[52] == true);
+        assert_or_panic(vec[53] == false);
+        assert_or_panic(vec[54] == true);
+        assert_or_panic(vec[55] == false);
+        assert_or_panic(vec[56] == true);
+        assert_or_panic(vec[57] == false);
+        assert_or_panic(vec[58] == false);
+        assert_or_panic(vec[59] == true);
+        assert_or_panic(vec[60] == true);
+        assert_or_panic(vec[61] == true);
+        assert_or_panic(vec[62] == true);
+        assert_or_panic(vec[63] == true);
+        assert_or_panic(vec[64] == false);
+        assert_or_panic(vec[65] == false);
+        assert_or_panic(vec[66] == false);
+        assert_or_panic(vec[67] == true);
+        assert_or_panic(vec[68] == true);
+        assert_or_panic(vec[69] == false);
+        assert_or_panic(vec[70] == true);
+        assert_or_panic(vec[71] == true);
+        assert_or_panic(vec[72] == false);
+        assert_or_panic(vec[73] == true);
+        assert_or_panic(vec[74] == true);
+        assert_or_panic(vec[75] == false);
+        assert_or_panic(vec[76] == false);
+        assert_or_panic(vec[77] == true);
+        assert_or_panic(vec[78] == false);
+        assert_or_panic(vec[79] == true);
+        assert_or_panic(vec[80] == false);
+        assert_or_panic(vec[81] == false);
+        assert_or_panic(vec[82] == true);
+        assert_or_panic(vec[83] == true);
+        assert_or_panic(vec[84] == false);
+        assert_or_panic(vec[85] == true);
+        assert_or_panic(vec[86] == false);
+        assert_or_panic(vec[87] == false);
+        assert_or_panic(vec[88] == true);
+        assert_or_panic(vec[89] == true);
+        assert_or_panic(vec[90] == true);
+        assert_or_panic(vec[91] == true);
+        assert_or_panic(vec[92] == true);
+        assert_or_panic(vec[93] == false);
+        assert_or_panic(vec[94] == false);
+        assert_or_panic(vec[95] == true);
+        assert_or_panic(vec[96] == false);
+        assert_or_panic(vec[97] == false);
+        assert_or_panic(vec[98] == true);
+        assert_or_panic(vec[99] == true);
+        assert_or_panic(vec[100] == true);
+        assert_or_panic(vec[101] == true);
+        assert_or_panic(vec[102] == true);
+        assert_or_panic(vec[103] == true);
+        assert_or_panic(vec[104] == true);
+        assert_or_panic(vec[105] == false);
+        assert_or_panic(vec[106] == false);
+        assert_or_panic(vec[107] == true);
+        assert_or_panic(vec[108] == false);
+        assert_or_panic(vec[109] == false);
+        assert_or_panic(vec[110] == true);
+        assert_or_panic(vec[111] == false);
+        assert_or_panic(vec[112] == false);
+        assert_or_panic(vec[113] == true);
+        assert_or_panic(vec[114] == false);
+        assert_or_panic(vec[115] == false);
+        assert_or_panic(vec[116] == false);
+        assert_or_panic(vec[117] == false);
+        assert_or_panic(vec[118] == false);
+        assert_or_panic(vec[119] == false);
+        assert_or_panic(vec[120] == true);
+        assert_or_panic(vec[121] == true);
+        assert_or_panic(vec[122] == true);
+        assert_or_panic(vec[123] == false);
+        assert_or_panic(vec[124] == true);
+        assert_or_panic(vec[125] == false);
+        assert_or_panic(vec[126] == false);
+        assert_or_panic(vec[127] == true);
+    }
+    {
+        zig_vector_256_bool((Vector256Bool){
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+        });
+
+        Vector256Bool vec = zig_ret_vector_256_bool();
+        assert_or_panic(vec[0] == true);
+        assert_or_panic(vec[1] == true);
+        assert_or_panic(vec[2] == true);
+        assert_or_panic(vec[3] == false);
+        assert_or_panic(vec[4] == true);
+        assert_or_panic(vec[5] == false);
+        assert_or_panic(vec[6] == false);
+        assert_or_panic(vec[7] == true);
+        assert_or_panic(vec[8] == false);
+        assert_or_panic(vec[9] == false);
+        assert_or_panic(vec[10] == false);
+        assert_or_panic(vec[11] == false);
+        assert_or_panic(vec[12] == false);
+        assert_or_panic(vec[13] == false);
+        assert_or_panic(vec[14] == false);
+        assert_or_panic(vec[15] == false);
+        assert_or_panic(vec[16] == true);
+        assert_or_panic(vec[17] == false);
+        assert_or_panic(vec[18] == true);
+        assert_or_panic(vec[19] == false);
+        assert_or_panic(vec[20] == false);
+        assert_or_panic(vec[21] == true);
+        assert_or_panic(vec[22] == true);
+        assert_or_panic(vec[23] == false);
+        assert_or_panic(vec[24] == false);
+        assert_or_panic(vec[25] == true);
+        assert_or_panic(vec[26] == true);
+        assert_or_panic(vec[27] == false);
+        assert_or_panic(vec[28] == true);
+        assert_or_panic(vec[29] == true);
+        assert_or_panic(vec[30] == true);
+        assert_or_panic(vec[31] == false);
+        assert_or_panic(vec[32] == true);
+        assert_or_panic(vec[33] == false);
+        assert_or_panic(vec[34] == true);
+        assert_or_panic(vec[35] == false);
+        assert_or_panic(vec[36] == true);
+        assert_or_panic(vec[37] == false);
+        assert_or_panic(vec[38] == true);
+        assert_or_panic(vec[39] == false);
+        assert_or_panic(vec[40] == false);
+        assert_or_panic(vec[41] == false);
+        assert_or_panic(vec[42] == true);
+        assert_or_panic(vec[43] == true);
+        assert_or_panic(vec[44] == true);
+        assert_or_panic(vec[45] == false);
+        assert_or_panic(vec[46] == false);
+        assert_or_panic(vec[47] == false);
+        assert_or_panic(vec[48] == true);
+        assert_or_panic(vec[49] == false);
+        assert_or_panic(vec[50] == true);
+        assert_or_panic(vec[51] == false);
+        assert_or_panic(vec[52] == true);
+        assert_or_panic(vec[53] == false);
+        assert_or_panic(vec[54] == true);
+        assert_or_panic(vec[55] == true);
+        assert_or_panic(vec[56] == false);
+        assert_or_panic(vec[57] == false);
+        assert_or_panic(vec[58] == false);
+        assert_or_panic(vec[59] == true);
+        assert_or_panic(vec[60] == true);
+        assert_or_panic(vec[61] == true);
+        assert_or_panic(vec[62] == false);
+        assert_or_panic(vec[63] == true);
+        assert_or_panic(vec[64] == false);
+        assert_or_panic(vec[65] == true);
+        assert_or_panic(vec[66] == false);
+        assert_or_panic(vec[67] == true);
+        assert_or_panic(vec[68] == true);
+        assert_or_panic(vec[69] == false);
+        assert_or_panic(vec[70] == true);
+        assert_or_panic(vec[71] == false);
+        assert_or_panic(vec[72] == true);
+        assert_or_panic(vec[73] == true);
+        assert_or_panic(vec[74] == false);
+        assert_or_panic(vec[75] == false);
+        assert_or_panic(vec[76] == false);
+        assert_or_panic(vec[77] == false);
+        assert_or_panic(vec[78] == false);
+        assert_or_panic(vec[79] == false);
+        assert_or_panic(vec[80] == false);
+        assert_or_panic(vec[81] == false);
+        assert_or_panic(vec[82] == false);
+        assert_or_panic(vec[83] == true);
+        assert_or_panic(vec[84] == false);
+        assert_or_panic(vec[85] == false);
+        assert_or_panic(vec[86] == false);
+        assert_or_panic(vec[87] == true);
+        assert_or_panic(vec[88] == false);
+        assert_or_panic(vec[89] == true);
+        assert_or_panic(vec[90] == true);
+        assert_or_panic(vec[91] == false);
+        assert_or_panic(vec[92] == false);
+        assert_or_panic(vec[93] == true);
+        assert_or_panic(vec[94] == true);
+        assert_or_panic(vec[95] == false);
+        assert_or_panic(vec[96] == false);
+        assert_or_panic(vec[97] == true);
+        assert_or_panic(vec[98] == false);
+        assert_or_panic(vec[99] == false);
+        assert_or_panic(vec[100] == false);
+        assert_or_panic(vec[101] == false);
+        assert_or_panic(vec[102] == false);
+        assert_or_panic(vec[103] == false);
+        assert_or_panic(vec[104] == false);
+        assert_or_panic(vec[105] == true);
+        assert_or_panic(vec[106] == true);
+        assert_or_panic(vec[107] == false);
+        assert_or_panic(vec[108] == true);
+        assert_or_panic(vec[109] == false);
+        assert_or_panic(vec[110] == true);
+        assert_or_panic(vec[111] == true);
+        assert_or_panic(vec[112] == false);
+        assert_or_panic(vec[113] == false);
+        assert_or_panic(vec[114] == false);
+        assert_or_panic(vec[115] == false);
+        assert_or_panic(vec[116] == false);
+        assert_or_panic(vec[117] == false);
+        assert_or_panic(vec[118] == false);
+        assert_or_panic(vec[119] == true);
+        assert_or_panic(vec[120] == true);
+        assert_or_panic(vec[121] == true);
+        assert_or_panic(vec[122] == false);
+        assert_or_panic(vec[123] == true);
+        assert_or_panic(vec[124] == true);
+        assert_or_panic(vec[125] == false);
+        assert_or_panic(vec[126] == false);
+        assert_or_panic(vec[127] == true);
+        assert_or_panic(vec[128] == true);
+        assert_or_panic(vec[129] == true);
+        assert_or_panic(vec[130] == true);
+        assert_or_panic(vec[131] == true);
+        assert_or_panic(vec[132] == false);
+        assert_or_panic(vec[133] == true);
+        assert_or_panic(vec[134] == true);
+        assert_or_panic(vec[135] == false);
+        assert_or_panic(vec[136] == false);
+        assert_or_panic(vec[137] == true);
+        assert_or_panic(vec[138] == true);
+        assert_or_panic(vec[139] == false);
+        assert_or_panic(vec[140] == true);
+        assert_or_panic(vec[141] == false);
+        assert_or_panic(vec[142] == true);
+        assert_or_panic(vec[143] == false);
+        assert_or_panic(vec[144] == true);
+        assert_or_panic(vec[145] == true);
+        assert_or_panic(vec[146] == true);
+        assert_or_panic(vec[147] == true);
+        assert_or_panic(vec[148] == false);
+        assert_or_panic(vec[149] == false);
+        assert_or_panic(vec[150] == false);
+        assert_or_panic(vec[151] == true);
+        assert_or_panic(vec[152] == false);
+        assert_or_panic(vec[153] == true);
+        assert_or_panic(vec[154] == false);
+        assert_or_panic(vec[155] == true);
+        assert_or_panic(vec[156] == true);
+        assert_or_panic(vec[157] == false);
+        assert_or_panic(vec[158] == true);
+        assert_or_panic(vec[159] == true);
+        assert_or_panic(vec[160] == true);
+        assert_or_panic(vec[161] == true);
+        assert_or_panic(vec[162] == true);
+        assert_or_panic(vec[163] == false);
+        assert_or_panic(vec[164] == false);
+        assert_or_panic(vec[165] == true);
+        assert_or_panic(vec[166] == false);
+        assert_or_panic(vec[167] == true);
+        assert_or_panic(vec[168] == true);
+        assert_or_panic(vec[169] == true);
+        assert_or_panic(vec[170] == true);
+        assert_or_panic(vec[171] == false);
+        assert_or_panic(vec[172] == true);
+        assert_or_panic(vec[173] == true);
+        assert_or_panic(vec[174] == true);
+        assert_or_panic(vec[175] == true);
+        assert_or_panic(vec[176] == true);
+        assert_or_panic(vec[177] == true);
+        assert_or_panic(vec[178] == true);
+        assert_or_panic(vec[179] == false);
+        assert_or_panic(vec[180] == true);
+        assert_or_panic(vec[181] == false);
+        assert_or_panic(vec[182] == false);
+        assert_or_panic(vec[183] == false);
+        assert_or_panic(vec[184] == true);
+        assert_or_panic(vec[185] == false);
+        assert_or_panic(vec[186] == true);
+        assert_or_panic(vec[187] == true);
+        assert_or_panic(vec[188] == false);
+        assert_or_panic(vec[189] == true);
+        assert_or_panic(vec[190] == false);
+        assert_or_panic(vec[191] == true);
+        assert_or_panic(vec[192] == false);
+        assert_or_panic(vec[193] == true);
+        assert_or_panic(vec[194] == false);
+        assert_or_panic(vec[195] == false);
+        assert_or_panic(vec[196] == true);
+        assert_or_panic(vec[197] == true);
+        assert_or_panic(vec[198] == true);
+        assert_or_panic(vec[199] == true);
+        assert_or_panic(vec[200] == true);
+        assert_or_panic(vec[201] == true);
+        assert_or_panic(vec[202] == true);
+        assert_or_panic(vec[203] == false);
+        assert_or_panic(vec[204] == true);
+        assert_or_panic(vec[205] == false);
+        assert_or_panic(vec[206] == false);
+        assert_or_panic(vec[207] == true);
+        assert_or_panic(vec[208] == true);
+        assert_or_panic(vec[209] == false);
+        assert_or_panic(vec[210] == false);
+        assert_or_panic(vec[211] == false);
+        assert_or_panic(vec[212] == true);
+        assert_or_panic(vec[213] == true);
+        assert_or_panic(vec[214] == true);
+        assert_or_panic(vec[215] == false);
+        assert_or_panic(vec[216] == false);
+        assert_or_panic(vec[217] == true);
+        assert_or_panic(vec[218] == true);
+        assert_or_panic(vec[219] == true);
+        assert_or_panic(vec[220] == true);
+        assert_or_panic(vec[221] == false);
+        assert_or_panic(vec[222] == true);
+        assert_or_panic(vec[223] == false);
+        assert_or_panic(vec[224] == true);
+        assert_or_panic(vec[225] == true);
+        assert_or_panic(vec[226] == true);
+        assert_or_panic(vec[227] == false);
+        assert_or_panic(vec[228] == false);
+        assert_or_panic(vec[229] == false);
+        assert_or_panic(vec[230] == false);
+        assert_or_panic(vec[231] == false);
+        assert_or_panic(vec[232] == true);
+        assert_or_panic(vec[233] == true);
+        assert_or_panic(vec[234] == false);
+        assert_or_panic(vec[235] == false);
+        assert_or_panic(vec[236] == false);
+        assert_or_panic(vec[237] == true);
+        assert_or_panic(vec[238] == true);
+        assert_or_panic(vec[239] == false);
+        assert_or_panic(vec[240] == true);
+        assert_or_panic(vec[241] == true);
+        assert_or_panic(vec[242] == true);
+        assert_or_panic(vec[243] == false);
+        assert_or_panic(vec[244] == true);
+        assert_or_panic(vec[245] == true);
+        assert_or_panic(vec[246] == false);
+        assert_or_panic(vec[247] == true);
+        assert_or_panic(vec[248] == false);
+        assert_or_panic(vec[249] == false);
+        assert_or_panic(vec[250] == true);
+        assert_or_panic(vec[251] == true);
+        assert_or_panic(vec[252] == false);
+        assert_or_panic(vec[253] == true);
+        assert_or_panic(vec[254] == false);
+        assert_or_panic(vec[255] == true);
+    }
+    {
+        zig_vector_512_bool((Vector512Bool){
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+        });
+
+        Vector512Bool vec = zig_ret_vector_512_bool();
+        assert_or_panic(vec[0] == true);
+        assert_or_panic(vec[1] == true);
+        assert_or_panic(vec[2] == true);
+        assert_or_panic(vec[3] == true);
+        assert_or_panic(vec[4] == false);
+        assert_or_panic(vec[5] == true);
+        assert_or_panic(vec[6] == false);
+        assert_or_panic(vec[7] == true);
+        assert_or_panic(vec[8] == true);
+        assert_or_panic(vec[9] == true);
+        assert_or_panic(vec[10] == false);
+        assert_or_panic(vec[11] == true);
+        assert_or_panic(vec[12] == false);
+        assert_or_panic(vec[13] == false);
+        assert_or_panic(vec[14] == false);
+        assert_or_panic(vec[15] == true);
+        assert_or_panic(vec[16] == true);
+        assert_or_panic(vec[17] == false);
+        assert_or_panic(vec[18] == false);
+        assert_or_panic(vec[19] == false);
+        assert_or_panic(vec[20] == true);
+        assert_or_panic(vec[21] == true);
+        assert_or_panic(vec[22] == false);
+        assert_or_panic(vec[23] == false);
+        assert_or_panic(vec[24] == false);
+        assert_or_panic(vec[25] == false);
+        assert_or_panic(vec[26] == true);
+        assert_or_panic(vec[27] == false);
+        assert_or_panic(vec[28] == false);
+        assert_or_panic(vec[29] == false);
+        assert_or_panic(vec[30] == true);
+        assert_or_panic(vec[31] == true);
+        assert_or_panic(vec[32] == true);
+        assert_or_panic(vec[33] == true);
+        assert_or_panic(vec[34] == false);
+        assert_or_panic(vec[35] == false);
+        assert_or_panic(vec[36] == false);
+        assert_or_panic(vec[37] == true);
+        assert_or_panic(vec[38] == true);
+        assert_or_panic(vec[39] == true);
+        assert_or_panic(vec[40] == false);
+        assert_or_panic(vec[41] == false);
+        assert_or_panic(vec[42] == true);
+        assert_or_panic(vec[43] == false);
+        assert_or_panic(vec[44] == false);
+        assert_or_panic(vec[45] == true);
+        assert_or_panic(vec[46] == false);
+        assert_or_panic(vec[47] == false);
+        assert_or_panic(vec[48] == true);
+        assert_or_panic(vec[49] == true);
+        assert_or_panic(vec[50] == true);
+        assert_or_panic(vec[51] == true);
+        assert_or_panic(vec[52] == false);
+        assert_or_panic(vec[53] == false);
+        assert_or_panic(vec[54] == false);
+        assert_or_panic(vec[55] == true);
+        assert_or_panic(vec[56] == false);
+        assert_or_panic(vec[57] == true);
+        assert_or_panic(vec[58] == false);
+        assert_or_panic(vec[59] == true);
+        assert_or_panic(vec[60] == true);
+        assert_or_panic(vec[61] == false);
+        assert_or_panic(vec[62] == false);
+        assert_or_panic(vec[63] == true);
+        assert_or_panic(vec[64] == true);
+        assert_or_panic(vec[65] == false);
+        assert_or_panic(vec[66] == true);
+        assert_or_panic(vec[67] == false);
+        assert_or_panic(vec[68] == false);
+        assert_or_panic(vec[69] == false);
+        assert_or_panic(vec[70] == true);
+        assert_or_panic(vec[71] == true);
+        assert_or_panic(vec[72] == true);
+        assert_or_panic(vec[73] == true);
+        assert_or_panic(vec[74] == true);
+        assert_or_panic(vec[75] == false);
+        assert_or_panic(vec[76] == true);
+        assert_or_panic(vec[77] == false);
+        assert_or_panic(vec[78] == true);
+        assert_or_panic(vec[79] == true);
+        assert_or_panic(vec[80] == true);
+        assert_or_panic(vec[81] == true);
+        assert_or_panic(vec[82] == true);
+        assert_or_panic(vec[83] == false);
+        assert_or_panic(vec[84] == true);
+        assert_or_panic(vec[85] == true);
+        assert_or_panic(vec[86] == false);
+        assert_or_panic(vec[87] == true);
+        assert_or_panic(vec[88] == false);
+        assert_or_panic(vec[89] == false);
+        assert_or_panic(vec[90] == true);
+        assert_or_panic(vec[91] == false);
+        assert_or_panic(vec[92] == true);
+        assert_or_panic(vec[93] == false);
+        assert_or_panic(vec[94] == false);
+        assert_or_panic(vec[95] == false);
+        assert_or_panic(vec[96] == true);
+        assert_or_panic(vec[97] == true);
+        assert_or_panic(vec[98] == false);
+        assert_or_panic(vec[99] == true);
+        assert_or_panic(vec[100] == true);
+        assert_or_panic(vec[101] == false);
+        assert_or_panic(vec[102] == true);
+        assert_or_panic(vec[103] == false);
+        assert_or_panic(vec[104] == true);
+        assert_or_panic(vec[105] == false);
+        assert_or_panic(vec[106] == true);
+        assert_or_panic(vec[107] == false);
+        assert_or_panic(vec[108] == false);
+        assert_or_panic(vec[109] == true);
+        assert_or_panic(vec[110] == false);
+        assert_or_panic(vec[111] == false);
+        assert_or_panic(vec[112] == true);
+        assert_or_panic(vec[113] == false);
+        assert_or_panic(vec[114] == true);
+        assert_or_panic(vec[115] == false);
+        assert_or_panic(vec[116] == true);
+        assert_or_panic(vec[117] == false);
+        assert_or_panic(vec[118] == false);
+        assert_or_panic(vec[119] == true);
+        assert_or_panic(vec[120] == true);
+        assert_or_panic(vec[121] == true);
+        assert_or_panic(vec[122] == false);
+        assert_or_panic(vec[123] == true);
+        assert_or_panic(vec[124] == false);
+        assert_or_panic(vec[125] == false);
+        assert_or_panic(vec[126] == true);
+        assert_or_panic(vec[127] == true);
+        assert_or_panic(vec[128] == false);
+        assert_or_panic(vec[129] == true);
+        assert_or_panic(vec[130] == true);
+        assert_or_panic(vec[131] == false);
+        assert_or_panic(vec[132] == true);
+        assert_or_panic(vec[133] == true);
+        assert_or_panic(vec[134] == false);
+        assert_or_panic(vec[135] == true);
+        assert_or_panic(vec[136] == true);
+        assert_or_panic(vec[137] == false);
+        assert_or_panic(vec[138] == false);
+        assert_or_panic(vec[139] == false);
+        assert_or_panic(vec[140] == true);
+        assert_or_panic(vec[141] == false);
+        assert_or_panic(vec[142] == true);
+        assert_or_panic(vec[143] == false);
+        assert_or_panic(vec[144] == false);
+        assert_or_panic(vec[145] == false);
+        assert_or_panic(vec[146] == true);
+        assert_or_panic(vec[147] == false);
+        assert_or_panic(vec[148] == true);
+        assert_or_panic(vec[149] == false);
+        assert_or_panic(vec[150] == false);
+        assert_or_panic(vec[151] == true);
+        assert_or_panic(vec[152] == false);
+        assert_or_panic(vec[153] == true);
+        assert_or_panic(vec[154] == true);
+        assert_or_panic(vec[155] == false);
+        assert_or_panic(vec[156] == true);
+        assert_or_panic(vec[157] == true);
+        assert_or_panic(vec[158] == false);
+        assert_or_panic(vec[159] == true);
+        assert_or_panic(vec[160] == true);
+        assert_or_panic(vec[161] == false);
+        assert_or_panic(vec[162] == false);
+        assert_or_panic(vec[163] == false);
+        assert_or_panic(vec[164] == true);
+        assert_or_panic(vec[165] == false);
+        assert_or_panic(vec[166] == true);
+        assert_or_panic(vec[167] == true);
+        assert_or_panic(vec[168] == true);
+        assert_or_panic(vec[169] == true);
+        assert_or_panic(vec[170] == false);
+        assert_or_panic(vec[171] == true);
+        assert_or_panic(vec[172] == false);
+        assert_or_panic(vec[173] == false);
+        assert_or_panic(vec[174] == true);
+        assert_or_panic(vec[175] == true);
+        assert_or_panic(vec[176] == true);
+        assert_or_panic(vec[177] == false);
+        assert_or_panic(vec[178] == false);
+        assert_or_panic(vec[179] == false);
+        assert_or_panic(vec[180] == true);
+        assert_or_panic(vec[181] == false);
+        assert_or_panic(vec[182] == false);
+        assert_or_panic(vec[183] == true);
+        assert_or_panic(vec[184] == true);
+        assert_or_panic(vec[185] == false);
+        assert_or_panic(vec[186] == true);
+        assert_or_panic(vec[187] == false);
+        assert_or_panic(vec[188] == true);
+        assert_or_panic(vec[189] == true);
+        assert_or_panic(vec[190] == true);
+        assert_or_panic(vec[191] == true);
+        assert_or_panic(vec[192] == true);
+        assert_or_panic(vec[193] == true);
+        assert_or_panic(vec[194] == true);
+        assert_or_panic(vec[195] == false);
+        assert_or_panic(vec[196] == false);
+        assert_or_panic(vec[197] == false);
+        assert_or_panic(vec[198] == false);
+        assert_or_panic(vec[199] == false);
+        assert_or_panic(vec[200] == true);
+        assert_or_panic(vec[201] == false);
+        assert_or_panic(vec[202] == true);
+        assert_or_panic(vec[203] == false);
+        assert_or_panic(vec[204] == true);
+        assert_or_panic(vec[205] == true);
+        assert_or_panic(vec[206] == false);
+        assert_or_panic(vec[207] == false);
+        assert_or_panic(vec[208] == false);
+        assert_or_panic(vec[209] == true);
+        assert_or_panic(vec[210] == true);
+        assert_or_panic(vec[211] == true);
+        assert_or_panic(vec[212] == false);
+        assert_or_panic(vec[213] == false);
+        assert_or_panic(vec[214] == true);
+        assert_or_panic(vec[215] == true);
+        assert_or_panic(vec[216] == true);
+        assert_or_panic(vec[217] == false);
+        assert_or_panic(vec[218] == false);
+        assert_or_panic(vec[219] == true);
+        assert_or_panic(vec[220] == false);
+        assert_or_panic(vec[221] == true);
+        assert_or_panic(vec[222] == true);
+        assert_or_panic(vec[223] == false);
+        assert_or_panic(vec[224] == true);
+        assert_or_panic(vec[225] == false);
+        assert_or_panic(vec[226] == false);
+        assert_or_panic(vec[227] == true);
+        assert_or_panic(vec[228] == false);
+        assert_or_panic(vec[229] == false);
+        assert_or_panic(vec[230] == true);
+        assert_or_panic(vec[231] == true);
+        assert_or_panic(vec[232] == false);
+        assert_or_panic(vec[233] == true);
+        assert_or_panic(vec[234] == true);
+        assert_or_panic(vec[235] == true);
+        assert_or_panic(vec[236] == true);
+        assert_or_panic(vec[237] == true);
+        assert_or_panic(vec[238] == false);
+        assert_or_panic(vec[239] == true);
+        assert_or_panic(vec[240] == false);
+        assert_or_panic(vec[241] == false);
+        assert_or_panic(vec[242] == true);
+        assert_or_panic(vec[243] == false);
+        assert_or_panic(vec[244] == true);
+        assert_or_panic(vec[245] == false);
+        assert_or_panic(vec[246] == true);
+        assert_or_panic(vec[247] == false);
+        assert_or_panic(vec[248] == true);
+        assert_or_panic(vec[249] == true);
+        assert_or_panic(vec[250] == true);
+        assert_or_panic(vec[251] == true);
+        assert_or_panic(vec[252] == true);
+        assert_or_panic(vec[253] == false);
+        assert_or_panic(vec[254] == false);
+        assert_or_panic(vec[255] == false);
+        assert_or_panic(vec[256] == false);
+        assert_or_panic(vec[257] == false);
+        assert_or_panic(vec[258] == false);
+        assert_or_panic(vec[259] == true);
+        assert_or_panic(vec[260] == true);
+        assert_or_panic(vec[261] == true);
+        assert_or_panic(vec[262] == true);
+        assert_or_panic(vec[263] == false);
+        assert_or_panic(vec[264] == false);
+        assert_or_panic(vec[265] == false);
+        assert_or_panic(vec[266] == true);
+        assert_or_panic(vec[267] == false);
+        assert_or_panic(vec[268] == true);
+        assert_or_panic(vec[269] == false);
+        assert_or_panic(vec[270] == true);
+        assert_or_panic(vec[271] == true);
+        assert_or_panic(vec[272] == true);
+        assert_or_panic(vec[273] == true);
+        assert_or_panic(vec[274] == true);
+        assert_or_panic(vec[275] == true);
+        assert_or_panic(vec[276] == false);
+        assert_or_panic(vec[277] == false);
+        assert_or_panic(vec[278] == true);
+        assert_or_panic(vec[279] == true);
+        assert_or_panic(vec[280] == false);
+        assert_or_panic(vec[281] == false);
+        assert_or_panic(vec[282] == false);
+        assert_or_panic(vec[283] == false);
+        assert_or_panic(vec[284] == true);
+        assert_or_panic(vec[285] == true);
+        assert_or_panic(vec[286] == true);
+        assert_or_panic(vec[287] == false);
+        assert_or_panic(vec[288] == false);
+        assert_or_panic(vec[289] == false);
+        assert_or_panic(vec[290] == true);
+        assert_or_panic(vec[291] == false);
+        assert_or_panic(vec[292] == true);
+        assert_or_panic(vec[293] == true);
+        assert_or_panic(vec[294] == false);
+        assert_or_panic(vec[295] == true);
+        assert_or_panic(vec[296] == true);
+        assert_or_panic(vec[297] == true);
+        assert_or_panic(vec[298] == false);
+        assert_or_panic(vec[299] == true);
+        assert_or_panic(vec[300] == true);
+        assert_or_panic(vec[301] == false);
+        assert_or_panic(vec[302] == false);
+        assert_or_panic(vec[303] == true);
+        assert_or_panic(vec[304] == false);
+        assert_or_panic(vec[305] == false);
+        assert_or_panic(vec[306] == true);
+        assert_or_panic(vec[307] == true);
+        assert_or_panic(vec[308] == true);
+        assert_or_panic(vec[309] == true);
+        assert_or_panic(vec[310] == false);
+        assert_or_panic(vec[311] == false);
+        assert_or_panic(vec[312] == false);
+        assert_or_panic(vec[313] == false);
+        assert_or_panic(vec[314] == false);
+        assert_or_panic(vec[315] == true);
+        assert_or_panic(vec[316] == false);
+        assert_or_panic(vec[317] == false);
+        assert_or_panic(vec[318] == true);
+        assert_or_panic(vec[319] == false);
+        assert_or_panic(vec[320] == false);
+        assert_or_panic(vec[321] == true);
+        assert_or_panic(vec[322] == true);
+        assert_or_panic(vec[323] == true);
+        assert_or_panic(vec[324] == true);
+        assert_or_panic(vec[325] == false);
+        assert_or_panic(vec[326] == false);
+        assert_or_panic(vec[327] == false);
+        assert_or_panic(vec[328] == true);
+        assert_or_panic(vec[329] == true);
+        assert_or_panic(vec[330] == false);
+        assert_or_panic(vec[331] == true);
+        assert_or_panic(vec[332] == true);
+        assert_or_panic(vec[333] == false);
+        assert_or_panic(vec[334] == false);
+        assert_or_panic(vec[335] == true);
+        assert_or_panic(vec[336] == true);
+        assert_or_panic(vec[337] == false);
+        assert_or_panic(vec[338] == true);
+        assert_or_panic(vec[339] == true);
+        assert_or_panic(vec[340] == true);
+        assert_or_panic(vec[341] == false);
+        assert_or_panic(vec[342] == false);
+        assert_or_panic(vec[343] == false);
+        assert_or_panic(vec[344] == true);
+        assert_or_panic(vec[345] == true);
+        assert_or_panic(vec[346] == false);
+        assert_or_panic(vec[347] == true);
+        assert_or_panic(vec[348] == false);
+        assert_or_panic(vec[349] == true);
+        assert_or_panic(vec[350] == false);
+        assert_or_panic(vec[351] == false);
+        assert_or_panic(vec[352] == true);
+        assert_or_panic(vec[353] == false);
+        assert_or_panic(vec[354] == true);
+        assert_or_panic(vec[355] == false);
+        assert_or_panic(vec[356] == false);
+        assert_or_panic(vec[357] == false);
+        assert_or_panic(vec[358] == false);
+        assert_or_panic(vec[359] == false);
+        assert_or_panic(vec[360] == true);
+        assert_or_panic(vec[361] == true);
+        assert_or_panic(vec[362] == false);
+        assert_or_panic(vec[363] == false);
+        assert_or_panic(vec[364] == false);
+        assert_or_panic(vec[365] == false);
+        assert_or_panic(vec[366] == true);
+        assert_or_panic(vec[367] == false);
+        assert_or_panic(vec[368] == true);
+        assert_or_panic(vec[369] == false);
+        assert_or_panic(vec[370] == true);
+        assert_or_panic(vec[371] == true);
+        assert_or_panic(vec[372] == false);
+        assert_or_panic(vec[373] == true);
+        assert_or_panic(vec[374] == true);
+        assert_or_panic(vec[375] == true);
+        assert_or_panic(vec[376] == true);
+        assert_or_panic(vec[377] == true);
+        assert_or_panic(vec[378] == false);
+        assert_or_panic(vec[379] == true);
+        assert_or_panic(vec[380] == false);
+        assert_or_panic(vec[381] == true);
+        assert_or_panic(vec[382] == true);
+        assert_or_panic(vec[383] == true);
+        assert_or_panic(vec[384] == true);
+        assert_or_panic(vec[385] == true);
+        assert_or_panic(vec[386] == false);
+        assert_or_panic(vec[387] == true);
+        assert_or_panic(vec[388] == true);
+        assert_or_panic(vec[389] == false);
+        assert_or_panic(vec[390] == true);
+        assert_or_panic(vec[391] == false);
+        assert_or_panic(vec[392] == true);
+        assert_or_panic(vec[393] == false);
+        assert_or_panic(vec[394] == true);
+        assert_or_panic(vec[395] == false);
+        assert_or_panic(vec[396] == true);
+        assert_or_panic(vec[397] == false);
+        assert_or_panic(vec[398] == false);
+        assert_or_panic(vec[399] == true);
+        assert_or_panic(vec[400] == true);
+        assert_or_panic(vec[401] == true);
+        assert_or_panic(vec[402] == true);
+        assert_or_panic(vec[403] == false);
+        assert_or_panic(vec[404] == false);
+        assert_or_panic(vec[405] == true);
+        assert_or_panic(vec[406] == false);
+        assert_or_panic(vec[407] == false);
+        assert_or_panic(vec[408] == false);
+        assert_or_panic(vec[409] == true);
+        assert_or_panic(vec[410] == false);
+        assert_or_panic(vec[411] == true);
+        assert_or_panic(vec[412] == true);
+        assert_or_panic(vec[413] == false);
+        assert_or_panic(vec[414] == true);
+        assert_or_panic(vec[415] == true);
+        assert_or_panic(vec[416] == false);
+        assert_or_panic(vec[417] == true);
+        assert_or_panic(vec[418] == true);
+        assert_or_panic(vec[419] == false);
+        assert_or_panic(vec[420] == false);
+        assert_or_panic(vec[421] == true);
+        assert_or_panic(vec[422] == false);
+        assert_or_panic(vec[423] == false);
+        assert_or_panic(vec[424] == true);
+        assert_or_panic(vec[425] == false);
+        assert_or_panic(vec[426] == true);
+        assert_or_panic(vec[427] == false);
+        assert_or_panic(vec[428] == false);
+        assert_or_panic(vec[429] == true);
+        assert_or_panic(vec[430] == false);
+        assert_or_panic(vec[431] == true);
+        assert_or_panic(vec[432] == true);
+        assert_or_panic(vec[433] == false);
+        assert_or_panic(vec[434] == true);
+        assert_or_panic(vec[435] == false);
+        assert_or_panic(vec[436] == true);
+        assert_or_panic(vec[437] == false);
+        assert_or_panic(vec[438] == true);
+        assert_or_panic(vec[439] == false);
+        assert_or_panic(vec[440] == false);
+        assert_or_panic(vec[441] == true);
+        assert_or_panic(vec[442] == true);
+        assert_or_panic(vec[443] == false);
+        assert_or_panic(vec[444] == true);
+        assert_or_panic(vec[445] == true);
+        assert_or_panic(vec[446] == false);
+        assert_or_panic(vec[447] == true);
+        assert_or_panic(vec[448] == true);
+        assert_or_panic(vec[449] == false);
+        assert_or_panic(vec[450] == false);
+        assert_or_panic(vec[451] == false);
+        assert_or_panic(vec[452] == false);
+        assert_or_panic(vec[453] == false);
+        assert_or_panic(vec[454] == true);
+        assert_or_panic(vec[455] == false);
+        assert_or_panic(vec[456] == false);
+        assert_or_panic(vec[457] == true);
+        assert_or_panic(vec[458] == false);
+        assert_or_panic(vec[459] == true);
+        assert_or_panic(vec[460] == false);
+        assert_or_panic(vec[461] == false);
+        assert_or_panic(vec[462] == false);
+        assert_or_panic(vec[463] == true);
+        assert_or_panic(vec[464] == false);
+        assert_or_panic(vec[465] == true);
+        assert_or_panic(vec[466] == false);
+        assert_or_panic(vec[467] == false);
+        assert_or_panic(vec[468] == false);
+        assert_or_panic(vec[469] == false);
+        assert_or_panic(vec[470] == true);
+        assert_or_panic(vec[471] == true);
+        assert_or_panic(vec[472] == false);
+        assert_or_panic(vec[473] == true);
+        assert_or_panic(vec[474] == true);
+        assert_or_panic(vec[475] == false);
+        assert_or_panic(vec[476] == false);
+        assert_or_panic(vec[477] == true);
+        assert_or_panic(vec[478] == true);
+        assert_or_panic(vec[479] == true);
+        assert_or_panic(vec[480] == false);
+        assert_or_panic(vec[481] == false);
+        assert_or_panic(vec[482] == true);
+        assert_or_panic(vec[483] == false);
+        assert_or_panic(vec[484] == false);
+        assert_or_panic(vec[485] == false);
+        assert_or_panic(vec[486] == true);
+        assert_or_panic(vec[487] == true);
+        assert_or_panic(vec[488] == false);
+        assert_or_panic(vec[489] == false);
+        assert_or_panic(vec[490] == false);
+        assert_or_panic(vec[491] == false);
+        assert_or_panic(vec[492] == false);
+        assert_or_panic(vec[493] == true);
+        assert_or_panic(vec[494] == true);
+        assert_or_panic(vec[495] == true);
+        assert_or_panic(vec[496] == true);
+        assert_or_panic(vec[497] == false);
+        assert_or_panic(vec[498] == false);
+        assert_or_panic(vec[499] == false);
+        assert_or_panic(vec[500] == true);
+        assert_or_panic(vec[501] == false);
+        assert_or_panic(vec[502] == true);
+        assert_or_panic(vec[503] == true);
+        assert_or_panic(vec[504] == true);
+        assert_or_panic(vec[505] == true);
+        assert_or_panic(vec[506] == false);
+        assert_or_panic(vec[507] == false);
+        assert_or_panic(vec[508] == true);
+        assert_or_panic(vec[509] == true);
+        assert_or_panic(vec[510] == false);
+        assert_or_panic(vec[511] == false);
+    }
+#endif
 }
 
 void c_u8(uint8_t x) {
test/c_abi/main.zig
@@ -890,6 +890,4264 @@ test "big simd vector" {
     try expect(x[7] == 16);
 }
 
+const Vector2Bool = @Vector(2, bool);
+const Vector4Bool = @Vector(4, bool);
+const Vector8Bool = @Vector(8, bool);
+const Vector16Bool = @Vector(16, bool);
+const Vector32Bool = @Vector(32, bool);
+const Vector64Bool = @Vector(64, bool);
+const Vector128Bool = @Vector(128, bool);
+const Vector256Bool = @Vector(256, bool);
+const Vector512Bool = @Vector(512, bool);
+
+extern fn c_vector_2_bool(Vector2Bool) void;
+extern fn c_vector_4_bool(Vector4Bool) void;
+extern fn c_vector_8_bool(Vector8Bool) void;
+extern fn c_vector_16_bool(Vector16Bool) void;
+extern fn c_vector_32_bool(Vector32Bool) void;
+extern fn c_vector_64_bool(Vector64Bool) void;
+extern fn c_vector_128_bool(Vector128Bool) void;
+extern fn c_vector_256_bool(Vector256Bool) void;
+extern fn c_vector_512_bool(Vector512Bool) void;
+
+extern fn c_ret_vector_2_bool() Vector2Bool;
+extern fn c_ret_vector_4_bool() Vector4Bool;
+extern fn c_ret_vector_8_bool() Vector8Bool;
+extern fn c_ret_vector_16_bool() Vector16Bool;
+extern fn c_ret_vector_32_bool() Vector32Bool;
+extern fn c_ret_vector_64_bool() Vector64Bool;
+extern fn c_ret_vector_128_bool() Vector128Bool;
+extern fn c_ret_vector_256_bool() Vector256Bool;
+extern fn c_ret_vector_512_bool() Vector512Bool;
+
+test "bool simd vector" {
+    if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch != .powerpc) return error.SkipZigTest;
+
+    {
+        c_vector_2_bool(.{
+            true,
+            true,
+        });
+
+        const vec = c_ret_vector_2_bool();
+        try expect(vec[0] == true);
+        try expect(vec[1] == false);
+    }
+    {
+        c_vector_4_bool(.{
+            true,
+            true,
+            false,
+            true,
+        });
+
+        const vec = c_ret_vector_4_bool();
+        try expect(vec[0] == true);
+        try expect(vec[1] == false);
+        try expect(vec[2] == true);
+        try expect(vec[3] == false);
+    }
+    {
+        c_vector_8_bool(.{
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+        });
+
+        const vec = c_ret_vector_8_bool();
+        try expect(vec[0] == false);
+        try expect(vec[1] == true);
+        try expect(vec[2] == false);
+        try expect(vec[3] == false);
+        try expect(vec[4] == true);
+        try expect(vec[5] == false);
+        try expect(vec[6] == false);
+        try expect(vec[7] == true);
+    }
+    {
+        c_vector_16_bool(.{
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+        });
+
+        const vec = c_ret_vector_16_bool();
+        try expect(vec[0] == true);
+        try expect(vec[1] == true);
+        try expect(vec[2] == false);
+        try expect(vec[3] == false);
+        try expect(vec[4] == false);
+        try expect(vec[5] == false);
+        try expect(vec[6] == true);
+        try expect(vec[7] == false);
+        try expect(vec[8] == true);
+        try expect(vec[9] == false);
+        try expect(vec[10] == false);
+        try expect(vec[11] == true);
+        try expect(vec[12] == true);
+        try expect(vec[13] == false);
+        try expect(vec[14] == true);
+        try expect(vec[15] == true);
+    }
+    {
+        c_vector_32_bool(.{
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+        });
+
+        const vec = c_ret_vector_32_bool();
+        try expect(vec[0] == true);
+        try expect(vec[1] == false);
+        try expect(vec[2] == true);
+        try expect(vec[3] == true);
+        try expect(vec[4] == true);
+        try expect(vec[5] == false);
+        try expect(vec[6] == true);
+        try expect(vec[7] == false);
+        try expect(vec[8] == true);
+        try expect(vec[9] == true);
+        try expect(vec[10] == true);
+        try expect(vec[11] == false);
+        try expect(vec[12] == true);
+        try expect(vec[13] == true);
+        try expect(vec[14] == false);
+        try expect(vec[15] == false);
+        try expect(vec[16] == true);
+        try expect(vec[17] == false);
+        try expect(vec[18] == false);
+        try expect(vec[19] == false);
+        try expect(vec[20] == false);
+        try expect(vec[21] == true);
+        try expect(vec[22] == true);
+        try expect(vec[23] == true);
+        try expect(vec[24] == false);
+        try expect(vec[25] == true);
+        try expect(vec[26] == false);
+        try expect(vec[27] == false);
+        try expect(vec[28] == true);
+        try expect(vec[29] == false);
+        try expect(vec[30] == false);
+        try expect(vec[31] == false);
+    }
+    {
+        c_vector_64_bool(.{
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+        });
+
+        const vec = c_ret_vector_64_bool();
+        try expect(vec[0] == false);
+        try expect(vec[1] == true);
+        try expect(vec[2] == false);
+        try expect(vec[3] == true);
+        try expect(vec[4] == true);
+        try expect(vec[5] == true);
+        try expect(vec[6] == false);
+        try expect(vec[7] == true);
+        try expect(vec[8] == true);
+        try expect(vec[9] == true);
+        try expect(vec[10] == true);
+        try expect(vec[11] == true);
+        try expect(vec[12] == true);
+        try expect(vec[13] == false);
+        try expect(vec[14] == true);
+        try expect(vec[15] == true);
+        try expect(vec[16] == true);
+        try expect(vec[17] == false);
+        try expect(vec[18] == false);
+        try expect(vec[19] == false);
+        try expect(vec[20] == true);
+        try expect(vec[21] == true);
+        try expect(vec[22] == false);
+        try expect(vec[23] == true);
+        try expect(vec[24] == false);
+        try expect(vec[25] == true);
+        try expect(vec[26] == false);
+        try expect(vec[27] == true);
+        try expect(vec[28] == false);
+        try expect(vec[29] == true);
+        try expect(vec[30] == false);
+        try expect(vec[31] == true);
+        try expect(vec[32] == false);
+        try expect(vec[33] == false);
+        try expect(vec[34] == true);
+        try expect(vec[35] == true);
+        try expect(vec[36] == false);
+        try expect(vec[37] == false);
+        try expect(vec[38] == false);
+        try expect(vec[39] == true);
+        try expect(vec[40] == true);
+        try expect(vec[41] == true);
+        try expect(vec[42] == true);
+        try expect(vec[43] == false);
+        try expect(vec[44] == false);
+        try expect(vec[45] == false);
+        try expect(vec[46] == true);
+        try expect(vec[47] == true);
+        try expect(vec[48] == false);
+        try expect(vec[49] == false);
+        try expect(vec[50] == true);
+        try expect(vec[51] == false);
+        try expect(vec[52] == false);
+        try expect(vec[53] == false);
+        try expect(vec[54] == false);
+        try expect(vec[55] == true);
+        try expect(vec[56] == false);
+        try expect(vec[57] == false);
+        try expect(vec[58] == false);
+        try expect(vec[59] == true);
+        try expect(vec[60] == true);
+        try expect(vec[61] == true);
+        try expect(vec[62] == true);
+        try expect(vec[63] == true);
+    }
+    {
+        c_vector_128_bool(.{
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+        });
+
+        const vec = c_ret_vector_128_bool();
+        try expect(vec[0] == false);
+        try expect(vec[1] == true);
+        try expect(vec[2] == true);
+        try expect(vec[3] == false);
+        try expect(vec[4] == true);
+        try expect(vec[5] == false);
+        try expect(vec[6] == false);
+        try expect(vec[7] == true);
+        try expect(vec[8] == true);
+        try expect(vec[9] == false);
+        try expect(vec[10] == true);
+        try expect(vec[11] == false);
+        try expect(vec[12] == false);
+        try expect(vec[13] == false);
+        try expect(vec[14] == true);
+        try expect(vec[15] == false);
+        try expect(vec[16] == true);
+        try expect(vec[17] == false);
+        try expect(vec[18] == false);
+        try expect(vec[19] == true);
+        try expect(vec[20] == false);
+        try expect(vec[21] == true);
+        try expect(vec[22] == false);
+        try expect(vec[23] == false);
+        try expect(vec[24] == false);
+        try expect(vec[25] == true);
+        try expect(vec[26] == true);
+        try expect(vec[27] == true);
+        try expect(vec[28] == false);
+        try expect(vec[29] == false);
+        try expect(vec[30] == false);
+        try expect(vec[31] == false);
+        try expect(vec[32] == true);
+        try expect(vec[33] == true);
+        try expect(vec[34] == true);
+        try expect(vec[35] == false);
+        try expect(vec[36] == true);
+        try expect(vec[37] == true);
+        try expect(vec[38] == false);
+        try expect(vec[39] == false);
+        try expect(vec[40] == false);
+        try expect(vec[41] == false);
+        try expect(vec[42] == true);
+        try expect(vec[43] == true);
+        try expect(vec[44] == true);
+        try expect(vec[45] == false);
+        try expect(vec[46] == false);
+        try expect(vec[47] == false);
+        try expect(vec[48] == false);
+        try expect(vec[49] == true);
+        try expect(vec[50] == false);
+        try expect(vec[51] == false);
+        try expect(vec[52] == true);
+        try expect(vec[53] == false);
+        try expect(vec[54] == false);
+        try expect(vec[55] == false);
+        try expect(vec[56] == false);
+        try expect(vec[57] == false);
+        try expect(vec[58] == true);
+        try expect(vec[59] == true);
+        try expect(vec[60] == true);
+        try expect(vec[61] == false);
+        try expect(vec[62] == true);
+        try expect(vec[63] == true);
+        try expect(vec[64] == false);
+        try expect(vec[65] == false);
+        try expect(vec[66] == false);
+        try expect(vec[67] == false);
+        try expect(vec[68] == false);
+        try expect(vec[69] == false);
+        try expect(vec[70] == false);
+        try expect(vec[71] == false);
+        try expect(vec[72] == true);
+        try expect(vec[73] == true);
+        try expect(vec[74] == true);
+        try expect(vec[75] == true);
+        try expect(vec[76] == true);
+        try expect(vec[77] == false);
+        try expect(vec[78] == false);
+        try expect(vec[79] == false);
+        try expect(vec[80] == false);
+        try expect(vec[81] == false);
+        try expect(vec[82] == false);
+        try expect(vec[83] == true);
+        try expect(vec[84] == false);
+        try expect(vec[85] == true);
+        try expect(vec[86] == false);
+        try expect(vec[87] == true);
+        try expect(vec[88] == false);
+        try expect(vec[89] == true);
+        try expect(vec[90] == false);
+        try expect(vec[91] == true);
+        try expect(vec[92] == true);
+        try expect(vec[93] == true);
+        try expect(vec[94] == true);
+        try expect(vec[95] == false);
+        try expect(vec[96] == false);
+        try expect(vec[97] == true);
+        try expect(vec[98] == false);
+        try expect(vec[99] == false);
+        try expect(vec[100] == true);
+        try expect(vec[101] == true);
+        try expect(vec[102] == true);
+        try expect(vec[103] == true);
+        try expect(vec[104] == false);
+        try expect(vec[105] == true);
+        try expect(vec[106] == true);
+        try expect(vec[107] == true);
+        try expect(vec[108] == false);
+        try expect(vec[109] == false);
+        try expect(vec[110] == true);
+        try expect(vec[111] == false);
+        try expect(vec[112] == false);
+        try expect(vec[113] == true);
+        try expect(vec[114] == true);
+        try expect(vec[115] == false);
+        try expect(vec[116] == true);
+        try expect(vec[117] == false);
+        try expect(vec[118] == true);
+        try expect(vec[119] == true);
+        try expect(vec[120] == true);
+        try expect(vec[121] == true);
+        try expect(vec[122] == true);
+        try expect(vec[123] == false);
+        try expect(vec[124] == false);
+        try expect(vec[125] == true);
+        try expect(vec[126] == false);
+        try expect(vec[127] == true);
+    }
+    {
+        c_vector_256_bool(.{
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+        });
+
+        const vec = c_ret_vector_256_bool();
+        try expect(vec[0] == true);
+        try expect(vec[1] == false);
+        try expect(vec[2] == true);
+        try expect(vec[3] == true);
+        try expect(vec[4] == false);
+        try expect(vec[5] == false);
+        try expect(vec[6] == false);
+        try expect(vec[7] == false);
+        try expect(vec[8] == false);
+        try expect(vec[9] == true);
+        try expect(vec[10] == false);
+        try expect(vec[11] == true);
+        try expect(vec[12] == false);
+        try expect(vec[13] == true);
+        try expect(vec[14] == false);
+        try expect(vec[15] == false);
+        try expect(vec[16] == true);
+        try expect(vec[17] == true);
+        try expect(vec[18] == true);
+        try expect(vec[19] == false);
+        try expect(vec[20] == false);
+        try expect(vec[21] == false);
+        try expect(vec[22] == true);
+        try expect(vec[23] == false);
+        try expect(vec[24] == true);
+        try expect(vec[25] == false);
+        try expect(vec[26] == false);
+        try expect(vec[27] == true);
+        try expect(vec[28] == true);
+        try expect(vec[29] == true);
+        try expect(vec[30] == false);
+        try expect(vec[31] == false);
+        try expect(vec[32] == true);
+        try expect(vec[33] == true);
+        try expect(vec[34] == true);
+        try expect(vec[35] == false);
+        try expect(vec[36] == true);
+        try expect(vec[37] == true);
+        try expect(vec[38] == true);
+        try expect(vec[39] == false);
+        try expect(vec[40] == true);
+        try expect(vec[41] == false);
+        try expect(vec[42] == true);
+        try expect(vec[43] == true);
+        try expect(vec[44] == false);
+        try expect(vec[45] == true);
+        try expect(vec[46] == false);
+        try expect(vec[47] == true);
+        try expect(vec[48] == true);
+        try expect(vec[49] == false);
+        try expect(vec[50] == false);
+        try expect(vec[51] == true);
+        try expect(vec[52] == true);
+        try expect(vec[53] == false);
+        try expect(vec[54] == false);
+        try expect(vec[55] == true);
+        try expect(vec[56] == false);
+        try expect(vec[57] == true);
+        try expect(vec[58] == true);
+        try expect(vec[59] == true);
+        try expect(vec[60] == false);
+        try expect(vec[61] == true);
+        try expect(vec[62] == true);
+        try expect(vec[63] == false);
+        try expect(vec[64] == true);
+        try expect(vec[65] == true);
+        try expect(vec[66] == false);
+        try expect(vec[67] == true);
+        try expect(vec[68] == false);
+        try expect(vec[69] == true);
+        try expect(vec[70] == true);
+        try expect(vec[71] == true);
+        try expect(vec[72] == false);
+        try expect(vec[73] == true);
+        try expect(vec[74] == true);
+        try expect(vec[75] == false);
+        try expect(vec[76] == true);
+        try expect(vec[77] == true);
+        try expect(vec[78] == true);
+        try expect(vec[79] == true);
+        try expect(vec[80] == false);
+        try expect(vec[81] == true);
+        try expect(vec[82] == false);
+        try expect(vec[83] == true);
+        try expect(vec[84] == true);
+        try expect(vec[85] == true);
+        try expect(vec[86] == false);
+        try expect(vec[87] == true);
+        try expect(vec[88] == false);
+        try expect(vec[89] == true);
+        try expect(vec[90] == false);
+        try expect(vec[91] == false);
+        try expect(vec[92] == true);
+        try expect(vec[93] == false);
+        try expect(vec[94] == false);
+        try expect(vec[95] == false);
+        try expect(vec[96] == true);
+        try expect(vec[97] == true);
+        try expect(vec[98] == false);
+        try expect(vec[99] == false);
+        try expect(vec[100] == false);
+        try expect(vec[101] == true);
+        try expect(vec[102] == true);
+        try expect(vec[103] == true);
+        try expect(vec[104] == false);
+        try expect(vec[105] == false);
+        try expect(vec[106] == false);
+        try expect(vec[107] == true);
+        try expect(vec[108] == false);
+        try expect(vec[109] == true);
+        try expect(vec[110] == true);
+        try expect(vec[111] == true);
+        try expect(vec[112] == true);
+        try expect(vec[113] == true);
+        try expect(vec[114] == true);
+        try expect(vec[115] == true);
+        try expect(vec[116] == true);
+        try expect(vec[117] == false);
+        try expect(vec[118] == true);
+        try expect(vec[119] == false);
+        try expect(vec[120] == true);
+        try expect(vec[121] == false);
+        try expect(vec[122] == false);
+        try expect(vec[123] == true);
+        try expect(vec[124] == true);
+        try expect(vec[125] == false);
+        try expect(vec[126] == true);
+        try expect(vec[127] == false);
+        try expect(vec[128] == false);
+        try expect(vec[129] == false);
+        try expect(vec[130] == false);
+        try expect(vec[131] == true);
+        try expect(vec[132] == false);
+        try expect(vec[133] == false);
+        try expect(vec[134] == true);
+        try expect(vec[135] == false);
+        try expect(vec[136] == false);
+        try expect(vec[137] == false);
+        try expect(vec[138] == false);
+        try expect(vec[139] == false);
+        try expect(vec[140] == false);
+        try expect(vec[141] == true);
+        try expect(vec[142] == false);
+        try expect(vec[143] == true);
+        try expect(vec[144] == false);
+        try expect(vec[145] == true);
+        try expect(vec[146] == true);
+        try expect(vec[147] == true);
+        try expect(vec[148] == false);
+        try expect(vec[149] == true);
+        try expect(vec[150] == true);
+        try expect(vec[151] == false);
+        try expect(vec[152] == true);
+        try expect(vec[153] == true);
+        try expect(vec[154] == false);
+        try expect(vec[155] == true);
+        try expect(vec[156] == true);
+        try expect(vec[157] == true);
+        try expect(vec[158] == true);
+        try expect(vec[159] == true);
+        try expect(vec[160] == true);
+        try expect(vec[161] == true);
+        try expect(vec[162] == false);
+        try expect(vec[163] == false);
+        try expect(vec[164] == false);
+        try expect(vec[165] == true);
+        try expect(vec[166] == false);
+        try expect(vec[167] == false);
+        try expect(vec[168] == true);
+        try expect(vec[169] == false);
+        try expect(vec[170] == true);
+        try expect(vec[171] == true);
+        try expect(vec[172] == true);
+        try expect(vec[173] == false);
+        try expect(vec[174] == false);
+        try expect(vec[175] == true);
+        try expect(vec[176] == true);
+        try expect(vec[177] == true);
+        try expect(vec[178] == true);
+        try expect(vec[179] == false);
+        try expect(vec[180] == true);
+        try expect(vec[181] == true);
+        try expect(vec[182] == false);
+        try expect(vec[183] == true);
+        try expect(vec[184] == false);
+        try expect(vec[185] == false);
+        try expect(vec[186] == false);
+        try expect(vec[187] == true);
+        try expect(vec[188] == true);
+        try expect(vec[189] == true);
+        try expect(vec[190] == true);
+        try expect(vec[191] == true);
+        try expect(vec[192] == true);
+        try expect(vec[193] == true);
+        try expect(vec[194] == true);
+        try expect(vec[195] == false);
+        try expect(vec[196] == false);
+        try expect(vec[197] == true);
+        try expect(vec[198] == false);
+        try expect(vec[199] == false);
+        try expect(vec[200] == false);
+        try expect(vec[201] == true);
+        try expect(vec[202] == true);
+        try expect(vec[203] == true);
+        try expect(vec[204] == true);
+        try expect(vec[205] == true);
+        try expect(vec[206] == true);
+        try expect(vec[207] == false);
+        try expect(vec[208] == false);
+        try expect(vec[209] == false);
+        try expect(vec[210] == true);
+        try expect(vec[211] == true);
+        try expect(vec[212] == true);
+        try expect(vec[213] == false);
+        try expect(vec[214] == true);
+        try expect(vec[215] == false);
+        try expect(vec[216] == true);
+        try expect(vec[217] == false);
+        try expect(vec[218] == true);
+        try expect(vec[219] == false);
+        try expect(vec[220] == true);
+        try expect(vec[221] == true);
+        try expect(vec[222] == true);
+        try expect(vec[223] == false);
+        try expect(vec[224] == true);
+        try expect(vec[225] == false);
+        try expect(vec[226] == true);
+        try expect(vec[227] == false);
+        try expect(vec[228] == true);
+        try expect(vec[229] == false);
+        try expect(vec[230] == true);
+        try expect(vec[231] == false);
+        try expect(vec[232] == false);
+        try expect(vec[233] == true);
+        try expect(vec[234] == false);
+        try expect(vec[235] == true);
+        try expect(vec[236] == true);
+        try expect(vec[237] == false);
+        try expect(vec[238] == false);
+        try expect(vec[239] == true);
+        try expect(vec[240] == false);
+        try expect(vec[241] == false);
+        try expect(vec[242] == false);
+        try expect(vec[243] == true);
+        try expect(vec[244] == true);
+        try expect(vec[245] == false);
+        try expect(vec[246] == false);
+        try expect(vec[247] == false);
+        try expect(vec[248] == false);
+        try expect(vec[249] == false);
+        try expect(vec[250] == true);
+        try expect(vec[251] == false);
+        try expect(vec[252] == true);
+        try expect(vec[253] == false);
+        try expect(vec[254] == false);
+        try expect(vec[255] == false);
+    }
+    {
+        c_vector_512_bool(.{
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            false,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            true,
+            false,
+            true,
+            true,
+            true,
+            false,
+            false,
+            true,
+            false,
+            false,
+            false,
+            true,
+            true,
+            false,
+            true,
+            false,
+            true,
+        });
+
+        const vec = c_ret_vector_512_bool();
+        try expect(vec[0] == false);
+        try expect(vec[1] == true);
+        try expect(vec[2] == false);
+        try expect(vec[3] == false);
+        try expect(vec[4] == false);
+        try expect(vec[5] == true);
+        try expect(vec[6] == false);
+        try expect(vec[7] == false);
+        try expect(vec[8] == false);
+        try expect(vec[9] == true);
+        try expect(vec[10] == false);
+        try expect(vec[11] == false);
+        try expect(vec[12] == false);
+        try expect(vec[13] == true);
+        try expect(vec[14] == false);
+        try expect(vec[15] == true);
+        try expect(vec[16] == false);
+        try expect(vec[17] == false);
+        try expect(vec[18] == false);
+        try expect(vec[19] == false);
+        try expect(vec[20] == false);
+        try expect(vec[21] == false);
+        try expect(vec[22] == true);
+        try expect(vec[23] == true);
+        try expect(vec[24] == false);
+        try expect(vec[25] == false);
+        try expect(vec[26] == false);
+        try expect(vec[27] == false);
+        try expect(vec[28] == true);
+        try expect(vec[29] == true);
+        try expect(vec[30] == false);
+        try expect(vec[31] == true);
+        try expect(vec[32] == false);
+        try expect(vec[33] == true);
+        try expect(vec[34] == true);
+        try expect(vec[35] == true);
+        try expect(vec[36] == false);
+        try expect(vec[37] == false);
+        try expect(vec[38] == true);
+        try expect(vec[39] == true);
+        try expect(vec[40] == false);
+        try expect(vec[41] == false);
+        try expect(vec[42] == false);
+        try expect(vec[43] == false);
+        try expect(vec[44] == false);
+        try expect(vec[45] == true);
+        try expect(vec[46] == false);
+        try expect(vec[47] == true);
+        try expect(vec[48] == true);
+        try expect(vec[49] == false);
+        try expect(vec[50] == true);
+        try expect(vec[51] == true);
+        try expect(vec[52] == true);
+        try expect(vec[53] == true);
+        try expect(vec[54] == false);
+        try expect(vec[55] == false);
+        try expect(vec[56] == false);
+        try expect(vec[57] == true);
+        try expect(vec[58] == true);
+        try expect(vec[59] == false);
+        try expect(vec[60] == false);
+        try expect(vec[61] == false);
+        try expect(vec[62] == false);
+        try expect(vec[63] == true);
+        try expect(vec[64] == true);
+        try expect(vec[65] == true);
+        try expect(vec[66] == true);
+        try expect(vec[67] == true);
+        try expect(vec[68] == false);
+        try expect(vec[69] == false);
+        try expect(vec[70] == false);
+        try expect(vec[71] == false);
+        try expect(vec[72] == false);
+        try expect(vec[73] == true);
+        try expect(vec[74] == false);
+        try expect(vec[75] == true);
+        try expect(vec[76] == false);
+        try expect(vec[77] == false);
+        try expect(vec[78] == true);
+        try expect(vec[79] == true);
+        try expect(vec[80] == false);
+        try expect(vec[81] == false);
+        try expect(vec[82] == false);
+        try expect(vec[83] == true);
+        try expect(vec[84] == false);
+        try expect(vec[85] == true);
+        try expect(vec[86] == true);
+        try expect(vec[87] == true);
+        try expect(vec[88] == false);
+        try expect(vec[89] == true);
+        try expect(vec[90] == false);
+        try expect(vec[91] == false);
+        try expect(vec[92] == true);
+        try expect(vec[93] == true);
+        try expect(vec[94] == false);
+        try expect(vec[95] == true);
+        try expect(vec[96] == true);
+        try expect(vec[97] == false);
+        try expect(vec[98] == true);
+        try expect(vec[99] == false);
+        try expect(vec[100] == true);
+        try expect(vec[101] == true);
+        try expect(vec[102] == false);
+        try expect(vec[103] == true);
+        try expect(vec[104] == true);
+        try expect(vec[105] == false);
+        try expect(vec[106] == false);
+        try expect(vec[107] == false);
+        try expect(vec[108] == true);
+        try expect(vec[109] == false);
+        try expect(vec[110] == false);
+        try expect(vec[111] == false);
+        try expect(vec[112] == true);
+        try expect(vec[113] == true);
+        try expect(vec[114] == true);
+        try expect(vec[115] == false);
+        try expect(vec[116] == true);
+        try expect(vec[117] == false);
+        try expect(vec[118] == true);
+        try expect(vec[119] == false);
+        try expect(vec[120] == true);
+        try expect(vec[121] == true);
+        try expect(vec[122] == false);
+        try expect(vec[123] == true);
+        try expect(vec[124] == false);
+        try expect(vec[125] == true);
+        try expect(vec[126] == true);
+        try expect(vec[127] == true);
+        try expect(vec[128] == false);
+        try expect(vec[129] == true);
+        try expect(vec[130] == false);
+        try expect(vec[131] == false);
+        try expect(vec[132] == false);
+        try expect(vec[133] == false);
+        try expect(vec[134] == false);
+        try expect(vec[135] == false);
+        try expect(vec[136] == true);
+        try expect(vec[137] == false);
+        try expect(vec[138] == true);
+        try expect(vec[139] == false);
+        try expect(vec[140] == true);
+        try expect(vec[141] == true);
+        try expect(vec[142] == false);
+        try expect(vec[143] == true);
+        try expect(vec[144] == false);
+        try expect(vec[145] == false);
+        try expect(vec[146] == true);
+        try expect(vec[147] == false);
+        try expect(vec[148] == false);
+        try expect(vec[149] == true);
+        try expect(vec[150] == false);
+        try expect(vec[151] == true);
+        try expect(vec[152] == false);
+        try expect(vec[153] == true);
+        try expect(vec[154] == false);
+        try expect(vec[155] == false);
+        try expect(vec[156] == true);
+        try expect(vec[157] == false);
+        try expect(vec[158] == true);
+        try expect(vec[159] == true);
+        try expect(vec[160] == true);
+        try expect(vec[161] == false);
+        try expect(vec[162] == false);
+        try expect(vec[163] == true);
+        try expect(vec[164] == false);
+        try expect(vec[165] == false);
+        try expect(vec[166] == false);
+        try expect(vec[167] == true);
+        try expect(vec[168] == true);
+        try expect(vec[169] == true);
+        try expect(vec[170] == false);
+        try expect(vec[171] == true);
+        try expect(vec[172] == false);
+        try expect(vec[173] == false);
+        try expect(vec[174] == false);
+        try expect(vec[175] == false);
+        try expect(vec[176] == false);
+        try expect(vec[177] == true);
+        try expect(vec[178] == true);
+        try expect(vec[179] == false);
+        try expect(vec[180] == false);
+        try expect(vec[181] == true);
+        try expect(vec[182] == false);
+        try expect(vec[183] == false);
+        try expect(vec[184] == false);
+        try expect(vec[185] == false);
+        try expect(vec[186] == false);
+        try expect(vec[187] == true);
+        try expect(vec[188] == true);
+        try expect(vec[189] == false);
+        try expect(vec[190] == false);
+        try expect(vec[191] == false);
+        try expect(vec[192] == false);
+        try expect(vec[193] == false);
+        try expect(vec[194] == false);
+        try expect(vec[195] == true);
+        try expect(vec[196] == true);
+        try expect(vec[197] == false);
+        try expect(vec[198] == true);
+        try expect(vec[199] == true);
+        try expect(vec[200] == true);
+        try expect(vec[201] == true);
+        try expect(vec[202] == true);
+        try expect(vec[203] == true);
+        try expect(vec[204] == false);
+        try expect(vec[205] == false);
+        try expect(vec[206] == false);
+        try expect(vec[207] == false);
+        try expect(vec[208] == true);
+        try expect(vec[209] == false);
+        try expect(vec[210] == true);
+        try expect(vec[211] == true);
+        try expect(vec[212] == true);
+        try expect(vec[213] == true);
+        try expect(vec[214] == false);
+        try expect(vec[215] == false);
+        try expect(vec[216] == false);
+        try expect(vec[217] == true);
+        try expect(vec[218] == true);
+        try expect(vec[219] == false);
+        try expect(vec[220] == true);
+        try expect(vec[221] == true);
+        try expect(vec[222] == false);
+        try expect(vec[223] == false);
+        try expect(vec[224] == false);
+        try expect(vec[225] == true);
+        try expect(vec[226] == true);
+        try expect(vec[227] == true);
+        try expect(vec[228] == true);
+        try expect(vec[229] == false);
+        try expect(vec[230] == true);
+        try expect(vec[231] == false);
+        try expect(vec[232] == true);
+        try expect(vec[233] == true);
+        try expect(vec[234] == true);
+        try expect(vec[235] == true);
+        try expect(vec[236] == false);
+        try expect(vec[237] == true);
+        try expect(vec[238] == false);
+        try expect(vec[239] == true);
+        try expect(vec[240] == false);
+        try expect(vec[241] == true);
+        try expect(vec[242] == false);
+        try expect(vec[243] == false);
+        try expect(vec[244] == false);
+        try expect(vec[245] == true);
+        try expect(vec[246] == true);
+        try expect(vec[247] == false);
+        try expect(vec[248] == true);
+        try expect(vec[249] == false);
+        try expect(vec[250] == false);
+        try expect(vec[251] == false);
+        try expect(vec[252] == true);
+        try expect(vec[253] == true);
+        try expect(vec[254] == true);
+        try expect(vec[255] == true);
+        try expect(vec[256] == true);
+        try expect(vec[257] == false);
+        try expect(vec[258] == true);
+        try expect(vec[259] == true);
+        try expect(vec[260] == true);
+        try expect(vec[261] == true);
+        try expect(vec[262] == false);
+        try expect(vec[263] == true);
+        try expect(vec[264] == false);
+        try expect(vec[265] == false);
+        try expect(vec[266] == true);
+        try expect(vec[267] == false);
+        try expect(vec[268] == true);
+        try expect(vec[269] == false);
+        try expect(vec[270] == false);
+        try expect(vec[271] == true);
+        try expect(vec[272] == true);
+        try expect(vec[273] == false);
+        try expect(vec[274] == true);
+        try expect(vec[275] == false);
+        try expect(vec[276] == false);
+        try expect(vec[277] == true);
+        try expect(vec[278] == false);
+        try expect(vec[279] == false);
+        try expect(vec[280] == true);
+        try expect(vec[281] == true);
+        try expect(vec[282] == true);
+        try expect(vec[283] == false);
+        try expect(vec[284] == false);
+        try expect(vec[285] == true);
+        try expect(vec[286] == true);
+        try expect(vec[287] == true);
+        try expect(vec[288] == false);
+        try expect(vec[289] == false);
+        try expect(vec[290] == false);
+        try expect(vec[291] == false);
+        try expect(vec[292] == false);
+        try expect(vec[293] == false);
+        try expect(vec[294] == true);
+        try expect(vec[295] == false);
+        try expect(vec[296] == true);
+        try expect(vec[297] == false);
+        try expect(vec[298] == true);
+        try expect(vec[299] == true);
+        try expect(vec[300] == false);
+        try expect(vec[301] == false);
+        try expect(vec[302] == false);
+        try expect(vec[303] == false);
+        try expect(vec[304] == true);
+        try expect(vec[305] == true);
+        try expect(vec[306] == true);
+        try expect(vec[307] == true);
+        try expect(vec[308] == true);
+        try expect(vec[309] == false);
+        try expect(vec[310] == true);
+        try expect(vec[311] == true);
+        try expect(vec[312] == true);
+        try expect(vec[313] == true);
+        try expect(vec[314] == true);
+        try expect(vec[315] == false);
+        try expect(vec[316] == true);
+        try expect(vec[317] == true);
+        try expect(vec[318] == true);
+        try expect(vec[319] == false);
+        try expect(vec[320] == true);
+        try expect(vec[321] == false);
+        try expect(vec[322] == true);
+        try expect(vec[323] == true);
+        try expect(vec[324] == true);
+        try expect(vec[325] == false);
+        try expect(vec[326] == false);
+        try expect(vec[327] == true);
+        try expect(vec[328] == true);
+        try expect(vec[329] == true);
+        try expect(vec[330] == false);
+        try expect(vec[331] == false);
+        try expect(vec[332] == true);
+        try expect(vec[333] == true);
+        try expect(vec[334] == false);
+        try expect(vec[335] == true);
+        try expect(vec[336] == true);
+        try expect(vec[337] == true);
+        try expect(vec[338] == true);
+        try expect(vec[339] == true);
+        try expect(vec[340] == true);
+        try expect(vec[341] == false);
+        try expect(vec[342] == true);
+        try expect(vec[343] == false);
+        try expect(vec[344] == true);
+        try expect(vec[345] == false);
+        try expect(vec[346] == false);
+        try expect(vec[347] == false);
+        try expect(vec[348] == false);
+        try expect(vec[349] == true);
+        try expect(vec[350] == true);
+        try expect(vec[351] == true);
+        try expect(vec[352] == true);
+        try expect(vec[353] == false);
+        try expect(vec[354] == true);
+        try expect(vec[355] == false);
+        try expect(vec[356] == true);
+        try expect(vec[357] == true);
+        try expect(vec[358] == false);
+        try expect(vec[359] == true);
+        try expect(vec[360] == false);
+        try expect(vec[361] == false);
+        try expect(vec[362] == true);
+        try expect(vec[363] == false);
+        try expect(vec[364] == false);
+        try expect(vec[365] == false);
+        try expect(vec[366] == false);
+        try expect(vec[367] == false);
+        try expect(vec[368] == false);
+        try expect(vec[369] == false);
+        try expect(vec[370] == true);
+        try expect(vec[371] == false);
+        try expect(vec[372] == true);
+        try expect(vec[373] == true);
+        try expect(vec[374] == false);
+        try expect(vec[375] == false);
+        try expect(vec[376] == true);
+        try expect(vec[377] == false);
+        try expect(vec[378] == false);
+        try expect(vec[379] == true);
+        try expect(vec[380] == false);
+        try expect(vec[381] == false);
+        try expect(vec[382] == true);
+        try expect(vec[383] == false);
+        try expect(vec[384] == false);
+        try expect(vec[385] == false);
+        try expect(vec[386] == false);
+        try expect(vec[387] == true);
+        try expect(vec[388] == true);
+        try expect(vec[389] == true);
+        try expect(vec[390] == true);
+        try expect(vec[391] == true);
+        try expect(vec[392] == true);
+        try expect(vec[393] == true);
+        try expect(vec[394] == false);
+        try expect(vec[395] == true);
+        try expect(vec[396] == true);
+        try expect(vec[397] == false);
+        try expect(vec[398] == false);
+        try expect(vec[399] == false);
+        try expect(vec[400] == true);
+        try expect(vec[401] == false);
+        try expect(vec[402] == true);
+        try expect(vec[403] == true);
+        try expect(vec[404] == false);
+        try expect(vec[405] == true);
+        try expect(vec[406] == true);
+        try expect(vec[407] == true);
+        try expect(vec[408] == true);
+        try expect(vec[409] == false);
+        try expect(vec[410] == false);
+        try expect(vec[411] == false);
+        try expect(vec[412] == true);
+        try expect(vec[413] == true);
+        try expect(vec[414] == false);
+        try expect(vec[415] == true);
+        try expect(vec[416] == false);
+        try expect(vec[417] == true);
+        try expect(vec[418] == false);
+        try expect(vec[419] == false);
+        try expect(vec[420] == false);
+        try expect(vec[421] == false);
+        try expect(vec[422] == true);
+        try expect(vec[423] == true);
+        try expect(vec[424] == true);
+        try expect(vec[425] == false);
+        try expect(vec[426] == true);
+        try expect(vec[427] == false);
+        try expect(vec[428] == false);
+        try expect(vec[429] == false);
+        try expect(vec[430] == true);
+        try expect(vec[431] == true);
+        try expect(vec[432] == false);
+        try expect(vec[433] == true);
+        try expect(vec[434] == false);
+        try expect(vec[435] == false);
+        try expect(vec[436] == true);
+        try expect(vec[437] == true);
+        try expect(vec[438] == true);
+        try expect(vec[439] == true);
+        try expect(vec[440] == true);
+        try expect(vec[441] == true);
+        try expect(vec[442] == false);
+        try expect(vec[443] == false);
+        try expect(vec[444] == false);
+        try expect(vec[445] == true);
+        try expect(vec[446] == true);
+        try expect(vec[447] == true);
+        try expect(vec[448] == false);
+        try expect(vec[449] == false);
+        try expect(vec[450] == false);
+        try expect(vec[451] == false);
+        try expect(vec[452] == false);
+        try expect(vec[453] == false);
+        try expect(vec[454] == false);
+        try expect(vec[455] == false);
+        try expect(vec[456] == false);
+        try expect(vec[457] == false);
+        try expect(vec[458] == false);
+        try expect(vec[459] == true);
+        try expect(vec[460] == false);
+        try expect(vec[461] == false);
+        try expect(vec[462] == false);
+        try expect(vec[463] == true);
+        try expect(vec[464] == false);
+        try expect(vec[465] == false);
+        try expect(vec[466] == false);
+        try expect(vec[467] == false);
+        try expect(vec[468] == true);
+        try expect(vec[469] == true);
+        try expect(vec[470] == true);
+        try expect(vec[471] == true);
+        try expect(vec[472] == true);
+        try expect(vec[473] == false);
+        try expect(vec[474] == false);
+        try expect(vec[475] == true);
+        try expect(vec[476] == true);
+        try expect(vec[477] == true);
+        try expect(vec[478] == false);
+        try expect(vec[479] == true);
+        try expect(vec[480] == true);
+        try expect(vec[481] == true);
+        try expect(vec[482] == false);
+        try expect(vec[483] == true);
+        try expect(vec[484] == false);
+        try expect(vec[485] == true);
+        try expect(vec[486] == false);
+        try expect(vec[487] == true);
+        try expect(vec[488] == false);
+        try expect(vec[489] == true);
+        try expect(vec[490] == true);
+        try expect(vec[491] == true);
+        try expect(vec[492] == true);
+        try expect(vec[493] == false);
+        try expect(vec[494] == true);
+        try expect(vec[495] == true);
+        try expect(vec[496] == false);
+        try expect(vec[497] == true);
+        try expect(vec[498] == false);
+        try expect(vec[499] == false);
+        try expect(vec[500] == false);
+        try expect(vec[501] == false);
+        try expect(vec[502] == false);
+        try expect(vec[503] == false);
+        try expect(vec[504] == false);
+        try expect(vec[505] == false);
+        try expect(vec[506] == false);
+        try expect(vec[507] == true);
+        try expect(vec[508] == true);
+        try expect(vec[509] == false);
+        try expect(vec[510] == true);
+        try expect(vec[511] == false);
+    }
+}
+
+comptime {
+    skip: {
+        if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .wasm32) break :skip;
+        if (builtin.zig_backend == .stage2_llvm and builtin.cpu.arch == .x86_64) break :skip;
+
+        _ = struct {
+            export fn zig_vector_2_bool(vec: Vector2Bool) void {
+                expect(vec[0] == false) catch @panic("test failure");
+                expect(vec[1] == true) catch @panic("test failure");
+            }
+
+            export fn zig_vector_4_bool(vec: Vector4Bool) void {
+                expect(vec[0] == false) catch @panic("test failure");
+                expect(vec[1] == false) catch @panic("test failure");
+                expect(vec[2] == false) catch @panic("test failure");
+                expect(vec[3] == false) catch @panic("test failure");
+            }
+
+            export fn zig_vector_8_bool(vec: Vector8Bool) void {
+                expect(vec[0] == true) catch @panic("test failure");
+                expect(vec[1] == true) catch @panic("test failure");
+                expect(vec[2] == false) catch @panic("test failure");
+                expect(vec[3] == true) catch @panic("test failure");
+                expect(vec[4] == false) catch @panic("test failure");
+                expect(vec[5] == true) catch @panic("test failure");
+                expect(vec[6] == true) catch @panic("test failure");
+                expect(vec[7] == false) catch @panic("test failure");
+            }
+
+            export fn zig_vector_16_bool(vec: Vector16Bool) void {
+                expect(vec[0] == true) catch @panic("test failure");
+                expect(vec[1] == false) catch @panic("test failure");
+                expect(vec[2] == true) catch @panic("test failure");
+                expect(vec[3] == true) catch @panic("test failure");
+                expect(vec[4] == true) catch @panic("test failure");
+                expect(vec[5] == false) catch @panic("test failure");
+                expect(vec[6] == false) catch @panic("test failure");
+                expect(vec[7] == false) catch @panic("test failure");
+                expect(vec[8] == true) catch @panic("test failure");
+                expect(vec[9] == true) catch @panic("test failure");
+                expect(vec[10] == true) catch @panic("test failure");
+                expect(vec[11] == true) catch @panic("test failure");
+                expect(vec[12] == false) catch @panic("test failure");
+                expect(vec[13] == false) catch @panic("test failure");
+                expect(vec[14] == false) catch @panic("test failure");
+                expect(vec[15] == true) catch @panic("test failure");
+            }
+
+            export fn zig_vector_32_bool(vec: Vector32Bool) void {
+                expect(vec[0] == false) catch @panic("test failure");
+                expect(vec[1] == false) catch @panic("test failure");
+                expect(vec[2] == false) catch @panic("test failure");
+                expect(vec[3] == true) catch @panic("test failure");
+                expect(vec[4] == true) catch @panic("test failure");
+                expect(vec[5] == false) catch @panic("test failure");
+                expect(vec[6] == false) catch @panic("test failure");
+                expect(vec[7] == true) catch @panic("test failure");
+                expect(vec[8] == false) catch @panic("test failure");
+                expect(vec[9] == true) catch @panic("test failure");
+                expect(vec[10] == true) catch @panic("test failure");
+                expect(vec[11] == true) catch @panic("test failure");
+                expect(vec[12] == false) catch @panic("test failure");
+                expect(vec[13] == false) catch @panic("test failure");
+                expect(vec[14] == true) catch @panic("test failure");
+                expect(vec[15] == true) catch @panic("test failure");
+                expect(vec[16] == true) catch @panic("test failure");
+                expect(vec[17] == true) catch @panic("test failure");
+                expect(vec[18] == true) catch @panic("test failure");
+                expect(vec[19] == false) catch @panic("test failure");
+                expect(vec[20] == true) catch @panic("test failure");
+                expect(vec[21] == true) catch @panic("test failure");
+                expect(vec[22] == true) catch @panic("test failure");
+                expect(vec[23] == false) catch @panic("test failure");
+                expect(vec[24] == false) catch @panic("test failure");
+                expect(vec[25] == true) catch @panic("test failure");
+                expect(vec[26] == true) catch @panic("test failure");
+                expect(vec[27] == false) catch @panic("test failure");
+                expect(vec[28] == true) catch @panic("test failure");
+                expect(vec[29] == true) catch @panic("test failure");
+                expect(vec[30] == false) catch @panic("test failure");
+                expect(vec[31] == true) catch @panic("test failure");
+            }
+
+            export fn zig_vector_64_bool(vec: Vector64Bool) void {
+                expect(vec[0] == true) catch @panic("test failure");
+                expect(vec[1] == true) catch @panic("test failure");
+                expect(vec[2] == false) catch @panic("test failure");
+                expect(vec[3] == true) catch @panic("test failure");
+                expect(vec[4] == false) catch @panic("test failure");
+                expect(vec[5] == true) catch @panic("test failure");
+                expect(vec[6] == false) catch @panic("test failure");
+                expect(vec[7] == false) catch @panic("test failure");
+                expect(vec[8] == true) catch @panic("test failure");
+                expect(vec[9] == true) catch @panic("test failure");
+                expect(vec[10] == true) catch @panic("test failure");
+                expect(vec[11] == true) catch @panic("test failure");
+                expect(vec[12] == true) catch @panic("test failure");
+                expect(vec[13] == true) catch @panic("test failure");
+                expect(vec[14] == true) catch @panic("test failure");
+                expect(vec[15] == false) catch @panic("test failure");
+                expect(vec[16] == false) catch @panic("test failure");
+                expect(vec[17] == true) catch @panic("test failure");
+                expect(vec[18] == true) catch @panic("test failure");
+                expect(vec[19] == false) catch @panic("test failure");
+                expect(vec[20] == true) catch @panic("test failure");
+                expect(vec[21] == true) catch @panic("test failure");
+                expect(vec[22] == true) catch @panic("test failure");
+                expect(vec[23] == true) catch @panic("test failure");
+                expect(vec[24] == false) catch @panic("test failure");
+                expect(vec[25] == false) catch @panic("test failure");
+                expect(vec[26] == true) catch @panic("test failure");
+                expect(vec[27] == false) catch @panic("test failure");
+                expect(vec[28] == false) catch @panic("test failure");
+                expect(vec[29] == true) catch @panic("test failure");
+                expect(vec[30] == false) catch @panic("test failure");
+                expect(vec[31] == true) catch @panic("test failure");
+                expect(vec[32] == false) catch @panic("test failure");
+                expect(vec[33] == true) catch @panic("test failure");
+                expect(vec[34] == true) catch @panic("test failure");
+                expect(vec[35] == false) catch @panic("test failure");
+                expect(vec[36] == true) catch @panic("test failure");
+                expect(vec[37] == true) catch @panic("test failure");
+                expect(vec[38] == false) catch @panic("test failure");
+                expect(vec[39] == false) catch @panic("test failure");
+                expect(vec[40] == true) catch @panic("test failure");
+                expect(vec[41] == true) catch @panic("test failure");
+                expect(vec[42] == true) catch @panic("test failure");
+                expect(vec[43] == true) catch @panic("test failure");
+                expect(vec[44] == true) catch @panic("test failure");
+                expect(vec[45] == false) catch @panic("test failure");
+                expect(vec[46] == true) catch @panic("test failure");
+                expect(vec[47] == false) catch @panic("test failure");
+                expect(vec[48] == false) catch @panic("test failure");
+                expect(vec[49] == false) catch @panic("test failure");
+                expect(vec[50] == false) catch @panic("test failure");
+                expect(vec[51] == false) catch @panic("test failure");
+                expect(vec[52] == true) catch @panic("test failure");
+                expect(vec[53] == false) catch @panic("test failure");
+                expect(vec[54] == false) catch @panic("test failure");
+                expect(vec[55] == true) catch @panic("test failure");
+                expect(vec[56] == true) catch @panic("test failure");
+                expect(vec[57] == false) catch @panic("test failure");
+                expect(vec[58] == false) catch @panic("test failure");
+                expect(vec[59] == false) catch @panic("test failure");
+                expect(vec[60] == true) catch @panic("test failure");
+                expect(vec[61] == true) catch @panic("test failure");
+                expect(vec[62] == true) catch @panic("test failure");
+                expect(vec[63] == true) catch @panic("test failure");
+            }
+
+            export fn zig_vector_128_bool(vec: Vector128Bool) void {
+                expect(vec[0] == true) catch @panic("test failure");
+                expect(vec[1] == true) catch @panic("test failure");
+                expect(vec[2] == false) catch @panic("test failure");
+                expect(vec[3] == true) catch @panic("test failure");
+                expect(vec[4] == true) catch @panic("test failure");
+                expect(vec[5] == false) catch @panic("test failure");
+                expect(vec[6] == false) catch @panic("test failure");
+                expect(vec[7] == true) catch @panic("test failure");
+                expect(vec[8] == true) catch @panic("test failure");
+                expect(vec[9] == true) catch @panic("test failure");
+                expect(vec[10] == true) catch @panic("test failure");
+                expect(vec[11] == true) catch @panic("test failure");
+                expect(vec[12] == false) catch @panic("test failure");
+                expect(vec[13] == false) catch @panic("test failure");
+                expect(vec[14] == false) catch @panic("test failure");
+                expect(vec[15] == true) catch @panic("test failure");
+                expect(vec[16] == false) catch @panic("test failure");
+                expect(vec[17] == true) catch @panic("test failure");
+                expect(vec[18] == false) catch @panic("test failure");
+                expect(vec[19] == false) catch @panic("test failure");
+                expect(vec[20] == true) catch @panic("test failure");
+                expect(vec[21] == false) catch @panic("test failure");
+                expect(vec[22] == true) catch @panic("test failure");
+                expect(vec[23] == false) catch @panic("test failure");
+                expect(vec[24] == false) catch @panic("test failure");
+                expect(vec[25] == false) catch @panic("test failure");
+                expect(vec[26] == true) catch @panic("test failure");
+                expect(vec[27] == false) catch @panic("test failure");
+                expect(vec[28] == true) catch @panic("test failure");
+                expect(vec[29] == true) catch @panic("test failure");
+                expect(vec[30] == false) catch @panic("test failure");
+                expect(vec[31] == true) catch @panic("test failure");
+                expect(vec[32] == false) catch @panic("test failure");
+                expect(vec[33] == true) catch @panic("test failure");
+                expect(vec[34] == true) catch @panic("test failure");
+                expect(vec[35] == false) catch @panic("test failure");
+                expect(vec[36] == false) catch @panic("test failure");
+                expect(vec[37] == false) catch @panic("test failure");
+                expect(vec[38] == false) catch @panic("test failure");
+                expect(vec[39] == true) catch @panic("test failure");
+                expect(vec[40] == true) catch @panic("test failure");
+                expect(vec[41] == false) catch @panic("test failure");
+                expect(vec[42] == true) catch @panic("test failure");
+                expect(vec[43] == false) catch @panic("test failure");
+                expect(vec[44] == false) catch @panic("test failure");
+                expect(vec[45] == true) catch @panic("test failure");
+                expect(vec[46] == false) catch @panic("test failure");
+                expect(vec[47] == false) catch @panic("test failure");
+                expect(vec[48] == true) catch @panic("test failure");
+                expect(vec[49] == true) catch @panic("test failure");
+                expect(vec[50] == false) catch @panic("test failure");
+                expect(vec[51] == false) catch @panic("test failure");
+                expect(vec[52] == true) catch @panic("test failure");
+                expect(vec[53] == false) catch @panic("test failure");
+                expect(vec[54] == false) catch @panic("test failure");
+                expect(vec[55] == true) catch @panic("test failure");
+                expect(vec[56] == true) catch @panic("test failure");
+                expect(vec[57] == true) catch @panic("test failure");
+                expect(vec[58] == true) catch @panic("test failure");
+                expect(vec[59] == true) catch @panic("test failure");
+                expect(vec[60] == true) catch @panic("test failure");
+                expect(vec[61] == true) catch @panic("test failure");
+                expect(vec[62] == true) catch @panic("test failure");
+                expect(vec[63] == false) catch @panic("test failure");
+                expect(vec[64] == false) catch @panic("test failure");
+                expect(vec[65] == true) catch @panic("test failure");
+                expect(vec[66] == false) catch @panic("test failure");
+                expect(vec[67] == true) catch @panic("test failure");
+                expect(vec[68] == true) catch @panic("test failure");
+                expect(vec[69] == true) catch @panic("test failure");
+                expect(vec[70] == true) catch @panic("test failure");
+                expect(vec[71] == false) catch @panic("test failure");
+                expect(vec[72] == false) catch @panic("test failure");
+                expect(vec[73] == false) catch @panic("test failure");
+                expect(vec[74] == true) catch @panic("test failure");
+                expect(vec[75] == true) catch @panic("test failure");
+                expect(vec[76] == false) catch @panic("test failure");
+                expect(vec[77] == true) catch @panic("test failure");
+                expect(vec[78] == true) catch @panic("test failure");
+                expect(vec[79] == true) catch @panic("test failure");
+                expect(vec[80] == true) catch @panic("test failure");
+                expect(vec[81] == false) catch @panic("test failure");
+                expect(vec[82] == true) catch @panic("test failure");
+                expect(vec[83] == true) catch @panic("test failure");
+                expect(vec[84] == true) catch @panic("test failure");
+                expect(vec[85] == true) catch @panic("test failure");
+                expect(vec[86] == true) catch @panic("test failure");
+                expect(vec[87] == true) catch @panic("test failure");
+                expect(vec[88] == false) catch @panic("test failure");
+                expect(vec[89] == true) catch @panic("test failure");
+                expect(vec[90] == true) catch @panic("test failure");
+                expect(vec[91] == true) catch @panic("test failure");
+                expect(vec[92] == true) catch @panic("test failure");
+                expect(vec[93] == true) catch @panic("test failure");
+                expect(vec[94] == true) catch @panic("test failure");
+                expect(vec[95] == false) catch @panic("test failure");
+                expect(vec[96] == false) catch @panic("test failure");
+                expect(vec[97] == false) catch @panic("test failure");
+                expect(vec[98] == true) catch @panic("test failure");
+                expect(vec[99] == true) catch @panic("test failure");
+                expect(vec[100] == true) catch @panic("test failure");
+                expect(vec[101] == true) catch @panic("test failure");
+                expect(vec[102] == true) catch @panic("test failure");
+                expect(vec[103] == true) catch @panic("test failure");
+                expect(vec[104] == true) catch @panic("test failure");
+                expect(vec[105] == false) catch @panic("test failure");
+                expect(vec[106] == false) catch @panic("test failure");
+                expect(vec[107] == false) catch @panic("test failure");
+                expect(vec[108] == false) catch @panic("test failure");
+                expect(vec[109] == false) catch @panic("test failure");
+                expect(vec[110] == true) catch @panic("test failure");
+                expect(vec[111] == true) catch @panic("test failure");
+                expect(vec[112] == true) catch @panic("test failure");
+                expect(vec[113] == false) catch @panic("test failure");
+                expect(vec[114] == false) catch @panic("test failure");
+                expect(vec[115] == false) catch @panic("test failure");
+                expect(vec[116] == false) catch @panic("test failure");
+                expect(vec[117] == false) catch @panic("test failure");
+                expect(vec[118] == true) catch @panic("test failure");
+                expect(vec[119] == false) catch @panic("test failure");
+                expect(vec[120] == false) catch @panic("test failure");
+                expect(vec[121] == false) catch @panic("test failure");
+                expect(vec[122] == false) catch @panic("test failure");
+                expect(vec[123] == true) catch @panic("test failure");
+                expect(vec[124] == true) catch @panic("test failure");
+                expect(vec[125] == false) catch @panic("test failure");
+                expect(vec[126] == true) catch @panic("test failure");
+                expect(vec[127] == false) catch @panic("test failure");
+            }
+
+            export fn zig_vector_256_bool(vec: Vector256Bool) void {
+                expect(vec[0] == false) catch @panic("test failure");
+                expect(vec[1] == false) catch @panic("test failure");
+                expect(vec[2] == false) catch @panic("test failure");
+                expect(vec[3] == false) catch @panic("test failure");
+                expect(vec[4] == true) catch @panic("test failure");
+                expect(vec[5] == true) catch @panic("test failure");
+                expect(vec[6] == false) catch @panic("test failure");
+                expect(vec[7] == false) catch @panic("test failure");
+                expect(vec[8] == false) catch @panic("test failure");
+                expect(vec[9] == true) catch @panic("test failure");
+                expect(vec[10] == true) catch @panic("test failure");
+                expect(vec[11] == false) catch @panic("test failure");
+                expect(vec[12] == true) catch @panic("test failure");
+                expect(vec[13] == false) catch @panic("test failure");
+                expect(vec[14] == false) catch @panic("test failure");
+                expect(vec[15] == false) catch @panic("test failure");
+                expect(vec[16] == false) catch @panic("test failure");
+                expect(vec[17] == true) catch @panic("test failure");
+                expect(vec[18] == true) catch @panic("test failure");
+                expect(vec[19] == true) catch @panic("test failure");
+                expect(vec[20] == false) catch @panic("test failure");
+                expect(vec[21] == true) catch @panic("test failure");
+                expect(vec[22] == true) catch @panic("test failure");
+                expect(vec[23] == false) catch @panic("test failure");
+                expect(vec[24] == true) catch @panic("test failure");
+                expect(vec[25] == false) catch @panic("test failure");
+                expect(vec[26] == false) catch @panic("test failure");
+                expect(vec[27] == true) catch @panic("test failure");
+                expect(vec[28] == true) catch @panic("test failure");
+                expect(vec[29] == true) catch @panic("test failure");
+                expect(vec[30] == false) catch @panic("test failure");
+                expect(vec[31] == true) catch @panic("test failure");
+                expect(vec[32] == false) catch @panic("test failure");
+                expect(vec[33] == true) catch @panic("test failure");
+                expect(vec[34] == false) catch @panic("test failure");
+                expect(vec[35] == false) catch @panic("test failure");
+                expect(vec[36] == false) catch @panic("test failure");
+                expect(vec[37] == true) catch @panic("test failure");
+                expect(vec[38] == false) catch @panic("test failure");
+                expect(vec[39] == false) catch @panic("test failure");
+                expect(vec[40] == true) catch @panic("test failure");
+                expect(vec[41] == true) catch @panic("test failure");
+                expect(vec[42] == false) catch @panic("test failure");
+                expect(vec[43] == true) catch @panic("test failure");
+                expect(vec[44] == true) catch @panic("test failure");
+                expect(vec[45] == false) catch @panic("test failure");
+                expect(vec[46] == true) catch @panic("test failure");
+                expect(vec[47] == false) catch @panic("test failure");
+                expect(vec[48] == true) catch @panic("test failure");
+                expect(vec[49] == false) catch @panic("test failure");
+                expect(vec[50] == true) catch @panic("test failure");
+                expect(vec[51] == false) catch @panic("test failure");
+                expect(vec[52] == true) catch @panic("test failure");
+                expect(vec[53] == true) catch @panic("test failure");
+                expect(vec[54] == true) catch @panic("test failure");
+                expect(vec[55] == false) catch @panic("test failure");
+                expect(vec[56] == false) catch @panic("test failure");
+                expect(vec[57] == true) catch @panic("test failure");
+                expect(vec[58] == true) catch @panic("test failure");
+                expect(vec[59] == false) catch @panic("test failure");
+                expect(vec[60] == false) catch @panic("test failure");
+                expect(vec[61] == true) catch @panic("test failure");
+                expect(vec[62] == true) catch @panic("test failure");
+                expect(vec[63] == false) catch @panic("test failure");
+                expect(vec[64] == false) catch @panic("test failure");
+                expect(vec[65] == false) catch @panic("test failure");
+                expect(vec[66] == true) catch @panic("test failure");
+                expect(vec[67] == true) catch @panic("test failure");
+                expect(vec[68] == false) catch @panic("test failure");
+                expect(vec[69] == true) catch @panic("test failure");
+                expect(vec[70] == false) catch @panic("test failure");
+                expect(vec[71] == true) catch @panic("test failure");
+                expect(vec[72] == false) catch @panic("test failure");
+                expect(vec[73] == true) catch @panic("test failure");
+                expect(vec[74] == false) catch @panic("test failure");
+                expect(vec[75] == false) catch @panic("test failure");
+                expect(vec[76] == true) catch @panic("test failure");
+                expect(vec[77] == false) catch @panic("test failure");
+                expect(vec[78] == false) catch @panic("test failure");
+                expect(vec[79] == false) catch @panic("test failure");
+                expect(vec[80] == false) catch @panic("test failure");
+                expect(vec[81] == false) catch @panic("test failure");
+                expect(vec[82] == true) catch @panic("test failure");
+                expect(vec[83] == false) catch @panic("test failure");
+                expect(vec[84] == false) catch @panic("test failure");
+                expect(vec[85] == false) catch @panic("test failure");
+                expect(vec[86] == true) catch @panic("test failure");
+                expect(vec[87] == true) catch @panic("test failure");
+                expect(vec[88] == true) catch @panic("test failure");
+                expect(vec[89] == false) catch @panic("test failure");
+                expect(vec[90] == true) catch @panic("test failure");
+                expect(vec[91] == false) catch @panic("test failure");
+                expect(vec[92] == true) catch @panic("test failure");
+                expect(vec[93] == false) catch @panic("test failure");
+                expect(vec[94] == true) catch @panic("test failure");
+                expect(vec[95] == true) catch @panic("test failure");
+                expect(vec[96] == true) catch @panic("test failure");
+                expect(vec[97] == true) catch @panic("test failure");
+                expect(vec[98] == false) catch @panic("test failure");
+                expect(vec[99] == true) catch @panic("test failure");
+                expect(vec[100] == false) catch @panic("test failure");
+                expect(vec[101] == true) catch @panic("test failure");
+                expect(vec[102] == true) catch @panic("test failure");
+                expect(vec[103] == false) catch @panic("test failure");
+                expect(vec[104] == false) catch @panic("test failure");
+                expect(vec[105] == true) catch @panic("test failure");
+                expect(vec[106] == false) catch @panic("test failure");
+                expect(vec[107] == true) catch @panic("test failure");
+                expect(vec[108] == false) catch @panic("test failure");
+                expect(vec[109] == false) catch @panic("test failure");
+                expect(vec[110] == false) catch @panic("test failure");
+                expect(vec[111] == false) catch @panic("test failure");
+                expect(vec[112] == false) catch @panic("test failure");
+                expect(vec[113] == false) catch @panic("test failure");
+                expect(vec[114] == false) catch @panic("test failure");
+                expect(vec[115] == false) catch @panic("test failure");
+                expect(vec[116] == false) catch @panic("test failure");
+                expect(vec[117] == false) catch @panic("test failure");
+                expect(vec[118] == false) catch @panic("test failure");
+                expect(vec[119] == false) catch @panic("test failure");
+                expect(vec[120] == false) catch @panic("test failure");
+                expect(vec[121] == false) catch @panic("test failure");
+                expect(vec[122] == true) catch @panic("test failure");
+                expect(vec[123] == true) catch @panic("test failure");
+                expect(vec[124] == false) catch @panic("test failure");
+                expect(vec[125] == false) catch @panic("test failure");
+                expect(vec[126] == false) catch @panic("test failure");
+                expect(vec[127] == true) catch @panic("test failure");
+                expect(vec[128] == true) catch @panic("test failure");
+                expect(vec[129] == true) catch @panic("test failure");
+                expect(vec[130] == true) catch @panic("test failure");
+                expect(vec[131] == false) catch @panic("test failure");
+                expect(vec[132] == false) catch @panic("test failure");
+                expect(vec[133] == false) catch @panic("test failure");
+                expect(vec[134] == true) catch @panic("test failure");
+                expect(vec[135] == true) catch @panic("test failure");
+                expect(vec[136] == false) catch @panic("test failure");
+                expect(vec[137] == false) catch @panic("test failure");
+                expect(vec[138] == true) catch @panic("test failure");
+                expect(vec[139] == true) catch @panic("test failure");
+                expect(vec[140] == true) catch @panic("test failure");
+                expect(vec[141] == true) catch @panic("test failure");
+                expect(vec[142] == true) catch @panic("test failure");
+                expect(vec[143] == false) catch @panic("test failure");
+                expect(vec[144] == true) catch @panic("test failure");
+                expect(vec[145] == true) catch @panic("test failure");
+                expect(vec[146] == true) catch @panic("test failure");
+                expect(vec[147] == false) catch @panic("test failure");
+                expect(vec[148] == false) catch @panic("test failure");
+                expect(vec[149] == false) catch @panic("test failure");
+                expect(vec[150] == false) catch @panic("test failure");
+                expect(vec[151] == false) catch @panic("test failure");
+                expect(vec[152] == false) catch @panic("test failure");
+                expect(vec[153] == false) catch @panic("test failure");
+                expect(vec[154] == true) catch @panic("test failure");
+                expect(vec[155] == false) catch @panic("test failure");
+                expect(vec[156] == false) catch @panic("test failure");
+                expect(vec[157] == false) catch @panic("test failure");
+                expect(vec[158] == true) catch @panic("test failure");
+                expect(vec[159] == true) catch @panic("test failure");
+                expect(vec[160] == false) catch @panic("test failure");
+                expect(vec[161] == true) catch @panic("test failure");
+                expect(vec[162] == false) catch @panic("test failure");
+                expect(vec[163] == false) catch @panic("test failure");
+                expect(vec[164] == false) catch @panic("test failure");
+                expect(vec[165] == true) catch @panic("test failure");
+                expect(vec[166] == false) catch @panic("test failure");
+                expect(vec[167] == true) catch @panic("test failure");
+                expect(vec[168] == false) catch @panic("test failure");
+                expect(vec[169] == false) catch @panic("test failure");
+                expect(vec[170] == false) catch @panic("test failure");
+                expect(vec[171] == false) catch @panic("test failure");
+                expect(vec[172] == true) catch @panic("test failure");
+                expect(vec[173] == true) catch @panic("test failure");
+                expect(vec[174] == true) catch @panic("test failure");
+                expect(vec[175] == true) catch @panic("test failure");
+                expect(vec[176] == true) catch @panic("test failure");
+                expect(vec[177] == true) catch @panic("test failure");
+                expect(vec[178] == false) catch @panic("test failure");
+                expect(vec[179] == true) catch @panic("test failure");
+                expect(vec[180] == true) catch @panic("test failure");
+                expect(vec[181] == false) catch @panic("test failure");
+                expect(vec[182] == true) catch @panic("test failure");
+                expect(vec[183] == false) catch @panic("test failure");
+                expect(vec[184] == true) catch @panic("test failure");
+                expect(vec[185] == false) catch @panic("test failure");
+                expect(vec[186] == true) catch @panic("test failure");
+                expect(vec[187] == false) catch @panic("test failure");
+                expect(vec[188] == true) catch @panic("test failure");
+                expect(vec[189] == false) catch @panic("test failure");
+                expect(vec[190] == false) catch @panic("test failure");
+                expect(vec[191] == false) catch @panic("test failure");
+                expect(vec[192] == false) catch @panic("test failure");
+                expect(vec[193] == true) catch @panic("test failure");
+                expect(vec[194] == true) catch @panic("test failure");
+                expect(vec[195] == true) catch @panic("test failure");
+                expect(vec[196] == false) catch @panic("test failure");
+                expect(vec[197] == false) catch @panic("test failure");
+                expect(vec[198] == true) catch @panic("test failure");
+                expect(vec[199] == false) catch @panic("test failure");
+                expect(vec[200] == false) catch @panic("test failure");
+                expect(vec[201] == true) catch @panic("test failure");
+                expect(vec[202] == true) catch @panic("test failure");
+                expect(vec[203] == false) catch @panic("test failure");
+                expect(vec[204] == true) catch @panic("test failure");
+                expect(vec[205] == false) catch @panic("test failure");
+                expect(vec[206] == true) catch @panic("test failure");
+                expect(vec[207] == false) catch @panic("test failure");
+                expect(vec[208] == false) catch @panic("test failure");
+                expect(vec[209] == false) catch @panic("test failure");
+                expect(vec[210] == true) catch @panic("test failure");
+                expect(vec[211] == true) catch @panic("test failure");
+                expect(vec[212] == false) catch @panic("test failure");
+                expect(vec[213] == false) catch @panic("test failure");
+                expect(vec[214] == false) catch @panic("test failure");
+                expect(vec[215] == true) catch @panic("test failure");
+                expect(vec[216] == false) catch @panic("test failure");
+                expect(vec[217] == true) catch @panic("test failure");
+                expect(vec[218] == true) catch @panic("test failure");
+                expect(vec[219] == true) catch @panic("test failure");
+                expect(vec[220] == false) catch @panic("test failure");
+                expect(vec[221] == true) catch @panic("test failure");
+                expect(vec[222] == false) catch @panic("test failure");
+                expect(vec[223] == true) catch @panic("test failure");
+                expect(vec[224] == false) catch @panic("test failure");
+                expect(vec[225] == false) catch @panic("test failure");
+                expect(vec[226] == false) catch @panic("test failure");
+                expect(vec[227] == true) catch @panic("test failure");
+                expect(vec[228] == true) catch @panic("test failure");
+                expect(vec[229] == false) catch @panic("test failure");
+                expect(vec[230] == false) catch @panic("test failure");
+                expect(vec[231] == false) catch @panic("test failure");
+                expect(vec[232] == false) catch @panic("test failure");
+                expect(vec[233] == false) catch @panic("test failure");
+                expect(vec[234] == true) catch @panic("test failure");
+                expect(vec[235] == false) catch @panic("test failure");
+                expect(vec[236] == false) catch @panic("test failure");
+                expect(vec[237] == false) catch @panic("test failure");
+                expect(vec[238] == true) catch @panic("test failure");
+                expect(vec[239] == false) catch @panic("test failure");
+                expect(vec[240] == true) catch @panic("test failure");
+                expect(vec[241] == true) catch @panic("test failure");
+                expect(vec[242] == true) catch @panic("test failure");
+                expect(vec[243] == false) catch @panic("test failure");
+                expect(vec[244] == false) catch @panic("test failure");
+                expect(vec[245] == true) catch @panic("test failure");
+                expect(vec[246] == false) catch @panic("test failure");
+                expect(vec[247] == false) catch @panic("test failure");
+                expect(vec[248] == false) catch @panic("test failure");
+                expect(vec[249] == true) catch @panic("test failure");
+                expect(vec[250] == false) catch @panic("test failure");
+                expect(vec[251] == false) catch @panic("test failure");
+                expect(vec[252] == true) catch @panic("test failure");
+                expect(vec[253] == true) catch @panic("test failure");
+                expect(vec[254] == true) catch @panic("test failure");
+                expect(vec[255] == true) catch @panic("test failure");
+            }
+
+            export fn zig_vector_512_bool(vec: Vector512Bool) void {
+                expect(vec[0] == false) catch @panic("test failure");
+                expect(vec[1] == true) catch @panic("test failure");
+                expect(vec[2] == true) catch @panic("test failure");
+                expect(vec[3] == false) catch @panic("test failure");
+                expect(vec[4] == true) catch @panic("test failure");
+                expect(vec[5] == false) catch @panic("test failure");
+                expect(vec[6] == true) catch @panic("test failure");
+                expect(vec[7] == false) catch @panic("test failure");
+                expect(vec[8] == false) catch @panic("test failure");
+                expect(vec[9] == false) catch @panic("test failure");
+                expect(vec[10] == false) catch @panic("test failure");
+                expect(vec[11] == false) catch @panic("test failure");
+                expect(vec[12] == true) catch @panic("test failure");
+                expect(vec[13] == false) catch @panic("test failure");
+                expect(vec[14] == true) catch @panic("test failure");
+                expect(vec[15] == false) catch @panic("test failure");
+                expect(vec[16] == false) catch @panic("test failure");
+                expect(vec[17] == false) catch @panic("test failure");
+                expect(vec[18] == true) catch @panic("test failure");
+                expect(vec[19] == true) catch @panic("test failure");
+                expect(vec[20] == true) catch @panic("test failure");
+                expect(vec[21] == true) catch @panic("test failure");
+                expect(vec[22] == false) catch @panic("test failure");
+                expect(vec[23] == false) catch @panic("test failure");
+                expect(vec[24] == false) catch @panic("test failure");
+                expect(vec[25] == true) catch @panic("test failure");
+                expect(vec[26] == true) catch @panic("test failure");
+                expect(vec[27] == false) catch @panic("test failure");
+                expect(vec[28] == true) catch @panic("test failure");
+                expect(vec[29] == true) catch @panic("test failure");
+                expect(vec[30] == false) catch @panic("test failure");
+                expect(vec[31] == false) catch @panic("test failure");
+                expect(vec[32] == true) catch @panic("test failure");
+                expect(vec[33] == true) catch @panic("test failure");
+                expect(vec[34] == false) catch @panic("test failure");
+                expect(vec[35] == false) catch @panic("test failure");
+                expect(vec[36] == false) catch @panic("test failure");
+                expect(vec[37] == false) catch @panic("test failure");
+                expect(vec[38] == false) catch @panic("test failure");
+                expect(vec[39] == false) catch @panic("test failure");
+                expect(vec[40] == false) catch @panic("test failure");
+                expect(vec[41] == true) catch @panic("test failure");
+                expect(vec[42] == true) catch @panic("test failure");
+                expect(vec[43] == true) catch @panic("test failure");
+                expect(vec[44] == false) catch @panic("test failure");
+                expect(vec[45] == true) catch @panic("test failure");
+                expect(vec[46] == true) catch @panic("test failure");
+                expect(vec[47] == true) catch @panic("test failure");
+                expect(vec[48] == true) catch @panic("test failure");
+                expect(vec[49] == true) catch @panic("test failure");
+                expect(vec[50] == false) catch @panic("test failure");
+                expect(vec[51] == true) catch @panic("test failure");
+                expect(vec[52] == true) catch @panic("test failure");
+                expect(vec[53] == true) catch @panic("test failure");
+                expect(vec[54] == false) catch @panic("test failure");
+                expect(vec[55] == true) catch @panic("test failure");
+                expect(vec[56] == false) catch @panic("test failure");
+                expect(vec[57] == false) catch @panic("test failure");
+                expect(vec[58] == true) catch @panic("test failure");
+                expect(vec[59] == false) catch @panic("test failure");
+                expect(vec[60] == true) catch @panic("test failure");
+                expect(vec[61] == true) catch @panic("test failure");
+                expect(vec[62] == false) catch @panic("test failure");
+                expect(vec[63] == false) catch @panic("test failure");
+                expect(vec[64] == false) catch @panic("test failure");
+                expect(vec[65] == true) catch @panic("test failure");
+                expect(vec[66] == true) catch @panic("test failure");
+                expect(vec[67] == true) catch @panic("test failure");
+                expect(vec[68] == true) catch @panic("test failure");
+                expect(vec[69] == false) catch @panic("test failure");
+                expect(vec[70] == false) catch @panic("test failure");
+                expect(vec[71] == true) catch @panic("test failure");
+                expect(vec[72] == true) catch @panic("test failure");
+                expect(vec[73] == false) catch @panic("test failure");
+                expect(vec[74] == true) catch @panic("test failure");
+                expect(vec[75] == true) catch @panic("test failure");
+                expect(vec[76] == false) catch @panic("test failure");
+                expect(vec[77] == false) catch @panic("test failure");
+                expect(vec[78] == true) catch @panic("test failure");
+                expect(vec[79] == false) catch @panic("test failure");
+                expect(vec[80] == false) catch @panic("test failure");
+                expect(vec[81] == false) catch @panic("test failure");
+                expect(vec[82] == true) catch @panic("test failure");
+                expect(vec[83] == true) catch @panic("test failure");
+                expect(vec[84] == true) catch @panic("test failure");
+                expect(vec[85] == false) catch @panic("test failure");
+                expect(vec[86] == false) catch @panic("test failure");
+                expect(vec[87] == true) catch @panic("test failure");
+                expect(vec[88] == false) catch @panic("test failure");
+                expect(vec[89] == true) catch @panic("test failure");
+                expect(vec[90] == false) catch @panic("test failure");
+                expect(vec[91] == false) catch @panic("test failure");
+                expect(vec[92] == true) catch @panic("test failure");
+                expect(vec[93] == false) catch @panic("test failure");
+                expect(vec[94] == false) catch @panic("test failure");
+                expect(vec[95] == true) catch @panic("test failure");
+                expect(vec[96] == true) catch @panic("test failure");
+                expect(vec[97] == false) catch @panic("test failure");
+                expect(vec[98] == false) catch @panic("test failure");
+                expect(vec[99] == false) catch @panic("test failure");
+                expect(vec[100] == false) catch @panic("test failure");
+                expect(vec[101] == true) catch @panic("test failure");
+                expect(vec[102] == false) catch @panic("test failure");
+                expect(vec[103] == false) catch @panic("test failure");
+                expect(vec[104] == false) catch @panic("test failure");
+                expect(vec[105] == false) catch @panic("test failure");
+                expect(vec[106] == false) catch @panic("test failure");
+                expect(vec[107] == false) catch @panic("test failure");
+                expect(vec[108] == true) catch @panic("test failure");
+                expect(vec[109] == true) catch @panic("test failure");
+                expect(vec[110] == true) catch @panic("test failure");
+                expect(vec[111] == true) catch @panic("test failure");
+                expect(vec[112] == true) catch @panic("test failure");
+                expect(vec[113] == false) catch @panic("test failure");
+                expect(vec[114] == false) catch @panic("test failure");
+                expect(vec[115] == false) catch @panic("test failure");
+                expect(vec[116] == false) catch @panic("test failure");
+                expect(vec[117] == true) catch @panic("test failure");
+                expect(vec[118] == true) catch @panic("test failure");
+                expect(vec[119] == false) catch @panic("test failure");
+                expect(vec[120] == true) catch @panic("test failure");
+                expect(vec[121] == true) catch @panic("test failure");
+                expect(vec[122] == false) catch @panic("test failure");
+                expect(vec[123] == false) catch @panic("test failure");
+                expect(vec[124] == true) catch @panic("test failure");
+                expect(vec[125] == false) catch @panic("test failure");
+                expect(vec[126] == false) catch @panic("test failure");
+                expect(vec[127] == false) catch @panic("test failure");
+                expect(vec[128] == false) catch @panic("test failure");
+                expect(vec[129] == true) catch @panic("test failure");
+                expect(vec[130] == true) catch @panic("test failure");
+                expect(vec[131] == true) catch @panic("test failure");
+                expect(vec[132] == true) catch @panic("test failure");
+                expect(vec[133] == false) catch @panic("test failure");
+                expect(vec[134] == false) catch @panic("test failure");
+                expect(vec[135] == false) catch @panic("test failure");
+                expect(vec[136] == false) catch @panic("test failure");
+                expect(vec[137] == true) catch @panic("test failure");
+                expect(vec[138] == false) catch @panic("test failure");
+                expect(vec[139] == false) catch @panic("test failure");
+                expect(vec[140] == false) catch @panic("test failure");
+                expect(vec[141] == false) catch @panic("test failure");
+                expect(vec[142] == true) catch @panic("test failure");
+                expect(vec[143] == true) catch @panic("test failure");
+                expect(vec[144] == false) catch @panic("test failure");
+                expect(vec[145] == true) catch @panic("test failure");
+                expect(vec[146] == false) catch @panic("test failure");
+                expect(vec[147] == true) catch @panic("test failure");
+                expect(vec[148] == false) catch @panic("test failure");
+                expect(vec[149] == false) catch @panic("test failure");
+                expect(vec[150] == true) catch @panic("test failure");
+                expect(vec[151] == true) catch @panic("test failure");
+                expect(vec[152] == false) catch @panic("test failure");
+                expect(vec[153] == true) catch @panic("test failure");
+                expect(vec[154] == true) catch @panic("test failure");
+                expect(vec[155] == false) catch @panic("test failure");
+                expect(vec[156] == false) catch @panic("test failure");
+                expect(vec[157] == false) catch @panic("test failure");
+                expect(vec[158] == true) catch @panic("test failure");
+                expect(vec[159] == false) catch @panic("test failure");
+                expect(vec[160] == false) catch @panic("test failure");
+                expect(vec[161] == false) catch @panic("test failure");
+                expect(vec[162] == false) catch @panic("test failure");
+                expect(vec[163] == true) catch @panic("test failure");
+                expect(vec[164] == true) catch @panic("test failure");
+                expect(vec[165] == false) catch @panic("test failure");
+                expect(vec[166] == false) catch @panic("test failure");
+                expect(vec[167] == true) catch @panic("test failure");
+                expect(vec[168] == false) catch @panic("test failure");
+                expect(vec[169] == true) catch @panic("test failure");
+                expect(vec[170] == true) catch @panic("test failure");
+                expect(vec[171] == false) catch @panic("test failure");
+                expect(vec[172] == false) catch @panic("test failure");
+                expect(vec[173] == false) catch @panic("test failure");
+                expect(vec[174] == false) catch @panic("test failure");
+                expect(vec[175] == false) catch @panic("test failure");
+                expect(vec[176] == false) catch @panic("test failure");
+                expect(vec[177] == true) catch @panic("test failure");
+                expect(vec[178] == false) catch @panic("test failure");
+                expect(vec[179] == false) catch @panic("test failure");
+                expect(vec[180] == false) catch @panic("test failure");
+                expect(vec[181] == false) catch @panic("test failure");
+                expect(vec[182] == false) catch @panic("test failure");
+                expect(vec[183] == false) catch @panic("test failure");
+                expect(vec[184] == true) catch @panic("test failure");
+                expect(vec[185] == false) catch @panic("test failure");
+                expect(vec[186] == false) catch @panic("test failure");
+                expect(vec[187] == false) catch @panic("test failure");
+                expect(vec[188] == false) catch @panic("test failure");
+                expect(vec[189] == true) catch @panic("test failure");
+                expect(vec[190] == false) catch @panic("test failure");
+                expect(vec[191] == false) catch @panic("test failure");
+                expect(vec[192] == false) catch @panic("test failure");
+                expect(vec[193] == false) catch @panic("test failure");
+                expect(vec[194] == false) catch @panic("test failure");
+                expect(vec[195] == false) catch @panic("test failure");
+                expect(vec[196] == true) catch @panic("test failure");
+                expect(vec[197] == true) catch @panic("test failure");
+                expect(vec[198] == true) catch @panic("test failure");
+                expect(vec[199] == false) catch @panic("test failure");
+                expect(vec[200] == true) catch @panic("test failure");
+                expect(vec[201] == true) catch @panic("test failure");
+                expect(vec[202] == false) catch @panic("test failure");
+                expect(vec[203] == false) catch @panic("test failure");
+                expect(vec[204] == false) catch @panic("test failure");
+                expect(vec[205] == false) catch @panic("test failure");
+                expect(vec[206] == false) catch @panic("test failure");
+                expect(vec[207] == true) catch @panic("test failure");
+                expect(vec[208] == true) catch @panic("test failure");
+                expect(vec[209] == false) catch @panic("test failure");
+                expect(vec[210] == false) catch @panic("test failure");
+                expect(vec[211] == false) catch @panic("test failure");
+                expect(vec[212] == true) catch @panic("test failure");
+                expect(vec[213] == false) catch @panic("test failure");
+                expect(vec[214] == false) catch @panic("test failure");
+                expect(vec[215] == true) catch @panic("test failure");
+                expect(vec[216] == true) catch @panic("test failure");
+                expect(vec[217] == true) catch @panic("test failure");
+                expect(vec[218] == false) catch @panic("test failure");
+                expect(vec[219] == false) catch @panic("test failure");
+                expect(vec[220] == true) catch @panic("test failure");
+                expect(vec[221] == false) catch @panic("test failure");
+                expect(vec[222] == true) catch @panic("test failure");
+                expect(vec[223] == true) catch @panic("test failure");
+                expect(vec[224] == true) catch @panic("test failure");
+                expect(vec[225] == true) catch @panic("test failure");
+                expect(vec[226] == false) catch @panic("test failure");
+                expect(vec[227] == true) catch @panic("test failure");
+                expect(vec[228] == false) catch @panic("test failure");
+                expect(vec[229] == false) catch @panic("test failure");
+                expect(vec[230] == false) catch @panic("test failure");
+                expect(vec[231] == true) catch @panic("test failure");
+                expect(vec[232] == false) catch @panic("test failure");
+                expect(vec[233] == false) catch @panic("test failure");
+                expect(vec[234] == false) catch @panic("test failure");
+                expect(vec[235] == false) catch @panic("test failure");
+                expect(vec[236] == false) catch @panic("test failure");
+                expect(vec[237] == false) catch @panic("test failure");
+                expect(vec[238] == false) catch @panic("test failure");
+                expect(vec[239] == true) catch @panic("test failure");
+                expect(vec[240] == false) catch @panic("test failure");
+                expect(vec[241] == false) catch @panic("test failure");
+                expect(vec[242] == false) catch @panic("test failure");
+                expect(vec[243] == true) catch @panic("test failure");
+                expect(vec[244] == true) catch @panic("test failure");
+                expect(vec[245] == true) catch @panic("test failure");
+                expect(vec[246] == true) catch @panic("test failure");
+                expect(vec[247] == false) catch @panic("test failure");
+                expect(vec[248] == true) catch @panic("test failure");
+                expect(vec[249] == true) catch @panic("test failure");
+                expect(vec[250] == false) catch @panic("test failure");
+                expect(vec[251] == false) catch @panic("test failure");
+                expect(vec[252] == false) catch @panic("test failure");
+                expect(vec[253] == true) catch @panic("test failure");
+                expect(vec[254] == false) catch @panic("test failure");
+                expect(vec[255] == false) catch @panic("test failure");
+                expect(vec[256] == true) catch @panic("test failure");
+                expect(vec[257] == true) catch @panic("test failure");
+                expect(vec[258] == false) catch @panic("test failure");
+                expect(vec[259] == true) catch @panic("test failure");
+                expect(vec[260] == false) catch @panic("test failure");
+                expect(vec[261] == true) catch @panic("test failure");
+                expect(vec[262] == true) catch @panic("test failure");
+                expect(vec[263] == false) catch @panic("test failure");
+                expect(vec[264] == false) catch @panic("test failure");
+                expect(vec[265] == false) catch @panic("test failure");
+                expect(vec[266] == false) catch @panic("test failure");
+                expect(vec[267] == true) catch @panic("test failure");
+                expect(vec[268] == false) catch @panic("test failure");
+                expect(vec[269] == true) catch @panic("test failure");
+                expect(vec[270] == true) catch @panic("test failure");
+                expect(vec[271] == false) catch @panic("test failure");
+                expect(vec[272] == false) catch @panic("test failure");
+                expect(vec[273] == true) catch @panic("test failure");
+                expect(vec[274] == true) catch @panic("test failure");
+                expect(vec[275] == true) catch @panic("test failure");
+                expect(vec[276] == false) catch @panic("test failure");
+                expect(vec[277] == true) catch @panic("test failure");
+                expect(vec[278] == false) catch @panic("test failure");
+                expect(vec[279] == false) catch @panic("test failure");
+                expect(vec[280] == true) catch @panic("test failure");
+                expect(vec[281] == true) catch @panic("test failure");
+                expect(vec[282] == false) catch @panic("test failure");
+                expect(vec[283] == true) catch @panic("test failure");
+                expect(vec[284] == false) catch @panic("test failure");
+                expect(vec[285] == true) catch @panic("test failure");
+                expect(vec[286] == true) catch @panic("test failure");
+                expect(vec[287] == true) catch @panic("test failure");
+                expect(vec[288] == true) catch @panic("test failure");
+                expect(vec[289] == true) catch @panic("test failure");
+                expect(vec[290] == true) catch @panic("test failure");
+                expect(vec[291] == true) catch @panic("test failure");
+                expect(vec[292] == true) catch @panic("test failure");
+                expect(vec[293] == true) catch @panic("test failure");
+                expect(vec[294] == true) catch @panic("test failure");
+                expect(vec[295] == false) catch @panic("test failure");
+                expect(vec[296] == true) catch @panic("test failure");
+                expect(vec[297] == false) catch @panic("test failure");
+                expect(vec[298] == true) catch @panic("test failure");
+                expect(vec[299] == false) catch @panic("test failure");
+                expect(vec[300] == true) catch @panic("test failure");
+                expect(vec[301] == true) catch @panic("test failure");
+                expect(vec[302] == false) catch @panic("test failure");
+                expect(vec[303] == true) catch @panic("test failure");
+                expect(vec[304] == false) catch @panic("test failure");
+                expect(vec[305] == true) catch @panic("test failure");
+                expect(vec[306] == false) catch @panic("test failure");
+                expect(vec[307] == true) catch @panic("test failure");
+                expect(vec[308] == true) catch @panic("test failure");
+                expect(vec[309] == false) catch @panic("test failure");
+                expect(vec[310] == true) catch @panic("test failure");
+                expect(vec[311] == true) catch @panic("test failure");
+                expect(vec[312] == true) catch @panic("test failure");
+                expect(vec[313] == false) catch @panic("test failure");
+                expect(vec[314] == false) catch @panic("test failure");
+                expect(vec[315] == false) catch @panic("test failure");
+                expect(vec[316] == false) catch @panic("test failure");
+                expect(vec[317] == true) catch @panic("test failure");
+                expect(vec[318] == true) catch @panic("test failure");
+                expect(vec[319] == true) catch @panic("test failure");
+                expect(vec[320] == true) catch @panic("test failure");
+                expect(vec[321] == true) catch @panic("test failure");
+                expect(vec[322] == true) catch @panic("test failure");
+                expect(vec[323] == true) catch @panic("test failure");
+                expect(vec[324] == true) catch @panic("test failure");
+                expect(vec[325] == true) catch @panic("test failure");
+                expect(vec[326] == false) catch @panic("test failure");
+                expect(vec[327] == true) catch @panic("test failure");
+                expect(vec[328] == false) catch @panic("test failure");
+                expect(vec[329] == false) catch @panic("test failure");
+                expect(vec[330] == true) catch @panic("test failure");
+                expect(vec[331] == false) catch @panic("test failure");
+                expect(vec[332] == false) catch @panic("test failure");
+                expect(vec[333] == false) catch @panic("test failure");
+                expect(vec[334] == false) catch @panic("test failure");
+                expect(vec[335] == false) catch @panic("test failure");
+                expect(vec[336] == false) catch @panic("test failure");
+                expect(vec[337] == false) catch @panic("test failure");
+                expect(vec[338] == false) catch @panic("test failure");
+                expect(vec[339] == false) catch @panic("test failure");
+                expect(vec[340] == false) catch @panic("test failure");
+                expect(vec[341] == false) catch @panic("test failure");
+                expect(vec[342] == true) catch @panic("test failure");
+                expect(vec[343] == true) catch @panic("test failure");
+                expect(vec[344] == false) catch @panic("test failure");
+                expect(vec[345] == false) catch @panic("test failure");
+                expect(vec[346] == false) catch @panic("test failure");
+                expect(vec[347] == false) catch @panic("test failure");
+                expect(vec[348] == false) catch @panic("test failure");
+                expect(vec[349] == true) catch @panic("test failure");
+                expect(vec[350] == true) catch @panic("test failure");
+                expect(vec[351] == true) catch @panic("test failure");
+                expect(vec[352] == true) catch @panic("test failure");
+                expect(vec[353] == false) catch @panic("test failure");
+                expect(vec[354] == false) catch @panic("test failure");
+                expect(vec[355] == false) catch @panic("test failure");
+                expect(vec[356] == false) catch @panic("test failure");
+                expect(vec[357] == true) catch @panic("test failure");
+                expect(vec[358] == true) catch @panic("test failure");
+                expect(vec[359] == false) catch @panic("test failure");
+                expect(vec[360] == false) catch @panic("test failure");
+                expect(vec[361] == false) catch @panic("test failure");
+                expect(vec[362] == true) catch @panic("test failure");
+                expect(vec[363] == true) catch @panic("test failure");
+                expect(vec[364] == false) catch @panic("test failure");
+                expect(vec[365] == false) catch @panic("test failure");
+                expect(vec[366] == false) catch @panic("test failure");
+                expect(vec[367] == false) catch @panic("test failure");
+                expect(vec[368] == false) catch @panic("test failure");
+                expect(vec[369] == true) catch @panic("test failure");
+                expect(vec[370] == true) catch @panic("test failure");
+                expect(vec[371] == false) catch @panic("test failure");
+                expect(vec[372] == true) catch @panic("test failure");
+                expect(vec[373] == true) catch @panic("test failure");
+                expect(vec[374] == false) catch @panic("test failure");
+                expect(vec[375] == true) catch @panic("test failure");
+                expect(vec[376] == true) catch @panic("test failure");
+                expect(vec[377] == false) catch @panic("test failure");
+                expect(vec[378] == true) catch @panic("test failure");
+                expect(vec[379] == true) catch @panic("test failure");
+                expect(vec[380] == false) catch @panic("test failure");
+                expect(vec[381] == true) catch @panic("test failure");
+                expect(vec[382] == true) catch @panic("test failure");
+                expect(vec[383] == false) catch @panic("test failure");
+                expect(vec[384] == true) catch @panic("test failure");
+                expect(vec[385] == false) catch @panic("test failure");
+                expect(vec[386] == true) catch @panic("test failure");
+                expect(vec[387] == true) catch @panic("test failure");
+                expect(vec[388] == true) catch @panic("test failure");
+                expect(vec[389] == true) catch @panic("test failure");
+                expect(vec[390] == false) catch @panic("test failure");
+                expect(vec[391] == false) catch @panic("test failure");
+                expect(vec[392] == false) catch @panic("test failure");
+                expect(vec[393] == true) catch @panic("test failure");
+                expect(vec[394] == true) catch @panic("test failure");
+                expect(vec[395] == true) catch @panic("test failure");
+                expect(vec[396] == true) catch @panic("test failure");
+                expect(vec[397] == false) catch @panic("test failure");
+                expect(vec[398] == true) catch @panic("test failure");
+                expect(vec[399] == true) catch @panic("test failure");
+                expect(vec[400] == true) catch @panic("test failure");
+                expect(vec[401] == false) catch @panic("test failure");
+                expect(vec[402] == false) catch @panic("test failure");
+                expect(vec[403] == true) catch @panic("test failure");
+                expect(vec[404] == false) catch @panic("test failure");
+                expect(vec[405] == false) catch @panic("test failure");
+                expect(vec[406] == false) catch @panic("test failure");
+                expect(vec[407] == true) catch @panic("test failure");
+                expect(vec[408] == true) catch @panic("test failure");
+                expect(vec[409] == true) catch @panic("test failure");
+                expect(vec[410] == false) catch @panic("test failure");
+                expect(vec[411] == true) catch @panic("test failure");
+                expect(vec[412] == false) catch @panic("test failure");
+                expect(vec[413] == false) catch @panic("test failure");
+                expect(vec[414] == false) catch @panic("test failure");
+                expect(vec[415] == true) catch @panic("test failure");
+                expect(vec[416] == false) catch @panic("test failure");
+                expect(vec[417] == false) catch @panic("test failure");
+                expect(vec[418] == true) catch @panic("test failure");
+                expect(vec[419] == true) catch @panic("test failure");
+                expect(vec[420] == true) catch @panic("test failure");
+                expect(vec[421] == true) catch @panic("test failure");
+                expect(vec[422] == false) catch @panic("test failure");
+                expect(vec[423] == true) catch @panic("test failure");
+                expect(vec[424] == true) catch @panic("test failure");
+                expect(vec[425] == false) catch @panic("test failure");
+                expect(vec[426] == false) catch @panic("test failure");
+                expect(vec[427] == false) catch @panic("test failure");
+                expect(vec[428] == true) catch @panic("test failure");
+                expect(vec[429] == false) catch @panic("test failure");
+                expect(vec[430] == true) catch @panic("test failure");
+                expect(vec[431] == true) catch @panic("test failure");
+                expect(vec[432] == false) catch @panic("test failure");
+                expect(vec[433] == false) catch @panic("test failure");
+                expect(vec[434] == false) catch @panic("test failure");
+                expect(vec[435] == false) catch @panic("test failure");
+                expect(vec[436] == true) catch @panic("test failure");
+                expect(vec[437] == false) catch @panic("test failure");
+                expect(vec[438] == true) catch @panic("test failure");
+                expect(vec[439] == false) catch @panic("test failure");
+                expect(vec[440] == false) catch @panic("test failure");
+                expect(vec[441] == false) catch @panic("test failure");
+                expect(vec[442] == false) catch @panic("test failure");
+                expect(vec[443] == true) catch @panic("test failure");
+                expect(vec[444] == false) catch @panic("test failure");
+                expect(vec[445] == false) catch @panic("test failure");
+                expect(vec[446] == true) catch @panic("test failure");
+                expect(vec[447] == true) catch @panic("test failure");
+                expect(vec[448] == true) catch @panic("test failure");
+                expect(vec[449] == false) catch @panic("test failure");
+                expect(vec[450] == true) catch @panic("test failure");
+                expect(vec[451] == true) catch @panic("test failure");
+                expect(vec[452] == false) catch @panic("test failure");
+                expect(vec[453] == true) catch @panic("test failure");
+                expect(vec[454] == false) catch @panic("test failure");
+                expect(vec[455] == true) catch @panic("test failure");
+                expect(vec[456] == false) catch @panic("test failure");
+                expect(vec[457] == false) catch @panic("test failure");
+                expect(vec[458] == false) catch @panic("test failure");
+                expect(vec[459] == true) catch @panic("test failure");
+                expect(vec[460] == false) catch @panic("test failure");
+                expect(vec[461] == false) catch @panic("test failure");
+                expect(vec[462] == false) catch @panic("test failure");
+                expect(vec[463] == true) catch @panic("test failure");
+                expect(vec[464] == true) catch @panic("test failure");
+                expect(vec[465] == true) catch @panic("test failure");
+                expect(vec[466] == true) catch @panic("test failure");
+                expect(vec[467] == true) catch @panic("test failure");
+                expect(vec[468] == false) catch @panic("test failure");
+                expect(vec[469] == false) catch @panic("test failure");
+                expect(vec[470] == false) catch @panic("test failure");
+                expect(vec[471] == false) catch @panic("test failure");
+                expect(vec[472] == false) catch @panic("test failure");
+                expect(vec[473] == false) catch @panic("test failure");
+                expect(vec[474] == true) catch @panic("test failure");
+                expect(vec[475] == true) catch @panic("test failure");
+                expect(vec[476] == true) catch @panic("test failure");
+                expect(vec[477] == true) catch @panic("test failure");
+                expect(vec[478] == true) catch @panic("test failure");
+                expect(vec[479] == false) catch @panic("test failure");
+                expect(vec[480] == true) catch @panic("test failure");
+                expect(vec[481] == true) catch @panic("test failure");
+                expect(vec[482] == false) catch @panic("test failure");
+                expect(vec[483] == true) catch @panic("test failure");
+                expect(vec[484] == false) catch @panic("test failure");
+                expect(vec[485] == true) catch @panic("test failure");
+                expect(vec[486] == false) catch @panic("test failure");
+                expect(vec[487] == true) catch @panic("test failure");
+                expect(vec[488] == false) catch @panic("test failure");
+                expect(vec[489] == false) catch @panic("test failure");
+                expect(vec[490] == false) catch @panic("test failure");
+                expect(vec[491] == true) catch @panic("test failure");
+                expect(vec[492] == false) catch @panic("test failure");
+                expect(vec[493] == false) catch @panic("test failure");
+                expect(vec[494] == false) catch @panic("test failure");
+                expect(vec[495] == true) catch @panic("test failure");
+                expect(vec[496] == true) catch @panic("test failure");
+                expect(vec[497] == false) catch @panic("test failure");
+                expect(vec[498] == false) catch @panic("test failure");
+                expect(vec[499] == true) catch @panic("test failure");
+                expect(vec[500] == false) catch @panic("test failure");
+                expect(vec[501] == true) catch @panic("test failure");
+                expect(vec[502] == false) catch @panic("test failure");
+                expect(vec[503] == false) catch @panic("test failure");
+                expect(vec[504] == false) catch @panic("test failure");
+                expect(vec[505] == true) catch @panic("test failure");
+                expect(vec[506] == true) catch @panic("test failure");
+                expect(vec[507] == true) catch @panic("test failure");
+                expect(vec[508] == true) catch @panic("test failure");
+                expect(vec[509] == false) catch @panic("test failure");
+                expect(vec[510] == false) catch @panic("test failure");
+                expect(vec[511] == true) catch @panic("test failure");
+            }
+
+            export fn zig_ret_vector_2_bool() Vector2Bool {
+                return .{
+                    false,
+                    false,
+                };
+            }
+
+            export fn zig_ret_vector_4_bool() Vector4Bool {
+                return .{
+                    false,
+                    true,
+                    true,
+                    true,
+                };
+            }
+
+            export fn zig_ret_vector_8_bool() Vector8Bool {
+                return .{
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                };
+            }
+
+            export fn zig_ret_vector_16_bool() Vector16Bool {
+                return .{
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                };
+            }
+
+            export fn zig_ret_vector_32_bool() Vector32Bool {
+                return .{
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                };
+            }
+
+            export fn zig_ret_vector_64_bool() Vector64Bool {
+                return .{
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                };
+            }
+
+            export fn zig_ret_vector_128_bool() Vector128Bool {
+                return .{
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                };
+            }
+
+            export fn zig_ret_vector_256_bool() Vector256Bool {
+                return .{
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                };
+            }
+
+            export fn zig_ret_vector_512_bool() Vector512Bool {
+                return .{
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    false,
+                    true,
+                    false,
+                    true,
+                    true,
+                    true,
+                    true,
+                    false,
+                    false,
+                    true,
+                    true,
+                    false,
+                    false,
+                };
+            }
+        };
+    }
+}
+
 const Vector2 = extern struct { x: f32, y: f32 };
 
 extern fn c_ptr_size_float_struct(Vector2) void;