diff --git a/src/LLVM.zig b/src/LLVM.zig index b0856d8..3a64b6b 100644 --- a/src/LLVM.zig +++ b/src/LLVM.zig @@ -507,6 +507,9 @@ pub const Context = opaque { } pub const get_struct_type = api.llvm_context_get_struct_type; + + pub const get_void_type = api.LLVMVoidTypeInContext; + pub const get_integer_type = api.LLVMIntTypeInContext; }; pub const BasicBlock = opaque { @@ -658,6 +661,14 @@ pub const Builder = opaque { pub fn create_insert_value(builder: *Builder, aggregate: *Value, element: *Value, index: c_uint) *Value { return api.LLVMBuildInsertValue(builder, aggregate, element, index, ""); } + + pub fn create_zero_extend(builder: *Builder, value: *Value, destination_type: *Type) *Value { + return api.LLVMBuildZExt(builder, value, destination_type, ""); + } + + pub fn create_sign_extend(builder: *Builder, value: *Value, destination_type: *Type) *Value { + return api.LLVMBuildSExt(builder, value, destination_type, ""); + } }; pub const GlobalValue = opaque { @@ -868,6 +879,10 @@ pub const DI = struct { pub fn create_member_type(builder: *DI.Builder, scope: *DI.Scope, name: []const u8, file: *DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, bit_offset: u64, flags: DI.Flags, member_type: *DI.Type) *DI.Type.Derived { return api.LLVMDIBuilderCreateMemberType(builder, scope, name.ptr, name.len, file, line, bit_size, align_in_bits, bit_offset, flags, member_type); } + + pub fn create_bit_field_member_type(builder: *DI.Builder, scope: *DI.Scope, name: []const u8, file: *DI.File, line: c_uint, bit_size: u64, bit_offset: u64, bit_storage_offset: u64, flags: DI.Flags, member_type: *DI.Type) *DI.Type.Derived { + return api.LLVMDIBuilderCreateBitFieldMemberType(builder, scope, name.ptr, name.len, file, line, bit_size, bit_offset, bit_storage_offset, flags, member_type); + } }; pub const create_debug_location = api.LLVMDIBuilderCreateDebugLocation; @@ -1234,69 +1249,7 @@ pub const lld = struct { }; }; -pub const Thread = struct { - context: *Context, - builder: *Builder, - i1: Integer, - i8: Integer, - i16: Integer, - i32: Integer, - i64: Integer, - i128: Integer, - - pub const Integer = struct { - type: *Type.Integer, - zero: *Constant.Integer, - }; - - pub fn initialize(thread: *Thread) void { - const context = Context.create(); - const type_i1 = api.LLVMInt1TypeInContext(context); - const type_i8 = api.LLVMInt8TypeInContext(context); - const type_i16 = api.LLVMInt16TypeInContext(context); - const type_i32 = api.LLVMInt32TypeInContext(context); - const type_i64 = api.LLVMInt64TypeInContext(context); - const type_i128 = api.LLVMInt128TypeInContext(context); - const zero_i1 = type_i1.get_constant(0, 0); - const zero_i8 = type_i8.get_constant(0, 0); - const zero_i16 = type_i16.get_constant(0, 0); - const zero_i32 = type_i32.get_constant(0, 0); - const zero_i64 = type_i64.get_constant(0, 0); - const zero_i128 = type_i128.get_constant(0, 0); - - thread.* = .{ - .context = context, - .builder = context.create_builder(), - .i1 = .{ - .type = type_i1, - .zero = zero_i1, - }, - .i8 = .{ - .type = type_i8, - .zero = zero_i8, - }, - .i16 = .{ - .type = type_i16, - .zero = zero_i16, - }, - .i32 = .{ - .type = type_i32, - .zero = zero_i32, - }, - .i64 = .{ - .type = type_i64, - .zero = zero_i64, - }, - .i128 = .{ - .type = type_i128, - .zero = zero_i128, - }, - }; - } -}; - pub const Global = struct { - threads: []Thread, host_triple: []const u8, host_cpu_model: []const u8, host_cpu_features: []const u8, @@ -1314,7 +1267,6 @@ pub fn initialize_all() void { } global = .{ - .threads = lib.global.arena.allocate(Thread, lib.global.thread_count), .host_triple = api.llvm_default_target_triple().to_slice() orelse unreachable, .host_cpu_model = api.llvm_host_cpu_name().to_slice() orelse unreachable, .host_cpu_features = api.llvm_host_cpu_features().to_slice() orelse unreachable, @@ -1336,16 +1288,11 @@ const LldArgvBuilder = struct { } }; -pub fn default_initialize() *Thread { +pub fn default_initialize() void { assert(lib.GlobalState.initialized); if (!initialized) { initialize_all(); } - - const thread = &global.threads[0]; - thread.initialize(); - - return thread; } pub const GenerateObject = struct { diff --git a/src/c_abi.c b/src/c_abi.c index 7795cb2..2b73c8a 100644 --- a/src/c_abi.c +++ b/src/c_abi.c @@ -4,11 +4,7 @@ #include #include -static void assert_or_panic(bool ok) { - if (!ok) { - __builtin_trap(); - } -} +extern void require(bool ok); #ifndef memcpy void* memcpy(void* dst_ptr, const void* src_ptr, size_t count) @@ -217,40 +213,40 @@ struct Struct_u64_u64 c_ret_struct_u64_u64(void) { } void c_struct_u64_u64_0(struct Struct_u64_u64 s) { - assert_or_panic(s.a == 23); - assert_or_panic(s.b == 24); + require(s.a == 23); + require(s.b == 24); } void c_struct_u64_u64_1(size_t a, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 25); - assert_or_panic(s.b == 26); + require(s.a == 25); + require(s.b == 26); } void c_struct_u64_u64_2(size_t a , size_t b, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 27); - assert_or_panic(s.b == 28); + require(s.a == 27); + require(s.b == 28); } void c_struct_u64_u64_3(size_t a, size_t b, size_t c, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 29); - assert_or_panic(s.b == 30); + require(s.a == 29); + require(s.b == 30); } void c_struct_u64_u64_4(size_t a, size_t b, size_t c, size_t d, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 31); - assert_or_panic(s.b == 32); + require(s.a == 31); + require(s.b == 32); } void c_struct_u64_u64_5(size_t a, size_t b, size_t c, size_t d, size_t e, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 33); - assert_or_panic(s.b == 34); + require(s.a == 33); + require(s.b == 34); } void c_struct_u64_u64_6(size_t a, size_t b, size_t c, size_t d, size_t e, size_t f, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 35); - assert_or_panic(s.b == 36); + require(s.a == 35); + require(s.b == 36); } void c_struct_u64_u64_7(size_t a, size_t b, size_t c, size_t d, size_t e, size_t f, size_t g, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 37); - assert_or_panic(s.b == 38); + require(s.a == 37); + require(s.b == 38); } void c_struct_u64_u64_8(size_t a, size_t b, size_t c, size_t d, size_t e, size_t f, size_t g, size_t h, struct Struct_u64_u64 s) { - assert_or_panic(s.a == 39); - assert_or_panic(s.b == 40); + require(s.a == 39); + require(s.b == 40); } struct BigStruct { @@ -324,15 +320,15 @@ typedef float Vector2Float __attribute__((ext_vector_type(2))); typedef float Vector4Float __attribute__((ext_vector_type(4))); void c_vector_2_float(Vector2Float vec) { - assert_or_panic(vec[0] == 1.0); - assert_or_panic(vec[1] == 2.0); + require(vec[0] == 1.0); + require(vec[1] == 2.0); } void c_vector_4_float(Vector4Float vec) { - assert_or_panic(vec[0] == 1.0); - assert_or_panic(vec[1] == 2.0); - assert_or_panic(vec[2] == 3.0); - assert_or_panic(vec[3] == 4.0); + require(vec[0] == 1.0); + require(vec[1] == 2.0); + require(vec[2] == 3.0); + require(vec[3] == 4.0); } Vector2Float c_ret_vector_2_float(void) { @@ -363,1055 +359,1055 @@ 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); + require(vec[0] == true); + require(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); + require(vec[0] == true); + require(vec[1] == true); + require(vec[2] == false); + require(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); + require(vec[0] == true); + require(vec[1] == false); + require(vec[2] == true); + require(vec[3] == true); + require(vec[4] == true); + require(vec[5] == true); + require(vec[6] == false); + require(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); + require(vec[0] == true); + require(vec[1] == false); + require(vec[2] == false); + require(vec[3] == false); + require(vec[4] == true); + require(vec[5] == false); + require(vec[6] == true); + require(vec[7] == true); + require(vec[8] == true); + require(vec[9] == true); + require(vec[10] == true); + require(vec[11] == true); + require(vec[12] == false); + require(vec[13] == false); + require(vec[14] == false); + require(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); + require(vec[0] == true); + require(vec[1] == false); + require(vec[2] == true); + require(vec[3] == true); + require(vec[4] == false); + require(vec[5] == false); + require(vec[6] == true); + require(vec[7] == false); + require(vec[8] == true); + require(vec[9] == false); + require(vec[10] == true); + require(vec[11] == true); + require(vec[12] == true); + require(vec[13] == false); + require(vec[14] == false); + require(vec[15] == true); + require(vec[16] == false); + require(vec[17] == true); + require(vec[18] == false); + require(vec[19] == true); + require(vec[20] == true); + require(vec[21] == true); + require(vec[22] == true); + require(vec[23] == true); + require(vec[24] == false); + require(vec[25] == true); + require(vec[26] == true); + require(vec[27] == true); + require(vec[28] == false); + require(vec[29] == true); + require(vec[30] == true); + require(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); + require(vec[0] == true); + require(vec[1] == true); + require(vec[2] == true); + require(vec[3] == false); + require(vec[4] == true); + require(vec[5] == false); + require(vec[6] == false); + require(vec[7] == false); + require(vec[8] == true); + require(vec[9] == false); + require(vec[10] == false); + require(vec[11] == false); + require(vec[12] == false); + require(vec[13] == true); + require(vec[14] == true); + require(vec[15] == true); + require(vec[16] == true); + require(vec[17] == false); + require(vec[18] == false); + require(vec[19] == true); + require(vec[20] == false); + require(vec[21] == true); + require(vec[22] == false); + require(vec[23] == true); + require(vec[24] == true); + require(vec[25] == true); + require(vec[26] == true); + require(vec[27] == true); + require(vec[28] == true); + require(vec[29] == true); + require(vec[30] == false); + require(vec[31] == false); + require(vec[32] == true); + require(vec[33] == true); + require(vec[34] == false); + require(vec[35] == true); + require(vec[36] == false); + require(vec[37] == false); + require(vec[38] == true); + require(vec[39] == true); + require(vec[40] == true); + require(vec[41] == false); + require(vec[42] == false); + require(vec[43] == true); + require(vec[44] == true); + require(vec[45] == false); + require(vec[46] == true); + require(vec[47] == false); + require(vec[48] == true); + require(vec[49] == false); + require(vec[50] == false); + require(vec[51] == true); + require(vec[52] == false); + require(vec[53] == true); + require(vec[54] == true); + require(vec[55] == true); + require(vec[56] == true); + require(vec[57] == true); + require(vec[58] == false); + require(vec[59] == false); + require(vec[60] == true); + require(vec[61] == false); + require(vec[62] == true); + require(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); + require(vec[0] == false); + require(vec[1] == false); + require(vec[2] == false); + require(vec[3] == false); + require(vec[4] == false); + require(vec[5] == true); + require(vec[6] == true); + require(vec[7] == false); + require(vec[8] == true); + require(vec[9] == true); + require(vec[10] == false); + require(vec[11] == true); + require(vec[12] == true); + require(vec[13] == false); + require(vec[14] == true); + require(vec[15] == true); + require(vec[16] == true); + require(vec[17] == false); + require(vec[18] == false); + require(vec[19] == false); + require(vec[20] == false); + require(vec[21] == true); + require(vec[22] == true); + require(vec[23] == false); + require(vec[24] == false); + require(vec[25] == false); + require(vec[26] == true); + require(vec[27] == true); + require(vec[28] == false); + require(vec[29] == true); + require(vec[30] == false); + require(vec[31] == false); + require(vec[32] == true); + require(vec[33] == false); + require(vec[34] == false); + require(vec[35] == true); + require(vec[36] == true); + require(vec[37] == true); + require(vec[38] == true); + require(vec[39] == true); + require(vec[40] == false); + require(vec[41] == true); + require(vec[42] == true); + require(vec[43] == true); + require(vec[44] == false); + require(vec[45] == false); + require(vec[46] == false); + require(vec[47] == false); + require(vec[48] == true); + require(vec[49] == true); + require(vec[50] == false); + require(vec[51] == true); + require(vec[52] == true); + require(vec[53] == true); + require(vec[54] == true); + require(vec[55] == true); + require(vec[56] == false); + require(vec[57] == true); + require(vec[58] == true); + require(vec[59] == false); + require(vec[60] == true); + require(vec[61] == false); + require(vec[62] == false); + require(vec[63] == true); + require(vec[64] == true); + require(vec[65] == false); + require(vec[66] == true); + require(vec[67] == true); + require(vec[68] == false); + require(vec[69] == true); + require(vec[70] == false); + require(vec[71] == false); + require(vec[72] == true); + require(vec[73] == true); + require(vec[74] == false); + require(vec[75] == true); + require(vec[76] == true); + require(vec[77] == true); + require(vec[78] == false); + require(vec[79] == true); + require(vec[80] == false); + require(vec[81] == false); + require(vec[82] == false); + require(vec[83] == false); + require(vec[84] == true); + require(vec[85] == false); + require(vec[86] == false); + require(vec[87] == false); + require(vec[88] == true); + require(vec[89] == true); + require(vec[90] == false); + require(vec[91] == false); + require(vec[92] == true); + require(vec[93] == true); + require(vec[94] == true); + require(vec[95] == true); + require(vec[96] == false); + require(vec[97] == false); + require(vec[98] == false); + require(vec[99] == false); + require(vec[100] == false); + require(vec[101] == true); + require(vec[102] == false); + require(vec[103] == false); + require(vec[104] == false); + require(vec[105] == false); + require(vec[106] == true); + require(vec[107] == true); + require(vec[108] == true); + require(vec[109] == true); + require(vec[110] == true); + require(vec[111] == false); + require(vec[112] == false); + require(vec[113] == true); + require(vec[114] == false); + require(vec[115] == true); + require(vec[116] == false); + require(vec[117] == false); + require(vec[118] == true); + require(vec[119] == false); + require(vec[120] == true); + require(vec[121] == false); + require(vec[122] == true); + require(vec[123] == true); + require(vec[124] == true); + require(vec[125] == true); + require(vec[126] == true); + require(vec[127] == true); } // WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target. #if !defined(__wasm__) 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); + require(vec[0] == false); + require(vec[1] == true); + require(vec[2] == true); + require(vec[3] == false); + require(vec[4] == false); + require(vec[5] == true); + require(vec[6] == true); + require(vec[7] == true); + require(vec[8] == false); + require(vec[9] == true); + require(vec[10] == true); + require(vec[11] == true); + require(vec[12] == false); + require(vec[13] == true); + require(vec[14] == false); + require(vec[15] == true); + require(vec[16] == false); + require(vec[17] == false); + require(vec[18] == true); + require(vec[19] == true); + require(vec[20] == false); + require(vec[21] == true); + require(vec[22] == false); + require(vec[23] == false); + require(vec[24] == false); + require(vec[25] == true); + require(vec[26] == true); + require(vec[27] == false); + require(vec[28] == false); + require(vec[29] == true); + require(vec[30] == true); + require(vec[31] == false); + require(vec[32] == true); + require(vec[33] == false); + require(vec[34] == false); + require(vec[35] == true); + require(vec[36] == false); + require(vec[37] == true); + require(vec[38] == false); + require(vec[39] == true); + require(vec[40] == true); + require(vec[41] == true); + require(vec[42] == true); + require(vec[43] == false); + require(vec[44] == false); + require(vec[45] == true); + require(vec[46] == false); + require(vec[47] == false); + require(vec[48] == false); + require(vec[49] == false); + require(vec[50] == false); + require(vec[51] == false); + require(vec[52] == true); + require(vec[53] == true); + require(vec[54] == true); + require(vec[55] == true); + require(vec[56] == true); + require(vec[57] == true); + require(vec[58] == false); + require(vec[59] == true); + require(vec[60] == true); + require(vec[61] == false); + require(vec[62] == false); + require(vec[63] == true); + require(vec[64] == false); + require(vec[65] == false); + require(vec[66] == false); + require(vec[67] == false); + require(vec[68] == false); + require(vec[69] == false); + require(vec[70] == true); + require(vec[71] == true); + require(vec[72] == true); + require(vec[73] == false); + require(vec[74] == false); + require(vec[75] == false); + require(vec[76] == true); + require(vec[77] == false); + require(vec[78] == true); + require(vec[79] == true); + require(vec[80] == false); + require(vec[81] == false); + require(vec[82] == true); + require(vec[83] == true); + require(vec[84] == false); + require(vec[85] == true); + require(vec[86] == true); + require(vec[87] == true); + require(vec[88] == true); + require(vec[89] == true); + require(vec[90] == true); + require(vec[91] == true); + require(vec[92] == false); + require(vec[93] == true); + require(vec[94] == true); + require(vec[95] == false); + require(vec[96] == false); + require(vec[97] == true); + require(vec[98] == true); + require(vec[99] == false); + require(vec[100] == true); + require(vec[101] == false); + require(vec[102] == false); + require(vec[103] == true); + require(vec[104] == false); + require(vec[105] == true); + require(vec[106] == true); + require(vec[107] == true); + require(vec[108] == true); + require(vec[109] == true); + require(vec[110] == false); + require(vec[111] == false); + require(vec[112] == false); + require(vec[113] == false); + require(vec[114] == true); + require(vec[115] == true); + require(vec[116] == false); + require(vec[117] == true); + require(vec[118] == false); + require(vec[119] == false); + require(vec[120] == true); + require(vec[121] == false); + require(vec[122] == false); + require(vec[123] == true); + require(vec[124] == false); + require(vec[125] == true); + require(vec[126] == true); + require(vec[127] == true); + require(vec[128] == true); + require(vec[129] == false); + require(vec[130] == true); + require(vec[131] == true); + require(vec[132] == false); + require(vec[133] == false); + require(vec[134] == true); + require(vec[135] == false); + require(vec[136] == false); + require(vec[137] == true); + require(vec[138] == false); + require(vec[139] == true); + require(vec[140] == false); + require(vec[141] == true); + require(vec[142] == true); + require(vec[143] == true); + require(vec[144] == true); + require(vec[145] == false); + require(vec[146] == true); + require(vec[147] == false); + require(vec[148] == false); + require(vec[149] == false); + require(vec[150] == true); + require(vec[151] == true); + require(vec[152] == true); + require(vec[153] == true); + require(vec[154] == true); + require(vec[155] == false); + require(vec[156] == true); + require(vec[157] == false); + require(vec[158] == false); + require(vec[159] == false); + require(vec[160] == true); + require(vec[161] == true); + require(vec[162] == false); + require(vec[163] == true); + require(vec[164] == true); + require(vec[165] == false); + require(vec[166] == false); + require(vec[167] == false); + require(vec[168] == false); + require(vec[169] == true); + require(vec[170] == false); + require(vec[171] == true); + require(vec[172] == false); + require(vec[173] == false); + require(vec[174] == false); + require(vec[175] == false); + require(vec[176] == true); + require(vec[177] == true); + require(vec[178] == true); + require(vec[179] == false); + require(vec[180] == true); + require(vec[181] == false); + require(vec[182] == true); + require(vec[183] == true); + require(vec[184] == false); + require(vec[185] == false); + require(vec[186] == true); + require(vec[187] == false); + require(vec[188] == false); + require(vec[189] == false); + require(vec[190] == false); + require(vec[191] == true); + require(vec[192] == true); + require(vec[193] == true); + require(vec[194] == true); + require(vec[195] == true); + require(vec[196] == true); + require(vec[197] == true); + require(vec[198] == false); + require(vec[199] == true); + require(vec[200] == false); + require(vec[201] == false); + require(vec[202] == true); + require(vec[203] == false); + require(vec[204] == true); + require(vec[205] == true); + require(vec[206] == true); + require(vec[207] == false); + require(vec[208] == false); + require(vec[209] == true); + require(vec[210] == true); + require(vec[211] == true); + require(vec[212] == false); + require(vec[213] == true); + require(vec[214] == true); + require(vec[215] == true); + require(vec[216] == true); + require(vec[217] == true); + require(vec[218] == false); + require(vec[219] == false); + require(vec[220] == false); + require(vec[221] == false); + require(vec[222] == false); + require(vec[223] == true); + require(vec[224] == true); + require(vec[225] == false); + require(vec[226] == true); + require(vec[227] == false); + require(vec[228] == false); + require(vec[229] == true); + require(vec[230] == false); + require(vec[231] == true); + require(vec[232] == false); + require(vec[233] == false); + require(vec[234] == false); + require(vec[235] == true); + require(vec[236] == false); + require(vec[237] == false); + require(vec[238] == false); + require(vec[239] == true); + require(vec[240] == true); + require(vec[241] == true); + require(vec[242] == true); + require(vec[243] == true); + require(vec[244] == true); + require(vec[245] == false); + require(vec[246] == false); + require(vec[247] == true); + require(vec[248] == false); + require(vec[249] == true); + require(vec[250] == true); + require(vec[251] == false); + require(vec[252] == true); + require(vec[253] == true); + require(vec[254] == true); + require(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); + require(vec[0] == true); + require(vec[1] == true); + require(vec[2] == true); + require(vec[3] == true); + require(vec[4] == true); + require(vec[5] == false); + require(vec[6] == false); + require(vec[7] == true); + require(vec[8] == true); + require(vec[9] == true); + require(vec[10] == true); + require(vec[11] == false); + require(vec[12] == true); + require(vec[13] == true); + require(vec[14] == false); + require(vec[15] == false); + require(vec[16] == false); + require(vec[17] == true); + require(vec[18] == true); + require(vec[19] == true); + require(vec[20] == true); + require(vec[21] == true); + require(vec[22] == false); + require(vec[23] == false); + require(vec[24] == true); + require(vec[25] == true); + require(vec[26] == false); + require(vec[27] == false); + require(vec[28] == false); + require(vec[29] == false); + require(vec[30] == false); + require(vec[31] == true); + require(vec[32] == true); + require(vec[33] == false); + require(vec[34] == true); + require(vec[35] == true); + require(vec[36] == true); + require(vec[37] == true); + require(vec[38] == true); + require(vec[39] == true); + require(vec[40] == false); + require(vec[41] == true); + require(vec[42] == true); + require(vec[43] == false); + require(vec[44] == false); + require(vec[45] == false); + require(vec[46] == true); + require(vec[47] == true); + require(vec[48] == false); + require(vec[49] == true); + require(vec[50] == false); + require(vec[51] == true); + require(vec[52] == true); + require(vec[53] == false); + require(vec[54] == true); + require(vec[55] == false); + require(vec[56] == false); + require(vec[57] == true); + require(vec[58] == true); + require(vec[59] == false); + require(vec[60] == true); + require(vec[61] == true); + require(vec[62] == false); + require(vec[63] == true); + require(vec[64] == false); + require(vec[65] == true); + require(vec[66] == true); + require(vec[67] == true); + require(vec[68] == true); + require(vec[69] == true); + require(vec[70] == true); + require(vec[71] == true); + require(vec[72] == true); + require(vec[73] == true); + require(vec[74] == false); + require(vec[75] == true); + require(vec[76] == false); + require(vec[77] == true); + require(vec[78] == false); + require(vec[79] == false); + require(vec[80] == false); + require(vec[81] == true); + require(vec[82] == false); + require(vec[83] == true); + require(vec[84] == true); + require(vec[85] == false); + require(vec[86] == true); + require(vec[87] == true); + require(vec[88] == true); + require(vec[89] == false); + require(vec[90] == true); + require(vec[91] == true); + require(vec[92] == false); + require(vec[93] == true); + require(vec[94] == false); + require(vec[95] == true); + require(vec[96] == true); + require(vec[97] == false); + require(vec[98] == false); + require(vec[99] == false); + require(vec[100] == true); + require(vec[101] == true); + require(vec[102] == false); + require(vec[103] == true); + require(vec[104] == false); + require(vec[105] == false); + require(vec[106] == true); + require(vec[107] == false); + require(vec[108] == false); + require(vec[109] == true); + require(vec[110] == false); + require(vec[111] == false); + require(vec[112] == false); + require(vec[113] == false); + require(vec[114] == false); + require(vec[115] == true); + require(vec[116] == true); + require(vec[117] == false); + require(vec[118] == false); + require(vec[119] == false); + require(vec[120] == false); + require(vec[121] == true); + require(vec[122] == false); + require(vec[123] == false); + require(vec[124] == true); + require(vec[125] == true); + require(vec[126] == false); + require(vec[127] == true); + require(vec[128] == false); + require(vec[129] == true); + require(vec[130] == true); + require(vec[131] == false); + require(vec[132] == true); + require(vec[133] == false); + require(vec[134] == false); + require(vec[135] == false); + require(vec[136] == false); + require(vec[137] == true); + require(vec[138] == true); + require(vec[139] == false); + require(vec[140] == false); + require(vec[141] == false); + require(vec[142] == true); + require(vec[143] == true); + require(vec[144] == false); + require(vec[145] == false); + require(vec[146] == true); + require(vec[147] == true); + require(vec[148] == true); + require(vec[149] == true); + require(vec[150] == true); + require(vec[151] == true); + require(vec[152] == true); + require(vec[153] == false); + require(vec[154] == true); + require(vec[155] == false); + require(vec[156] == false); + require(vec[157] == true); + require(vec[158] == false); + require(vec[159] == true); + require(vec[160] == false); + require(vec[161] == true); + require(vec[162] == true); + require(vec[163] == true); + require(vec[164] == true); + require(vec[165] == true); + require(vec[166] == true); + require(vec[167] == true); + require(vec[168] == true); + require(vec[169] == false); + require(vec[170] == true); + require(vec[171] == true); + require(vec[172] == false); + require(vec[173] == true); + require(vec[174] == true); + require(vec[175] == false); + require(vec[176] == false); + require(vec[177] == false); + require(vec[178] == true); + require(vec[179] == false); + require(vec[180] == false); + require(vec[181] == true); + require(vec[182] == true); + require(vec[183] == true); + require(vec[184] == true); + require(vec[185] == true); + require(vec[186] == true); + require(vec[187] == true); + require(vec[188] == true); + require(vec[189] == true); + require(vec[190] == false); + require(vec[191] == true); + require(vec[192] == true); + require(vec[193] == false); + require(vec[194] == false); + require(vec[195] == true); + require(vec[196] == true); + require(vec[197] == false); + require(vec[198] == true); + require(vec[199] == true); + require(vec[200] == false); + require(vec[201] == true); + require(vec[202] == true); + require(vec[203] == false); + require(vec[204] == true); + require(vec[205] == true); + require(vec[206] == true); + require(vec[207] == true); + require(vec[208] == false); + require(vec[209] == true); + require(vec[210] == false); + require(vec[211] == true); + require(vec[212] == true); + require(vec[213] == false); + require(vec[214] == true); + require(vec[215] == false); + require(vec[216] == true); + require(vec[217] == false); + require(vec[218] == true); + require(vec[219] == false); + require(vec[220] == false); + require(vec[221] == true); + require(vec[222] == false); + require(vec[223] == false); + require(vec[224] == false); + require(vec[225] == true); + require(vec[226] == true); + require(vec[227] == false); + require(vec[228] == false); + require(vec[229] == false); + require(vec[230] == true); + require(vec[231] == false); + require(vec[232] == true); + require(vec[233] == false); + require(vec[234] == false); + require(vec[235] == false); + require(vec[236] == true); + require(vec[237] == true); + require(vec[238] == false); + require(vec[239] == false); + require(vec[240] == false); + require(vec[241] == false); + require(vec[242] == false); + require(vec[243] == true); + require(vec[244] == true); + require(vec[245] == false); + require(vec[246] == true); + require(vec[247] == false); + require(vec[248] == false); + require(vec[249] == true); + require(vec[250] == false); + require(vec[251] == false); + require(vec[252] == false); + require(vec[253] == true); + require(vec[254] == false); + require(vec[255] == false); + require(vec[256] == false); + require(vec[257] == false); + require(vec[258] == true); + require(vec[259] == true); + require(vec[260] == true); + require(vec[261] == true); + require(vec[262] == false); + require(vec[263] == true); + require(vec[264] == false); + require(vec[265] == false); + require(vec[266] == false); + require(vec[267] == true); + require(vec[268] == false); + require(vec[269] == false); + require(vec[270] == true); + require(vec[271] == true); + require(vec[272] == false); + require(vec[273] == false); + require(vec[274] == false); + require(vec[275] == false); + require(vec[276] == false); + require(vec[277] == true); + require(vec[278] == false); + require(vec[279] == true); + require(vec[280] == true); + require(vec[281] == true); + require(vec[282] == true); + require(vec[283] == true); + require(vec[284] == false); + require(vec[285] == false); + require(vec[286] == false); + require(vec[287] == false); + require(vec[288] == false); + require(vec[289] == false); + require(vec[290] == false); + require(vec[291] == false); + require(vec[292] == false); + require(vec[293] == true); + require(vec[294] == true); + require(vec[295] == true); + require(vec[296] == true); + require(vec[297] == true); + require(vec[298] == true); + require(vec[299] == false); + require(vec[300] == true); + require(vec[301] == false); + require(vec[302] == true); + require(vec[303] == true); + require(vec[304] == true); + require(vec[305] == false); + require(vec[306] == false); + require(vec[307] == true); + require(vec[308] == true); + require(vec[309] == true); + require(vec[310] == false); + require(vec[311] == true); + require(vec[312] == true); + require(vec[313] == true); + require(vec[314] == false); + require(vec[315] == true); + require(vec[316] == true); + require(vec[317] == true); + require(vec[318] == false); + require(vec[319] == true); + require(vec[320] == true); + require(vec[321] == false); + require(vec[322] == false); + require(vec[323] == true); + require(vec[324] == false); + require(vec[325] == false); + require(vec[326] == false); + require(vec[327] == false); + require(vec[328] == true); + require(vec[329] == false); + require(vec[330] == true); + require(vec[331] == true); + require(vec[332] == true); + require(vec[333] == true); + require(vec[334] == false); + require(vec[335] == false); + require(vec[336] == true); + require(vec[337] == false); + require(vec[338] == true); + require(vec[339] == false); + require(vec[340] == false); + require(vec[341] == false); + require(vec[342] == true); + require(vec[343] == false); + require(vec[344] == true); + require(vec[345] == false); + require(vec[346] == false); + require(vec[347] == true); + require(vec[348] == true); + require(vec[349] == true); + require(vec[350] == true); + require(vec[351] == false); + require(vec[352] == false); + require(vec[353] == false); + require(vec[354] == true); + require(vec[355] == true); + require(vec[356] == false); + require(vec[357] == true); + require(vec[358] == false); + require(vec[359] == false); + require(vec[360] == true); + require(vec[361] == false); + require(vec[362] == true); + require(vec[363] == false); + require(vec[364] == true); + require(vec[365] == true); + require(vec[366] == false); + require(vec[367] == false); + require(vec[368] == true); + require(vec[369] == true); + require(vec[370] == true); + require(vec[371] == true); + require(vec[372] == false); + require(vec[373] == false); + require(vec[374] == true); + require(vec[375] == false); + require(vec[376] == true); + require(vec[377] == true); + require(vec[378] == false); + require(vec[379] == true); + require(vec[380] == true); + require(vec[381] == false); + require(vec[382] == true); + require(vec[383] == true); + require(vec[384] == true); + require(vec[385] == false); + require(vec[386] == true); + require(vec[387] == true); + require(vec[388] == true); + require(vec[389] == false); + require(vec[390] == false); + require(vec[391] == true); + require(vec[392] == false); + require(vec[393] == true); + require(vec[394] == true); + require(vec[395] == true); + require(vec[396] == false); + require(vec[397] == false); + require(vec[398] == false); + require(vec[399] == false); + require(vec[400] == false); + require(vec[401] == true); + require(vec[402] == false); + require(vec[403] == false); + require(vec[404] == false); + require(vec[405] == false); + require(vec[406] == true); + require(vec[407] == false); + require(vec[408] == false); + require(vec[409] == true); + require(vec[410] == true); + require(vec[411] == false); + require(vec[412] == false); + require(vec[413] == false); + require(vec[414] == false); + require(vec[415] == true); + require(vec[416] == true); + require(vec[417] == true); + require(vec[418] == true); + require(vec[419] == true); + require(vec[420] == false); + require(vec[421] == false); + require(vec[422] == false); + require(vec[423] == true); + require(vec[424] == false); + require(vec[425] == false); + require(vec[426] == false); + require(vec[427] == false); + require(vec[428] == true); + require(vec[429] == false); + require(vec[430] == true); + require(vec[431] == false); + require(vec[432] == true); + require(vec[433] == true); + require(vec[434] == true); + require(vec[435] == true); + require(vec[436] == false); + require(vec[437] == false); + require(vec[438] == false); + require(vec[439] == false); + require(vec[440] == false); + require(vec[441] == true); + require(vec[442] == true); + require(vec[443] == true); + require(vec[444] == true); + require(vec[445] == true); + require(vec[446] == true); + require(vec[447] == true); + require(vec[448] == true); + require(vec[449] == true); + require(vec[450] == false); + require(vec[451] == false); + require(vec[452] == true); + require(vec[453] == false); + require(vec[454] == true); + require(vec[455] == false); + require(vec[456] == false); + require(vec[457] == true); + require(vec[458] == false); + require(vec[459] == false); + require(vec[460] == true); + require(vec[461] == true); + require(vec[462] == true); + require(vec[463] == true); + require(vec[464] == true); + require(vec[465] == true); + require(vec[466] == false); + require(vec[467] == true); + require(vec[468] == false); + require(vec[469] == false); + require(vec[470] == false); + require(vec[471] == true); + require(vec[472] == true); + require(vec[473] == false); + require(vec[474] == true); + require(vec[475] == true); + require(vec[476] == false); + require(vec[477] == false); + require(vec[478] == true); + require(vec[479] == true); + require(vec[480] == false); + require(vec[481] == false); + require(vec[482] == true); + require(vec[483] == true); + require(vec[484] == false); + require(vec[485] == true); + require(vec[486] == false); + require(vec[487] == true); + require(vec[488] == true); + require(vec[489] == true); + require(vec[490] == true); + require(vec[491] == true); + require(vec[492] == true); + require(vec[493] == true); + require(vec[494] == true); + require(vec[495] == true); + require(vec[496] == false); + require(vec[497] == true); + require(vec[498] == true); + require(vec[499] == true); + require(vec[500] == false); + require(vec[501] == false); + require(vec[502] == true); + require(vec[503] == false); + require(vec[504] == false); + require(vec[505] == false); + require(vec[506] == true); + require(vec[507] == true); + require(vec[508] == false); + require(vec[509] == true); + require(vec[510] == false); + require(vec[511] == true); } #endif @@ -2581,16 +2577,16 @@ void run_c_tests(void) { // float complex a = 1.25f + I * 2.6f; // float complex b = 11.3f - I * 1.5f; // float complex z = bb_cmultf(a, b); - // assert_or_panic(creal(z) == 1.5f); - // assert_or_panic(cimag(z) == 13.5f); + // require(creal(z) == 1.5f); + // require(cimag(z) == 13.5f); //} // { // double complex a = 1.25 + I * 2.6; // double complex b = 11.3 - I * 1.5; // double complex z = bb_cmultd(a, b); - // assert_or_panic(creal(z) == 1.5); - // assert_or_panic(cimag(z) == 13.5); + // require(creal(z) == 1.5); + // require(cimag(z) == 13.5); // } // { @@ -2599,8 +2595,8 @@ void run_c_tests(void) { // float b_r = 11.3f; // float b_i = -1.5f; // float complex z = bb_cmultf_comp(a_r, a_i, b_r, b_i); - // assert_or_panic(creal(z) == 1.5f); - // assert_or_panic(cimag(z) == 13.5f); + // require(creal(z) == 1.5f); + // require(cimag(z) == 13.5f); // } // { @@ -2609,16 +2605,16 @@ void run_c_tests(void) { // double b_r = 11.3; // double b_i = -1.5; // double complex z = bb_cmultd_comp(a_r, a_i, b_r, b_i); - // assert_or_panic(creal(z) == 1.5); - // assert_or_panic(cimag(z) == 13.5); + // require(creal(z) == 1.5); + // require(cimag(z) == 13.5); // } #endif #if !defined(__mips__) && !defined(ZIG_PPC32) { struct Struct_u64_u64 s = bb_ret_struct_u64_u64(); - assert_or_panic(s.a == 1); - assert_or_panic(s.b == 2); + require(s.a == 1); + require(s.b == 2); bb_struct_u64_u64_0((struct Struct_u64_u64){ .a = 3, .b = 4 }); bb_struct_u64_u64_1(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }); bb_struct_u64_u64_2(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }); @@ -2699,11 +2695,11 @@ void run_c_tests(void) { { struct BigStruct s = {30, 31, 32, 33, 34}; struct BigStruct res = bb_big_struct_both(s); - assert_or_panic(res.a == 20); - assert_or_panic(res.b == 21); - assert_or_panic(res.c == 22); - assert_or_panic(res.d == 23); - assert_or_panic(res.e == 24); + require(res.a == 20); + require(res.b == 21); + require(res.c == 22); + require(res.d == 23); + require(res.e == 24); } #endif @@ -2724,18 +2720,18 @@ void run_c_tests(void) { // #endif { - assert_or_panic(bb_ret_bool() == 1); + require(bb_ret_bool() == 1); - assert_or_panic(bb_ret_u8() == 0xff); - assert_or_panic(bb_ret_u16() == 0xffff); - assert_or_panic(bb_ret_u32() == 0xffffffff); - assert_or_panic(bb_ret_u64() == 0xffffffffffffffff); + require(bb_ret_u8() == 0xff); + require(bb_ret_u16() == 0xffff); + require(bb_ret_u32() == 0xffffffff); + require(bb_ret_u64() == 0xffffffffffffffff); - assert_or_panic(bb_ret_s8() == -1); - assert_or_panic(bb_ret_s16() == -1); - assert_or_panic(bb_ret_s32() == -1); - assert_or_panic(bb_ret_s64() == -1); + require(bb_ret_s8() == -1); + require(bb_ret_s16() == -1); + require(bb_ret_s32() == -1); + require(bb_ret_s64() == -1); } #if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32) @@ -2746,8 +2742,8 @@ void run_c_tests(void) { }); Vector2Bool vec = bb_ret_vector_2_bool(); - assert_or_panic(vec[0] == false); - assert_or_panic(vec[1] == false); + require(vec[0] == false); + require(vec[1] == false); } { bb_vector_4_bool((Vector4Bool){ @@ -2758,10 +2754,10 @@ void run_c_tests(void) { }); Vector4Bool vec = bb_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); + require(vec[0] == false); + require(vec[1] == true); + require(vec[2] == true); + require(vec[3] == true); } { bb_vector_8_bool((Vector8Bool){ @@ -2776,14 +2772,14 @@ void run_c_tests(void) { }); Vector8Bool vec = bb_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); + require(vec[0] == false); + require(vec[1] == false); + require(vec[2] == false); + require(vec[3] == false); + require(vec[4] == true); + require(vec[5] == false); + require(vec[6] == false); + require(vec[7] == false); } { bb_vector_16_bool((Vector16Bool){ @@ -2806,22 +2802,22 @@ void run_c_tests(void) { }); Vector16Bool vec = bb_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); + require(vec[0] == false); + require(vec[1] == true); + require(vec[2] == false); + require(vec[3] == false); + require(vec[4] == false); + require(vec[5] == true); + require(vec[6] == false); + require(vec[7] == false); + require(vec[8] == true); + require(vec[9] == false); + require(vec[10] == false); + require(vec[11] == false); + require(vec[12] == false); + require(vec[13] == true); + require(vec[14] == false); + require(vec[15] == false); } { bb_vector_32_bool((Vector32Bool){ @@ -2860,38 +2856,38 @@ void run_c_tests(void) { }); Vector32Bool vec = bb_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); + require(vec[0] == false); + require(vec[1] == true); + require(vec[2] == false); + require(vec[3] == false); + require(vec[4] == true); + require(vec[5] == false); + require(vec[6] == true); + require(vec[7] == true); + require(vec[8] == true); + require(vec[9] == true); + require(vec[10] == true); + require(vec[11] == true); + require(vec[12] == false); + require(vec[13] == false); + require(vec[14] == false); + require(vec[15] == false); + require(vec[16] == false); + require(vec[17] == false); + require(vec[18] == true); + require(vec[19] == true); + require(vec[20] == true); + require(vec[21] == false); + require(vec[22] == true); + require(vec[23] == false); + require(vec[24] == true); + require(vec[25] == false); + require(vec[26] == false); + require(vec[27] == true); + require(vec[28] == false); + require(vec[29] == false); + require(vec[30] == true); + require(vec[31] == true); } { bb_vector_64_bool((Vector64Bool){ @@ -2962,70 +2958,70 @@ void run_c_tests(void) { }); Vector64Bool vec = bb_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); + require(vec[0] == true); + require(vec[1] == false); + require(vec[2] == true); + require(vec[3] == false); + require(vec[4] == false); + require(vec[5] == true); + require(vec[6] == false); + require(vec[7] == true); + require(vec[8] == true); + require(vec[9] == false); + require(vec[10] == true); + require(vec[11] == false); + require(vec[12] == true); + require(vec[13] == false); + require(vec[14] == false); + require(vec[15] == true); + require(vec[16] == false); + require(vec[17] == false); + require(vec[18] == true); + require(vec[19] == true); + require(vec[20] == false); + require(vec[21] == false); + require(vec[22] == true); + require(vec[23] == false); + require(vec[24] == false); + require(vec[25] == true); + require(vec[26] == true); + require(vec[27] == true); + require(vec[28] == true); + require(vec[29] == true); + require(vec[30] == false); + require(vec[31] == false); + require(vec[32] == true); + require(vec[33] == true); + require(vec[34] == true); + require(vec[35] == true); + require(vec[36] == false); + require(vec[37] == true); + require(vec[38] == false); + require(vec[39] == true); + require(vec[40] == true); + require(vec[41] == true); + require(vec[42] == true); + require(vec[43] == true); + require(vec[44] == false); + require(vec[45] == false); + require(vec[46] == false); + require(vec[47] == true); + require(vec[48] == true); + require(vec[49] == true); + require(vec[50] == false); + require(vec[51] == true); + require(vec[52] == true); + require(vec[53] == true); + require(vec[54] == false); + require(vec[55] == false); + require(vec[56] == false); + require(vec[57] == true); + require(vec[58] == false); + require(vec[59] == false); + require(vec[60] == true); + require(vec[61] == false); + require(vec[62] == true); + require(vec[63] == false); } { bb_vector_128_bool((Vector128Bool){ @@ -3160,134 +3156,134 @@ void run_c_tests(void) { }); Vector128Bool vec = bb_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); + require(vec[0] == true); + require(vec[1] == true); + require(vec[2] == false); + require(vec[3] == false); + require(vec[4] == false); + require(vec[5] == true); + require(vec[6] == true); + require(vec[7] == false); + require(vec[8] == false); + require(vec[9] == true); + require(vec[10] == false); + require(vec[11] == false); + require(vec[12] == false); + require(vec[13] == true); + require(vec[14] == false); + require(vec[15] == true); + require(vec[16] == true); + require(vec[17] == false); + require(vec[18] == false); + require(vec[19] == true); + require(vec[20] == true); + require(vec[21] == true); + require(vec[22] == true); + require(vec[23] == true); + require(vec[24] == false); + require(vec[25] == false); + require(vec[26] == true); + require(vec[27] == true); + require(vec[28] == true); + require(vec[29] == false); + require(vec[30] == false); + require(vec[31] == true); + require(vec[32] == true); + require(vec[33] == false); + require(vec[34] == true); + require(vec[35] == true); + require(vec[36] == true); + require(vec[37] == false); + require(vec[38] == true); + require(vec[39] == true); + require(vec[40] == true); + require(vec[41] == false); + require(vec[42] == true); + require(vec[43] == true); + require(vec[44] == false); + require(vec[45] == false); + require(vec[46] == false); + require(vec[47] == true); + require(vec[48] == false); + require(vec[49] == false); + require(vec[50] == false); + require(vec[51] == false); + require(vec[52] == true); + require(vec[53] == false); + require(vec[54] == true); + require(vec[55] == false); + require(vec[56] == true); + require(vec[57] == false); + require(vec[58] == false); + require(vec[59] == true); + require(vec[60] == true); + require(vec[61] == true); + require(vec[62] == true); + require(vec[63] == true); + require(vec[64] == false); + require(vec[65] == false); + require(vec[66] == false); + require(vec[67] == true); + require(vec[68] == true); + require(vec[69] == false); + require(vec[70] == true); + require(vec[71] == true); + require(vec[72] == false); + require(vec[73] == true); + require(vec[74] == true); + require(vec[75] == false); + require(vec[76] == false); + require(vec[77] == true); + require(vec[78] == false); + require(vec[79] == true); + require(vec[80] == false); + require(vec[81] == false); + require(vec[82] == true); + require(vec[83] == true); + require(vec[84] == false); + require(vec[85] == true); + require(vec[86] == false); + require(vec[87] == false); + require(vec[88] == true); + require(vec[89] == true); + require(vec[90] == true); + require(vec[91] == true); + require(vec[92] == true); + require(vec[93] == false); + require(vec[94] == false); + require(vec[95] == true); + require(vec[96] == false); + require(vec[97] == false); + require(vec[98] == true); + require(vec[99] == true); + require(vec[100] == true); + require(vec[101] == true); + require(vec[102] == true); + require(vec[103] == true); + require(vec[104] == true); + require(vec[105] == false); + require(vec[106] == false); + require(vec[107] == true); + require(vec[108] == false); + require(vec[109] == false); + require(vec[110] == true); + require(vec[111] == false); + require(vec[112] == false); + require(vec[113] == true); + require(vec[114] == false); + require(vec[115] == false); + require(vec[116] == false); + require(vec[117] == false); + require(vec[118] == false); + require(vec[119] == false); + require(vec[120] == true); + require(vec[121] == true); + require(vec[122] == true); + require(vec[123] == false); + require(vec[124] == true); + require(vec[125] == false); + require(vec[126] == false); + require(vec[127] == true); } { bb_vector_256_bool((Vector256Bool){ @@ -3550,262 +3546,262 @@ void run_c_tests(void) { }); Vector256Bool vec = bb_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); + require(vec[0] == true); + require(vec[1] == true); + require(vec[2] == true); + require(vec[3] == false); + require(vec[4] == true); + require(vec[5] == false); + require(vec[6] == false); + require(vec[7] == true); + require(vec[8] == false); + require(vec[9] == false); + require(vec[10] == false); + require(vec[11] == false); + require(vec[12] == false); + require(vec[13] == false); + require(vec[14] == false); + require(vec[15] == false); + require(vec[16] == true); + require(vec[17] == false); + require(vec[18] == true); + require(vec[19] == false); + require(vec[20] == false); + require(vec[21] == true); + require(vec[22] == true); + require(vec[23] == false); + require(vec[24] == false); + require(vec[25] == true); + require(vec[26] == true); + require(vec[27] == false); + require(vec[28] == true); + require(vec[29] == true); + require(vec[30] == true); + require(vec[31] == false); + require(vec[32] == true); + require(vec[33] == false); + require(vec[34] == true); + require(vec[35] == false); + require(vec[36] == true); + require(vec[37] == false); + require(vec[38] == true); + require(vec[39] == false); + require(vec[40] == false); + require(vec[41] == false); + require(vec[42] == true); + require(vec[43] == true); + require(vec[44] == true); + require(vec[45] == false); + require(vec[46] == false); + require(vec[47] == false); + require(vec[48] == true); + require(vec[49] == false); + require(vec[50] == true); + require(vec[51] == false); + require(vec[52] == true); + require(vec[53] == false); + require(vec[54] == true); + require(vec[55] == true); + require(vec[56] == false); + require(vec[57] == false); + require(vec[58] == false); + require(vec[59] == true); + require(vec[60] == true); + require(vec[61] == true); + require(vec[62] == false); + require(vec[63] == true); + require(vec[64] == false); + require(vec[65] == true); + require(vec[66] == false); + require(vec[67] == true); + require(vec[68] == true); + require(vec[69] == false); + require(vec[70] == true); + require(vec[71] == false); + require(vec[72] == true); + require(vec[73] == true); + require(vec[74] == false); + require(vec[75] == false); + require(vec[76] == false); + require(vec[77] == false); + require(vec[78] == false); + require(vec[79] == false); + require(vec[80] == false); + require(vec[81] == false); + require(vec[82] == false); + require(vec[83] == true); + require(vec[84] == false); + require(vec[85] == false); + require(vec[86] == false); + require(vec[87] == true); + require(vec[88] == false); + require(vec[89] == true); + require(vec[90] == true); + require(vec[91] == false); + require(vec[92] == false); + require(vec[93] == true); + require(vec[94] == true); + require(vec[95] == false); + require(vec[96] == false); + require(vec[97] == true); + require(vec[98] == false); + require(vec[99] == false); + require(vec[100] == false); + require(vec[101] == false); + require(vec[102] == false); + require(vec[103] == false); + require(vec[104] == false); + require(vec[105] == true); + require(vec[106] == true); + require(vec[107] == false); + require(vec[108] == true); + require(vec[109] == false); + require(vec[110] == true); + require(vec[111] == true); + require(vec[112] == false); + require(vec[113] == false); + require(vec[114] == false); + require(vec[115] == false); + require(vec[116] == false); + require(vec[117] == false); + require(vec[118] == false); + require(vec[119] == true); + require(vec[120] == true); + require(vec[121] == true); + require(vec[122] == false); + require(vec[123] == true); + require(vec[124] == true); + require(vec[125] == false); + require(vec[126] == false); + require(vec[127] == true); + require(vec[128] == true); + require(vec[129] == true); + require(vec[130] == true); + require(vec[131] == true); + require(vec[132] == false); + require(vec[133] == true); + require(vec[134] == true); + require(vec[135] == false); + require(vec[136] == false); + require(vec[137] == true); + require(vec[138] == true); + require(vec[139] == false); + require(vec[140] == true); + require(vec[141] == false); + require(vec[142] == true); + require(vec[143] == false); + require(vec[144] == true); + require(vec[145] == true); + require(vec[146] == true); + require(vec[147] == true); + require(vec[148] == false); + require(vec[149] == false); + require(vec[150] == false); + require(vec[151] == true); + require(vec[152] == false); + require(vec[153] == true); + require(vec[154] == false); + require(vec[155] == true); + require(vec[156] == true); + require(vec[157] == false); + require(vec[158] == true); + require(vec[159] == true); + require(vec[160] == true); + require(vec[161] == true); + require(vec[162] == true); + require(vec[163] == false); + require(vec[164] == false); + require(vec[165] == true); + require(vec[166] == false); + require(vec[167] == true); + require(vec[168] == true); + require(vec[169] == true); + require(vec[170] == true); + require(vec[171] == false); + require(vec[172] == true); + require(vec[173] == true); + require(vec[174] == true); + require(vec[175] == true); + require(vec[176] == true); + require(vec[177] == true); + require(vec[178] == true); + require(vec[179] == false); + require(vec[180] == true); + require(vec[181] == false); + require(vec[182] == false); + require(vec[183] == false); + require(vec[184] == true); + require(vec[185] == false); + require(vec[186] == true); + require(vec[187] == true); + require(vec[188] == false); + require(vec[189] == true); + require(vec[190] == false); + require(vec[191] == true); + require(vec[192] == false); + require(vec[193] == true); + require(vec[194] == false); + require(vec[195] == false); + require(vec[196] == true); + require(vec[197] == true); + require(vec[198] == true); + require(vec[199] == true); + require(vec[200] == true); + require(vec[201] == true); + require(vec[202] == true); + require(vec[203] == false); + require(vec[204] == true); + require(vec[205] == false); + require(vec[206] == false); + require(vec[207] == true); + require(vec[208] == true); + require(vec[209] == false); + require(vec[210] == false); + require(vec[211] == false); + require(vec[212] == true); + require(vec[213] == true); + require(vec[214] == true); + require(vec[215] == false); + require(vec[216] == false); + require(vec[217] == true); + require(vec[218] == true); + require(vec[219] == true); + require(vec[220] == true); + require(vec[221] == false); + require(vec[222] == true); + require(vec[223] == false); + require(vec[224] == true); + require(vec[225] == true); + require(vec[226] == true); + require(vec[227] == false); + require(vec[228] == false); + require(vec[229] == false); + require(vec[230] == false); + require(vec[231] == false); + require(vec[232] == true); + require(vec[233] == true); + require(vec[234] == false); + require(vec[235] == false); + require(vec[236] == false); + require(vec[237] == true); + require(vec[238] == true); + require(vec[239] == false); + require(vec[240] == true); + require(vec[241] == true); + require(vec[242] == true); + require(vec[243] == false); + require(vec[244] == true); + require(vec[245] == true); + require(vec[246] == false); + require(vec[247] == true); + require(vec[248] == false); + require(vec[249] == false); + require(vec[250] == true); + require(vec[251] == true); + require(vec[252] == false); + require(vec[253] == true); + require(vec[254] == false); + require(vec[255] == true); } { bb_vector_512_bool((Vector512Bool){ @@ -4324,665 +4320,665 @@ void run_c_tests(void) { }); Vector512Bool vec = bb_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); + require(vec[0] == true); + require(vec[1] == true); + require(vec[2] == true); + require(vec[3] == true); + require(vec[4] == false); + require(vec[5] == true); + require(vec[6] == false); + require(vec[7] == true); + require(vec[8] == true); + require(vec[9] == true); + require(vec[10] == false); + require(vec[11] == true); + require(vec[12] == false); + require(vec[13] == false); + require(vec[14] == false); + require(vec[15] == true); + require(vec[16] == true); + require(vec[17] == false); + require(vec[18] == false); + require(vec[19] == false); + require(vec[20] == true); + require(vec[21] == true); + require(vec[22] == false); + require(vec[23] == false); + require(vec[24] == false); + require(vec[25] == false); + require(vec[26] == true); + require(vec[27] == false); + require(vec[28] == false); + require(vec[29] == false); + require(vec[30] == true); + require(vec[31] == true); + require(vec[32] == true); + require(vec[33] == true); + require(vec[34] == false); + require(vec[35] == false); + require(vec[36] == false); + require(vec[37] == true); + require(vec[38] == true); + require(vec[39] == true); + require(vec[40] == false); + require(vec[41] == false); + require(vec[42] == true); + require(vec[43] == false); + require(vec[44] == false); + require(vec[45] == true); + require(vec[46] == false); + require(vec[47] == false); + require(vec[48] == true); + require(vec[49] == true); + require(vec[50] == true); + require(vec[51] == true); + require(vec[52] == false); + require(vec[53] == false); + require(vec[54] == false); + require(vec[55] == true); + require(vec[56] == false); + require(vec[57] == true); + require(vec[58] == false); + require(vec[59] == true); + require(vec[60] == true); + require(vec[61] == false); + require(vec[62] == false); + require(vec[63] == true); + require(vec[64] == true); + require(vec[65] == false); + require(vec[66] == true); + require(vec[67] == false); + require(vec[68] == false); + require(vec[69] == false); + require(vec[70] == true); + require(vec[71] == true); + require(vec[72] == true); + require(vec[73] == true); + require(vec[74] == true); + require(vec[75] == false); + require(vec[76] == true); + require(vec[77] == false); + require(vec[78] == true); + require(vec[79] == true); + require(vec[80] == true); + require(vec[81] == true); + require(vec[82] == true); + require(vec[83] == false); + require(vec[84] == true); + require(vec[85] == true); + require(vec[86] == false); + require(vec[87] == true); + require(vec[88] == false); + require(vec[89] == false); + require(vec[90] == true); + require(vec[91] == false); + require(vec[92] == true); + require(vec[93] == false); + require(vec[94] == false); + require(vec[95] == false); + require(vec[96] == true); + require(vec[97] == true); + require(vec[98] == false); + require(vec[99] == true); + require(vec[100] == true); + require(vec[101] == false); + require(vec[102] == true); + require(vec[103] == false); + require(vec[104] == true); + require(vec[105] == false); + require(vec[106] == true); + require(vec[107] == false); + require(vec[108] == false); + require(vec[109] == true); + require(vec[110] == false); + require(vec[111] == false); + require(vec[112] == true); + require(vec[113] == false); + require(vec[114] == true); + require(vec[115] == false); + require(vec[116] == true); + require(vec[117] == false); + require(vec[118] == false); + require(vec[119] == true); + require(vec[120] == true); + require(vec[121] == true); + require(vec[122] == false); + require(vec[123] == true); + require(vec[124] == false); + require(vec[125] == false); + require(vec[126] == true); + require(vec[127] == true); + require(vec[128] == false); + require(vec[129] == true); + require(vec[130] == true); + require(vec[131] == false); + require(vec[132] == true); + require(vec[133] == true); + require(vec[134] == false); + require(vec[135] == true); + require(vec[136] == true); + require(vec[137] == false); + require(vec[138] == false); + require(vec[139] == false); + require(vec[140] == true); + require(vec[141] == false); + require(vec[142] == true); + require(vec[143] == false); + require(vec[144] == false); + require(vec[145] == false); + require(vec[146] == true); + require(vec[147] == false); + require(vec[148] == true); + require(vec[149] == false); + require(vec[150] == false); + require(vec[151] == true); + require(vec[152] == false); + require(vec[153] == true); + require(vec[154] == true); + require(vec[155] == false); + require(vec[156] == true); + require(vec[157] == true); + require(vec[158] == false); + require(vec[159] == true); + require(vec[160] == true); + require(vec[161] == false); + require(vec[162] == false); + require(vec[163] == false); + require(vec[164] == true); + require(vec[165] == false); + require(vec[166] == true); + require(vec[167] == true); + require(vec[168] == true); + require(vec[169] == true); + require(vec[170] == false); + require(vec[171] == true); + require(vec[172] == false); + require(vec[173] == false); + require(vec[174] == true); + require(vec[175] == true); + require(vec[176] == true); + require(vec[177] == false); + require(vec[178] == false); + require(vec[179] == false); + require(vec[180] == true); + require(vec[181] == false); + require(vec[182] == false); + require(vec[183] == true); + require(vec[184] == true); + require(vec[185] == false); + require(vec[186] == true); + require(vec[187] == false); + require(vec[188] == true); + require(vec[189] == true); + require(vec[190] == true); + require(vec[191] == true); + require(vec[192] == true); + require(vec[193] == true); + require(vec[194] == true); + require(vec[195] == false); + require(vec[196] == false); + require(vec[197] == false); + require(vec[198] == false); + require(vec[199] == false); + require(vec[200] == true); + require(vec[201] == false); + require(vec[202] == true); + require(vec[203] == false); + require(vec[204] == true); + require(vec[205] == true); + require(vec[206] == false); + require(vec[207] == false); + require(vec[208] == false); + require(vec[209] == true); + require(vec[210] == true); + require(vec[211] == true); + require(vec[212] == false); + require(vec[213] == false); + require(vec[214] == true); + require(vec[215] == true); + require(vec[216] == true); + require(vec[217] == false); + require(vec[218] == false); + require(vec[219] == true); + require(vec[220] == false); + require(vec[221] == true); + require(vec[222] == true); + require(vec[223] == false); + require(vec[224] == true); + require(vec[225] == false); + require(vec[226] == false); + require(vec[227] == true); + require(vec[228] == false); + require(vec[229] == false); + require(vec[230] == true); + require(vec[231] == true); + require(vec[232] == false); + require(vec[233] == true); + require(vec[234] == true); + require(vec[235] == true); + require(vec[236] == true); + require(vec[237] == true); + require(vec[238] == false); + require(vec[239] == true); + require(vec[240] == false); + require(vec[241] == false); + require(vec[242] == true); + require(vec[243] == false); + require(vec[244] == true); + require(vec[245] == false); + require(vec[246] == true); + require(vec[247] == false); + require(vec[248] == true); + require(vec[249] == true); + require(vec[250] == true); + require(vec[251] == true); + require(vec[252] == true); + require(vec[253] == false); + require(vec[254] == false); + require(vec[255] == false); + require(vec[256] == false); + require(vec[257] == false); + require(vec[258] == false); + require(vec[259] == true); + require(vec[260] == true); + require(vec[261] == true); + require(vec[262] == true); + require(vec[263] == false); + require(vec[264] == false); + require(vec[265] == false); + require(vec[266] == true); + require(vec[267] == false); + require(vec[268] == true); + require(vec[269] == false); + require(vec[270] == true); + require(vec[271] == true); + require(vec[272] == true); + require(vec[273] == true); + require(vec[274] == true); + require(vec[275] == true); + require(vec[276] == false); + require(vec[277] == false); + require(vec[278] == true); + require(vec[279] == true); + require(vec[280] == false); + require(vec[281] == false); + require(vec[282] == false); + require(vec[283] == false); + require(vec[284] == true); + require(vec[285] == true); + require(vec[286] == true); + require(vec[287] == false); + require(vec[288] == false); + require(vec[289] == false); + require(vec[290] == true); + require(vec[291] == false); + require(vec[292] == true); + require(vec[293] == true); + require(vec[294] == false); + require(vec[295] == true); + require(vec[296] == true); + require(vec[297] == true); + require(vec[298] == false); + require(vec[299] == true); + require(vec[300] == true); + require(vec[301] == false); + require(vec[302] == false); + require(vec[303] == true); + require(vec[304] == false); + require(vec[305] == false); + require(vec[306] == true); + require(vec[307] == true); + require(vec[308] == true); + require(vec[309] == true); + require(vec[310] == false); + require(vec[311] == false); + require(vec[312] == false); + require(vec[313] == false); + require(vec[314] == false); + require(vec[315] == true); + require(vec[316] == false); + require(vec[317] == false); + require(vec[318] == true); + require(vec[319] == false); + require(vec[320] == false); + require(vec[321] == true); + require(vec[322] == true); + require(vec[323] == true); + require(vec[324] == true); + require(vec[325] == false); + require(vec[326] == false); + require(vec[327] == false); + require(vec[328] == true); + require(vec[329] == true); + require(vec[330] == false); + require(vec[331] == true); + require(vec[332] == true); + require(vec[333] == false); + require(vec[334] == false); + require(vec[335] == true); + require(vec[336] == true); + require(vec[337] == false); + require(vec[338] == true); + require(vec[339] == true); + require(vec[340] == true); + require(vec[341] == false); + require(vec[342] == false); + require(vec[343] == false); + require(vec[344] == true); + require(vec[345] == true); + require(vec[346] == false); + require(vec[347] == true); + require(vec[348] == false); + require(vec[349] == true); + require(vec[350] == false); + require(vec[351] == false); + require(vec[352] == true); + require(vec[353] == false); + require(vec[354] == true); + require(vec[355] == false); + require(vec[356] == false); + require(vec[357] == false); + require(vec[358] == false); + require(vec[359] == false); + require(vec[360] == true); + require(vec[361] == true); + require(vec[362] == false); + require(vec[363] == false); + require(vec[364] == false); + require(vec[365] == false); + require(vec[366] == true); + require(vec[367] == false); + require(vec[368] == true); + require(vec[369] == false); + require(vec[370] == true); + require(vec[371] == true); + require(vec[372] == false); + require(vec[373] == true); + require(vec[374] == true); + require(vec[375] == true); + require(vec[376] == true); + require(vec[377] == true); + require(vec[378] == false); + require(vec[379] == true); + require(vec[380] == false); + require(vec[381] == true); + require(vec[382] == true); + require(vec[383] == true); + require(vec[384] == true); + require(vec[385] == true); + require(vec[386] == false); + require(vec[387] == true); + require(vec[388] == true); + require(vec[389] == false); + require(vec[390] == true); + require(vec[391] == false); + require(vec[392] == true); + require(vec[393] == false); + require(vec[394] == true); + require(vec[395] == false); + require(vec[396] == true); + require(vec[397] == false); + require(vec[398] == false); + require(vec[399] == true); + require(vec[400] == true); + require(vec[401] == true); + require(vec[402] == true); + require(vec[403] == false); + require(vec[404] == false); + require(vec[405] == true); + require(vec[406] == false); + require(vec[407] == false); + require(vec[408] == false); + require(vec[409] == true); + require(vec[410] == false); + require(vec[411] == true); + require(vec[412] == true); + require(vec[413] == false); + require(vec[414] == true); + require(vec[415] == true); + require(vec[416] == false); + require(vec[417] == true); + require(vec[418] == true); + require(vec[419] == false); + require(vec[420] == false); + require(vec[421] == true); + require(vec[422] == false); + require(vec[423] == false); + require(vec[424] == true); + require(vec[425] == false); + require(vec[426] == true); + require(vec[427] == false); + require(vec[428] == false); + require(vec[429] == true); + require(vec[430] == false); + require(vec[431] == true); + require(vec[432] == true); + require(vec[433] == false); + require(vec[434] == true); + require(vec[435] == false); + require(vec[436] == true); + require(vec[437] == false); + require(vec[438] == true); + require(vec[439] == false); + require(vec[440] == false); + require(vec[441] == true); + require(vec[442] == true); + require(vec[443] == false); + require(vec[444] == true); + require(vec[445] == true); + require(vec[446] == false); + require(vec[447] == true); + require(vec[448] == true); + require(vec[449] == false); + require(vec[450] == false); + require(vec[451] == false); + require(vec[452] == false); + require(vec[453] == false); + require(vec[454] == true); + require(vec[455] == false); + require(vec[456] == false); + require(vec[457] == true); + require(vec[458] == false); + require(vec[459] == true); + require(vec[460] == false); + require(vec[461] == false); + require(vec[462] == false); + require(vec[463] == true); + require(vec[464] == false); + require(vec[465] == true); + require(vec[466] == false); + require(vec[467] == false); + require(vec[468] == false); + require(vec[469] == false); + require(vec[470] == true); + require(vec[471] == true); + require(vec[472] == false); + require(vec[473] == true); + require(vec[474] == true); + require(vec[475] == false); + require(vec[476] == false); + require(vec[477] == true); + require(vec[478] == true); + require(vec[479] == true); + require(vec[480] == false); + require(vec[481] == false); + require(vec[482] == true); + require(vec[483] == false); + require(vec[484] == false); + require(vec[485] == false); + require(vec[486] == true); + require(vec[487] == true); + require(vec[488] == false); + require(vec[489] == false); + require(vec[490] == false); + require(vec[491] == false); + require(vec[492] == false); + require(vec[493] == true); + require(vec[494] == true); + require(vec[495] == true); + require(vec[496] == true); + require(vec[497] == false); + require(vec[498] == false); + require(vec[499] == false); + require(vec[500] == true); + require(vec[501] == false); + require(vec[502] == true); + require(vec[503] == true); + require(vec[504] == true); + require(vec[505] == true); + require(vec[506] == false); + require(vec[507] == false); + require(vec[508] == true); + require(vec[509] == true); + require(vec[510] == false); + require(vec[511] == false); } #endif } void c_u8(uint8_t x) { - assert_or_panic(x == 0xff); + require(x == 0xff); } void c_u16(uint16_t x) { - assert_or_panic(x == 0xfffe); + require(x == 0xfffe); } void c_u32(uint32_t x) { - assert_or_panic(x == 0xfffffffd); + require(x == 0xfffffffd); } void c_u64(uint64_t x) { - assert_or_panic(x == 0xfffffffffffffffcULL); + require(x == 0xfffffffffffffffcULL); } // #ifndef ZIG_NO_I128 // void c_struct_u128(struct u128 x) { -// assert_or_panic(x.value == 0xfffffffffffffffcULL); +// require(x.value == 0xfffffffffffffffcULL); // } // #endif void c_s8(int8_t x) { - assert_or_panic(x == -1); + require(x == -1); } void c_s16(int16_t x) { - assert_or_panic(x == -2); + require(x == -2); } void c_s32(int32_t x) { - assert_or_panic(x == -3); + require(x == -3); } void c_s64(int64_t x) { - assert_or_panic(x == -4); + require(x == -4); } // #ifndef ZIG_NO_I128 // void c_struct_i128(struct i128 x) { -// assert_or_panic(x.value == -6); +// require(x.value == -6); // } // #endif // void c_f32(float x) { -// assert_or_panic(x == 12.34f); +// require(x == 12.34f); // } // void c_f64(double x) { -// assert_or_panic(x == 56.78); +// require(x == 56.78); // } // // void c_long_double(long double x) { -// assert_or_panic(x == 12.34l); +// require(x == 12.34l); // } void c_ptr(void *x) { - assert_or_panic(x == (void *)0xdeadbeefL); + require(x == (void *)0xdeadbeefL); } void c_bool(bool x) { - assert_or_panic(x); + require(x); } void c_five_integers(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e) { - assert_or_panic(a == 12); - assert_or_panic(b == 34); - assert_or_panic(c == 56); - assert_or_panic(d == 78); - assert_or_panic(e == 90); + require(a == 12); + require(b == 34); + require(c == 56); + require(d == 78); + require(e == 90); } // void c_five_floats(float a, float b, float c, float d, float e) { -// assert_or_panic(a == 1.0); -// assert_or_panic(b == 2.0); -// assert_or_panic(c == 3.0); -// assert_or_panic(d == 4.0); -// assert_or_panic(e == 5.0); +// require(a == 1.0); +// require(b == 2.0); +// require(c == 3.0); +// require(d == 4.0); +// require(e == 5.0); // } // // float complex c_cmultf_comp(float a_r, float a_i, float b_r, float b_i) { -// assert_or_panic(a_r == 1.25f); -// assert_or_panic(a_i == 2.6f); -// assert_or_panic(b_r == 11.3f); -// assert_or_panic(b_i == -1.5f); +// require(a_r == 1.25f); +// require(a_i == 2.6f); +// require(b_r == 11.3f); +// require(b_i == -1.5f); // // return 1.5f + I * 13.5f; // } // // double complex c_cmultd_comp(double a_r, double a_i, double b_r, double b_i) { -// assert_or_panic(a_r == 1.25); -// assert_or_panic(a_i == 2.6); -// assert_or_panic(b_r == 11.3); -// assert_or_panic(b_i == -1.5); +// require(a_r == 1.25); +// require(a_i == 2.6); +// require(b_r == 11.3); +// require(b_i == -1.5); // // return 1.5 + I * 13.5; // } // // float complex c_cmultf(float complex a, float complex b) { -// assert_or_panic(creal(a) == 1.25f); -// assert_or_panic(cimag(a) == 2.6f); -// assert_or_panic(creal(b) == 11.3f); -// assert_or_panic(cimag(b) == -1.5f); +// require(creal(a) == 1.25f); +// require(cimag(a) == 2.6f); +// require(creal(b) == 11.3f); +// require(cimag(b) == -1.5f); // // return 1.5f + I * 13.5f; // } // // double complex c_cmultd(double complex a, double complex b) { -// assert_or_panic(creal(a) == 1.25); -// assert_or_panic(cimag(a) == 2.6); -// assert_or_panic(creal(b) == 11.3); -// assert_or_panic(cimag(b) == -1.5); +// require(creal(a) == 1.25); +// require(cimag(a) == 2.6); +// require(creal(b) == 11.3); +// require(cimag(b) == -1.5); // // return 1.5 + I * 13.5; // } void c_big_struct(struct BigStruct x) { - assert_or_panic(x.a == 1); - assert_or_panic(x.b == 2); - assert_or_panic(x.c == 3); - assert_or_panic(x.d == 4); - assert_or_panic(x.e == 5); + require(x.a == 1); + require(x.b == 2); + require(x.c == 3); + require(x.d == 4); + require(x.e == 5); } void c_big_union(union BigUnion x) { - assert_or_panic(x.a.a == 1); - assert_or_panic(x.a.b == 2); - assert_or_panic(x.a.c == 3); - assert_or_panic(x.a.d == 4); + require(x.a.a == 1); + require(x.a.b == 2); + require(x.a.c == 3); + require(x.a.d == 4); } void c_small_struct_ints(struct SmallStructInts x) { - assert_or_panic(x.a == 1); - assert_or_panic(x.b == 2); - assert_or_panic(x.c == 3); - assert_or_panic(x.d == 4); + require(x.a == 1); + require(x.b == 2); + require(x.c == 3); + require(x.d == 4); struct SmallStructInts y = bb_ret_small_struct_ints(); - assert_or_panic(y.a == 1); - assert_or_panic(y.b == 2); - assert_or_panic(y.c == 3); - assert_or_panic(y.d == 4); + require(y.a == 1); + require(y.b == 2); + require(y.c == 3); + require(y.d == 4); } struct SmallStructInts c_ret_small_struct_ints() { @@ -4996,15 +4992,15 @@ struct SmallStructInts c_ret_small_struct_ints() { } void c_med_struct_ints(struct MedStructInts s) { - assert_or_panic(s.x == 1); - assert_or_panic(s.y == 2); - assert_or_panic(s.z == 3); + require(s.x == 1); + require(s.y == 2); + require(s.z == 3); struct MedStructInts s2 = bb_ret_med_struct_ints(); - assert_or_panic(s2.x == 1); - assert_or_panic(s2.y == 2); - assert_or_panic(s2.z == 3); + require(s2.x == 1); + require(s2.y == 2); + require(s2.z == 3); } struct MedStructInts c_ret_med_struct_ints() { @@ -5017,15 +5013,15 @@ struct MedStructInts c_ret_med_struct_ints() { } // void c_med_struct_mixed(struct MedStructMixed x) { -// assert_or_panic(x.a == 1234); -// assert_or_panic(x.b == 100.0f); -// assert_or_panic(x.c == 1337.0f); +// require(x.a == 1234); +// require(x.b == 100.0f); +// require(x.c == 1337.0f); // // struct MedStructMixed y = bb_ret_med_struct_mixed(); // -// assert_or_panic(y.a == 1234); -// assert_or_panic(y.b == 100.0f); -// assert_or_panic(y.c == 1337.0f); +// require(y.a == 1234); +// require(y.b == 100.0f); +// require(y.c == 1337.0f); // } struct MedStructMixed c_ret_med_struct_mixed() { @@ -5038,20 +5034,20 @@ struct MedStructMixed c_ret_med_struct_mixed() { } void c_split_struct_ints(struct SplitStructInts x) { - assert_or_panic(x.a == 1234); - assert_or_panic(x.b == 100); - assert_or_panic(x.c == 1337); + require(x.a == 1234); + require(x.b == 100); + require(x.c == 1337); } // void c_split_struct_mixed(struct SplitStructMixed x) { -// assert_or_panic(x.a == 1234); -// assert_or_panic(x.b == 100); -// assert_or_panic(x.c == 1337.0f); +// require(x.a == 1234); +// require(x.b == 100); +// require(x.c == 1337.0f); // struct SplitStructMixed y = bb_ret_split_struct_mixed(); // -// assert_or_panic(y.a == 1234); -// assert_or_panic(y.b == 100); -// assert_or_panic(y.c == 1337.0f); +// require(y.a == 1234); +// require(y.b == 100); +// require(y.c == 1337.0f); // } uint8_t c_ret_small_packed_struct() { @@ -5064,10 +5060,10 @@ uint8_t c_ret_small_packed_struct() { } void c_small_packed_struct(uint8_t x) { - assert_or_panic(((x >> 0) & 0x3) == 0); - assert_or_panic(((x >> 2) & 0x3) == 1); - assert_or_panic(((x >> 4) & 0x3) == 2); - assert_or_panic(((x >> 6) & 0x3) == 3); + require(((x >> 0) & 0x3) == 0); + require(((x >> 2) & 0x3) == 1); + require(((x >> 4) & 0x3) == 2); + require(((x >> 6) & 0x3) == 3); } // #ifndef ZIG_NO_I128 @@ -5079,8 +5075,8 @@ void c_small_packed_struct(uint8_t x) { // } // void c_big_packed_struct(__int128 x) { -// assert_or_panic(((x >> 0) & 0xFFFFFFFFFFFFFFFF) == 1); -// assert_or_panic(((x >> 64) & 0xFFFFFFFFFFFFFFFF) == 2); +// require(((x >> 0) & 0xFFFFFFFFFFFFFFFF) == 1); +// require(((x >> 64) & 0xFFFFFFFFFFFFFFFF) == 2); // } // #endif @@ -5094,56 +5090,56 @@ struct SplitStructMixed c_ret_split_struct_mixed() { } struct BigStruct c_big_struct_both(struct BigStruct x) { - assert_or_panic(x.a == 1); - assert_or_panic(x.b == 2); - assert_or_panic(x.c == 3); - assert_or_panic(x.d == 4); - assert_or_panic(x.e == 5); + require(x.a == 1); + require(x.b == 2); + require(x.c == 3); + require(x.d == 4); + require(x.e == 5); struct BigStruct y = {10, 11, 12, 13, 14}; return y; } void c_small_struct_floats(Vector3 vec) { - assert_or_panic(vec.x == 3.0); - assert_or_panic(vec.y == 6.0); - assert_or_panic(vec.z == 12.0); + require(vec.x == 3.0); + require(vec.y == 6.0); + require(vec.z == 12.0); } // void c_small_struct_floats_extra(Vector3 vec, const char *str) { -// assert_or_panic(vec.x == 3.0); -// assert_or_panic(vec.y == 6.0); -// assert_or_panic(vec.z == 12.0); -// assert_or_panic(!strcmp(str, "hello")); +// require(vec.x == 3.0); +// require(vec.y == 6.0); +// require(vec.z == 12.0); +// require(!strcmp(str, "hello")); // } void c_big_struct_floats(Vector5 vec) { - assert_or_panic(vec.x == 76.0); - assert_or_panic(vec.y == -1.0); - assert_or_panic(vec.z == -12.0); - assert_or_panic(vec.w == 69); - assert_or_panic(vec.q == 55); + require(vec.x == 76.0); + require(vec.y == -1.0); + require(vec.z == -12.0); + require(vec.w == 69); + require(vec.q == 55); } void c_multiple_struct_ints(Rect x, Rect y) { - assert_or_panic(x.left == 1); - assert_or_panic(x.right == 21); - assert_or_panic(x.top == 16); - assert_or_panic(x.bottom == 4); - assert_or_panic(y.left == 178); - assert_or_panic(y.right == 189); - assert_or_panic(y.top == 21); - assert_or_panic(y.bottom == 15); + require(x.left == 1); + require(x.right == 21); + require(x.top == 16); + require(x.bottom == 4); + require(y.left == 178); + require(y.right == 189); + require(y.top == 21); + require(y.bottom == 15); } void c_multiple_struct_floats(FloatRect x, FloatRect y) { - assert_or_panic(x.left == 1); - assert_or_panic(x.right == 21); - assert_or_panic(x.top == 16); - assert_or_panic(x.bottom == 4); - assert_or_panic(y.left == 178); - assert_or_panic(y.right == 189); - assert_or_panic(y.top == 21); - assert_or_panic(y.bottom == 15); + require(x.left == 1); + require(x.right == 21); + require(x.top == 16); + require(x.bottom == 4); + require(y.left == 178); + require(y.right == 189); + require(y.top == 21); + require(y.bottom == 15); } bool c_ret_bool() { @@ -5181,8 +5177,8 @@ typedef struct { } StructWithArray; void c_struct_with_array(StructWithArray x) { - assert_or_panic(x.a == 1); - assert_or_panic(x.b == 2); + require(x.a == 1); + require(x.b == 2); } StructWithArray c_ret_struct_with_array() { @@ -5201,10 +5197,10 @@ typedef struct { } FloatArrayStruct; void c_float_array_struct(FloatArrayStruct x) { - assert_or_panic(x.origin.x == 5); - assert_or_panic(x.origin.y == 6); - assert_or_panic(x.size.width == 7); - assert_or_panic(x.size.height == 8); + require(x.origin.x == 5); + require(x.origin.y == 6); + require(x.size.width == 7); + require(x.size.height == 8); } FloatArrayStruct c_ret_float_array_struct() { @@ -5219,8 +5215,8 @@ FloatArrayStruct c_ret_float_array_struct() { typedef uint32_t SmallVec __attribute__((vector_size(2 * sizeof(uint32_t)))); void c_small_vec(SmallVec vec) { - assert_or_panic(vec[0] == 1); - assert_or_panic(vec[1] == 2); + require(vec[0] == 1); + require(vec[1] == 2); } SmallVec c_ret_small_vec(void) { @@ -5230,10 +5226,10 @@ SmallVec c_ret_small_vec(void) { typedef size_t MediumVec __attribute__((vector_size(4 * sizeof(size_t)))); void c_medium_vec(MediumVec vec) { - assert_or_panic(vec[0] == 1); - assert_or_panic(vec[1] == 2); - assert_or_panic(vec[2] == 3); - assert_or_panic(vec[3] == 4); + require(vec[0] == 1); + require(vec[1] == 2); + require(vec[2] == 3); + require(vec[3] == 4); } MediumVec c_ret_medium_vec(void) { @@ -5243,14 +5239,14 @@ MediumVec c_ret_medium_vec(void) { typedef size_t BigVec __attribute__((vector_size(8 * sizeof(size_t)))); void c_big_vec(BigVec vec) { - assert_or_panic(vec[0] == 1); - assert_or_panic(vec[1] == 2); - assert_or_panic(vec[2] == 3); - assert_or_panic(vec[3] == 4); - assert_or_panic(vec[4] == 5); - assert_or_panic(vec[5] == 6); - assert_or_panic(vec[6] == 7); - assert_or_panic(vec[7] == 8); + require(vec[0] == 1); + require(vec[1] == 2); + require(vec[2] == 3); + require(vec[3] == 4); + require(vec[4] == 5); + require(vec[5] == 6); + require(vec[6] == 7); + require(vec[7] == 8); } BigVec c_ret_big_vec(void) { @@ -5262,8 +5258,8 @@ typedef struct { } Vector2; void c_ptr_size_float_struct(Vector2 vec) { - assert_or_panic(vec.x == 1); - assert_or_panic(vec.y == 2); + require(vec.x == 1); + require(vec.y == 2); } Vector2 c_ret_ptr_size_float_struct(void) { return (Vector2){3, 4}; @@ -5356,24 +5352,24 @@ struct ByVal { }; void c_func_ptr_byval(void *a, void *b, struct ByVal in, unsigned long c, void *d, unsigned long e) { - assert_or_panic((intptr_t)a == 1); - assert_or_panic((intptr_t)b == 2); + require((intptr_t)a == 1); + require((intptr_t)b == 2); - assert_or_panic(in.origin.x == 9); - assert_or_panic(in.origin.y == 10); - assert_or_panic(in.origin.z == 11); - assert_or_panic(in.size.width == 12); - assert_or_panic(in.size.height == 13); - assert_or_panic(in.size.depth == 14); + require(in.origin.x == 9); + require(in.origin.y == 10); + require(in.origin.z == 11); + require(in.size.width == 12); + require(in.size.height == 13); + require(in.size.depth == 14); - assert_or_panic(c == 3); - assert_or_panic((intptr_t)d == 4); - assert_or_panic(e == 5); + require(c == 3); + require((intptr_t)d == 4); + require(e == 5); } #ifndef ZIG_NO_RAW_F16 __fp16 c_f16(__fp16 a) { - assert_or_panic(a == 12); + require(a == 12); return 34; } #endif @@ -5382,21 +5378,21 @@ typedef struct { __fp16 a; } f16_struct; // f16_struct c_f16_struct(f16_struct a) { -// assert_or_panic(a.a == 12); +// require(a.a == 12); // return (f16_struct){34}; // } // #if defined __x86_64__ || defined __i386__ // typedef long double f80; // f80 c_f80(f80 a) { -// assert_or_panic((double)a == 12.34); +// require((double)a == 12.34); // return 56.78; // } // typedef struct { // f80 a; // } f80_struct; // f80_struct c_f80_struct(f80_struct a) { -// assert_or_panic((double)a.a == 12.34); +// require((double)a.a == 12.34); // return (f80_struct){56.78}; // } // typedef struct { @@ -5404,32 +5400,32 @@ typedef struct { // int b; // } f80_extra_struct; // f80_extra_struct c_f80_extra_struct(f80_extra_struct a) { -// assert_or_panic((double)a.a == 12.34); -// assert_or_panic(a.b == 42); +// require((double)a.a == 12.34); +// require(a.b == 42); // return (f80_extra_struct){56.78, 24}; // } // #endif // #ifndef ZIG_NO_F128 // __float128 c_f128(__float128 a) { -// assert_or_panic((double)a == 12.34); +// require((double)a == 12.34); // return 56.78; // } // typedef struct { // __float128 a; // } f128_struct; // f128_struct c_f128_struct(f128_struct a) { -// assert_or_panic((double)a.a == 12.34); +// require((double)a.a == 12.34); // return (f128_struct){56.78}; // } // #endif // void __attribute__((stdcall)) stdcall_scalars(char a, short b, int c, float d, double e) { -// assert_or_panic(a == 1); -// assert_or_panic(b == 2); -// assert_or_panic(c == 3); -// assert_or_panic(d == 4.0); -// assert_or_panic(e == 5.0); +// require(a == 1); +// require(b == 2); +// require(c == 3); +// require(d == 4.0); +// require(e == 5.0); // } // // typedef struct { @@ -5438,20 +5434,20 @@ typedef struct { // } Coord2; // // Coord2 __attribute__((stdcall)) stdcall_coord2(Coord2 a, Coord2 b, Coord2 c) { -// assert_or_panic(a.x == 0x1111); -// assert_or_panic(a.y == 0x2222); -// assert_or_panic(b.x == 0x3333); -// assert_or_panic(b.y == 0x4444); -// assert_or_panic(c.x == 0x5555); -// assert_or_panic(c.y == 0x6666); +// require(a.x == 0x1111); +// require(a.y == 0x2222); +// require(b.x == 0x3333); +// require(b.y == 0x4444); +// require(c.x == 0x5555); +// require(c.y == 0x6666); // return (Coord2){123, 456}; // } // // void __attribute__((stdcall)) stdcall_big_union(union BigUnion x) { -// assert_or_panic(x.a.a == 1); -// assert_or_panic(x.a.b == 2); -// assert_or_panic(x.a.c == 3); -// assert_or_panic(x.a.d == 4); +// require(x.a.a == 1); +// require(x.a.b == 2); +// require(x.a.c == 3); +// require(x.a.d == 4); // } #ifdef __x86_64__ diff --git a/src/converter.zig b/src/converter.zig index 3920b0e..49a21d2 100644 --- a/src/converter.zig +++ b/src/converter.zig @@ -51,6 +51,7 @@ const GlobalKeyword = enum { const GlobalKind = enum { @"fn", @"struct", + bits, }; const FunctionKeyword = enum { @@ -71,16 +72,21 @@ const CallingConvention = enum { }; const Module = struct { - llvm: *llvm.Module, - di_builder: ?*llvm.DI.Builder, - global_scope: *llvm.DI.Scope = undefined, - file: *llvm.DI.File = undefined, - debug_integer_types: [8]*llvm.DI.Type = undefined, + llvm: LLVM, globals: Variable.Array = .{}, types: Type.Array = .{}, values: Value.Array = .{}, - debug_tag: c_uint = 0, current_function: ?*Variable = null, + debug_tag: c_uint = 0, + + const LLVM = struct { + context: *llvm.Context, + handle: *llvm.Module, + builder: *llvm.Builder, + di_builder: ?*llvm.DI.Builder = null, + global_scope: *llvm.DI.Scope, + file: *llvm.DI.File, + }; pub fn get_type(module: *Module, index: usize) *Type { assert(index < module.types.count); @@ -89,13 +95,18 @@ const Module = struct { } pub fn integer_type(module: *Module, bit_count: u32, sign: bool) *Type { - assert(lib.is_power_of_two(bit_count)); - const index = @as(usize, @intFromBool(sign)) * 4 + @ctz(bit_count) - 3; - const result = module.get_type(index); - assert(result.bb == .integer); - assert(result.bb.integer.bit_count == bit_count); - assert(result.bb.integer.signed == sign); - return result; + switch (bit_count) { + 1...64 => { + const index = @as(usize, @intFromBool(sign)) * 64 + bit_count; + const result = module.get_type(index); + assert(result.bb == .integer); + assert(result.bb.integer.bit_count == bit_count); + assert(result.bb.integer.signed == sign); + return result; + }, + 128 => @trap(), + else => @trap(), + } } pub fn void_type(module: *Module) *Type { @@ -105,15 +116,17 @@ const Module = struct { return result; } - pub fn initialize(arena: *Arena, thread: *llvm.Thread, options: ConvertOptions) *Module { - const module = arena.allocate_one(Module); - const m = thread.context.create_module(options.name); - module.* = Module{ - .llvm = m, - .di_builder = if (options.has_debug_info) m.create_di_builder() else null, - }; + pub fn initialize(arena: *Arena, options: ConvertOptions) *Module { + const context = llvm.Context.create(); + const handle = context.create_module(options.name); - if (module.di_builder) |di_builder| { + var maybe_di_builder: ?*llvm.DI.Builder = null; + var global_scope: *llvm.DI.Scope = undefined; + var file: *llvm.DI.File = undefined; + + if (options.has_debug_info) { + const di_builder = handle.create_di_builder(); + maybe_di_builder = di_builder; var directory: []const u8 = undefined; var file_name: []const u8 = undefined; if (lib.string.last_character(options.path, '/')) |index| { @@ -122,52 +135,69 @@ const Module = struct { } else { os.abort(); } - const file = di_builder.create_file(file_name, directory); + file = di_builder.create_file(file_name, directory); const compile_unit = di_builder.create_compile_unit(file, options.build_mode.is_optimized()); - module.global_scope = compile_unit.to_scope(); - module.file = file; + global_scope = compile_unit.to_scope(); } + const module = arena.allocate_one(Module); + module.* = .{ + .llvm = .{ + .global_scope = global_scope, + .file = file, + .handle = handle, + .context = context, + .builder = context.create_builder(), + }, + }; + + var llvm_integer_types: [64]*llvm.Type = undefined; + + for (1..64 + 1) |bit_count| { + llvm_integer_types[bit_count - 1] = context.get_integer_type(@intCast(bit_count)).to_type(); + } + + const llvm_i128 = context.get_integer_type(128).to_type(); + + _ = module.types.add(.{ + .name = "void", + .llvm = .{ + .handle = context.get_void_type(), + .debug = if (maybe_di_builder) |di_builder| di_builder.create_basic_type("void", 0, .void, .{}) else undefined, + }, + .bb = .void, + }); + for ([2]bool{ false, true }) |sign| { - for (0..4) |i| { + for (1..64 + 1) |bit_count| { var name_buffer = [3]u8{ if (sign) 's' else 'u', 0, 0 }; - const bit_count = @as(u32, 1) << @intCast(3 + i); - switch (bit_count) { - 8 => name_buffer[1] = '8', - 16 => { - name_buffer[1] = '1'; - name_buffer[2] = '6'; - }, - 32 => { - name_buffer[1] = '3'; - name_buffer[2] = '2'; - }, - 64 => { - name_buffer[1] = '6'; - name_buffer[2] = '4'; - }, - else => unreachable, + var digit_buffer = [2]u8{ 0, 0 }; + + var it = bit_count; + var i: usize = 0; + while (it != 0) : (i += 1) { + const digit: u8 = @intCast((it % 10) + '0'); + digit_buffer[i] = digit; + it = it / 10; } + + name_buffer[1] = digit_buffer[1]; + name_buffer[2] = digit_buffer[0]; + const name_length = @as(usize, 2) + @intFromBool(bit_count > 9); + const name = arena.duplicate_string(name_buffer[0..name_length]); _ = module.types.add(.{ .name = name, .bb = .{ .integer = .{ - .bit_count = bit_count, + .bit_count = @intCast(bit_count), .signed = sign, }, }, .llvm = .{ - .handle = switch (bit_count) { - 1 => thread.i1.type.to_type(), - 8 => thread.i8.type.to_type(), - 16 => thread.i16.type.to_type(), - 32 => thread.i32.type.to_type(), - 64 => thread.i64.type.to_type(), - else => unreachable, - }, - .debug = if (module.di_builder) |di_builder| blk: { + .handle = llvm_integer_types[bit_count - 1], + .debug = if (maybe_di_builder) |di_builder| blk: { const dwarf_type: llvm.Dwarf.Type = if (bit_count == 8 and !sign) .unsigned_char else if (sign) .signed else .unsigned; break :blk di_builder.create_basic_type(name, bit_count, dwarf_type, .{}); } else undefined, @@ -176,6 +206,26 @@ const Module = struct { } } + for ([2]bool{ false, true }) |sign| { + const name = if (sign) "s128" else "u128"; + _ = module.types.add(.{ + .name = name, + .bb = .{ + .integer = .{ + .bit_count = 128, + .signed = sign, + }, + }, + .llvm = .{ + .handle = llvm_i128, + .debug = if (maybe_di_builder) |di_builder| blk: { + const dwarf_type: llvm.Dwarf.Type = if (sign) .signed else .unsigned; + break :blk di_builder.create_basic_type(name, 128, dwarf_type, .{}); + } else undefined, + }, + }); + } + return module; } }; @@ -197,6 +247,7 @@ pub const Value = struct { instruction, constant_integer, struct_initialization, + bits_initialization, }, type: *Type, llvm: *llvm.Value, @@ -220,6 +271,12 @@ const Field = struct { byte_offset: usize, }; +const FunctionType = struct { + semantic_argument_types: []const *Type, + semantic_return_type: *Type, + calling_convention: CallingConvention, +}; + const StructType = struct { fields: []const Field, bit_size: u64, @@ -228,10 +285,9 @@ const StructType = struct { byte_alignment: u64, }; -const FunctionType = struct { - semantic_argument_types: []const *Type, - semantic_return_type: *Type, - calling_convention: CallingConvention, +const Bits = struct { + fields: []const Field, + backing_type: *Type, }; pub const Type = struct { @@ -247,6 +303,7 @@ pub const Type = struct { signed: bool, }, @"struct": StructType, + bits: Bits, function: FunctionType, }; @@ -254,6 +311,7 @@ pub const Type = struct { return switch (ty.bb) { .integer => |integer| integer.bit_count, .@"struct" => |struct_type| struct_type.bit_size, + .bits => |bits| bits.backing_type.get_bit_size(), .void, .forward_declaration, .function => unreachable, }; } @@ -262,6 +320,7 @@ pub const Type = struct { return switch (ty.bb) { .integer => |integer| @divExact(@max(8, lib.next_power_of_two(integer.bit_count)), 8), .@"struct" => |struct_type| struct_type.byte_size, + .bits => |bits| bits.backing_type.get_byte_size(), .void, .forward_declaration, .function => unreachable, }; } @@ -270,6 +329,7 @@ pub const Type = struct { return switch (ty.bb) { .integer => |integer| integer.bit_count, .@"struct" => |struct_type| struct_type.bit_alignment, + .bits => |bits| bits.backing_type.get_bit_alignment(), .void, .forward_declaration, .function => unreachable, }; } @@ -277,13 +337,14 @@ pub const Type = struct { pub fn get_byte_alignment(ty: *const Type) u64 { return switch (ty.bb) { .integer => |integer| @divExact(@max(8, lib.next_power_of_two(integer.bit_count)), 8), - .@"struct" => |struct_type| struct_type.bit_alignment, + .@"struct" => |struct_type| struct_type.byte_alignment, + .bits => |bits| bits.backing_type.get_byte_alignment(), .void, .forward_declaration, .function => unreachable, }; } const Array = struct { - buffer: [64]Type = undefined, + buffer: [1024]Type = undefined, count: usize = 0, pub fn get(types: *Array) []Type { @@ -523,7 +584,7 @@ const Converter = struct { } } - fn parse_block(noalias converter: *Converter, noalias thread: *llvm.Thread, noalias module: *Module) void { + fn parse_block(noalias converter: *Converter, noalias module: *Module) void { converter.skip_space(); const current_function_global = module.current_function orelse unreachable; @@ -534,8 +595,8 @@ const Converter = struct { const current_scope = current_function.current_scope; defer current_function.current_scope = current_scope; - if (module.di_builder) |di_builder| { - const lexical_block = di_builder.create_lexical_block(current_scope, module.file, block_line, block_column); + if (module.llvm.di_builder) |di_builder| { + const lexical_block = di_builder.create_lexical_block(current_scope, module.llvm.file, block_line, block_column); current_function.current_scope = lexical_block.to_scope(); } @@ -561,10 +622,10 @@ const Converter = struct { const column = converter.get_column(); var statement_debug_location: *llvm.DI.Location = undefined; - if (module.di_builder) |_| { + if (module.llvm.di_builder) |_| { const inlined_at: ?*llvm.DI.Metadata = null; // TODO - statement_debug_location = llvm.DI.create_debug_location(thread.context, line, column, current_function.current_scope, inlined_at); - thread.builder.set_current_debug_location(statement_debug_location); + statement_debug_location = llvm.DI.create_debug_location(module.llvm.context, line, column, current_function.current_scope, inlined_at); + module.llvm.builder.set_current_debug_location(statement_debug_location); } const statement_start_ch = converter.content[converter.offset]; @@ -588,33 +649,33 @@ const Converter = struct { converter.skip_space(); - if (module.di_builder) |_| { - thread.builder.clear_current_debug_location(); + if (module.llvm.di_builder) |_| { + module.llvm.builder.clear_current_debug_location(); } const local_storage = module.values.add(); local_storage.* = .{ - .llvm = thread.builder.create_alloca(local_type.llvm.handle, local_name), + .llvm = module.llvm.builder.create_alloca(local_type.llvm.handle, local_name), .type = local_type, .bb = .local, }; - const value = converter.parse_value(thread, module, local_type); + const value = converter.parse_value(module, local_type); - if (module.di_builder) |di_builder| { - thread.builder.set_current_debug_location(statement_debug_location); + if (module.llvm.di_builder) |di_builder| { + module.llvm.builder.set_current_debug_location(statement_debug_location); const debug_type = local_type.llvm.debug; const always_preserve = true; // TODO: const alignment = 0; const flags = llvm.DI.Flags{}; - const local_variable = di_builder.create_auto_variable(current_function.current_scope, local_name, module.file, line, debug_type, always_preserve, flags, alignment); + const local_variable = di_builder.create_auto_variable(current_function.current_scope, local_name, module.llvm.file, line, debug_type, always_preserve, flags, alignment); const inlined_at: ?*llvm.DI.Metadata = null; // TODO - const debug_location = llvm.DI.create_debug_location(thread.context, line, column, current_function.current_scope, inlined_at); + const debug_location = llvm.DI.create_debug_location(module.llvm.context, line, column, current_function.current_scope, inlined_at); _ = di_builder.insert_declare_record_at_end(local_storage.llvm, local_variable, di_builder.null_expression(), debug_location, current_function.current_basic_block); - thread.builder.set_current_debug_location(statement_debug_location); + module.llvm.builder.set_current_debug_location(statement_debug_location); } - _ = thread.builder.create_store(value.llvm, local_storage.llvm); + _ = module.llvm.builder.create_store(value.llvm, local_storage.llvm); const local = current_function.locals.add(); local.* = .{ @@ -630,27 +691,27 @@ const Converter = struct { if (string_to_enum(StatementStartKeyword, statement_start_identifier)) |statement_start_keyword| { switch (statement_start_keyword) { .@"return" => { - const return_value = converter.parse_value(thread, module, current_function_global.value.type.bb.function.semantic_return_type); - thread.builder.create_ret(return_value.llvm); + const return_value = converter.parse_value(module, current_function_global.value.type.bb.function.semantic_return_type); + module.llvm.builder.create_ret(return_value.llvm); }, .@"if" => { - const taken_block = thread.context.create_basic_block("", current_function_global.value.llvm.to_function()); - const not_taken_block = thread.context.create_basic_block("", current_function_global.value.llvm.to_function()); + const taken_block = module.llvm.context.create_basic_block("", current_function_global.value.llvm.to_function()); + const not_taken_block = module.llvm.context.create_basic_block("", current_function_global.value.llvm.to_function()); converter.skip_space(); converter.expect_character(left_parenthesis); converter.skip_space(); - const condition = converter.parse_value(thread, module, null); + const condition = converter.parse_value(module, null); converter.skip_space(); converter.expect_character(right_parenthesis); - _ = thread.builder.create_conditional_branch(condition.llvm, taken_block, not_taken_block); - thread.builder.position_at_end(taken_block); + _ = module.llvm.builder.create_conditional_branch(condition.llvm, taken_block, not_taken_block); + module.llvm.builder.position_at_end(taken_block); - converter.parse_block(thread, module); + converter.parse_block(module); const is_first_block_terminated = current_function.current_basic_block.get_terminator() != null; if (!is_first_block_terminated) { @@ -670,8 +731,8 @@ const Converter = struct { var is_second_block_terminated = false; if (is_else) { - thread.builder.position_at_end(not_taken_block); - converter.parse_block(thread, module); + module.llvm.builder.position_at_end(not_taken_block); + converter.parse_block(module); is_second_block_terminated = current_function.current_basic_block.get_terminator() != null; } else { @trap(); @@ -692,7 +753,7 @@ const Converter = struct { const variable = if (current_function.locals.find(statement_start_identifier)) |local| local else if (module.globals.find(statement_start_identifier)) |global| global else { converter.report_error(); }; - const call = thread.builder.create_call(variable.value.type.llvm.handle.to_function(), variable.value.llvm, &.{}); + const call = module.llvm.builder.create_call(variable.value.type.llvm.handle.to_function(), variable.value.llvm, &.{}); _ = call; @trap(); } else { @@ -738,7 +799,7 @@ const Converter = struct { } }; - fn parse_value(noalias converter: *Converter, noalias thread: *llvm.Thread, noalias module: *Module, maybe_expected_type: ?*Type) *Value { + fn parse_value(noalias converter: *Converter, noalias module: *Module, maybe_expected_type: ?*Type) *Value { converter.skip_space(); var value_state = ExpressionState.none; @@ -751,9 +812,14 @@ const Converter = struct { iterative_expected_type = previous_value.?.type; } - const current_value = switch (converter.content[converter.offset] == left_parenthesis) { - true => os.abort(), - false => converter.parse_single_value(thread, module, iterative_expected_type), + const current_value = switch (converter.consume_character_if_match(left_parenthesis)) { + true => blk: { + const r = converter.parse_value(module, iterative_expected_type); + converter.skip_space(); + converter.expect_character(right_parenthesis); + break :blk r; + }, + false => converter.parse_single_value(module, iterative_expected_type), }; converter.skip_space(); @@ -766,20 +832,20 @@ const Converter = struct { const llvm_value = switch (value_state) { .none => current_value.llvm, - .sub => thread.builder.create_sub(left.?.llvm, right.llvm), - .add => thread.builder.create_add(left.?.llvm, right.llvm), - .mul => thread.builder.create_mul(left.?.llvm, right.llvm), - .sdiv => thread.builder.create_sdiv(left.?.llvm, right.llvm), - .udiv => thread.builder.create_udiv(left.?.llvm, right.llvm), - .srem => thread.builder.create_srem(left.?.llvm, right.llvm), - .urem => thread.builder.create_urem(left.?.llvm, right.llvm), - .shl => thread.builder.create_shl(left.?.llvm, right.llvm), - .ashr => thread.builder.create_ashr(left.?.llvm, right.llvm), - .lshr => thread.builder.create_lshr(left.?.llvm, right.llvm), - .@"and" => thread.builder.create_and(left.?.llvm, right.llvm), - .@"or" => thread.builder.create_or(left.?.llvm, right.llvm), - .xor => thread.builder.create_xor(left.?.llvm, right.llvm), - .icmp_ne => |icmp| thread.builder.create_compare(icmp.to_int_predicate(), left.?.llvm, right.llvm), + .sub => module.llvm.builder.create_sub(left.?.llvm, right.llvm), + .add => module.llvm.builder.create_add(left.?.llvm, right.llvm), + .mul => module.llvm.builder.create_mul(left.?.llvm, right.llvm), + .sdiv => module.llvm.builder.create_sdiv(left.?.llvm, right.llvm), + .udiv => module.llvm.builder.create_udiv(left.?.llvm, right.llvm), + .srem => module.llvm.builder.create_srem(left.?.llvm, right.llvm), + .urem => module.llvm.builder.create_urem(left.?.llvm, right.llvm), + .shl => module.llvm.builder.create_shl(left.?.llvm, right.llvm), + .ashr => module.llvm.builder.create_ashr(left.?.llvm, right.llvm), + .lshr => module.llvm.builder.create_lshr(left.?.llvm, right.llvm), + .@"and" => module.llvm.builder.create_and(left.?.llvm, right.llvm), + .@"or" => module.llvm.builder.create_or(left.?.llvm, right.llvm), + .xor => module.llvm.builder.create_xor(left.?.llvm, right.llvm), + .icmp_ne => |icmp| module.llvm.builder.create_compare(icmp.to_int_predicate(), left.?.llvm, right.llvm), }; previous_value = module.values.add(); @@ -891,16 +957,60 @@ const Converter = struct { negative, }; - fn parse_single_value(noalias converter: *Converter, noalias thread: *llvm.Thread, noalias module: *Module, expected_type: ?*Type) *Value { + const Intrinsic = enum { + extend, + foo, + }; + + fn parse_intrinsic(noalias converter: *Converter, noalias module: *Module, expected_type: ?*Type) *Value { + converter.expect_character('#'); + converter.skip_space(); + const intrinsic_name = converter.parse_identifier(); + const intrinsic_keyword = string_to_enum(Intrinsic, intrinsic_name) orelse converter.report_error(); + converter.skip_space(); + + converter.expect_character(left_parenthesis); + + converter.skip_space(); + + switch (intrinsic_keyword) { + .extend => { + const source_value = converter.parse_value(module, null); + converter.skip_space(); + converter.expect_character(right_parenthesis); + const source_type = source_value.type; + const destination_type = expected_type orelse converter.report_error(); + if (source_type.get_bit_size() >= destination_type.get_bit_size()) { + converter.report_error(); + } + + const extension_instruction = switch (source_type.bb.integer.signed) { + true => module.llvm.builder.create_sign_extend(source_value.llvm, destination_type.llvm.handle), + false => module.llvm.builder.create_zero_extend(source_value.llvm, destination_type.llvm.handle), + }; + const value = module.values.add(); + value.* = .{ + .llvm = extension_instruction, + .type = destination_type, + .bb = .instruction, + }; + + return value; + }, + else => unreachable, + } + } + + fn parse_single_value(noalias converter: *Converter, noalias module: *Module, expected_type: ?*Type) *Value { converter.skip_space(); if (module.current_function) |function| { - if (module.di_builder) |_| { + if (module.llvm.di_builder) |_| { const line = converter.get_line(); const column = converter.get_column(); const inlined_at: ?*llvm.DI.Metadata = null; // TODO - const debug_location = llvm.DI.create_debug_location(thread.context, line, column, function.value.bb.function.current_scope, inlined_at); - thread.builder.set_current_debug_location(debug_location); + const debug_location = llvm.DI.create_debug_location(module.llvm.context, line, column, function.value.bb.function.current_scope, inlined_at); + module.llvm.builder.set_current_debug_location(debug_location); } } @@ -950,7 +1060,7 @@ const Converter = struct { converter.skip_space(); - const field_value = converter.parse_value(thread, module, field.type); + const field_value = converter.parse_value(module, field.type); if (must_be_constant) { if (field_index != field_count) { @@ -958,7 +1068,7 @@ const Converter = struct { } @trap(); } else { - llvm_value = thread.builder.create_insert_value(llvm_value, field_value.llvm, field_index); + llvm_value = module.llvm.builder.create_insert_value(llvm_value, field_value.llvm, field_index); } converter.skip_space(); @@ -984,11 +1094,65 @@ const Converter = struct { return value; }, + .bits => |*bits| { + var field_count: usize = 0; + + var llvm_value = bits.backing_type.llvm.handle.to_integer().get_constant(0, @intFromBool(false)).to_value(); + + while (converter.consume_character_if_match('.')) : (field_count += 1) { + converter.skip_space(); + + const field_name = converter.parse_identifier(); + const field_index: u32 = for (bits.fields, 0..) |*field, field_index| { + if (lib.string.equal(field.name, field_name)) { + break @intCast(field_index); + } + } else converter.report_error(); + + const field = bits.fields[field_index]; + + converter.skip_space(); + + converter.expect_character('='); + + converter.skip_space(); + + const field_value = converter.parse_value(module, field.type); + + const extended_field_value = module.llvm.builder.create_zero_extend(field_value.llvm, bits.backing_type.llvm.handle); + const shifted_value = module.llvm.builder.create_shl(extended_field_value, bits.backing_type.llvm.handle.to_integer().get_constant(field.bit_offset, @intFromBool(false)).to_value()); + const or_value = module.llvm.builder.create_or(llvm_value, shifted_value); + llvm_value = or_value; + + converter.skip_space(); + + _ = converter.consume_character_if_match(','); + + converter.skip_space(); + } + + if (field_count != bits.fields.len) { + // expect: 'zero' keyword + @trap(); + } + + converter.expect_character(right_brace); + + const value = module.values.add(); + value.* = .{ + .llvm = llvm_value, + .type = ty, + .bb = .bits_initialization, + }; + + return value; + }, else => converter.report_error(), } @trap(); }, + '#' => return converter.parse_intrinsic(module, expected_type), else => os.abort(), }; @@ -1027,14 +1191,14 @@ const Converter = struct { @trap(); }, .unknown => { - const argument_value = converter.parse_value(thread, module, variable.value.type.bb.function.semantic_argument_types[argument_count]); + const argument_value = converter.parse_value(module, variable.value.type.bb.function.semantic_argument_types[argument_count]); llvm_arguments[argument_count] = argument_value.llvm; }, } } const llvm_argument_values = llvm_arguments[0..argument_count]; - const llvm_call = thread.builder.create_call(variable.value.type.llvm.handle.to_function(), variable.value.llvm, llvm_argument_values); + const llvm_call = module.llvm.builder.create_call(variable.value.type.llvm.handle.to_function(), variable.value.llvm, llvm_argument_values); llvm_call.to_instruction().set_calling_convention(variable.value.llvm.get_calling_convention()); const call = module.values.add(); call.* = .{ @@ -1055,22 +1219,43 @@ const Converter = struct { } } else converter.report_error(); const field = struct_type.fields[field_index]; - const gep = thread.builder.create_struct_gep(variable.value.type.llvm.handle.to_struct(), variable.value.llvm, field_index); + const gep = module.llvm.builder.create_struct_gep(variable.value.type.llvm.handle.to_struct(), variable.value.llvm, field_index); const load = module.values.add(); - // const llvm_field_index = thread.llvminteger_type.get_constant(field_index, @intFromBool(false)); load.* = .{ - .llvm = thread.builder.create_load(field.type.llvm.handle, gep), + .llvm = module.llvm.builder.create_load(field.type.llvm.handle, gep), .type = field.type, .bb = .instruction, }; break :b load; }, + .bits => |*bits| { + const field_name = converter.parse_identifier(); + const field_index: u32 = for (bits.fields, 0..) |field, field_index| { + if (lib.string.equal(field.name, field_name)) { + break @intCast(field_index); + } + } else converter.report_error(); + const field = bits.fields[field_index]; + + const bitfield_load = module.llvm.builder.create_load(bits.backing_type.llvm.handle, variable.value.llvm); + const bitfield_shifted = module.llvm.builder.create_lshr(bitfield_load, bits.backing_type.llvm.handle.to_integer().get_constant(field.bit_offset, @intFromBool(false)).to_value()); + const bitfield_masked = module.llvm.builder.create_and(bitfield_shifted, bits.backing_type.llvm.handle.to_integer().get_constant((@as(u64, 1) << @intCast(field.type.get_bit_size())) - 1, @intFromBool(false)).to_value()); + + const value = module.values.add(); + value.* = .{ + .type = bits.backing_type, + .llvm = bitfield_masked, + .bb = .instruction, + }; + + break :b value; + }, else => @trap(), } } else { const load = module.values.add(); load.* = .{ - .llvm = thread.builder.create_load(variable.value.type.llvm.handle, variable.value.llvm), + .llvm = module.llvm.builder.create_load(variable.value.type.llvm.handle, variable.value.llvm), .type = variable.value.type, .bb = .instruction, }; @@ -1154,9 +1339,9 @@ pub noinline fn convert(options: ConvertOptions) void { .line_character_offset = 0, }; - const thread = llvm.default_initialize(); + llvm.default_initialize(); - const module = Module.initialize(lib.global.arena, thread, options); + const module = Module.initialize(lib.global.arena, options); while (true) { converter.skip_space(); @@ -1322,7 +1507,7 @@ pub noinline fn convert(options: ConvertOptions) void { for (arguments, argument_types, debug_argument_types[1..]) |*argument, *argument_type, *debug_argument_type| { argument_type.* = argument.type.llvm.handle; debug_argument_type.* = argument.type.llvm.debug; - if (module.di_builder) |_| { + if (module.llvm.di_builder) |_| { assert(@intFromPtr(argument.type.llvm.debug) != 0xaaaa_aaaa_aaaa_aaaa); } } @@ -1333,7 +1518,7 @@ pub noinline fn convert(options: ConvertOptions) void { } const llvm_function_type = llvm.Type.Function.get(return_type.llvm.handle, argument_types, false); - const llvm_handle = module.llvm.create_function(.{ + const llvm_handle = module.llvm.handle.create_function(.{ .name = global_name, .linkage = switch (is_export) { true => .ExternalLinkage, @@ -1343,20 +1528,20 @@ pub noinline fn convert(options: ConvertOptions) void { }); llvm_handle.set_calling_convention(calling_convention.to_llvm()); - const entry_block = thread.context.create_basic_block("entry", llvm_handle); - thread.builder.position_at_end(entry_block); + const entry_block = module.llvm.context.create_basic_block("entry", llvm_handle); + module.llvm.builder.position_at_end(entry_block); const global = module.globals.add(); var subroutine_type: *llvm.DI.Type.Subroutine = undefined; - const current_scope: *llvm.DI.Scope = if (module.di_builder) |di_builder| blk: { + const current_scope: *llvm.DI.Scope = if (module.llvm.di_builder) |di_builder| blk: { const subroutine_type_flags = llvm.DI.Flags{}; - subroutine_type = di_builder.create_subroutine_type(module.file, debug_argument_types, subroutine_type_flags); + subroutine_type = di_builder.create_subroutine_type(module.llvm.file, debug_argument_types, subroutine_type_flags); const scope_line: u32 = @intCast(converter.line_offset + 1); const local_to_unit = !is_export; const flags = llvm.DI.Flags{}; const is_definition = true; - const subprogram = di_builder.create_function(module.global_scope, global_name, linkage_name, module.file, global_line, subroutine_type, local_to_unit, is_definition, scope_line, flags, options.build_mode.is_optimized()); + const subprogram = di_builder.create_function(module.llvm.global_scope, global_name, linkage_name, module.llvm.file, global_line, subroutine_type, local_to_unit, is_definition, scope_line, flags, options.build_mode.is_optimized()); llvm_handle.set_subprogram(subprogram); break :blk @ptrCast(subprogram); @@ -1408,7 +1593,7 @@ pub noinline fn convert(options: ConvertOptions) void { const argument_variables = global.value.bb.function.arguments.add_many(argument_count); for (argument_variables, arguments) |*argument_variable, *argument| { - const argument_alloca = thread.builder.create_alloca(argument.type.llvm.handle, argument.name); + const argument_alloca = module.llvm.builder.create_alloca(argument.type.llvm.handle, argument.name); const argument_value = module.values.add(); argument_value.* = .{ .llvm = argument_alloca, @@ -1429,31 +1614,31 @@ pub noinline fn convert(options: ConvertOptions) void { switch (calling_convention) { .unknown => { for (argument_variables, llvm_arguments) |*argument_variable, llvm_argument| { - _ = thread.builder.create_store(llvm_argument.to_value(), argument_variable.value.llvm); + _ = module.llvm.builder.create_store(llvm_argument.to_value(), argument_variable.value.llvm); } }, .c => @trap(), } - if (module.di_builder) |di_builder| { + if (module.llvm.di_builder) |di_builder| { for (argument_variables, arguments, 0..) |argument_variable, argument, argument_number| { const always_preserve = true; const flags = llvm.DI.Flags{}; - const parameter_variable = di_builder.create_parameter_variable(global.value.bb.function.current_scope, argument_variable.name, @intCast(argument_number + 1), module.file, argument.line, argument.type.llvm.debug, always_preserve, flags); + const parameter_variable = di_builder.create_parameter_variable(global.value.bb.function.current_scope, argument_variable.name, @intCast(argument_number + 1), module.llvm.file, argument.line, argument.type.llvm.debug, always_preserve, flags); const inlined_at: ?*llvm.DI.Metadata = null; // TODO - const debug_location = llvm.DI.create_debug_location(thread.context, argument.line, argument.column, global.value.bb.function.current_scope, inlined_at); + const debug_location = llvm.DI.create_debug_location(module.llvm.context, argument.line, argument.column, global.value.bb.function.current_scope, inlined_at); _ = di_builder.insert_declare_record_at_end(argument_variable.value.llvm, parameter_variable, di_builder.null_expression(), debug_location, global.value.bb.function.current_basic_block); } } } - converter.parse_block(thread, module); + converter.parse_block(module); - if (module.di_builder) |di_builder| { + if (module.llvm.di_builder) |di_builder| { di_builder.finalize_subprogram(llvm_handle.get_subprogram()); } - if (lib.optimization_mode == .Debug and module.di_builder == null) { + if (lib.optimization_mode == .Debug and module.llvm.di_builder == null) { const verify_result = llvm_handle.verify(); if (!verify_result.success) { os.abort(); @@ -1469,14 +1654,14 @@ pub noinline fn convert(options: ConvertOptions) void { @trap(); } - const llvm_struct_type = thread.context.create_forward_declared_struct_type(global_name); + const llvm_struct_type = module.llvm.context.create_forward_declared_struct_type(global_name); const struct_type = module.types.add(.{ .name = global_name, .bb = .forward_declaration, .llvm = .{ .handle = llvm_struct_type.to_type(), - .debug = if (module.di_builder) |di_builder| blk: { - const r = di_builder.create_replaceable_composite_type(module.debug_tag, global_name, module.global_scope, module.file, global_line); + .debug = if (module.llvm.di_builder) |di_builder| blk: { + const r = di_builder.create_replaceable_composite_type(module.debug_tag, global_name, module.llvm.global_scope, module.llvm.file, global_line); module.debug_tag += 1; break :blk r.to_type(); } else undefined, @@ -1523,8 +1708,8 @@ pub noinline fn convert(options: ConvertOptions) void { }; llvm_field_type_buffer[field_count] = field_type.llvm.handle; - if (module.di_builder) |di_builder| { - const member_type = di_builder.create_member_type(module.global_scope, field_name, module.file, field_line, field_bit_size, @intCast(field_bit_alignment), field_bit_offset, .{}, field_type.llvm.debug); + if (module.llvm.di_builder) |di_builder| { + const member_type = di_builder.create_member_type(module.llvm.global_scope, field_name, module.llvm.file, field_line, field_bit_size, @intCast(field_bit_alignment), field_bit_offset, .{}, field_type.llvm.debug); llvm_debug_member_type_buffer[field_count] = member_type; } @@ -1555,9 +1740,9 @@ pub noinline fn convert(options: ConvertOptions) void { const element_types = llvm_field_type_buffer[0..field_count]; llvm_struct_type.set_body(element_types); - if (module.di_builder) |di_builder| { + if (module.llvm.di_builder) |di_builder| { const member_types = llvm_debug_member_type_buffer[0..field_count]; - const debug_struct_type = di_builder.create_struct_type(module.global_scope, global_name, module.file, global_line, bit_size, @intCast(bit_alignment), .{}, member_types); + const debug_struct_type = di_builder.create_struct_type(module.llvm.global_scope, global_name, module.llvm.file, global_line, bit_size, @intCast(bit_alignment), .{}, member_types); const forward_declared: *llvm.DI.Type.Composite = @ptrCast(struct_type.llvm.debug); forward_declared.replace_all_uses_with(debug_struct_type); struct_type.llvm.debug = debug_struct_type.to_type(); @@ -1573,19 +1758,103 @@ pub noinline fn convert(options: ConvertOptions) void { }, }; }, + .bits => { + // TODO: allow implicit backing type? + const backing_type = converter.parse_type(module); + if (backing_type.bb != .integer) { + converter.report_error(); + } + + if (backing_type.get_bit_size() > 64) { + converter.report_error(); + } + + converter.skip_space(); + + converter.expect_character(left_brace); + + var field_buffer: [128]Field = undefined; + var llvm_debug_field_buffer: [128]*llvm.DI.Type.Derived = undefined; + var field_count: usize = 0; + + var field_bit_offset: u64 = 0; + + while (true) : (field_count += 1) { + converter.skip_space(); + + if (converter.consume_character_if_match(right_brace)) { + break; + } + + const field_line = converter.get_line(); + + const field_name = converter.parse_identifier(); + + converter.skip_space(); + + converter.expect_character(':'); + + converter.skip_space(); + + const field_type = converter.parse_type(module); + + field_buffer[field_count] = .{ + .name = field_name, + .type = field_type, + .bit_offset = field_bit_offset, + .byte_offset = 0, + }; + + const field_bit_size = field_type.get_bit_size(); + field_bit_offset += field_bit_size; + + if (module.llvm.di_builder) |di_builder| { + const member_type = di_builder.create_bit_field_member_type(module.llvm.global_scope, field_name, module.llvm.file, field_line, field_bit_size, field_bit_offset, 0, .{}, backing_type.llvm.debug); + llvm_debug_field_buffer[field_count] = member_type; + } + + converter.skip_space(); + + _ = converter.consume_character_if_match(','); + } + + _ = converter.consume_character_if_match(';'); + + const fields = lib.global.arena.allocate(Field, field_count); + @memcpy(fields, field_buffer[0..field_count]); + + const bit_size = backing_type.get_bit_size(); + const bit_alignment = backing_type.get_bit_alignment(); + + const debug_member_types = llvm_debug_field_buffer[0..field_count]; + + _ = module.types.add(.{ + .name = global_name, + .llvm = .{ + .handle = backing_type.llvm.handle, + .debug = if (module.llvm.di_builder) |di_builder| di_builder.create_struct_type(module.llvm.global_scope, global_name, module.llvm.file, global_line, bit_size, @intCast(bit_alignment), .{}, debug_member_types).to_type() else undefined, + }, + .bb = .{ + .bits = .{ + .fields = fields, + .backing_type = backing_type, + }, + }, + }); + }, } } else { converter.report_error(); } } else { if (global_type) |expected_type| { - const value = converter.parse_value(thread, module, expected_type); + const value = converter.parse_value(module, expected_type); converter.skip_space(); converter.expect_character(';'); - const global_variable = module.llvm.create_global_variable(.{ + const global_variable = module.llvm.handle.create_global_variable(.{ .linkage = switch (is_export) { true => .ExternalLinkage, false => .InternalLinkage, @@ -1595,11 +1864,11 @@ pub noinline fn convert(options: ConvertOptions) void { .type = expected_type.llvm.handle, }); - if (module.di_builder) |di_builder| { + if (module.llvm.di_builder) |di_builder| { const linkage_name = global_name; const local_to_unit = is_export; // TODO: extern const alignment = 0; // TODO - const global_variable_expression = di_builder.create_global_variable(module.global_scope, global_name, linkage_name, module.file, global_line, expected_type.llvm.debug, local_to_unit, di_builder.null_expression(), alignment); + const global_variable_expression = di_builder.create_global_variable(module.llvm.global_scope, global_name, linkage_name, module.llvm.file, global_line, expected_type.llvm.debug, local_to_unit, di_builder.null_expression(), alignment); global_variable.add_debug_info(global_variable_expression); } @@ -1621,21 +1890,21 @@ pub noinline fn convert(options: ConvertOptions) void { } } - if (module.di_builder) |di_builder| { + if (module.llvm.di_builder) |di_builder| { di_builder.finalize(); } if (lib.optimization_mode == .Debug) { - const verify_result = module.llvm.verify(); + const verify_result = module.llvm.handle.verify(); if (!verify_result.success) { - lib.print_string(module.llvm.to_string()); + lib.print_string(module.llvm.handle.to_string()); lib.print_string("============================\n"); lib.print_string(verify_result.error_message orelse unreachable); os.abort(); } if (!lib.is_test) { - const module_string = module.llvm.to_string(); + const module_string = module.llvm.handle.to_string(); lib.print_string_stderr(module_string); } } @@ -1654,7 +1923,7 @@ pub noinline fn convert(options: ConvertOptions) void { os.abort(); }; - const object_generate_result = llvm.object_generate(module.llvm, target_machine, .{ + const object_generate_result = llvm.object_generate(module.llvm.handle, target_machine, .{ .optimize_when_possible = @intFromBool(@intFromEnum(options.build_mode) > @intFromEnum(BuildMode.soft_optimize)), .debug_info = options.has_debug_info, .optimization_level = if (options.build_mode != .debug_none) options.build_mode.to_llvm_ir() else null, diff --git a/src/converter_test.zig b/src/converter_test.zig index aa0a8fb..0b9079a 100644 --- a/src/converter_test.zig +++ b/src/converter_test.zig @@ -160,3 +160,11 @@ test "basic_call" { test "struct" { try invsrc(@src()); } + +test "extend" { + try invsrc(@src()); +} + +test "bits" { + try invsrc(@src()); +} diff --git a/src/llvm_api.zig b/src/llvm_api.zig index aef20af..5c8623f 100644 --- a/src/llvm_api.zig +++ b/src/llvm_api.zig @@ -53,6 +53,8 @@ pub extern fn LLVMBuildLoad2(builder: *llvm.Builder, ty: *llvm.Type, pointer: *l pub extern fn LLVMBuildCall2(builder: *llvm.Builder, ty: *llvm.Type.Function, pointer: *llvm.Value, argument_pointer: [*]const *llvm.Value, argument_count: c_uint, name: [*:0]const u8) *llvm.Value; pub extern fn LLVMBuildStructGEP2(builder: *llvm.Builder, struct_type: *llvm.Type.Struct, pointer: *llvm.Value, index: c_uint, name: [*:0]const u8) *llvm.Value; pub extern fn LLVMBuildInsertValue(builder: *llvm.Builder, aggregate: *llvm.Value, element: *llvm.Value, index: c_uint, name: [*:0]const u8) *llvm.Value; +pub extern fn LLVMBuildZExt(builder: *llvm.Builder, value: *llvm.Value, destination_type: *llvm.Type, name: [*:0]const u8) *llvm.Value; +pub extern fn LLVMBuildSExt(builder: *llvm.Builder, value: *llvm.Value, destination_type: *llvm.Type, name: [*:0]const u8) *llvm.Value; pub extern fn LLVMSetCurrentDebugLocation2(builder: *llvm.Builder, location: ?*llvm.DI.Location) void; @@ -62,6 +64,7 @@ pub extern fn llvm_value_is_instruction(value: *llvm.Value) bool; // TYPES // Types: integers +pub extern fn LLVMVoidTypeInContext(context: *llvm.Context) *llvm.Type; pub extern fn LLVMInt1TypeInContext(context: *llvm.Context) *llvm.Type.Integer; pub extern fn LLVMInt8TypeInContext(context: *llvm.Context) *llvm.Type.Integer; pub extern fn LLVMInt16TypeInContext(context: *llvm.Context) *llvm.Type.Integer; @@ -133,6 +136,7 @@ pub extern fn LLVMDIBuilderCreateLexicalBlock(builder: *llvm.DI.Builder, scope: pub extern fn LLVMDIBuilderCreateReplaceableCompositeType(builder: *llvm.DI.Builder, tag: c_uint, name_pointer: [*]const u8, name_length: usize, scope: *llvm.DI.Scope, file: *llvm.DI.File, line: c_uint, runtime_language: c_uint, bit_size: u64, align_in_bits: u32, flags: llvm.DI.Flags, unique_identifier_pointer: ?[*]const u8, unique_identifier_length: usize) *llvm.DI.Type.Composite; pub extern fn LLVMDIBuilderCreateStructType(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, file: *llvm.DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, flags: llvm.DI.Flags, derived_from: ?*llvm.DI.Type, member_pointer: [*]const *llvm.DI.Type.Derived, member_length: c_uint, runtime_language: c_uint, vtable_holder: ?*llvm.DI.Metadata, unique_id_pointer: ?[*]const u8, unique_id_length: usize) *llvm.DI.Type.Composite; pub extern fn LLVMDIBuilderCreateMemberType(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, file: *llvm.DI.File, line: c_uint, bit_size: u64, align_in_bits: u32, bit_offset: u64, flags: llvm.DI.Flags, member_type: *llvm.DI.Type) *llvm.DI.Type.Derived; +pub extern fn LLVMDIBuilderCreateBitFieldMemberType(builder: *llvm.DI.Builder, scope: *llvm.DI.Scope, name_pointer: [*]const u8, name_length: usize, file: *llvm.DI.File, line: c_uint, bit_size: u64, bit_offset: u64, bit_storage_offset: u64, flags: llvm.DI.Flags, member_type: *llvm.DI.Type) *llvm.DI.Type.Derived; pub extern fn LLVMMetadataReplaceAllUsesWith(forward: *llvm.DI.Type.Composite, complete: *llvm.DI.Type.Composite) void; diff --git a/src/main.zig b/src/main.zig index 8bd2960..ba62540 100644 --- a/src/main.zig +++ b/src/main.zig @@ -136,6 +136,11 @@ pub const panic = struct { @branchHint(.cold); abort(); } + + pub fn sliceCastLenRemainder(_: usize) noreturn { + @branchHint(.cold); + abort(); + } }; pub fn main(argc: c_int, argv: [*:null]const ?[*:0]const u8) callconv(.C) c_int { diff --git a/tests/bits.bbb b/tests/bits.bbb new file mode 100644 index 0000000..5048119 --- /dev/null +++ b/tests/bits.bbb @@ -0,0 +1,18 @@ +BitField = bits u8 +{ + a: u2, + b: u2, + c: u2, + d: u2, +}; + +[export] main = fn [cc(c)] () s32 +{ + >b: BitField = { + .a = 3, + .b = 2, + .c = 2, + .d = 3, + }; + return #extend((b.a - b.d) + (b.b - b.c)); +} diff --git a/tests/c_abi.bbb b/tests/c_abi.bbb index 0bdf097..e0bdcea 100644 --- a/tests/c_abi.bbb +++ b/tests/c_abi.bbb @@ -13,7 +13,7 @@ BigStruct = struct e: u8, } -SmallPackedStruct = bitfield(u8) +SmallPackedStruct = bits u8 { a: u2, b: u2, @@ -140,6 +140,14 @@ ByVal = struct [extern] c_modify_by_ref_param = fn [cc(.c)] (x: ByRef) ByRef; [extern] c_func_ptr_byval fn [cc(c)] (a: u64, b: u64, c: ByVal, d: u64, e: u64, f: u64) void; +[export] require = fn [cc(c)] (ok: u8) +{ + if (!ok) + { + #trap(); + } +} + [export] main = fn [cc(c)] () s32 { run_c_tests(); diff --git a/tests/extend.bbb b/tests/extend.bbb new file mode 100644 index 0000000..7518732 --- /dev/null +++ b/tests/extend.bbb @@ -0,0 +1,5 @@ +[export] main = fn [cc(c)] () s32 +{ + >result: s8 = 0; + return #extend(result); +}