master
1#include <complex.h>
2#include <inttypes.h>
3#include <stdbool.h>
4#include <stdlib.h>
5#include <string.h>
6
7void zig_panic(void);
8
9static void assert_or_panic(bool ok) {
10 if (!ok) {
11 zig_panic();
12 }
13}
14
15#if defined __powerpc__ && !defined _ARCH_PPC64
16# define ZIG_PPC32
17#endif
18
19#ifdef __riscv
20# ifdef _ILP32
21# define ZIG_RISCV32
22# else
23# define ZIG_RISCV64
24# endif
25#endif
26
27#if defined(__aarch64__) && defined(__linux__)
28// TODO: https://github.com/ziglang/zig/issues/14908
29#define ZIG_BUG_14908
30#endif
31
32#ifdef __i386__
33# define ZIG_NO_I128
34#endif
35
36#ifdef __arm__
37# define ZIG_NO_I128
38#endif
39
40#ifdef __hexagon__
41# define ZIG_NO_I128
42#endif
43
44#ifdef __mips__
45# define ZIG_NO_I128
46#endif
47
48#ifdef ZIG_PPC32
49# define ZIG_NO_I128
50#endif
51
52#ifdef ZIG_RISCV32
53# define ZIG_NO_I128
54#endif
55
56#ifdef __i386__
57# define ZIG_NO_COMPLEX
58#endif
59
60#ifdef __mips__
61# define ZIG_NO_COMPLEX
62#endif
63
64#ifdef __arm__
65# define ZIG_NO_COMPLEX
66#endif
67
68#ifdef __hexagon__
69# define ZIG_NO_COMPLEX
70#endif
71
72#ifdef __powerpc__
73# define ZIG_NO_COMPLEX
74#endif
75
76#ifdef __riscv
77# define ZIG_NO_COMPLEX
78#endif
79
80#ifdef __s390x__
81# define ZIG_NO_COMPLEX
82#endif
83
84#ifdef __x86_64__
85#define ZIG_NO_RAW_F16
86#endif
87
88#ifdef __i386__
89#define ZIG_NO_RAW_F16
90#endif
91
92#ifdef __hexagon__
93#define ZIG_NO_RAW_F16
94#endif
95
96#ifdef __loongarch__
97#define ZIG_NO_RAW_F16
98#endif
99
100#ifdef __mips__
101#define ZIG_NO_RAW_F16
102#endif
103
104#ifdef __riscv
105#define ZIG_NO_RAW_F16
106#endif
107
108#ifdef __s390x__
109#define ZIG_NO_RAW_F16
110#endif
111
112#ifdef __wasm__
113#define ZIG_NO_RAW_F16
114#endif
115
116#ifdef __powerpc__
117#define ZIG_NO_RAW_F16
118#endif
119
120#ifdef __aarch64__
121#define ZIG_NO_F128
122#endif
123
124#ifdef __arm__
125#define ZIG_NO_F128
126#endif
127
128#ifdef __hexagon__
129#define ZIG_NO_F128
130#endif
131
132#ifdef __loongarch__
133#define ZIG_NO_F128
134#endif
135
136#ifdef __mips__
137#define ZIG_NO_F128
138#endif
139
140#ifdef __riscv
141#define ZIG_NO_F128
142#endif
143
144#ifdef __powerpc__
145#define ZIG_NO_F128
146#endif
147
148#ifdef __s390x__
149#define ZIG_NO_F128
150#endif
151
152#ifdef __APPLE__
153#define ZIG_NO_F128
154#endif
155
156#ifndef ZIG_NO_I128
157struct i128 {
158 __int128 value;
159};
160
161struct u128 {
162 unsigned __int128 value;
163};
164#endif
165
166void zig_u8(uint8_t);
167void zig_u16(uint16_t);
168void zig_u32(uint32_t);
169void zig_u64(uint64_t);
170#ifndef ZIG_NO_I128
171void zig_struct_u128(struct u128);
172#endif
173void zig_i8(int8_t);
174void zig_i16(int16_t);
175void zig_i32(int32_t);
176void zig_i64(int64_t);
177#ifndef ZIG_NO_I128
178void zig_struct_i128(struct i128);
179#endif
180void zig_five_integers(int32_t, int32_t, int32_t, int32_t, int32_t);
181
182void zig_f32(float);
183void zig_f64(double);
184void zig_longdouble(long double);
185void zig_five_floats(float, float, float, float, float);
186
187bool zig_ret_bool();
188uint8_t zig_ret_u8();
189uint16_t zig_ret_u16();
190uint32_t zig_ret_u32();
191uint64_t zig_ret_u64();
192int8_t zig_ret_i8();
193int16_t zig_ret_i16();
194int32_t zig_ret_i32();
195int64_t zig_ret_i64();
196
197void zig_ptr(void *);
198
199void zig_bool(bool);
200
201// Note: These two functions match the signature of __mulsc3 and __muldc3 in compiler-rt (and libgcc)
202float complex zig_cmultf_comp(float a_r, float a_i, float b_r, float b_i);
203double complex zig_cmultd_comp(double a_r, double a_i, double b_r, double b_i);
204
205float complex zig_cmultf(float complex a, float complex b);
206double complex zig_cmultd(double complex a, double complex b);
207
208struct Struct_u64_u64 {
209 uint64_t a;
210 uint64_t b;
211};
212
213struct Struct_u64_u64 zig_ret_struct_u64_u64(void);
214
215void zig_struct_u64_u64_0(struct Struct_u64_u64, size_t);
216void zig_struct_u64_u64_1(size_t, struct Struct_u64_u64, size_t);
217void zig_struct_u64_u64_2(size_t, size_t, struct Struct_u64_u64, size_t);
218void zig_struct_u64_u64_3(size_t, size_t, size_t, struct Struct_u64_u64, size_t);
219void zig_struct_u64_u64_4(size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
220void zig_struct_u64_u64_5(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
221void zig_struct_u64_u64_6(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
222void zig_struct_u64_u64_7(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
223void zig_struct_u64_u64_8(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
224
225struct Struct_u64_u64 c_ret_struct_u64_u64(void) {
226 return (struct Struct_u64_u64){ 21, 22 };
227}
228
229void c_struct_u64_u64_0(struct Struct_u64_u64 s, size_t i) {
230 assert_or_panic(s.a == 23);
231 assert_or_panic(s.b == 24);
232 assert_or_panic(i == 1);
233}
234void c_struct_u64_u64_1(size_t a0, struct Struct_u64_u64 s, size_t i) {
235 assert_or_panic(s.a == 25);
236 assert_or_panic(s.b == 26);
237 assert_or_panic(i == 2);
238}
239void c_struct_u64_u64_2(size_t, size_t, struct Struct_u64_u64 s, size_t i) {
240 assert_or_panic(s.a == 27);
241 assert_or_panic(s.b == 28);
242 assert_or_panic(i == 3);
243}
244void c_struct_u64_u64_3(size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
245 assert_or_panic(s.a == 29);
246 assert_or_panic(s.b == 30);
247 assert_or_panic(i == 4);
248}
249void c_struct_u64_u64_4(size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
250 assert_or_panic(s.a == 31);
251 assert_or_panic(s.b == 32);
252 assert_or_panic(i == 5);
253}
254void c_struct_u64_u64_5(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
255 assert_or_panic(s.a == 33);
256 assert_or_panic(s.b == 34);
257 assert_or_panic(i == 6);
258}
259void c_struct_u64_u64_6(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
260 assert_or_panic(s.a == 35);
261 assert_or_panic(s.b == 36);
262 assert_or_panic(i == 7);
263}
264void c_struct_u64_u64_7(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
265 assert_or_panic(s.a == 37);
266 assert_or_panic(s.b == 38);
267 assert_or_panic(i == 8);
268}
269void c_struct_u64_u64_8(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64 s, size_t i) {
270 assert_or_panic(s.a == 39);
271 assert_or_panic(s.b == 40);
272 assert_or_panic(i == 9);
273}
274
275struct Struct_f32 {
276 float a;
277};
278
279struct Struct_f32 zig_ret_struct_f32(void);
280
281void zig_struct_f32(struct Struct_f32);
282
283struct Struct_f32 c_ret_struct_f32(void) {
284 return (struct Struct_f32){ 2.5f };
285}
286
287void c_struct_f32(struct Struct_f32 s) {
288 assert_or_panic(s.a == 2.5f);
289}
290
291struct Struct_f64 {
292 double a;
293};
294
295struct Struct_f64 zig_ret_struct_f64(void);
296
297void zig_struct_f64(struct Struct_f64);
298
299struct Struct_f64 c_ret_struct_f64(void) {
300 return (struct Struct_f64){ 2.5 };
301}
302
303void c_struct_f64(struct Struct_f64 s) {
304 assert_or_panic(s.a == 2.5);
305}
306
307struct Struct_f32f32_f32 {
308 struct {
309 float b, c;
310 } a;
311 float d;
312};
313
314struct Struct_f32f32_f32 zig_ret_struct_f32f32_f32(void);
315
316void zig_struct_f32f32_f32(struct Struct_f32f32_f32);
317
318struct Struct_f32f32_f32 c_ret_struct_f32f32_f32(void) {
319 return (struct Struct_f32f32_f32){ { 1.0f, 2.0f }, 3.0f };
320}
321
322void c_struct_f32f32_f32(struct Struct_f32f32_f32 s) {
323 assert_or_panic(s.a.b == 1.0f);
324 assert_or_panic(s.a.c == 2.0f);
325 assert_or_panic(s.d == 3.0f);
326}
327
328struct Struct_f32_f32f32 {
329 float a;
330 struct {
331 float c, d;
332 } b;
333};
334
335struct Struct_f32_f32f32 zig_ret_struct_f32_f32f32(void);
336
337void zig_struct_f32_f32f32(struct Struct_f32_f32f32);
338
339struct Struct_f32_f32f32 c_ret_struct_f32_f32f32(void) {
340 return (struct Struct_f32_f32f32){ 1.0f, { 2.0f, 3.0f } };
341}
342
343void c_struct_f32_f32f32(struct Struct_f32_f32f32 s) {
344 assert_or_panic(s.a == 1.0f);
345 assert_or_panic(s.b.c == 2.0f);
346 assert_or_panic(s.b.d == 3.0f);
347}
348
349struct Struct_u32_Union_u32_u32u32 {
350 uint32_t a;
351 union {
352 struct {
353 uint32_t d, e;
354 } c;
355 } b;
356};
357
358struct Struct_u32_Union_u32_u32u32 zig_ret_struct_u32_union_u32_u32u32(void);
359
360void zig_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32);
361
362struct Struct_u32_Union_u32_u32u32 c_ret_struct_u32_union_u32_u32u32(void) {
363 struct Struct_u32_Union_u32_u32u32 s;
364 s.a = 1;
365 s.b.c.d = 2;
366 s.b.c.e = 3;
367 return s;
368}
369
370void c_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32 s) {
371 assert_or_panic(s.a == 1);
372 assert_or_panic(s.b.c.d == 2);
373 assert_or_panic(s.b.c.e == 3);
374}
375
376struct Struct_i32_i32 {
377 int32_t a;
378 int32_t b;
379};
380
381void zig_struct_i32_i32(struct Struct_i32_i32);
382
383struct BigStruct {
384 uint64_t a;
385 uint64_t b;
386 uint64_t c;
387 uint64_t d;
388 uint8_t e;
389};
390
391void zig_big_struct(struct BigStruct);
392
393union BigUnion {
394 struct BigStruct a;
395};
396
397void zig_big_union(union BigUnion);
398
399struct SmallStructInts {
400 uint8_t a;
401 uint8_t b;
402 uint8_t c;
403 uint8_t d;
404};
405
406void zig_small_struct_ints(struct SmallStructInts);
407struct SmallStructInts zig_ret_small_struct_ints();
408
409struct MedStructInts {
410 int32_t x;
411 int32_t y;
412 int32_t z;
413};
414
415void zig_med_struct_ints(struct MedStructInts);
416struct MedStructInts zig_ret_med_struct_ints();
417
418struct MedStructMixed {
419 uint32_t a;
420 float b;
421 float c;
422 uint32_t d;
423};
424
425void zig_med_struct_mixed(struct MedStructMixed);
426struct MedStructMixed zig_ret_med_struct_mixed();
427
428void zig_small_packed_struct(uint8_t);
429#ifndef ZIG_NO_I128
430void zig_big_packed_struct(__int128);
431#endif
432
433struct SplitStructInts {
434 uint64_t a;
435 uint8_t b;
436 uint32_t c;
437};
438void zig_split_struct_ints(struct SplitStructInts);
439
440struct SplitStructMixed {
441 uint64_t a;
442 uint8_t b;
443 float c;
444};
445void zig_split_struct_mixed(struct SplitStructMixed);
446struct SplitStructMixed zig_ret_split_struct_mixed();
447
448struct BigStruct zig_big_struct_both(struct BigStruct);
449
450typedef float Vector2Float __attribute__((ext_vector_type(2)));
451typedef float Vector4Float __attribute__((ext_vector_type(4)));
452
453void c_vector_2_float(Vector2Float vec) {
454 assert_or_panic(vec[0] == 1.0);
455 assert_or_panic(vec[1] == 2.0);
456}
457
458void c_vector_4_float(Vector4Float vec) {
459 assert_or_panic(vec[0] == 1.0);
460 assert_or_panic(vec[1] == 2.0);
461 assert_or_panic(vec[2] == 3.0);
462 assert_or_panic(vec[3] == 4.0);
463}
464
465Vector2Float c_ret_vector_2_float(void) {
466 return (Vector2Float){
467 1.0,
468 2.0,
469 };
470}
471Vector4Float c_ret_vector_4_float(void) {
472 return (Vector4Float){
473 1.0,
474 2.0,
475 3.0,
476 4.0,
477 };
478}
479
480#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32) || defined(__wasm__)
481
482typedef bool Vector2Bool __attribute__((ext_vector_type(2)));
483typedef bool Vector4Bool __attribute__((ext_vector_type(4)));
484typedef bool Vector8Bool __attribute__((ext_vector_type(8)));
485typedef bool Vector16Bool __attribute__((ext_vector_type(16)));
486typedef bool Vector32Bool __attribute__((ext_vector_type(32)));
487typedef bool Vector64Bool __attribute__((ext_vector_type(64)));
488typedef bool Vector128Bool __attribute__((ext_vector_type(128)));
489typedef bool Vector256Bool __attribute__((ext_vector_type(256)));
490typedef bool Vector512Bool __attribute__((ext_vector_type(512)));
491
492void c_vector_2_bool(Vector2Bool vec) {
493 assert_or_panic(vec[0] == true);
494 assert_or_panic(vec[1] == true);
495}
496
497void c_vector_4_bool(Vector4Bool vec) {
498 assert_or_panic(vec[0] == true);
499 assert_or_panic(vec[1] == true);
500 assert_or_panic(vec[2] == false);
501 assert_or_panic(vec[3] == true);
502}
503
504void c_vector_8_bool(Vector8Bool vec) {
505 assert_or_panic(vec[0] == true);
506 assert_or_panic(vec[1] == false);
507 assert_or_panic(vec[2] == true);
508 assert_or_panic(vec[3] == true);
509 assert_or_panic(vec[4] == true);
510 assert_or_panic(vec[5] == true);
511 assert_or_panic(vec[6] == false);
512 assert_or_panic(vec[7] == true);
513}
514
515void c_vector_16_bool(Vector16Bool vec) {
516 assert_or_panic(vec[0] == true);
517 assert_or_panic(vec[1] == false);
518 assert_or_panic(vec[2] == false);
519 assert_or_panic(vec[3] == false);
520 assert_or_panic(vec[4] == true);
521 assert_or_panic(vec[5] == false);
522 assert_or_panic(vec[6] == true);
523 assert_or_panic(vec[7] == true);
524 assert_or_panic(vec[8] == true);
525 assert_or_panic(vec[9] == true);
526 assert_or_panic(vec[10] == true);
527 assert_or_panic(vec[11] == true);
528 assert_or_panic(vec[12] == false);
529 assert_or_panic(vec[13] == false);
530 assert_or_panic(vec[14] == false);
531 assert_or_panic(vec[15] == false);
532}
533
534void c_vector_32_bool(Vector32Bool vec) {
535 assert_or_panic(vec[0] == true);
536 assert_or_panic(vec[1] == false);
537 assert_or_panic(vec[2] == true);
538 assert_or_panic(vec[3] == true);
539 assert_or_panic(vec[4] == false);
540 assert_or_panic(vec[5] == false);
541 assert_or_panic(vec[6] == true);
542 assert_or_panic(vec[7] == false);
543 assert_or_panic(vec[8] == true);
544 assert_or_panic(vec[9] == false);
545 assert_or_panic(vec[10] == true);
546 assert_or_panic(vec[11] == true);
547 assert_or_panic(vec[12] == true);
548 assert_or_panic(vec[13] == false);
549 assert_or_panic(vec[14] == false);
550 assert_or_panic(vec[15] == true);
551 assert_or_panic(vec[16] == false);
552 assert_or_panic(vec[17] == true);
553 assert_or_panic(vec[18] == false);
554 assert_or_panic(vec[19] == true);
555 assert_or_panic(vec[20] == true);
556 assert_or_panic(vec[21] == true);
557 assert_or_panic(vec[22] == true);
558 assert_or_panic(vec[23] == true);
559 assert_or_panic(vec[24] == false);
560 assert_or_panic(vec[25] == true);
561 assert_or_panic(vec[26] == true);
562 assert_or_panic(vec[27] == true);
563 assert_or_panic(vec[28] == false);
564 assert_or_panic(vec[29] == true);
565 assert_or_panic(vec[30] == true);
566 assert_or_panic(vec[31] == false);
567}
568
569void c_vector_64_bool(Vector64Bool vec) {
570 assert_or_panic(vec[0] == true);
571 assert_or_panic(vec[1] == true);
572 assert_or_panic(vec[2] == true);
573 assert_or_panic(vec[3] == false);
574 assert_or_panic(vec[4] == true);
575 assert_or_panic(vec[5] == false);
576 assert_or_panic(vec[6] == false);
577 assert_or_panic(vec[7] == false);
578 assert_or_panic(vec[8] == true);
579 assert_or_panic(vec[9] == false);
580 assert_or_panic(vec[10] == false);
581 assert_or_panic(vec[11] == false);
582 assert_or_panic(vec[12] == false);
583 assert_or_panic(vec[13] == true);
584 assert_or_panic(vec[14] == true);
585 assert_or_panic(vec[15] == true);
586 assert_or_panic(vec[16] == true);
587 assert_or_panic(vec[17] == false);
588 assert_or_panic(vec[18] == false);
589 assert_or_panic(vec[19] == true);
590 assert_or_panic(vec[20] == false);
591 assert_or_panic(vec[21] == true);
592 assert_or_panic(vec[22] == false);
593 assert_or_panic(vec[23] == true);
594 assert_or_panic(vec[24] == true);
595 assert_or_panic(vec[25] == true);
596 assert_or_panic(vec[26] == true);
597 assert_or_panic(vec[27] == true);
598 assert_or_panic(vec[28] == true);
599 assert_or_panic(vec[29] == true);
600 assert_or_panic(vec[30] == false);
601 assert_or_panic(vec[31] == false);
602 assert_or_panic(vec[32] == true);
603 assert_or_panic(vec[33] == true);
604 assert_or_panic(vec[34] == false);
605 assert_or_panic(vec[35] == true);
606 assert_or_panic(vec[36] == false);
607 assert_or_panic(vec[37] == false);
608 assert_or_panic(vec[38] == true);
609 assert_or_panic(vec[39] == true);
610 assert_or_panic(vec[40] == true);
611 assert_or_panic(vec[41] == false);
612 assert_or_panic(vec[42] == false);
613 assert_or_panic(vec[43] == true);
614 assert_or_panic(vec[44] == true);
615 assert_or_panic(vec[45] == false);
616 assert_or_panic(vec[46] == true);
617 assert_or_panic(vec[47] == false);
618 assert_or_panic(vec[48] == true);
619 assert_or_panic(vec[49] == false);
620 assert_or_panic(vec[50] == false);
621 assert_or_panic(vec[51] == true);
622 assert_or_panic(vec[52] == false);
623 assert_or_panic(vec[53] == true);
624 assert_or_panic(vec[54] == true);
625 assert_or_panic(vec[55] == true);
626 assert_or_panic(vec[56] == true);
627 assert_or_panic(vec[57] == true);
628 assert_or_panic(vec[58] == false);
629 assert_or_panic(vec[59] == false);
630 assert_or_panic(vec[60] == true);
631 assert_or_panic(vec[61] == false);
632 assert_or_panic(vec[62] == true);
633 assert_or_panic(vec[63] == false);
634}
635
636void c_vector_128_bool(Vector128Bool vec) {
637 assert_or_panic(vec[0] == false);
638 assert_or_panic(vec[1] == false);
639 assert_or_panic(vec[2] == false);
640 assert_or_panic(vec[3] == false);
641 assert_or_panic(vec[4] == false);
642 assert_or_panic(vec[5] == true);
643 assert_or_panic(vec[6] == true);
644 assert_or_panic(vec[7] == false);
645 assert_or_panic(vec[8] == true);
646 assert_or_panic(vec[9] == true);
647 assert_or_panic(vec[10] == false);
648 assert_or_panic(vec[11] == true);
649 assert_or_panic(vec[12] == true);
650 assert_or_panic(vec[13] == false);
651 assert_or_panic(vec[14] == true);
652 assert_or_panic(vec[15] == true);
653 assert_or_panic(vec[16] == true);
654 assert_or_panic(vec[17] == false);
655 assert_or_panic(vec[18] == false);
656 assert_or_panic(vec[19] == false);
657 assert_or_panic(vec[20] == false);
658 assert_or_panic(vec[21] == true);
659 assert_or_panic(vec[22] == true);
660 assert_or_panic(vec[23] == false);
661 assert_or_panic(vec[24] == false);
662 assert_or_panic(vec[25] == false);
663 assert_or_panic(vec[26] == true);
664 assert_or_panic(vec[27] == true);
665 assert_or_panic(vec[28] == false);
666 assert_or_panic(vec[29] == true);
667 assert_or_panic(vec[30] == false);
668 assert_or_panic(vec[31] == false);
669 assert_or_panic(vec[32] == true);
670 assert_or_panic(vec[33] == false);
671 assert_or_panic(vec[34] == false);
672 assert_or_panic(vec[35] == true);
673 assert_or_panic(vec[36] == true);
674 assert_or_panic(vec[37] == true);
675 assert_or_panic(vec[38] == true);
676 assert_or_panic(vec[39] == true);
677 assert_or_panic(vec[40] == false);
678 assert_or_panic(vec[41] == true);
679 assert_or_panic(vec[42] == true);
680 assert_or_panic(vec[43] == true);
681 assert_or_panic(vec[44] == false);
682 assert_or_panic(vec[45] == false);
683 assert_or_panic(vec[46] == false);
684 assert_or_panic(vec[47] == false);
685 assert_or_panic(vec[48] == true);
686 assert_or_panic(vec[49] == true);
687 assert_or_panic(vec[50] == false);
688 assert_or_panic(vec[51] == true);
689 assert_or_panic(vec[52] == true);
690 assert_or_panic(vec[53] == true);
691 assert_or_panic(vec[54] == true);
692 assert_or_panic(vec[55] == true);
693 assert_or_panic(vec[56] == false);
694 assert_or_panic(vec[57] == true);
695 assert_or_panic(vec[58] == true);
696 assert_or_panic(vec[59] == false);
697 assert_or_panic(vec[60] == true);
698 assert_or_panic(vec[61] == false);
699 assert_or_panic(vec[62] == false);
700 assert_or_panic(vec[63] == true);
701 assert_or_panic(vec[64] == true);
702 assert_or_panic(vec[65] == false);
703 assert_or_panic(vec[66] == true);
704 assert_or_panic(vec[67] == true);
705 assert_or_panic(vec[68] == false);
706 assert_or_panic(vec[69] == true);
707 assert_or_panic(vec[70] == false);
708 assert_or_panic(vec[71] == false);
709 assert_or_panic(vec[72] == true);
710 assert_or_panic(vec[73] == true);
711 assert_or_panic(vec[74] == false);
712 assert_or_panic(vec[75] == true);
713 assert_or_panic(vec[76] == true);
714 assert_or_panic(vec[77] == true);
715 assert_or_panic(vec[78] == false);
716 assert_or_panic(vec[79] == true);
717 assert_or_panic(vec[80] == false);
718 assert_or_panic(vec[81] == false);
719 assert_or_panic(vec[82] == false);
720 assert_or_panic(vec[83] == false);
721 assert_or_panic(vec[84] == true);
722 assert_or_panic(vec[85] == false);
723 assert_or_panic(vec[86] == false);
724 assert_or_panic(vec[87] == false);
725 assert_or_panic(vec[88] == true);
726 assert_or_panic(vec[89] == true);
727 assert_or_panic(vec[90] == false);
728 assert_or_panic(vec[91] == false);
729 assert_or_panic(vec[92] == true);
730 assert_or_panic(vec[93] == true);
731 assert_or_panic(vec[94] == true);
732 assert_or_panic(vec[95] == true);
733 assert_or_panic(vec[96] == false);
734 assert_or_panic(vec[97] == false);
735 assert_or_panic(vec[98] == false);
736 assert_or_panic(vec[99] == false);
737 assert_or_panic(vec[100] == false);
738 assert_or_panic(vec[101] == true);
739 assert_or_panic(vec[102] == false);
740 assert_or_panic(vec[103] == false);
741 assert_or_panic(vec[104] == false);
742 assert_or_panic(vec[105] == false);
743 assert_or_panic(vec[106] == true);
744 assert_or_panic(vec[107] == true);
745 assert_or_panic(vec[108] == true);
746 assert_or_panic(vec[109] == true);
747 assert_or_panic(vec[110] == true);
748 assert_or_panic(vec[111] == false);
749 assert_or_panic(vec[112] == false);
750 assert_or_panic(vec[113] == true);
751 assert_or_panic(vec[114] == false);
752 assert_or_panic(vec[115] == true);
753 assert_or_panic(vec[116] == false);
754 assert_or_panic(vec[117] == false);
755 assert_or_panic(vec[118] == true);
756 assert_or_panic(vec[119] == false);
757 assert_or_panic(vec[120] == true);
758 assert_or_panic(vec[121] == false);
759 assert_or_panic(vec[122] == true);
760 assert_or_panic(vec[123] == true);
761 assert_or_panic(vec[124] == true);
762 assert_or_panic(vec[125] == true);
763 assert_or_panic(vec[126] == true);
764 assert_or_panic(vec[127] == true);
765}
766
767// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target.
768#if !defined(__wasm__)
769
770void c_vector_256_bool(Vector256Bool vec) {
771 assert_or_panic(vec[0] == false);
772 assert_or_panic(vec[1] == true);
773 assert_or_panic(vec[2] == true);
774 assert_or_panic(vec[3] == false);
775 assert_or_panic(vec[4] == false);
776 assert_or_panic(vec[5] == true);
777 assert_or_panic(vec[6] == true);
778 assert_or_panic(vec[7] == true);
779 assert_or_panic(vec[8] == false);
780 assert_or_panic(vec[9] == true);
781 assert_or_panic(vec[10] == true);
782 assert_or_panic(vec[11] == true);
783 assert_or_panic(vec[12] == false);
784 assert_or_panic(vec[13] == true);
785 assert_or_panic(vec[14] == false);
786 assert_or_panic(vec[15] == true);
787 assert_or_panic(vec[16] == false);
788 assert_or_panic(vec[17] == false);
789 assert_or_panic(vec[18] == true);
790 assert_or_panic(vec[19] == true);
791 assert_or_panic(vec[20] == false);
792 assert_or_panic(vec[21] == true);
793 assert_or_panic(vec[22] == false);
794 assert_or_panic(vec[23] == false);
795 assert_or_panic(vec[24] == false);
796 assert_or_panic(vec[25] == true);
797 assert_or_panic(vec[26] == true);
798 assert_or_panic(vec[27] == false);
799 assert_or_panic(vec[28] == false);
800 assert_or_panic(vec[29] == true);
801 assert_or_panic(vec[30] == true);
802 assert_or_panic(vec[31] == false);
803 assert_or_panic(vec[32] == true);
804 assert_or_panic(vec[33] == false);
805 assert_or_panic(vec[34] == false);
806 assert_or_panic(vec[35] == true);
807 assert_or_panic(vec[36] == false);
808 assert_or_panic(vec[37] == true);
809 assert_or_panic(vec[38] == false);
810 assert_or_panic(vec[39] == true);
811 assert_or_panic(vec[40] == true);
812 assert_or_panic(vec[41] == true);
813 assert_or_panic(vec[42] == true);
814 assert_or_panic(vec[43] == false);
815 assert_or_panic(vec[44] == false);
816 assert_or_panic(vec[45] == true);
817 assert_or_panic(vec[46] == false);
818 assert_or_panic(vec[47] == false);
819 assert_or_panic(vec[48] == false);
820 assert_or_panic(vec[49] == false);
821 assert_or_panic(vec[50] == false);
822 assert_or_panic(vec[51] == false);
823 assert_or_panic(vec[52] == true);
824 assert_or_panic(vec[53] == true);
825 assert_or_panic(vec[54] == true);
826 assert_or_panic(vec[55] == true);
827 assert_or_panic(vec[56] == true);
828 assert_or_panic(vec[57] == true);
829 assert_or_panic(vec[58] == false);
830 assert_or_panic(vec[59] == true);
831 assert_or_panic(vec[60] == true);
832 assert_or_panic(vec[61] == false);
833 assert_or_panic(vec[62] == false);
834 assert_or_panic(vec[63] == true);
835 assert_or_panic(vec[64] == false);
836 assert_or_panic(vec[65] == false);
837 assert_or_panic(vec[66] == false);
838 assert_or_panic(vec[67] == false);
839 assert_or_panic(vec[68] == false);
840 assert_or_panic(vec[69] == false);
841 assert_or_panic(vec[70] == true);
842 assert_or_panic(vec[71] == true);
843 assert_or_panic(vec[72] == true);
844 assert_or_panic(vec[73] == false);
845 assert_or_panic(vec[74] == false);
846 assert_or_panic(vec[75] == false);
847 assert_or_panic(vec[76] == true);
848 assert_or_panic(vec[77] == false);
849 assert_or_panic(vec[78] == true);
850 assert_or_panic(vec[79] == true);
851 assert_or_panic(vec[80] == false);
852 assert_or_panic(vec[81] == false);
853 assert_or_panic(vec[82] == true);
854 assert_or_panic(vec[83] == true);
855 assert_or_panic(vec[84] == false);
856 assert_or_panic(vec[85] == true);
857 assert_or_panic(vec[86] == true);
858 assert_or_panic(vec[87] == true);
859 assert_or_panic(vec[88] == true);
860 assert_or_panic(vec[89] == true);
861 assert_or_panic(vec[90] == true);
862 assert_or_panic(vec[91] == true);
863 assert_or_panic(vec[92] == false);
864 assert_or_panic(vec[93] == true);
865 assert_or_panic(vec[94] == true);
866 assert_or_panic(vec[95] == false);
867 assert_or_panic(vec[96] == false);
868 assert_or_panic(vec[97] == true);
869 assert_or_panic(vec[98] == true);
870 assert_or_panic(vec[99] == false);
871 assert_or_panic(vec[100] == true);
872 assert_or_panic(vec[101] == false);
873 assert_or_panic(vec[102] == false);
874 assert_or_panic(vec[103] == true);
875 assert_or_panic(vec[104] == false);
876 assert_or_panic(vec[105] == true);
877 assert_or_panic(vec[106] == true);
878 assert_or_panic(vec[107] == true);
879 assert_or_panic(vec[108] == true);
880 assert_or_panic(vec[109] == true);
881 assert_or_panic(vec[110] == false);
882 assert_or_panic(vec[111] == false);
883 assert_or_panic(vec[112] == false);
884 assert_or_panic(vec[113] == false);
885 assert_or_panic(vec[114] == true);
886 assert_or_panic(vec[115] == true);
887 assert_or_panic(vec[116] == false);
888 assert_or_panic(vec[117] == true);
889 assert_or_panic(vec[118] == false);
890 assert_or_panic(vec[119] == false);
891 assert_or_panic(vec[120] == true);
892 assert_or_panic(vec[121] == false);
893 assert_or_panic(vec[122] == false);
894 assert_or_panic(vec[123] == true);
895 assert_or_panic(vec[124] == false);
896 assert_or_panic(vec[125] == true);
897 assert_or_panic(vec[126] == true);
898 assert_or_panic(vec[127] == true);
899 assert_or_panic(vec[128] == true);
900 assert_or_panic(vec[129] == false);
901 assert_or_panic(vec[130] == true);
902 assert_or_panic(vec[131] == true);
903 assert_or_panic(vec[132] == false);
904 assert_or_panic(vec[133] == false);
905 assert_or_panic(vec[134] == true);
906 assert_or_panic(vec[135] == false);
907 assert_or_panic(vec[136] == false);
908 assert_or_panic(vec[137] == true);
909 assert_or_panic(vec[138] == false);
910 assert_or_panic(vec[139] == true);
911 assert_or_panic(vec[140] == false);
912 assert_or_panic(vec[141] == true);
913 assert_or_panic(vec[142] == true);
914 assert_or_panic(vec[143] == true);
915 assert_or_panic(vec[144] == true);
916 assert_or_panic(vec[145] == false);
917 assert_or_panic(vec[146] == true);
918 assert_or_panic(vec[147] == false);
919 assert_or_panic(vec[148] == false);
920 assert_or_panic(vec[149] == false);
921 assert_or_panic(vec[150] == true);
922 assert_or_panic(vec[151] == true);
923 assert_or_panic(vec[152] == true);
924 assert_or_panic(vec[153] == true);
925 assert_or_panic(vec[154] == true);
926 assert_or_panic(vec[155] == false);
927 assert_or_panic(vec[156] == true);
928 assert_or_panic(vec[157] == false);
929 assert_or_panic(vec[158] == false);
930 assert_or_panic(vec[159] == false);
931 assert_or_panic(vec[160] == true);
932 assert_or_panic(vec[161] == true);
933 assert_or_panic(vec[162] == false);
934 assert_or_panic(vec[163] == true);
935 assert_or_panic(vec[164] == true);
936 assert_or_panic(vec[165] == false);
937 assert_or_panic(vec[166] == false);
938 assert_or_panic(vec[167] == false);
939 assert_or_panic(vec[168] == false);
940 assert_or_panic(vec[169] == true);
941 assert_or_panic(vec[170] == false);
942 assert_or_panic(vec[171] == true);
943 assert_or_panic(vec[172] == false);
944 assert_or_panic(vec[173] == false);
945 assert_or_panic(vec[174] == false);
946 assert_or_panic(vec[175] == false);
947 assert_or_panic(vec[176] == true);
948 assert_or_panic(vec[177] == true);
949 assert_or_panic(vec[178] == true);
950 assert_or_panic(vec[179] == false);
951 assert_or_panic(vec[180] == true);
952 assert_or_panic(vec[181] == false);
953 assert_or_panic(vec[182] == true);
954 assert_or_panic(vec[183] == true);
955 assert_or_panic(vec[184] == false);
956 assert_or_panic(vec[185] == false);
957 assert_or_panic(vec[186] == true);
958 assert_or_panic(vec[187] == false);
959 assert_or_panic(vec[188] == false);
960 assert_or_panic(vec[189] == false);
961 assert_or_panic(vec[190] == false);
962 assert_or_panic(vec[191] == true);
963 assert_or_panic(vec[192] == true);
964 assert_or_panic(vec[193] == true);
965 assert_or_panic(vec[194] == true);
966 assert_or_panic(vec[195] == true);
967 assert_or_panic(vec[196] == true);
968 assert_or_panic(vec[197] == true);
969 assert_or_panic(vec[198] == false);
970 assert_or_panic(vec[199] == true);
971 assert_or_panic(vec[200] == false);
972 assert_or_panic(vec[201] == false);
973 assert_or_panic(vec[202] == true);
974 assert_or_panic(vec[203] == false);
975 assert_or_panic(vec[204] == true);
976 assert_or_panic(vec[205] == true);
977 assert_or_panic(vec[206] == true);
978 assert_or_panic(vec[207] == false);
979 assert_or_panic(vec[208] == false);
980 assert_or_panic(vec[209] == true);
981 assert_or_panic(vec[210] == true);
982 assert_or_panic(vec[211] == true);
983 assert_or_panic(vec[212] == false);
984 assert_or_panic(vec[213] == true);
985 assert_or_panic(vec[214] == true);
986 assert_or_panic(vec[215] == true);
987 assert_or_panic(vec[216] == true);
988 assert_or_panic(vec[217] == true);
989 assert_or_panic(vec[218] == false);
990 assert_or_panic(vec[219] == false);
991 assert_or_panic(vec[220] == false);
992 assert_or_panic(vec[221] == false);
993 assert_or_panic(vec[222] == false);
994 assert_or_panic(vec[223] == true);
995 assert_or_panic(vec[224] == true);
996 assert_or_panic(vec[225] == false);
997 assert_or_panic(vec[226] == true);
998 assert_or_panic(vec[227] == false);
999 assert_or_panic(vec[228] == false);
1000 assert_or_panic(vec[229] == true);
1001 assert_or_panic(vec[230] == false);
1002 assert_or_panic(vec[231] == true);
1003 assert_or_panic(vec[232] == false);
1004 assert_or_panic(vec[233] == false);
1005 assert_or_panic(vec[234] == false);
1006 assert_or_panic(vec[235] == true);
1007 assert_or_panic(vec[236] == false);
1008 assert_or_panic(vec[237] == false);
1009 assert_or_panic(vec[238] == false);
1010 assert_or_panic(vec[239] == true);
1011 assert_or_panic(vec[240] == true);
1012 assert_or_panic(vec[241] == true);
1013 assert_or_panic(vec[242] == true);
1014 assert_or_panic(vec[243] == true);
1015 assert_or_panic(vec[244] == true);
1016 assert_or_panic(vec[245] == false);
1017 assert_or_panic(vec[246] == false);
1018 assert_or_panic(vec[247] == true);
1019 assert_or_panic(vec[248] == false);
1020 assert_or_panic(vec[249] == true);
1021 assert_or_panic(vec[250] == true);
1022 assert_or_panic(vec[251] == false);
1023 assert_or_panic(vec[252] == true);
1024 assert_or_panic(vec[253] == true);
1025 assert_or_panic(vec[254] == true);
1026 assert_or_panic(vec[255] == false);
1027}
1028
1029void c_vector_512_bool(Vector512Bool vec) {
1030 assert_or_panic(vec[0] == true);
1031 assert_or_panic(vec[1] == true);
1032 assert_or_panic(vec[2] == true);
1033 assert_or_panic(vec[3] == true);
1034 assert_or_panic(vec[4] == true);
1035 assert_or_panic(vec[5] == false);
1036 assert_or_panic(vec[6] == false);
1037 assert_or_panic(vec[7] == true);
1038 assert_or_panic(vec[8] == true);
1039 assert_or_panic(vec[9] == true);
1040 assert_or_panic(vec[10] == true);
1041 assert_or_panic(vec[11] == false);
1042 assert_or_panic(vec[12] == true);
1043 assert_or_panic(vec[13] == true);
1044 assert_or_panic(vec[14] == false);
1045 assert_or_panic(vec[15] == false);
1046 assert_or_panic(vec[16] == false);
1047 assert_or_panic(vec[17] == true);
1048 assert_or_panic(vec[18] == true);
1049 assert_or_panic(vec[19] == true);
1050 assert_or_panic(vec[20] == true);
1051 assert_or_panic(vec[21] == true);
1052 assert_or_panic(vec[22] == false);
1053 assert_or_panic(vec[23] == false);
1054 assert_or_panic(vec[24] == true);
1055 assert_or_panic(vec[25] == true);
1056 assert_or_panic(vec[26] == false);
1057 assert_or_panic(vec[27] == false);
1058 assert_or_panic(vec[28] == false);
1059 assert_or_panic(vec[29] == false);
1060 assert_or_panic(vec[30] == false);
1061 assert_or_panic(vec[31] == true);
1062 assert_or_panic(vec[32] == true);
1063 assert_or_panic(vec[33] == false);
1064 assert_or_panic(vec[34] == true);
1065 assert_or_panic(vec[35] == true);
1066 assert_or_panic(vec[36] == true);
1067 assert_or_panic(vec[37] == true);
1068 assert_or_panic(vec[38] == true);
1069 assert_or_panic(vec[39] == true);
1070 assert_or_panic(vec[40] == false);
1071 assert_or_panic(vec[41] == true);
1072 assert_or_panic(vec[42] == true);
1073 assert_or_panic(vec[43] == false);
1074 assert_or_panic(vec[44] == false);
1075 assert_or_panic(vec[45] == false);
1076 assert_or_panic(vec[46] == true);
1077 assert_or_panic(vec[47] == true);
1078 assert_or_panic(vec[48] == false);
1079 assert_or_panic(vec[49] == true);
1080 assert_or_panic(vec[50] == false);
1081 assert_or_panic(vec[51] == true);
1082 assert_or_panic(vec[52] == true);
1083 assert_or_panic(vec[53] == false);
1084 assert_or_panic(vec[54] == true);
1085 assert_or_panic(vec[55] == false);
1086 assert_or_panic(vec[56] == false);
1087 assert_or_panic(vec[57] == true);
1088 assert_or_panic(vec[58] == true);
1089 assert_or_panic(vec[59] == false);
1090 assert_or_panic(vec[60] == true);
1091 assert_or_panic(vec[61] == true);
1092 assert_or_panic(vec[62] == false);
1093 assert_or_panic(vec[63] == true);
1094 assert_or_panic(vec[64] == false);
1095 assert_or_panic(vec[65] == true);
1096 assert_or_panic(vec[66] == true);
1097 assert_or_panic(vec[67] == true);
1098 assert_or_panic(vec[68] == true);
1099 assert_or_panic(vec[69] == true);
1100 assert_or_panic(vec[70] == true);
1101 assert_or_panic(vec[71] == true);
1102 assert_or_panic(vec[72] == true);
1103 assert_or_panic(vec[73] == true);
1104 assert_or_panic(vec[74] == false);
1105 assert_or_panic(vec[75] == true);
1106 assert_or_panic(vec[76] == false);
1107 assert_or_panic(vec[77] == true);
1108 assert_or_panic(vec[78] == false);
1109 assert_or_panic(vec[79] == false);
1110 assert_or_panic(vec[80] == false);
1111 assert_or_panic(vec[81] == true);
1112 assert_or_panic(vec[82] == false);
1113 assert_or_panic(vec[83] == true);
1114 assert_or_panic(vec[84] == true);
1115 assert_or_panic(vec[85] == false);
1116 assert_or_panic(vec[86] == true);
1117 assert_or_panic(vec[87] == true);
1118 assert_or_panic(vec[88] == true);
1119 assert_or_panic(vec[89] == false);
1120 assert_or_panic(vec[90] == true);
1121 assert_or_panic(vec[91] == true);
1122 assert_or_panic(vec[92] == false);
1123 assert_or_panic(vec[93] == true);
1124 assert_or_panic(vec[94] == false);
1125 assert_or_panic(vec[95] == true);
1126 assert_or_panic(vec[96] == true);
1127 assert_or_panic(vec[97] == false);
1128 assert_or_panic(vec[98] == false);
1129 assert_or_panic(vec[99] == false);
1130 assert_or_panic(vec[100] == true);
1131 assert_or_panic(vec[101] == true);
1132 assert_or_panic(vec[102] == false);
1133 assert_or_panic(vec[103] == true);
1134 assert_or_panic(vec[104] == false);
1135 assert_or_panic(vec[105] == false);
1136 assert_or_panic(vec[106] == true);
1137 assert_or_panic(vec[107] == false);
1138 assert_or_panic(vec[108] == false);
1139 assert_or_panic(vec[109] == true);
1140 assert_or_panic(vec[110] == false);
1141 assert_or_panic(vec[111] == false);
1142 assert_or_panic(vec[112] == false);
1143 assert_or_panic(vec[113] == false);
1144 assert_or_panic(vec[114] == false);
1145 assert_or_panic(vec[115] == true);
1146 assert_or_panic(vec[116] == true);
1147 assert_or_panic(vec[117] == false);
1148 assert_or_panic(vec[118] == false);
1149 assert_or_panic(vec[119] == false);
1150 assert_or_panic(vec[120] == false);
1151 assert_or_panic(vec[121] == true);
1152 assert_or_panic(vec[122] == false);
1153 assert_or_panic(vec[123] == false);
1154 assert_or_panic(vec[124] == true);
1155 assert_or_panic(vec[125] == true);
1156 assert_or_panic(vec[126] == false);
1157 assert_or_panic(vec[127] == true);
1158 assert_or_panic(vec[128] == false);
1159 assert_or_panic(vec[129] == true);
1160 assert_or_panic(vec[130] == true);
1161 assert_or_panic(vec[131] == false);
1162 assert_or_panic(vec[132] == true);
1163 assert_or_panic(vec[133] == false);
1164 assert_or_panic(vec[134] == false);
1165 assert_or_panic(vec[135] == false);
1166 assert_or_panic(vec[136] == false);
1167 assert_or_panic(vec[137] == true);
1168 assert_or_panic(vec[138] == true);
1169 assert_or_panic(vec[139] == false);
1170 assert_or_panic(vec[140] == false);
1171 assert_or_panic(vec[141] == false);
1172 assert_or_panic(vec[142] == true);
1173 assert_or_panic(vec[143] == true);
1174 assert_or_panic(vec[144] == false);
1175 assert_or_panic(vec[145] == false);
1176 assert_or_panic(vec[146] == true);
1177 assert_or_panic(vec[147] == true);
1178 assert_or_panic(vec[148] == true);
1179 assert_or_panic(vec[149] == true);
1180 assert_or_panic(vec[150] == true);
1181 assert_or_panic(vec[151] == true);
1182 assert_or_panic(vec[152] == true);
1183 assert_or_panic(vec[153] == false);
1184 assert_or_panic(vec[154] == true);
1185 assert_or_panic(vec[155] == false);
1186 assert_or_panic(vec[156] == false);
1187 assert_or_panic(vec[157] == true);
1188 assert_or_panic(vec[158] == false);
1189 assert_or_panic(vec[159] == true);
1190 assert_or_panic(vec[160] == false);
1191 assert_or_panic(vec[161] == true);
1192 assert_or_panic(vec[162] == true);
1193 assert_or_panic(vec[163] == true);
1194 assert_or_panic(vec[164] == true);
1195 assert_or_panic(vec[165] == true);
1196 assert_or_panic(vec[166] == true);
1197 assert_or_panic(vec[167] == true);
1198 assert_or_panic(vec[168] == true);
1199 assert_or_panic(vec[169] == false);
1200 assert_or_panic(vec[170] == true);
1201 assert_or_panic(vec[171] == true);
1202 assert_or_panic(vec[172] == false);
1203 assert_or_panic(vec[173] == true);
1204 assert_or_panic(vec[174] == true);
1205 assert_or_panic(vec[175] == false);
1206 assert_or_panic(vec[176] == false);
1207 assert_or_panic(vec[177] == false);
1208 assert_or_panic(vec[178] == true);
1209 assert_or_panic(vec[179] == false);
1210 assert_or_panic(vec[180] == false);
1211 assert_or_panic(vec[181] == true);
1212 assert_or_panic(vec[182] == true);
1213 assert_or_panic(vec[183] == true);
1214 assert_or_panic(vec[184] == true);
1215 assert_or_panic(vec[185] == true);
1216 assert_or_panic(vec[186] == true);
1217 assert_or_panic(vec[187] == true);
1218 assert_or_panic(vec[188] == true);
1219 assert_or_panic(vec[189] == true);
1220 assert_or_panic(vec[190] == false);
1221 assert_or_panic(vec[191] == true);
1222 assert_or_panic(vec[192] == true);
1223 assert_or_panic(vec[193] == false);
1224 assert_or_panic(vec[194] == false);
1225 assert_or_panic(vec[195] == true);
1226 assert_or_panic(vec[196] == true);
1227 assert_or_panic(vec[197] == false);
1228 assert_or_panic(vec[198] == true);
1229 assert_or_panic(vec[199] == true);
1230 assert_or_panic(vec[200] == false);
1231 assert_or_panic(vec[201] == true);
1232 assert_or_panic(vec[202] == true);
1233 assert_or_panic(vec[203] == false);
1234 assert_or_panic(vec[204] == true);
1235 assert_or_panic(vec[205] == true);
1236 assert_or_panic(vec[206] == true);
1237 assert_or_panic(vec[207] == true);
1238 assert_or_panic(vec[208] == false);
1239 assert_or_panic(vec[209] == true);
1240 assert_or_panic(vec[210] == false);
1241 assert_or_panic(vec[211] == true);
1242 assert_or_panic(vec[212] == true);
1243 assert_or_panic(vec[213] == false);
1244 assert_or_panic(vec[214] == true);
1245 assert_or_panic(vec[215] == false);
1246 assert_or_panic(vec[216] == true);
1247 assert_or_panic(vec[217] == false);
1248 assert_or_panic(vec[218] == true);
1249 assert_or_panic(vec[219] == false);
1250 assert_or_panic(vec[220] == false);
1251 assert_or_panic(vec[221] == true);
1252 assert_or_panic(vec[222] == false);
1253 assert_or_panic(vec[223] == false);
1254 assert_or_panic(vec[224] == false);
1255 assert_or_panic(vec[225] == true);
1256 assert_or_panic(vec[226] == true);
1257 assert_or_panic(vec[227] == false);
1258 assert_or_panic(vec[228] == false);
1259 assert_or_panic(vec[229] == false);
1260 assert_or_panic(vec[230] == true);
1261 assert_or_panic(vec[231] == false);
1262 assert_or_panic(vec[232] == true);
1263 assert_or_panic(vec[233] == false);
1264 assert_or_panic(vec[234] == false);
1265 assert_or_panic(vec[235] == false);
1266 assert_or_panic(vec[236] == true);
1267 assert_or_panic(vec[237] == true);
1268 assert_or_panic(vec[238] == false);
1269 assert_or_panic(vec[239] == false);
1270 assert_or_panic(vec[240] == false);
1271 assert_or_panic(vec[241] == false);
1272 assert_or_panic(vec[242] == false);
1273 assert_or_panic(vec[243] == true);
1274 assert_or_panic(vec[244] == true);
1275 assert_or_panic(vec[245] == false);
1276 assert_or_panic(vec[246] == true);
1277 assert_or_panic(vec[247] == false);
1278 assert_or_panic(vec[248] == false);
1279 assert_or_panic(vec[249] == true);
1280 assert_or_panic(vec[250] == false);
1281 assert_or_panic(vec[251] == false);
1282 assert_or_panic(vec[252] == false);
1283 assert_or_panic(vec[253] == true);
1284 assert_or_panic(vec[254] == false);
1285 assert_or_panic(vec[255] == false);
1286 assert_or_panic(vec[256] == false);
1287 assert_or_panic(vec[257] == false);
1288 assert_or_panic(vec[258] == true);
1289 assert_or_panic(vec[259] == true);
1290 assert_or_panic(vec[260] == true);
1291 assert_or_panic(vec[261] == true);
1292 assert_or_panic(vec[262] == false);
1293 assert_or_panic(vec[263] == true);
1294 assert_or_panic(vec[264] == false);
1295 assert_or_panic(vec[265] == false);
1296 assert_or_panic(vec[266] == false);
1297 assert_or_panic(vec[267] == true);
1298 assert_or_panic(vec[268] == false);
1299 assert_or_panic(vec[269] == false);
1300 assert_or_panic(vec[270] == true);
1301 assert_or_panic(vec[271] == true);
1302 assert_or_panic(vec[272] == false);
1303 assert_or_panic(vec[273] == false);
1304 assert_or_panic(vec[274] == false);
1305 assert_or_panic(vec[275] == false);
1306 assert_or_panic(vec[276] == false);
1307 assert_or_panic(vec[277] == true);
1308 assert_or_panic(vec[278] == false);
1309 assert_or_panic(vec[279] == true);
1310 assert_or_panic(vec[280] == true);
1311 assert_or_panic(vec[281] == true);
1312 assert_or_panic(vec[282] == true);
1313 assert_or_panic(vec[283] == true);
1314 assert_or_panic(vec[284] == false);
1315 assert_or_panic(vec[285] == false);
1316 assert_or_panic(vec[286] == false);
1317 assert_or_panic(vec[287] == false);
1318 assert_or_panic(vec[288] == false);
1319 assert_or_panic(vec[289] == false);
1320 assert_or_panic(vec[290] == false);
1321 assert_or_panic(vec[291] == false);
1322 assert_or_panic(vec[292] == false);
1323 assert_or_panic(vec[293] == true);
1324 assert_or_panic(vec[294] == true);
1325 assert_or_panic(vec[295] == true);
1326 assert_or_panic(vec[296] == true);
1327 assert_or_panic(vec[297] == true);
1328 assert_or_panic(vec[298] == true);
1329 assert_or_panic(vec[299] == false);
1330 assert_or_panic(vec[300] == true);
1331 assert_or_panic(vec[301] == false);
1332 assert_or_panic(vec[302] == true);
1333 assert_or_panic(vec[303] == true);
1334 assert_or_panic(vec[304] == true);
1335 assert_or_panic(vec[305] == false);
1336 assert_or_panic(vec[306] == false);
1337 assert_or_panic(vec[307] == true);
1338 assert_or_panic(vec[308] == true);
1339 assert_or_panic(vec[309] == true);
1340 assert_or_panic(vec[310] == false);
1341 assert_or_panic(vec[311] == true);
1342 assert_or_panic(vec[312] == true);
1343 assert_or_panic(vec[313] == true);
1344 assert_or_panic(vec[314] == false);
1345 assert_or_panic(vec[315] == true);
1346 assert_or_panic(vec[316] == true);
1347 assert_or_panic(vec[317] == true);
1348 assert_or_panic(vec[318] == false);
1349 assert_or_panic(vec[319] == true);
1350 assert_or_panic(vec[320] == true);
1351 assert_or_panic(vec[321] == false);
1352 assert_or_panic(vec[322] == false);
1353 assert_or_panic(vec[323] == true);
1354 assert_or_panic(vec[324] == false);
1355 assert_or_panic(vec[325] == false);
1356 assert_or_panic(vec[326] == false);
1357 assert_or_panic(vec[327] == false);
1358 assert_or_panic(vec[328] == true);
1359 assert_or_panic(vec[329] == false);
1360 assert_or_panic(vec[330] == true);
1361 assert_or_panic(vec[331] == true);
1362 assert_or_panic(vec[332] == true);
1363 assert_or_panic(vec[333] == true);
1364 assert_or_panic(vec[334] == false);
1365 assert_or_panic(vec[335] == false);
1366 assert_or_panic(vec[336] == true);
1367 assert_or_panic(vec[337] == false);
1368 assert_or_panic(vec[338] == true);
1369 assert_or_panic(vec[339] == false);
1370 assert_or_panic(vec[340] == false);
1371 assert_or_panic(vec[341] == false);
1372 assert_or_panic(vec[342] == true);
1373 assert_or_panic(vec[343] == false);
1374 assert_or_panic(vec[344] == true);
1375 assert_or_panic(vec[345] == false);
1376 assert_or_panic(vec[346] == false);
1377 assert_or_panic(vec[347] == true);
1378 assert_or_panic(vec[348] == true);
1379 assert_or_panic(vec[349] == true);
1380 assert_or_panic(vec[350] == true);
1381 assert_or_panic(vec[351] == false);
1382 assert_or_panic(vec[352] == false);
1383 assert_or_panic(vec[353] == false);
1384 assert_or_panic(vec[354] == true);
1385 assert_or_panic(vec[355] == true);
1386 assert_or_panic(vec[356] == false);
1387 assert_or_panic(vec[357] == true);
1388 assert_or_panic(vec[358] == false);
1389 assert_or_panic(vec[359] == false);
1390 assert_or_panic(vec[360] == true);
1391 assert_or_panic(vec[361] == false);
1392 assert_or_panic(vec[362] == true);
1393 assert_or_panic(vec[363] == false);
1394 assert_or_panic(vec[364] == true);
1395 assert_or_panic(vec[365] == true);
1396 assert_or_panic(vec[366] == false);
1397 assert_or_panic(vec[367] == false);
1398 assert_or_panic(vec[368] == true);
1399 assert_or_panic(vec[369] == true);
1400 assert_or_panic(vec[370] == true);
1401 assert_or_panic(vec[371] == true);
1402 assert_or_panic(vec[372] == false);
1403 assert_or_panic(vec[373] == false);
1404 assert_or_panic(vec[374] == true);
1405 assert_or_panic(vec[375] == false);
1406 assert_or_panic(vec[376] == true);
1407 assert_or_panic(vec[377] == true);
1408 assert_or_panic(vec[378] == false);
1409 assert_or_panic(vec[379] == true);
1410 assert_or_panic(vec[380] == true);
1411 assert_or_panic(vec[381] == false);
1412 assert_or_panic(vec[382] == true);
1413 assert_or_panic(vec[383] == true);
1414 assert_or_panic(vec[384] == true);
1415 assert_or_panic(vec[385] == false);
1416 assert_or_panic(vec[386] == true);
1417 assert_or_panic(vec[387] == true);
1418 assert_or_panic(vec[388] == true);
1419 assert_or_panic(vec[389] == false);
1420 assert_or_panic(vec[390] == false);
1421 assert_or_panic(vec[391] == true);
1422 assert_or_panic(vec[392] == false);
1423 assert_or_panic(vec[393] == true);
1424 assert_or_panic(vec[394] == true);
1425 assert_or_panic(vec[395] == true);
1426 assert_or_panic(vec[396] == false);
1427 assert_or_panic(vec[397] == false);
1428 assert_or_panic(vec[398] == false);
1429 assert_or_panic(vec[399] == false);
1430 assert_or_panic(vec[400] == false);
1431 assert_or_panic(vec[401] == true);
1432 assert_or_panic(vec[402] == false);
1433 assert_or_panic(vec[403] == false);
1434 assert_or_panic(vec[404] == false);
1435 assert_or_panic(vec[405] == false);
1436 assert_or_panic(vec[406] == true);
1437 assert_or_panic(vec[407] == false);
1438 assert_or_panic(vec[408] == false);
1439 assert_or_panic(vec[409] == true);
1440 assert_or_panic(vec[410] == true);
1441 assert_or_panic(vec[411] == false);
1442 assert_or_panic(vec[412] == false);
1443 assert_or_panic(vec[413] == false);
1444 assert_or_panic(vec[414] == false);
1445 assert_or_panic(vec[415] == true);
1446 assert_or_panic(vec[416] == true);
1447 assert_or_panic(vec[417] == true);
1448 assert_or_panic(vec[418] == true);
1449 assert_or_panic(vec[419] == true);
1450 assert_or_panic(vec[420] == false);
1451 assert_or_panic(vec[421] == false);
1452 assert_or_panic(vec[422] == false);
1453 assert_or_panic(vec[423] == true);
1454 assert_or_panic(vec[424] == false);
1455 assert_or_panic(vec[425] == false);
1456 assert_or_panic(vec[426] == false);
1457 assert_or_panic(vec[427] == false);
1458 assert_or_panic(vec[428] == true);
1459 assert_or_panic(vec[429] == false);
1460 assert_or_panic(vec[430] == true);
1461 assert_or_panic(vec[431] == false);
1462 assert_or_panic(vec[432] == true);
1463 assert_or_panic(vec[433] == true);
1464 assert_or_panic(vec[434] == true);
1465 assert_or_panic(vec[435] == true);
1466 assert_or_panic(vec[436] == false);
1467 assert_or_panic(vec[437] == false);
1468 assert_or_panic(vec[438] == false);
1469 assert_or_panic(vec[439] == false);
1470 assert_or_panic(vec[440] == false);
1471 assert_or_panic(vec[441] == true);
1472 assert_or_panic(vec[442] == true);
1473 assert_or_panic(vec[443] == true);
1474 assert_or_panic(vec[444] == true);
1475 assert_or_panic(vec[445] == true);
1476 assert_or_panic(vec[446] == true);
1477 assert_or_panic(vec[447] == true);
1478 assert_or_panic(vec[448] == true);
1479 assert_or_panic(vec[449] == true);
1480 assert_or_panic(vec[450] == false);
1481 assert_or_panic(vec[451] == false);
1482 assert_or_panic(vec[452] == true);
1483 assert_or_panic(vec[453] == false);
1484 assert_or_panic(vec[454] == true);
1485 assert_or_panic(vec[455] == false);
1486 assert_or_panic(vec[456] == false);
1487 assert_or_panic(vec[457] == true);
1488 assert_or_panic(vec[458] == false);
1489 assert_or_panic(vec[459] == false);
1490 assert_or_panic(vec[460] == true);
1491 assert_or_panic(vec[461] == true);
1492 assert_or_panic(vec[462] == true);
1493 assert_or_panic(vec[463] == true);
1494 assert_or_panic(vec[464] == true);
1495 assert_or_panic(vec[465] == true);
1496 assert_or_panic(vec[466] == false);
1497 assert_or_panic(vec[467] == true);
1498 assert_or_panic(vec[468] == false);
1499 assert_or_panic(vec[469] == false);
1500 assert_or_panic(vec[470] == false);
1501 assert_or_panic(vec[471] == true);
1502 assert_or_panic(vec[472] == true);
1503 assert_or_panic(vec[473] == false);
1504 assert_or_panic(vec[474] == true);
1505 assert_or_panic(vec[475] == true);
1506 assert_or_panic(vec[476] == false);
1507 assert_or_panic(vec[477] == false);
1508 assert_or_panic(vec[478] == true);
1509 assert_or_panic(vec[479] == true);
1510 assert_or_panic(vec[480] == false);
1511 assert_or_panic(vec[481] == false);
1512 assert_or_panic(vec[482] == true);
1513 assert_or_panic(vec[483] == true);
1514 assert_or_panic(vec[484] == false);
1515 assert_or_panic(vec[485] == true);
1516 assert_or_panic(vec[486] == false);
1517 assert_or_panic(vec[487] == true);
1518 assert_or_panic(vec[488] == true);
1519 assert_or_panic(vec[489] == true);
1520 assert_or_panic(vec[490] == true);
1521 assert_or_panic(vec[491] == true);
1522 assert_or_panic(vec[492] == true);
1523 assert_or_panic(vec[493] == true);
1524 assert_or_panic(vec[494] == true);
1525 assert_or_panic(vec[495] == true);
1526 assert_or_panic(vec[496] == false);
1527 assert_or_panic(vec[497] == true);
1528 assert_or_panic(vec[498] == true);
1529 assert_or_panic(vec[499] == true);
1530 assert_or_panic(vec[500] == false);
1531 assert_or_panic(vec[501] == false);
1532 assert_or_panic(vec[502] == true);
1533 assert_or_panic(vec[503] == false);
1534 assert_or_panic(vec[504] == false);
1535 assert_or_panic(vec[505] == false);
1536 assert_or_panic(vec[506] == true);
1537 assert_or_panic(vec[507] == true);
1538 assert_or_panic(vec[508] == false);
1539 assert_or_panic(vec[509] == true);
1540 assert_or_panic(vec[510] == false);
1541 assert_or_panic(vec[511] == true);
1542}
1543
1544#endif
1545
1546Vector2Bool c_ret_vector_2_bool(void) {
1547 return (Vector2Bool){
1548 true,
1549 false,
1550 };
1551}
1552
1553Vector4Bool c_ret_vector_4_bool(void) {
1554 return (Vector4Bool){
1555 true,
1556 false,
1557 true,
1558 false,
1559 };
1560}
1561
1562Vector8Bool c_ret_vector_8_bool(void) {
1563 return (Vector8Bool){
1564 false,
1565 true,
1566 false,
1567 false,
1568 true,
1569 false,
1570 false,
1571 true,
1572 };
1573}
1574
1575Vector16Bool c_ret_vector_16_bool(void) {
1576 return (Vector16Bool){
1577 true,
1578 true,
1579 false,
1580 false,
1581 false,
1582 false,
1583 true,
1584 false,
1585 true,
1586 false,
1587 false,
1588 true,
1589 true,
1590 false,
1591 true,
1592 true,
1593 };
1594}
1595
1596Vector32Bool c_ret_vector_32_bool(void) {
1597 return (Vector32Bool){
1598 true,
1599 false,
1600 true,
1601 true,
1602 true,
1603 false,
1604 true,
1605 false,
1606 true,
1607 true,
1608 true,
1609 false,
1610 true,
1611 true,
1612 false,
1613 false,
1614 true,
1615 false,
1616 false,
1617 false,
1618 false,
1619 true,
1620 true,
1621 true,
1622 false,
1623 true,
1624 false,
1625 false,
1626 true,
1627 false,
1628 false,
1629 false,
1630 };
1631}
1632
1633Vector64Bool c_ret_vector_64_bool(void) {
1634 return (Vector64Bool){
1635 false,
1636 true,
1637 false,
1638 true,
1639 true,
1640 true,
1641 false,
1642 true,
1643 true,
1644 true,
1645 true,
1646 true,
1647 true,
1648 false,
1649 true,
1650 true,
1651 true,
1652 false,
1653 false,
1654 false,
1655 true,
1656 true,
1657 false,
1658 true,
1659 false,
1660 true,
1661 false,
1662 true,
1663 false,
1664 true,
1665 false,
1666 true,
1667 false,
1668 false,
1669 true,
1670 true,
1671 false,
1672 false,
1673 false,
1674 true,
1675 true,
1676 true,
1677 true,
1678 false,
1679 false,
1680 false,
1681 true,
1682 true,
1683 false,
1684 false,
1685 true,
1686 false,
1687 false,
1688 false,
1689 false,
1690 true,
1691 false,
1692 false,
1693 false,
1694 true,
1695 true,
1696 true,
1697 true,
1698 true,
1699 };
1700}
1701
1702Vector128Bool c_ret_vector_128_bool(void) {
1703 return (Vector128Bool){
1704 false,
1705 true,
1706 true,
1707 false,
1708 true,
1709 false,
1710 false,
1711 true,
1712 true,
1713 false,
1714 true,
1715 false,
1716 false,
1717 false,
1718 true,
1719 false,
1720 true,
1721 false,
1722 false,
1723 true,
1724 false,
1725 true,
1726 false,
1727 false,
1728 false,
1729 true,
1730 true,
1731 true,
1732 false,
1733 false,
1734 false,
1735 false,
1736 true,
1737 true,
1738 true,
1739 false,
1740 true,
1741 true,
1742 false,
1743 false,
1744 false,
1745 false,
1746 true,
1747 true,
1748 true,
1749 false,
1750 false,
1751 false,
1752 false,
1753 true,
1754 false,
1755 false,
1756 true,
1757 false,
1758 false,
1759 false,
1760 false,
1761 false,
1762 true,
1763 true,
1764 true,
1765 false,
1766 true,
1767 true,
1768 false,
1769 false,
1770 false,
1771 false,
1772 false,
1773 false,
1774 false,
1775 false,
1776 true,
1777 true,
1778 true,
1779 true,
1780 true,
1781 false,
1782 false,
1783 false,
1784 false,
1785 false,
1786 false,
1787 true,
1788 false,
1789 true,
1790 false,
1791 true,
1792 false,
1793 true,
1794 false,
1795 true,
1796 true,
1797 true,
1798 true,
1799 false,
1800 false,
1801 true,
1802 false,
1803 false,
1804 true,
1805 true,
1806 true,
1807 true,
1808 false,
1809 true,
1810 true,
1811 true,
1812 false,
1813 false,
1814 true,
1815 false,
1816 false,
1817 true,
1818 true,
1819 false,
1820 true,
1821 false,
1822 true,
1823 true,
1824 true,
1825 true,
1826 true,
1827 false,
1828 false,
1829 true,
1830 false,
1831 true,
1832 };
1833}
1834
1835Vector256Bool c_ret_vector_256_bool(void) {
1836 return (Vector256Bool){
1837 true,
1838 false,
1839 true,
1840 true,
1841 false,
1842 false,
1843 false,
1844 false,
1845 false,
1846 true,
1847 false,
1848 true,
1849 false,
1850 true,
1851 false,
1852 false,
1853 true,
1854 true,
1855 true,
1856 false,
1857 false,
1858 false,
1859 true,
1860 false,
1861 true,
1862 false,
1863 false,
1864 true,
1865 true,
1866 true,
1867 false,
1868 false,
1869 true,
1870 true,
1871 true,
1872 false,
1873 true,
1874 true,
1875 true,
1876 false,
1877 true,
1878 false,
1879 true,
1880 true,
1881 false,
1882 true,
1883 false,
1884 true,
1885 true,
1886 false,
1887 false,
1888 true,
1889 true,
1890 false,
1891 false,
1892 true,
1893 false,
1894 true,
1895 true,
1896 true,
1897 false,
1898 true,
1899 true,
1900 false,
1901 true,
1902 true,
1903 false,
1904 true,
1905 false,
1906 true,
1907 true,
1908 true,
1909 false,
1910 true,
1911 true,
1912 false,
1913 true,
1914 true,
1915 true,
1916 true,
1917 false,
1918 true,
1919 false,
1920 true,
1921 true,
1922 true,
1923 false,
1924 true,
1925 false,
1926 true,
1927 false,
1928 false,
1929 true,
1930 false,
1931 false,
1932 false,
1933 true,
1934 true,
1935 false,
1936 false,
1937 false,
1938 true,
1939 true,
1940 true,
1941 false,
1942 false,
1943 false,
1944 true,
1945 false,
1946 true,
1947 true,
1948 true,
1949 true,
1950 true,
1951 true,
1952 true,
1953 true,
1954 false,
1955 true,
1956 false,
1957 true,
1958 false,
1959 false,
1960 true,
1961 true,
1962 false,
1963 true,
1964 false,
1965 false,
1966 false,
1967 false,
1968 true,
1969 false,
1970 false,
1971 true,
1972 false,
1973 false,
1974 false,
1975 false,
1976 false,
1977 false,
1978 true,
1979 false,
1980 true,
1981 false,
1982 true,
1983 true,
1984 true,
1985 false,
1986 true,
1987 true,
1988 false,
1989 true,
1990 true,
1991 false,
1992 true,
1993 true,
1994 true,
1995 true,
1996 true,
1997 true,
1998 true,
1999 false,
2000 false,
2001 false,
2002 true,
2003 false,
2004 false,
2005 true,
2006 false,
2007 true,
2008 true,
2009 true,
2010 false,
2011 false,
2012 true,
2013 true,
2014 true,
2015 true,
2016 false,
2017 true,
2018 true,
2019 false,
2020 true,
2021 false,
2022 false,
2023 false,
2024 true,
2025 true,
2026 true,
2027 true,
2028 true,
2029 true,
2030 true,
2031 true,
2032 false,
2033 false,
2034 true,
2035 false,
2036 false,
2037 false,
2038 true,
2039 true,
2040 true,
2041 true,
2042 true,
2043 true,
2044 false,
2045 false,
2046 false,
2047 true,
2048 true,
2049 true,
2050 false,
2051 true,
2052 false,
2053 true,
2054 false,
2055 true,
2056 false,
2057 true,
2058 true,
2059 true,
2060 false,
2061 true,
2062 false,
2063 true,
2064 false,
2065 true,
2066 false,
2067 true,
2068 false,
2069 false,
2070 true,
2071 false,
2072 true,
2073 true,
2074 false,
2075 false,
2076 true,
2077 false,
2078 false,
2079 false,
2080 true,
2081 true,
2082 false,
2083 false,
2084 false,
2085 false,
2086 false,
2087 true,
2088 false,
2089 true,
2090 false,
2091 false,
2092 false,
2093 };
2094}
2095
2096Vector512Bool c_ret_vector_512_bool(void) {
2097 return (Vector512Bool){
2098 false,
2099 true,
2100 false,
2101 false,
2102 false,
2103 true,
2104 false,
2105 false,
2106 false,
2107 true,
2108 false,
2109 false,
2110 false,
2111 true,
2112 false,
2113 true,
2114 false,
2115 false,
2116 false,
2117 false,
2118 false,
2119 false,
2120 true,
2121 true,
2122 false,
2123 false,
2124 false,
2125 false,
2126 true,
2127 true,
2128 false,
2129 true,
2130 false,
2131 true,
2132 true,
2133 true,
2134 false,
2135 false,
2136 true,
2137 true,
2138 false,
2139 false,
2140 false,
2141 false,
2142 false,
2143 true,
2144 false,
2145 true,
2146 true,
2147 false,
2148 true,
2149 true,
2150 true,
2151 true,
2152 false,
2153 false,
2154 false,
2155 true,
2156 true,
2157 false,
2158 false,
2159 false,
2160 false,
2161 true,
2162 true,
2163 true,
2164 true,
2165 true,
2166 false,
2167 false,
2168 false,
2169 false,
2170 false,
2171 true,
2172 false,
2173 true,
2174 false,
2175 false,
2176 true,
2177 true,
2178 false,
2179 false,
2180 false,
2181 true,
2182 false,
2183 true,
2184 true,
2185 true,
2186 false,
2187 true,
2188 false,
2189 false,
2190 true,
2191 true,
2192 false,
2193 true,
2194 true,
2195 false,
2196 true,
2197 false,
2198 true,
2199 true,
2200 false,
2201 true,
2202 true,
2203 false,
2204 false,
2205 false,
2206 true,
2207 false,
2208 false,
2209 false,
2210 true,
2211 true,
2212 true,
2213 false,
2214 true,
2215 false,
2216 true,
2217 false,
2218 true,
2219 true,
2220 false,
2221 true,
2222 false,
2223 true,
2224 true,
2225 true,
2226 false,
2227 true,
2228 false,
2229 false,
2230 false,
2231 false,
2232 false,
2233 false,
2234 true,
2235 false,
2236 true,
2237 false,
2238 true,
2239 true,
2240 false,
2241 true,
2242 false,
2243 false,
2244 true,
2245 false,
2246 false,
2247 true,
2248 false,
2249 true,
2250 false,
2251 true,
2252 false,
2253 false,
2254 true,
2255 false,
2256 true,
2257 true,
2258 true,
2259 false,
2260 false,
2261 true,
2262 false,
2263 false,
2264 false,
2265 true,
2266 true,
2267 true,
2268 false,
2269 true,
2270 false,
2271 false,
2272 false,
2273 false,
2274 false,
2275 true,
2276 true,
2277 false,
2278 false,
2279 true,
2280 false,
2281 false,
2282 false,
2283 false,
2284 false,
2285 true,
2286 true,
2287 false,
2288 false,
2289 false,
2290 false,
2291 false,
2292 false,
2293 true,
2294 true,
2295 false,
2296 true,
2297 true,
2298 true,
2299 true,
2300 true,
2301 true,
2302 false,
2303 false,
2304 false,
2305 false,
2306 true,
2307 false,
2308 true,
2309 true,
2310 true,
2311 true,
2312 false,
2313 false,
2314 false,
2315 true,
2316 true,
2317 false,
2318 true,
2319 true,
2320 false,
2321 false,
2322 false,
2323 true,
2324 true,
2325 true,
2326 true,
2327 false,
2328 true,
2329 false,
2330 true,
2331 true,
2332 true,
2333 true,
2334 false,
2335 true,
2336 false,
2337 true,
2338 false,
2339 true,
2340 false,
2341 false,
2342 false,
2343 true,
2344 true,
2345 false,
2346 true,
2347 false,
2348 false,
2349 false,
2350 true,
2351 true,
2352 true,
2353 true,
2354 true,
2355 false,
2356 true,
2357 true,
2358 true,
2359 true,
2360 false,
2361 true,
2362 false,
2363 false,
2364 true,
2365 false,
2366 true,
2367 false,
2368 false,
2369 true,
2370 true,
2371 false,
2372 true,
2373 false,
2374 false,
2375 true,
2376 false,
2377 false,
2378 true,
2379 true,
2380 true,
2381 false,
2382 false,
2383 true,
2384 true,
2385 true,
2386 false,
2387 false,
2388 false,
2389 false,
2390 false,
2391 false,
2392 true,
2393 false,
2394 true,
2395 false,
2396 true,
2397 true,
2398 false,
2399 false,
2400 false,
2401 false,
2402 true,
2403 true,
2404 true,
2405 true,
2406 true,
2407 false,
2408 true,
2409 true,
2410 true,
2411 true,
2412 true,
2413 false,
2414 true,
2415 true,
2416 true,
2417 false,
2418 true,
2419 false,
2420 true,
2421 true,
2422 true,
2423 false,
2424 false,
2425 true,
2426 true,
2427 true,
2428 false,
2429 false,
2430 true,
2431 true,
2432 false,
2433 true,
2434 true,
2435 true,
2436 true,
2437 true,
2438 true,
2439 false,
2440 true,
2441 false,
2442 true,
2443 false,
2444 false,
2445 false,
2446 false,
2447 true,
2448 true,
2449 true,
2450 true,
2451 false,
2452 true,
2453 false,
2454 true,
2455 true,
2456 false,
2457 true,
2458 false,
2459 false,
2460 true,
2461 false,
2462 false,
2463 false,
2464 false,
2465 false,
2466 false,
2467 false,
2468 true,
2469 false,
2470 true,
2471 true,
2472 false,
2473 false,
2474 true,
2475 false,
2476 false,
2477 true,
2478 false,
2479 false,
2480 true,
2481 false,
2482 false,
2483 false,
2484 false,
2485 true,
2486 true,
2487 true,
2488 true,
2489 true,
2490 true,
2491 true,
2492 false,
2493 true,
2494 true,
2495 false,
2496 false,
2497 false,
2498 true,
2499 false,
2500 true,
2501 true,
2502 false,
2503 true,
2504 true,
2505 true,
2506 true,
2507 false,
2508 false,
2509 false,
2510 true,
2511 true,
2512 false,
2513 true,
2514 false,
2515 true,
2516 false,
2517 false,
2518 false,
2519 false,
2520 true,
2521 true,
2522 true,
2523 false,
2524 true,
2525 false,
2526 false,
2527 false,
2528 true,
2529 true,
2530 false,
2531 true,
2532 false,
2533 false,
2534 true,
2535 true,
2536 true,
2537 true,
2538 true,
2539 true,
2540 false,
2541 false,
2542 false,
2543 true,
2544 true,
2545 true,
2546 false,
2547 false,
2548 false,
2549 false,
2550 false,
2551 false,
2552 false,
2553 false,
2554 false,
2555 false,
2556 false,
2557 true,
2558 false,
2559 false,
2560 false,
2561 true,
2562 false,
2563 false,
2564 false,
2565 false,
2566 true,
2567 true,
2568 true,
2569 true,
2570 true,
2571 false,
2572 false,
2573 true,
2574 true,
2575 true,
2576 false,
2577 true,
2578 true,
2579 true,
2580 false,
2581 true,
2582 false,
2583 true,
2584 false,
2585 true,
2586 false,
2587 true,
2588 true,
2589 true,
2590 true,
2591 false,
2592 true,
2593 true,
2594 false,
2595 true,
2596 false,
2597 false,
2598 false,
2599 false,
2600 false,
2601 false,
2602 false,
2603 false,
2604 false,
2605 true,
2606 true,
2607 false,
2608 true,
2609 false,
2610 };
2611}
2612
2613void zig_vector_2_bool(Vector2Bool vec);
2614void zig_vector_4_bool(Vector4Bool vec);
2615void zig_vector_8_bool(Vector8Bool vec);
2616void zig_vector_16_bool(Vector16Bool vec);
2617void zig_vector_32_bool(Vector32Bool vec);
2618void zig_vector_64_bool(Vector64Bool vec);
2619void zig_vector_128_bool(Vector128Bool vec);
2620void zig_vector_256_bool(Vector256Bool vec);
2621void zig_vector_512_bool(Vector512Bool vec);
2622
2623Vector2Bool zig_ret_vector_2_bool(void);
2624Vector4Bool zig_ret_vector_4_bool(void);
2625Vector8Bool zig_ret_vector_8_bool(void);
2626Vector16Bool zig_ret_vector_16_bool(void);
2627Vector32Bool zig_ret_vector_32_bool(void);
2628Vector64Bool zig_ret_vector_64_bool(void);
2629Vector128Bool zig_ret_vector_128_bool(void);
2630Vector256Bool zig_ret_vector_256_bool(void);
2631Vector512Bool zig_ret_vector_512_bool(void);
2632
2633#endif
2634
2635typedef struct Vector3 {
2636 float x;
2637 float y;
2638 float z;
2639} Vector3;
2640
2641typedef struct Vector5 {
2642 float x;
2643 float y;
2644 float z;
2645 float w;
2646 float q;
2647} Vector5;
2648
2649typedef struct Rect {
2650 uint32_t left;
2651 uint32_t right;
2652 uint32_t top;
2653 uint32_t bottom;
2654} Rect;
2655
2656void zig_multiple_struct_ints(struct Rect, struct Rect);
2657
2658typedef struct FloatRect {
2659 float left;
2660 float right;
2661 float top;
2662 float bottom;
2663} FloatRect;
2664
2665void zig_multiple_struct_floats(struct FloatRect, struct FloatRect);
2666
2667void run_c_tests(void) {
2668 zig_u8(0xff);
2669 zig_u16(0xfffe);
2670 zig_u32(0xfffffffd);
2671 zig_u64(0xfffffffffffffffc);
2672
2673#ifndef ZIG_NO_I128
2674 {
2675 struct u128 s = {0xfffffffffffffffc};
2676 zig_struct_u128(s);
2677 }
2678#endif
2679
2680#ifndef ZIG_BUG_14908
2681 zig_i8(-1);
2682 zig_i16(-2);
2683#endif
2684 zig_i32(-3);
2685 zig_i64(-4);
2686
2687#ifndef ZIG_NO_I128
2688 {
2689 struct i128 s = {-6};
2690 zig_struct_i128(s);
2691 }
2692#endif
2693
2694 zig_five_integers(12, 34, 56, 78, 90);
2695
2696 zig_f32(12.34f);
2697 zig_f64(56.78);
2698 zig_longdouble(12.34l);
2699 zig_five_floats(1.0f, 2.0f, 3.0f, 4.0f, 5.0f);
2700
2701 zig_ptr((void *)0xdeadbeefL);
2702
2703 zig_bool(true);
2704
2705#ifndef ZIG_NO_COMPLEX
2706 // TODO: Resolve https://github.com/ziglang/zig/issues/8465
2707 //{
2708 // float complex a = 1.25f + I * 2.6f;
2709 // float complex b = 11.3f - I * 1.5f;
2710 // float complex z = zig_cmultf(a, b);
2711 // assert_or_panic(creal(z) == 1.5f);
2712 // assert_or_panic(cimag(z) == 13.5f);
2713 //}
2714
2715 {
2716 double complex a = 1.25 + I * 2.6;
2717 double complex b = 11.3 - I * 1.5;
2718 double complex z = zig_cmultd(a, b);
2719 assert_or_panic(creal(z) == 1.5);
2720 assert_or_panic(cimag(z) == 13.5);
2721 }
2722
2723 {
2724 float a_r = 1.25f;
2725 float a_i = 2.6f;
2726 float b_r = 11.3f;
2727 float b_i = -1.5f;
2728 float complex z = zig_cmultf_comp(a_r, a_i, b_r, b_i);
2729 assert_or_panic(creal(z) == 1.5f);
2730 assert_or_panic(cimag(z) == 13.5f);
2731 }
2732
2733 {
2734 double a_r = 1.25;
2735 double a_i = 2.6;
2736 double b_r = 11.3;
2737 double b_i = -1.5;
2738 double complex z = zig_cmultd_comp(a_r, a_i, b_r, b_i);
2739 assert_or_panic(creal(z) == 1.5);
2740 assert_or_panic(cimag(z) == 13.5);
2741 }
2742#endif
2743
2744#if !defined(ZIG_PPC32) && !defined(__hexagon__) && !defined(__s390x__)
2745 {
2746 struct Struct_u64_u64 s = zig_ret_struct_u64_u64();
2747 assert_or_panic(s.a == 1);
2748 assert_or_panic(s.b == 2);
2749 zig_struct_u64_u64_0((struct Struct_u64_u64){ .a = 3, .b = 4 }, 1);
2750 zig_struct_u64_u64_1(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }, 2);
2751 zig_struct_u64_u64_2(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }, 3);
2752 zig_struct_u64_u64_3(0, 1, 2, (struct Struct_u64_u64){ .a = 9, .b = 10 }, 4);
2753 zig_struct_u64_u64_4(0, 1, 2, 3, (struct Struct_u64_u64){ .a = 11, .b = 12 }, 5);
2754 zig_struct_u64_u64_5(0, 1, 2, 3, 4, (struct Struct_u64_u64){ .a = 13, .b = 14 }, 6);
2755 zig_struct_u64_u64_6(0, 1, 2, 3, 4, 5, (struct Struct_u64_u64){ .a = 15, .b = 16 }, 7);
2756 zig_struct_u64_u64_7(0, 1, 2, 3, 4, 5, 6, (struct Struct_u64_u64){ .a = 17, .b = 18 }, 8);
2757 zig_struct_u64_u64_8(0, 1, 2, 3, 4, 5, 6, 7, (struct Struct_u64_u64){ .a = 19, .b = 20 }, 9);
2758 }
2759
2760#if !defined(ZIG_RISCV64)
2761#if !defined(__mips64__)
2762 {
2763 struct Struct_f32 s = zig_ret_struct_f32();
2764 assert_or_panic(s.a == 2.5f);
2765 zig_struct_f32((struct Struct_f32){ 2.5f });
2766 }
2767#endif
2768
2769#if !(defined(__arm__) && defined(__SOFTFP__))
2770#if !defined(ZIG_RISCV32)
2771 {
2772 struct Struct_f64 s = zig_ret_struct_f64();
2773 assert_or_panic(s.a == 2.5);
2774 zig_struct_f64((struct Struct_f64){ 2.5 });
2775 }
2776#endif
2777
2778#if !defined(__loongarch__) && !defined(__mips64__)
2779 {
2780 struct Struct_f32f32_f32 s = zig_ret_struct_f32f32_f32();
2781 assert_or_panic(s.a.b == 1.0f);
2782 assert_or_panic(s.a.c == 2.0f);
2783 assert_or_panic(s.d == 3.0f);
2784 zig_struct_f32f32_f32((struct Struct_f32f32_f32){ { 1.0f, 2.0f }, 3.0f });
2785 }
2786
2787 {
2788 struct Struct_f32_f32f32 s = zig_ret_struct_f32_f32f32();
2789 assert_or_panic(s.a == 1.0f);
2790 assert_or_panic(s.b.c == 2.0f);
2791 assert_or_panic(s.b.d == 3.0f);
2792 zig_struct_f32_f32f32((struct Struct_f32_f32f32){ 1.0f, { 2.0f, 3.0f } });
2793 }
2794#endif
2795#endif
2796#endif
2797
2798#if !defined(__powerpc__) && !defined(__loongarch__) && !defined(__mips64__)
2799 {
2800 struct Struct_u32_Union_u32_u32u32 s = zig_ret_struct_u32_union_u32_u32u32();
2801 assert_or_panic(s.a == 1);
2802 assert_or_panic(s.b.c.d == 2);
2803 assert_or_panic(s.b.c.e == 3);
2804 zig_struct_u32_union_u32_u32u32(s);
2805 }
2806
2807 {
2808 struct Struct_i32_i32 s = {1, 2};
2809 zig_struct_i32_i32(s);
2810 }
2811#endif
2812
2813#if !defined(__powerpc64__) && !defined(__loongarch__) && !defined(__mips64__)
2814 {
2815 struct BigStruct s = {1, 2, 3, 4, 5};
2816 zig_big_struct(s);
2817 }
2818#endif
2819#endif
2820
2821#if !defined __i386__ && !defined __arm__ && !defined __aarch64__ && \
2822 !defined __powerpc__ && !defined ZIG_RISCV64 && !defined(__loongarch__) && \
2823 !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
2824 {
2825 struct SmallStructInts s = {1, 2, 3, 4};
2826 zig_small_struct_ints(s);
2827 }
2828#endif
2829
2830#if !defined __arm__ && !defined __aarch64__ && \
2831 !defined __powerpc__ && !defined ZIG_RISCV64 && !defined(__loongarch__) && \
2832 !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
2833 {
2834 struct MedStructInts s = {1, 2, 3};
2835 zig_med_struct_ints(s);
2836 }
2837#endif
2838
2839#ifndef ZIG_NO_I128
2840 {
2841 __int128 s = 0;
2842 s |= 1 << 0;
2843 s |= (__int128)2 << 64;
2844 zig_big_packed_struct(s);
2845 }
2846#endif
2847
2848 {
2849 uint8_t s = 0;
2850 s |= 0 << 0;
2851 s |= 1 << 2;
2852 s |= 2 << 4;
2853 s |= 3 << 6;
2854 zig_small_packed_struct(s);
2855 }
2856
2857#if !defined __i386__ && !defined __arm__ && \
2858 !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \
2859 !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
2860 {
2861 struct SplitStructInts s = {1234, 100, 1337};
2862 zig_split_struct_ints(s);
2863 }
2864#endif
2865
2866#if !defined __arm__ && !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \
2867 !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
2868 {
2869 struct MedStructMixed s = {1234, 100.0f, 1337.0f};
2870 zig_med_struct_mixed(s);
2871 }
2872#endif
2873
2874#if !defined __i386__ && !defined __arm__ && \
2875 !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && \
2876 !defined(__mips64__) && !defined(__hexagon__) && !defined(__s390x__)
2877 {
2878 struct SplitStructMixed s = {1234, 100, 1337.0f};
2879 zig_split_struct_mixed(s);
2880 }
2881#endif
2882
2883#if !defined(__powerpc__) && !defined(__loongarch__) && !defined(__mips64__) && !defined(__hexagon__) && \
2884 !defined(__s390x__)
2885 {
2886 struct BigStruct s = {30, 31, 32, 33, 34};
2887 struct BigStruct res = zig_big_struct_both(s);
2888 assert_or_panic(res.a == 20);
2889 assert_or_panic(res.b == 21);
2890 assert_or_panic(res.c == 22);
2891 assert_or_panic(res.d == 23);
2892 assert_or_panic(res.e == 24);
2893 }
2894#endif
2895
2896#if !defined ZIG_PPC32 && !defined _ARCH_PPC64 && !defined(__loongarch__) && !defined(__mips64__) && \
2897 !defined(__hexagon__) && !defined(__s390x__)
2898 {
2899 struct Rect r1 = {1, 21, 16, 4};
2900 struct Rect r2 = {178, 189, 21, 15};
2901 zig_multiple_struct_ints(r1, r2);
2902 }
2903#endif
2904
2905#if !defined ZIG_PPC32 && !defined(__loongarch__) && !defined(__mips64__) && !defined(__hexagon__) && \
2906 !defined(__s390x__)
2907 {
2908 struct FloatRect r1 = {1, 21, 16, 4};
2909 struct FloatRect r2 = {178, 189, 21, 15};
2910 zig_multiple_struct_floats(r1, r2);
2911 }
2912#endif
2913
2914 {
2915 assert_or_panic(zig_ret_bool() == 1);
2916
2917 assert_or_panic(zig_ret_u8() == 0xff);
2918 assert_or_panic(zig_ret_u16() == 0xffff);
2919 assert_or_panic(zig_ret_u32() == 0xffffffff);
2920 assert_or_panic(zig_ret_u64() == 0xffffffffffffffff);
2921
2922 assert_or_panic(zig_ret_i8() == -1);
2923 assert_or_panic(zig_ret_i16() == -1);
2924 assert_or_panic(zig_ret_i32() == -1);
2925 assert_or_panic(zig_ret_i64() == -1);
2926 }
2927
2928#if defined(ZIG_BACKEND_STAGE2_X86_64) || defined(ZIG_PPC32)
2929 {
2930 zig_vector_2_bool((Vector2Bool){
2931 false,
2932 true,
2933 });
2934
2935 Vector2Bool vec = zig_ret_vector_2_bool();
2936 assert_or_panic(vec[0] == false);
2937 assert_or_panic(vec[1] == false);
2938 }
2939 {
2940 zig_vector_4_bool((Vector4Bool){
2941 false,
2942 false,
2943 false,
2944 false,
2945 });
2946
2947 Vector4Bool vec = zig_ret_vector_4_bool();
2948 assert_or_panic(vec[0] == false);
2949 assert_or_panic(vec[1] == true);
2950 assert_or_panic(vec[2] == true);
2951 assert_or_panic(vec[3] == true);
2952 }
2953 {
2954 zig_vector_8_bool((Vector8Bool){
2955 true,
2956 true,
2957 false,
2958 true,
2959 false,
2960 true,
2961 true,
2962 false,
2963 });
2964
2965 Vector8Bool vec = zig_ret_vector_8_bool();
2966 assert_or_panic(vec[0] == false);
2967 assert_or_panic(vec[1] == false);
2968 assert_or_panic(vec[2] == false);
2969 assert_or_panic(vec[3] == false);
2970 assert_or_panic(vec[4] == true);
2971 assert_or_panic(vec[5] == false);
2972 assert_or_panic(vec[6] == false);
2973 assert_or_panic(vec[7] == false);
2974 }
2975 {
2976 zig_vector_16_bool((Vector16Bool){
2977 true,
2978 false,
2979 true,
2980 true,
2981 true,
2982 false,
2983 false,
2984 false,
2985 true,
2986 true,
2987 true,
2988 true,
2989 false,
2990 false,
2991 false,
2992 true,
2993 });
2994
2995 Vector16Bool vec = zig_ret_vector_16_bool();
2996 assert_or_panic(vec[0] == false);
2997 assert_or_panic(vec[1] == true);
2998 assert_or_panic(vec[2] == false);
2999 assert_or_panic(vec[3] == false);
3000 assert_or_panic(vec[4] == false);
3001 assert_or_panic(vec[5] == true);
3002 assert_or_panic(vec[6] == false);
3003 assert_or_panic(vec[7] == false);
3004 assert_or_panic(vec[8] == true);
3005 assert_or_panic(vec[9] == false);
3006 assert_or_panic(vec[10] == false);
3007 assert_or_panic(vec[11] == false);
3008 assert_or_panic(vec[12] == false);
3009 assert_or_panic(vec[13] == true);
3010 assert_or_panic(vec[14] == false);
3011 assert_or_panic(vec[15] == false);
3012 }
3013 {
3014 zig_vector_32_bool((Vector32Bool){
3015 false,
3016 false,
3017 false,
3018 true,
3019 true,
3020 false,
3021 false,
3022 true,
3023 false,
3024 true,
3025 true,
3026 true,
3027 false,
3028 false,
3029 true,
3030 true,
3031 true,
3032 true,
3033 true,
3034 false,
3035 true,
3036 true,
3037 true,
3038 false,
3039 false,
3040 true,
3041 true,
3042 false,
3043 true,
3044 true,
3045 false,
3046 true,
3047 });
3048
3049 Vector32Bool vec = zig_ret_vector_32_bool();
3050 assert_or_panic(vec[0] == false);
3051 assert_or_panic(vec[1] == true);
3052 assert_or_panic(vec[2] == false);
3053 assert_or_panic(vec[3] == false);
3054 assert_or_panic(vec[4] == true);
3055 assert_or_panic(vec[5] == false);
3056 assert_or_panic(vec[6] == true);
3057 assert_or_panic(vec[7] == true);
3058 assert_or_panic(vec[8] == true);
3059 assert_or_panic(vec[9] == true);
3060 assert_or_panic(vec[10] == true);
3061 assert_or_panic(vec[11] == true);
3062 assert_or_panic(vec[12] == false);
3063 assert_or_panic(vec[13] == false);
3064 assert_or_panic(vec[14] == false);
3065 assert_or_panic(vec[15] == false);
3066 assert_or_panic(vec[16] == false);
3067 assert_or_panic(vec[17] == false);
3068 assert_or_panic(vec[18] == true);
3069 assert_or_panic(vec[19] == true);
3070 assert_or_panic(vec[20] == true);
3071 assert_or_panic(vec[21] == false);
3072 assert_or_panic(vec[22] == true);
3073 assert_or_panic(vec[23] == false);
3074 assert_or_panic(vec[24] == true);
3075 assert_or_panic(vec[25] == false);
3076 assert_or_panic(vec[26] == false);
3077 assert_or_panic(vec[27] == true);
3078 assert_or_panic(vec[28] == false);
3079 assert_or_panic(vec[29] == false);
3080 assert_or_panic(vec[30] == true);
3081 assert_or_panic(vec[31] == true);
3082 }
3083 {
3084 zig_vector_64_bool((Vector64Bool){
3085 true,
3086 true,
3087 false,
3088 true,
3089 false,
3090 true,
3091 false,
3092 false,
3093 true,
3094 true,
3095 true,
3096 true,
3097 true,
3098 true,
3099 true,
3100 false,
3101 false,
3102 true,
3103 true,
3104 false,
3105 true,
3106 true,
3107 true,
3108 true,
3109 false,
3110 false,
3111 true,
3112 false,
3113 false,
3114 true,
3115 false,
3116 true,
3117 false,
3118 true,
3119 true,
3120 false,
3121 true,
3122 true,
3123 false,
3124 false,
3125 true,
3126 true,
3127 true,
3128 true,
3129 true,
3130 false,
3131 true,
3132 false,
3133 false,
3134 false,
3135 false,
3136 false,
3137 true,
3138 false,
3139 false,
3140 true,
3141 true,
3142 false,
3143 false,
3144 false,
3145 true,
3146 true,
3147 true,
3148 true,
3149 });
3150
3151 Vector64Bool vec = zig_ret_vector_64_bool();
3152 assert_or_panic(vec[0] == true);
3153 assert_or_panic(vec[1] == false);
3154 assert_or_panic(vec[2] == true);
3155 assert_or_panic(vec[3] == false);
3156 assert_or_panic(vec[4] == false);
3157 assert_or_panic(vec[5] == true);
3158 assert_or_panic(vec[6] == false);
3159 assert_or_panic(vec[7] == true);
3160 assert_or_panic(vec[8] == true);
3161 assert_or_panic(vec[9] == false);
3162 assert_or_panic(vec[10] == true);
3163 assert_or_panic(vec[11] == false);
3164 assert_or_panic(vec[12] == true);
3165 assert_or_panic(vec[13] == false);
3166 assert_or_panic(vec[14] == false);
3167 assert_or_panic(vec[15] == true);
3168 assert_or_panic(vec[16] == false);
3169 assert_or_panic(vec[17] == false);
3170 assert_or_panic(vec[18] == true);
3171 assert_or_panic(vec[19] == true);
3172 assert_or_panic(vec[20] == false);
3173 assert_or_panic(vec[21] == false);
3174 assert_or_panic(vec[22] == true);
3175 assert_or_panic(vec[23] == false);
3176 assert_or_panic(vec[24] == false);
3177 assert_or_panic(vec[25] == true);
3178 assert_or_panic(vec[26] == true);
3179 assert_or_panic(vec[27] == true);
3180 assert_or_panic(vec[28] == true);
3181 assert_or_panic(vec[29] == true);
3182 assert_or_panic(vec[30] == false);
3183 assert_or_panic(vec[31] == false);
3184 assert_or_panic(vec[32] == true);
3185 assert_or_panic(vec[33] == true);
3186 assert_or_panic(vec[34] == true);
3187 assert_or_panic(vec[35] == true);
3188 assert_or_panic(vec[36] == false);
3189 assert_or_panic(vec[37] == true);
3190 assert_or_panic(vec[38] == false);
3191 assert_or_panic(vec[39] == true);
3192 assert_or_panic(vec[40] == true);
3193 assert_or_panic(vec[41] == true);
3194 assert_or_panic(vec[42] == true);
3195 assert_or_panic(vec[43] == true);
3196 assert_or_panic(vec[44] == false);
3197 assert_or_panic(vec[45] == false);
3198 assert_or_panic(vec[46] == false);
3199 assert_or_panic(vec[47] == true);
3200 assert_or_panic(vec[48] == true);
3201 assert_or_panic(vec[49] == true);
3202 assert_or_panic(vec[50] == false);
3203 assert_or_panic(vec[51] == true);
3204 assert_or_panic(vec[52] == true);
3205 assert_or_panic(vec[53] == true);
3206 assert_or_panic(vec[54] == false);
3207 assert_or_panic(vec[55] == false);
3208 assert_or_panic(vec[56] == false);
3209 assert_or_panic(vec[57] == true);
3210 assert_or_panic(vec[58] == false);
3211 assert_or_panic(vec[59] == false);
3212 assert_or_panic(vec[60] == true);
3213 assert_or_panic(vec[61] == false);
3214 assert_or_panic(vec[62] == true);
3215 assert_or_panic(vec[63] == false);
3216 }
3217 {
3218 zig_vector_128_bool((Vector128Bool){
3219 true,
3220 true,
3221 false,
3222 true,
3223 true,
3224 false,
3225 false,
3226 true,
3227 true,
3228 true,
3229 true,
3230 true,
3231 false,
3232 false,
3233 false,
3234 true,
3235 false,
3236 true,
3237 false,
3238 false,
3239 true,
3240 false,
3241 true,
3242 false,
3243 false,
3244 false,
3245 true,
3246 false,
3247 true,
3248 true,
3249 false,
3250 true,
3251 false,
3252 true,
3253 true,
3254 false,
3255 false,
3256 false,
3257 false,
3258 true,
3259 true,
3260 false,
3261 true,
3262 false,
3263 false,
3264 true,
3265 false,
3266 false,
3267 true,
3268 true,
3269 false,
3270 false,
3271 true,
3272 false,
3273 false,
3274 true,
3275 true,
3276 true,
3277 true,
3278 true,
3279 true,
3280 true,
3281 true,
3282 false,
3283 false,
3284 true,
3285 false,
3286 true,
3287 true,
3288 true,
3289 true,
3290 false,
3291 false,
3292 false,
3293 true,
3294 true,
3295 false,
3296 true,
3297 true,
3298 true,
3299 true,
3300 false,
3301 true,
3302 true,
3303 true,
3304 true,
3305 true,
3306 true,
3307 false,
3308 true,
3309 true,
3310 true,
3311 true,
3312 true,
3313 true,
3314 false,
3315 false,
3316 false,
3317 true,
3318 true,
3319 true,
3320 true,
3321 true,
3322 true,
3323 true,
3324 false,
3325 false,
3326 false,
3327 false,
3328 false,
3329 true,
3330 true,
3331 true,
3332 false,
3333 false,
3334 false,
3335 false,
3336 false,
3337 true,
3338 false,
3339 false,
3340 false,
3341 false,
3342 true,
3343 true,
3344 false,
3345 true,
3346 false,
3347 });
3348
3349 Vector128Bool vec = zig_ret_vector_128_bool();
3350 assert_or_panic(vec[0] == true);
3351 assert_or_panic(vec[1] == true);
3352 assert_or_panic(vec[2] == false);
3353 assert_or_panic(vec[3] == false);
3354 assert_or_panic(vec[4] == false);
3355 assert_or_panic(vec[5] == true);
3356 assert_or_panic(vec[6] == true);
3357 assert_or_panic(vec[7] == false);
3358 assert_or_panic(vec[8] == false);
3359 assert_or_panic(vec[9] == true);
3360 assert_or_panic(vec[10] == false);
3361 assert_or_panic(vec[11] == false);
3362 assert_or_panic(vec[12] == false);
3363 assert_or_panic(vec[13] == true);
3364 assert_or_panic(vec[14] == false);
3365 assert_or_panic(vec[15] == true);
3366 assert_or_panic(vec[16] == true);
3367 assert_or_panic(vec[17] == false);
3368 assert_or_panic(vec[18] == false);
3369 assert_or_panic(vec[19] == true);
3370 assert_or_panic(vec[20] == true);
3371 assert_or_panic(vec[21] == true);
3372 assert_or_panic(vec[22] == true);
3373 assert_or_panic(vec[23] == true);
3374 assert_or_panic(vec[24] == false);
3375 assert_or_panic(vec[25] == false);
3376 assert_or_panic(vec[26] == true);
3377 assert_or_panic(vec[27] == true);
3378 assert_or_panic(vec[28] == true);
3379 assert_or_panic(vec[29] == false);
3380 assert_or_panic(vec[30] == false);
3381 assert_or_panic(vec[31] == true);
3382 assert_or_panic(vec[32] == true);
3383 assert_or_panic(vec[33] == false);
3384 assert_or_panic(vec[34] == true);
3385 assert_or_panic(vec[35] == true);
3386 assert_or_panic(vec[36] == true);
3387 assert_or_panic(vec[37] == false);
3388 assert_or_panic(vec[38] == true);
3389 assert_or_panic(vec[39] == true);
3390 assert_or_panic(vec[40] == true);
3391 assert_or_panic(vec[41] == false);
3392 assert_or_panic(vec[42] == true);
3393 assert_or_panic(vec[43] == true);
3394 assert_or_panic(vec[44] == false);
3395 assert_or_panic(vec[45] == false);
3396 assert_or_panic(vec[46] == false);
3397 assert_or_panic(vec[47] == true);
3398 assert_or_panic(vec[48] == false);
3399 assert_or_panic(vec[49] == false);
3400 assert_or_panic(vec[50] == false);
3401 assert_or_panic(vec[51] == false);
3402 assert_or_panic(vec[52] == true);
3403 assert_or_panic(vec[53] == false);
3404 assert_or_panic(vec[54] == true);
3405 assert_or_panic(vec[55] == false);
3406 assert_or_panic(vec[56] == true);
3407 assert_or_panic(vec[57] == false);
3408 assert_or_panic(vec[58] == false);
3409 assert_or_panic(vec[59] == true);
3410 assert_or_panic(vec[60] == true);
3411 assert_or_panic(vec[61] == true);
3412 assert_or_panic(vec[62] == true);
3413 assert_or_panic(vec[63] == true);
3414 assert_or_panic(vec[64] == false);
3415 assert_or_panic(vec[65] == false);
3416 assert_or_panic(vec[66] == false);
3417 assert_or_panic(vec[67] == true);
3418 assert_or_panic(vec[68] == true);
3419 assert_or_panic(vec[69] == false);
3420 assert_or_panic(vec[70] == true);
3421 assert_or_panic(vec[71] == true);
3422 assert_or_panic(vec[72] == false);
3423 assert_or_panic(vec[73] == true);
3424 assert_or_panic(vec[74] == true);
3425 assert_or_panic(vec[75] == false);
3426 assert_or_panic(vec[76] == false);
3427 assert_or_panic(vec[77] == true);
3428 assert_or_panic(vec[78] == false);
3429 assert_or_panic(vec[79] == true);
3430 assert_or_panic(vec[80] == false);
3431 assert_or_panic(vec[81] == false);
3432 assert_or_panic(vec[82] == true);
3433 assert_or_panic(vec[83] == true);
3434 assert_or_panic(vec[84] == false);
3435 assert_or_panic(vec[85] == true);
3436 assert_or_panic(vec[86] == false);
3437 assert_or_panic(vec[87] == false);
3438 assert_or_panic(vec[88] == true);
3439 assert_or_panic(vec[89] == true);
3440 assert_or_panic(vec[90] == true);
3441 assert_or_panic(vec[91] == true);
3442 assert_or_panic(vec[92] == true);
3443 assert_or_panic(vec[93] == false);
3444 assert_or_panic(vec[94] == false);
3445 assert_or_panic(vec[95] == true);
3446 assert_or_panic(vec[96] == false);
3447 assert_or_panic(vec[97] == false);
3448 assert_or_panic(vec[98] == true);
3449 assert_or_panic(vec[99] == true);
3450 assert_or_panic(vec[100] == true);
3451 assert_or_panic(vec[101] == true);
3452 assert_or_panic(vec[102] == true);
3453 assert_or_panic(vec[103] == true);
3454 assert_or_panic(vec[104] == true);
3455 assert_or_panic(vec[105] == false);
3456 assert_or_panic(vec[106] == false);
3457 assert_or_panic(vec[107] == true);
3458 assert_or_panic(vec[108] == false);
3459 assert_or_panic(vec[109] == false);
3460 assert_or_panic(vec[110] == true);
3461 assert_or_panic(vec[111] == false);
3462 assert_or_panic(vec[112] == false);
3463 assert_or_panic(vec[113] == true);
3464 assert_or_panic(vec[114] == false);
3465 assert_or_panic(vec[115] == false);
3466 assert_or_panic(vec[116] == false);
3467 assert_or_panic(vec[117] == false);
3468 assert_or_panic(vec[118] == false);
3469 assert_or_panic(vec[119] == false);
3470 assert_or_panic(vec[120] == true);
3471 assert_or_panic(vec[121] == true);
3472 assert_or_panic(vec[122] == true);
3473 assert_or_panic(vec[123] == false);
3474 assert_or_panic(vec[124] == true);
3475 assert_or_panic(vec[125] == false);
3476 assert_or_panic(vec[126] == false);
3477 assert_or_panic(vec[127] == true);
3478 }
3479 {
3480 zig_vector_256_bool((Vector256Bool){
3481 false,
3482 false,
3483 false,
3484 false,
3485 true,
3486 true,
3487 false,
3488 false,
3489 false,
3490 true,
3491 true,
3492 false,
3493 true,
3494 false,
3495 false,
3496 false,
3497 false,
3498 true,
3499 true,
3500 true,
3501 false,
3502 true,
3503 true,
3504 false,
3505 true,
3506 false,
3507 false,
3508 true,
3509 true,
3510 true,
3511 false,
3512 true,
3513 false,
3514 true,
3515 false,
3516 false,
3517 false,
3518 true,
3519 false,
3520 false,
3521 true,
3522 true,
3523 false,
3524 true,
3525 true,
3526 false,
3527 true,
3528 false,
3529 true,
3530 false,
3531 true,
3532 false,
3533 true,
3534 true,
3535 true,
3536 false,
3537 false,
3538 true,
3539 true,
3540 false,
3541 false,
3542 true,
3543 true,
3544 false,
3545 false,
3546 false,
3547 true,
3548 true,
3549 false,
3550 true,
3551 false,
3552 true,
3553 false,
3554 true,
3555 false,
3556 false,
3557 true,
3558 false,
3559 false,
3560 false,
3561 false,
3562 false,
3563 true,
3564 false,
3565 false,
3566 false,
3567 true,
3568 true,
3569 true,
3570 false,
3571 true,
3572 false,
3573 true,
3574 false,
3575 true,
3576 true,
3577 true,
3578 true,
3579 false,
3580 true,
3581 false,
3582 true,
3583 true,
3584 false,
3585 false,
3586 true,
3587 false,
3588 true,
3589 false,
3590 false,
3591 false,
3592 false,
3593 false,
3594 false,
3595 false,
3596 false,
3597 false,
3598 false,
3599 false,
3600 false,
3601 false,
3602 false,
3603 true,
3604 true,
3605 false,
3606 false,
3607 false,
3608 true,
3609 true,
3610 true,
3611 true,
3612 false,
3613 false,
3614 false,
3615 true,
3616 true,
3617 false,
3618 false,
3619 true,
3620 true,
3621 true,
3622 true,
3623 true,
3624 false,
3625 true,
3626 true,
3627 true,
3628 false,
3629 false,
3630 false,
3631 false,
3632 false,
3633 false,
3634 false,
3635 true,
3636 false,
3637 false,
3638 false,
3639 true,
3640 true,
3641 false,
3642 true,
3643 false,
3644 false,
3645 false,
3646 true,
3647 false,
3648 true,
3649 false,
3650 false,
3651 false,
3652 false,
3653 true,
3654 true,
3655 true,
3656 true,
3657 true,
3658 true,
3659 false,
3660 true,
3661 true,
3662 false,
3663 true,
3664 false,
3665 true,
3666 false,
3667 true,
3668 false,
3669 true,
3670 false,
3671 false,
3672 false,
3673 false,
3674 true,
3675 true,
3676 true,
3677 false,
3678 false,
3679 true,
3680 false,
3681 false,
3682 true,
3683 true,
3684 false,
3685 true,
3686 false,
3687 true,
3688 false,
3689 false,
3690 false,
3691 true,
3692 true,
3693 false,
3694 false,
3695 false,
3696 true,
3697 false,
3698 true,
3699 true,
3700 true,
3701 false,
3702 true,
3703 false,
3704 true,
3705 false,
3706 false,
3707 false,
3708 true,
3709 true,
3710 false,
3711 false,
3712 false,
3713 false,
3714 false,
3715 true,
3716 false,
3717 false,
3718 false,
3719 true,
3720 false,
3721 true,
3722 true,
3723 true,
3724 false,
3725 false,
3726 true,
3727 false,
3728 false,
3729 false,
3730 true,
3731 false,
3732 false,
3733 true,
3734 true,
3735 true,
3736 true,
3737 });
3738
3739 Vector256Bool vec = zig_ret_vector_256_bool();
3740 assert_or_panic(vec[0] == true);
3741 assert_or_panic(vec[1] == true);
3742 assert_or_panic(vec[2] == true);
3743 assert_or_panic(vec[3] == false);
3744 assert_or_panic(vec[4] == true);
3745 assert_or_panic(vec[5] == false);
3746 assert_or_panic(vec[6] == false);
3747 assert_or_panic(vec[7] == true);
3748 assert_or_panic(vec[8] == false);
3749 assert_or_panic(vec[9] == false);
3750 assert_or_panic(vec[10] == false);
3751 assert_or_panic(vec[11] == false);
3752 assert_or_panic(vec[12] == false);
3753 assert_or_panic(vec[13] == false);
3754 assert_or_panic(vec[14] == false);
3755 assert_or_panic(vec[15] == false);
3756 assert_or_panic(vec[16] == true);
3757 assert_or_panic(vec[17] == false);
3758 assert_or_panic(vec[18] == true);
3759 assert_or_panic(vec[19] == false);
3760 assert_or_panic(vec[20] == false);
3761 assert_or_panic(vec[21] == true);
3762 assert_or_panic(vec[22] == true);
3763 assert_or_panic(vec[23] == false);
3764 assert_or_panic(vec[24] == false);
3765 assert_or_panic(vec[25] == true);
3766 assert_or_panic(vec[26] == true);
3767 assert_or_panic(vec[27] == false);
3768 assert_or_panic(vec[28] == true);
3769 assert_or_panic(vec[29] == true);
3770 assert_or_panic(vec[30] == true);
3771 assert_or_panic(vec[31] == false);
3772 assert_or_panic(vec[32] == true);
3773 assert_or_panic(vec[33] == false);
3774 assert_or_panic(vec[34] == true);
3775 assert_or_panic(vec[35] == false);
3776 assert_or_panic(vec[36] == true);
3777 assert_or_panic(vec[37] == false);
3778 assert_or_panic(vec[38] == true);
3779 assert_or_panic(vec[39] == false);
3780 assert_or_panic(vec[40] == false);
3781 assert_or_panic(vec[41] == false);
3782 assert_or_panic(vec[42] == true);
3783 assert_or_panic(vec[43] == true);
3784 assert_or_panic(vec[44] == true);
3785 assert_or_panic(vec[45] == false);
3786 assert_or_panic(vec[46] == false);
3787 assert_or_panic(vec[47] == false);
3788 assert_or_panic(vec[48] == true);
3789 assert_or_panic(vec[49] == false);
3790 assert_or_panic(vec[50] == true);
3791 assert_or_panic(vec[51] == false);
3792 assert_or_panic(vec[52] == true);
3793 assert_or_panic(vec[53] == false);
3794 assert_or_panic(vec[54] == true);
3795 assert_or_panic(vec[55] == true);
3796 assert_or_panic(vec[56] == false);
3797 assert_or_panic(vec[57] == false);
3798 assert_or_panic(vec[58] == false);
3799 assert_or_panic(vec[59] == true);
3800 assert_or_panic(vec[60] == true);
3801 assert_or_panic(vec[61] == true);
3802 assert_or_panic(vec[62] == false);
3803 assert_or_panic(vec[63] == true);
3804 assert_or_panic(vec[64] == false);
3805 assert_or_panic(vec[65] == true);
3806 assert_or_panic(vec[66] == false);
3807 assert_or_panic(vec[67] == true);
3808 assert_or_panic(vec[68] == true);
3809 assert_or_panic(vec[69] == false);
3810 assert_or_panic(vec[70] == true);
3811 assert_or_panic(vec[71] == false);
3812 assert_or_panic(vec[72] == true);
3813 assert_or_panic(vec[73] == true);
3814 assert_or_panic(vec[74] == false);
3815 assert_or_panic(vec[75] == false);
3816 assert_or_panic(vec[76] == false);
3817 assert_or_panic(vec[77] == false);
3818 assert_or_panic(vec[78] == false);
3819 assert_or_panic(vec[79] == false);
3820 assert_or_panic(vec[80] == false);
3821 assert_or_panic(vec[81] == false);
3822 assert_or_panic(vec[82] == false);
3823 assert_or_panic(vec[83] == true);
3824 assert_or_panic(vec[84] == false);
3825 assert_or_panic(vec[85] == false);
3826 assert_or_panic(vec[86] == false);
3827 assert_or_panic(vec[87] == true);
3828 assert_or_panic(vec[88] == false);
3829 assert_or_panic(vec[89] == true);
3830 assert_or_panic(vec[90] == true);
3831 assert_or_panic(vec[91] == false);
3832 assert_or_panic(vec[92] == false);
3833 assert_or_panic(vec[93] == true);
3834 assert_or_panic(vec[94] == true);
3835 assert_or_panic(vec[95] == false);
3836 assert_or_panic(vec[96] == false);
3837 assert_or_panic(vec[97] == true);
3838 assert_or_panic(vec[98] == false);
3839 assert_or_panic(vec[99] == false);
3840 assert_or_panic(vec[100] == false);
3841 assert_or_panic(vec[101] == false);
3842 assert_or_panic(vec[102] == false);
3843 assert_or_panic(vec[103] == false);
3844 assert_or_panic(vec[104] == false);
3845 assert_or_panic(vec[105] == true);
3846 assert_or_panic(vec[106] == true);
3847 assert_or_panic(vec[107] == false);
3848 assert_or_panic(vec[108] == true);
3849 assert_or_panic(vec[109] == false);
3850 assert_or_panic(vec[110] == true);
3851 assert_or_panic(vec[111] == true);
3852 assert_or_panic(vec[112] == false);
3853 assert_or_panic(vec[113] == false);
3854 assert_or_panic(vec[114] == false);
3855 assert_or_panic(vec[115] == false);
3856 assert_or_panic(vec[116] == false);
3857 assert_or_panic(vec[117] == false);
3858 assert_or_panic(vec[118] == false);
3859 assert_or_panic(vec[119] == true);
3860 assert_or_panic(vec[120] == true);
3861 assert_or_panic(vec[121] == true);
3862 assert_or_panic(vec[122] == false);
3863 assert_or_panic(vec[123] == true);
3864 assert_or_panic(vec[124] == true);
3865 assert_or_panic(vec[125] == false);
3866 assert_or_panic(vec[126] == false);
3867 assert_or_panic(vec[127] == true);
3868 assert_or_panic(vec[128] == true);
3869 assert_or_panic(vec[129] == true);
3870 assert_or_panic(vec[130] == true);
3871 assert_or_panic(vec[131] == true);
3872 assert_or_panic(vec[132] == false);
3873 assert_or_panic(vec[133] == true);
3874 assert_or_panic(vec[134] == true);
3875 assert_or_panic(vec[135] == false);
3876 assert_or_panic(vec[136] == false);
3877 assert_or_panic(vec[137] == true);
3878 assert_or_panic(vec[138] == true);
3879 assert_or_panic(vec[139] == false);
3880 assert_or_panic(vec[140] == true);
3881 assert_or_panic(vec[141] == false);
3882 assert_or_panic(vec[142] == true);
3883 assert_or_panic(vec[143] == false);
3884 assert_or_panic(vec[144] == true);
3885 assert_or_panic(vec[145] == true);
3886 assert_or_panic(vec[146] == true);
3887 assert_or_panic(vec[147] == true);
3888 assert_or_panic(vec[148] == false);
3889 assert_or_panic(vec[149] == false);
3890 assert_or_panic(vec[150] == false);
3891 assert_or_panic(vec[151] == true);
3892 assert_or_panic(vec[152] == false);
3893 assert_or_panic(vec[153] == true);
3894 assert_or_panic(vec[154] == false);
3895 assert_or_panic(vec[155] == true);
3896 assert_or_panic(vec[156] == true);
3897 assert_or_panic(vec[157] == false);
3898 assert_or_panic(vec[158] == true);
3899 assert_or_panic(vec[159] == true);
3900 assert_or_panic(vec[160] == true);
3901 assert_or_panic(vec[161] == true);
3902 assert_or_panic(vec[162] == true);
3903 assert_or_panic(vec[163] == false);
3904 assert_or_panic(vec[164] == false);
3905 assert_or_panic(vec[165] == true);
3906 assert_or_panic(vec[166] == false);
3907 assert_or_panic(vec[167] == true);
3908 assert_or_panic(vec[168] == true);
3909 assert_or_panic(vec[169] == true);
3910 assert_or_panic(vec[170] == true);
3911 assert_or_panic(vec[171] == false);
3912 assert_or_panic(vec[172] == true);
3913 assert_or_panic(vec[173] == true);
3914 assert_or_panic(vec[174] == true);
3915 assert_or_panic(vec[175] == true);
3916 assert_or_panic(vec[176] == true);
3917 assert_or_panic(vec[177] == true);
3918 assert_or_panic(vec[178] == true);
3919 assert_or_panic(vec[179] == false);
3920 assert_or_panic(vec[180] == true);
3921 assert_or_panic(vec[181] == false);
3922 assert_or_panic(vec[182] == false);
3923 assert_or_panic(vec[183] == false);
3924 assert_or_panic(vec[184] == true);
3925 assert_or_panic(vec[185] == false);
3926 assert_or_panic(vec[186] == true);
3927 assert_or_panic(vec[187] == true);
3928 assert_or_panic(vec[188] == false);
3929 assert_or_panic(vec[189] == true);
3930 assert_or_panic(vec[190] == false);
3931 assert_or_panic(vec[191] == true);
3932 assert_or_panic(vec[192] == false);
3933 assert_or_panic(vec[193] == true);
3934 assert_or_panic(vec[194] == false);
3935 assert_or_panic(vec[195] == false);
3936 assert_or_panic(vec[196] == true);
3937 assert_or_panic(vec[197] == true);
3938 assert_or_panic(vec[198] == true);
3939 assert_or_panic(vec[199] == true);
3940 assert_or_panic(vec[200] == true);
3941 assert_or_panic(vec[201] == true);
3942 assert_or_panic(vec[202] == true);
3943 assert_or_panic(vec[203] == false);
3944 assert_or_panic(vec[204] == true);
3945 assert_or_panic(vec[205] == false);
3946 assert_or_panic(vec[206] == false);
3947 assert_or_panic(vec[207] == true);
3948 assert_or_panic(vec[208] == true);
3949 assert_or_panic(vec[209] == false);
3950 assert_or_panic(vec[210] == false);
3951 assert_or_panic(vec[211] == false);
3952 assert_or_panic(vec[212] == true);
3953 assert_or_panic(vec[213] == true);
3954 assert_or_panic(vec[214] == true);
3955 assert_or_panic(vec[215] == false);
3956 assert_or_panic(vec[216] == false);
3957 assert_or_panic(vec[217] == true);
3958 assert_or_panic(vec[218] == true);
3959 assert_or_panic(vec[219] == true);
3960 assert_or_panic(vec[220] == true);
3961 assert_or_panic(vec[221] == false);
3962 assert_or_panic(vec[222] == true);
3963 assert_or_panic(vec[223] == false);
3964 assert_or_panic(vec[224] == true);
3965 assert_or_panic(vec[225] == true);
3966 assert_or_panic(vec[226] == true);
3967 assert_or_panic(vec[227] == false);
3968 assert_or_panic(vec[228] == false);
3969 assert_or_panic(vec[229] == false);
3970 assert_or_panic(vec[230] == false);
3971 assert_or_panic(vec[231] == false);
3972 assert_or_panic(vec[232] == true);
3973 assert_or_panic(vec[233] == true);
3974 assert_or_panic(vec[234] == false);
3975 assert_or_panic(vec[235] == false);
3976 assert_or_panic(vec[236] == false);
3977 assert_or_panic(vec[237] == true);
3978 assert_or_panic(vec[238] == true);
3979 assert_or_panic(vec[239] == false);
3980 assert_or_panic(vec[240] == true);
3981 assert_or_panic(vec[241] == true);
3982 assert_or_panic(vec[242] == true);
3983 assert_or_panic(vec[243] == false);
3984 assert_or_panic(vec[244] == true);
3985 assert_or_panic(vec[245] == true);
3986 assert_or_panic(vec[246] == false);
3987 assert_or_panic(vec[247] == true);
3988 assert_or_panic(vec[248] == false);
3989 assert_or_panic(vec[249] == false);
3990 assert_or_panic(vec[250] == true);
3991 assert_or_panic(vec[251] == true);
3992 assert_or_panic(vec[252] == false);
3993 assert_or_panic(vec[253] == true);
3994 assert_or_panic(vec[254] == false);
3995 assert_or_panic(vec[255] == true);
3996 }
3997 {
3998 zig_vector_512_bool((Vector512Bool){
3999 false,
4000 true,
4001 true,
4002 false,
4003 true,
4004 false,
4005 true,
4006 false,
4007 false,
4008 false,
4009 false,
4010 false,
4011 true,
4012 false,
4013 true,
4014 false,
4015 false,
4016 false,
4017 true,
4018 true,
4019 true,
4020 true,
4021 false,
4022 false,
4023 false,
4024 true,
4025 true,
4026 false,
4027 true,
4028 true,
4029 false,
4030 false,
4031 true,
4032 true,
4033 false,
4034 false,
4035 false,
4036 false,
4037 false,
4038 false,
4039 false,
4040 true,
4041 true,
4042 true,
4043 false,
4044 true,
4045 true,
4046 true,
4047 true,
4048 true,
4049 false,
4050 true,
4051 true,
4052 true,
4053 false,
4054 true,
4055 false,
4056 false,
4057 true,
4058 false,
4059 true,
4060 true,
4061 false,
4062 false,
4063 false,
4064 true,
4065 true,
4066 true,
4067 true,
4068 false,
4069 false,
4070 true,
4071 true,
4072 false,
4073 true,
4074 true,
4075 false,
4076 false,
4077 true,
4078 false,
4079 false,
4080 false,
4081 true,
4082 true,
4083 true,
4084 false,
4085 false,
4086 true,
4087 false,
4088 true,
4089 false,
4090 false,
4091 true,
4092 false,
4093 false,
4094 true,
4095 true,
4096 false,
4097 false,
4098 false,
4099 false,
4100 true,
4101 false,
4102 false,
4103 false,
4104 false,
4105 false,
4106 false,
4107 true,
4108 true,
4109 true,
4110 true,
4111 true,
4112 false,
4113 false,
4114 false,
4115 false,
4116 true,
4117 true,
4118 false,
4119 true,
4120 true,
4121 false,
4122 false,
4123 true,
4124 false,
4125 false,
4126 false,
4127 false,
4128 true,
4129 true,
4130 true,
4131 true,
4132 false,
4133 false,
4134 false,
4135 false,
4136 true,
4137 false,
4138 false,
4139 false,
4140 false,
4141 true,
4142 true,
4143 false,
4144 true,
4145 false,
4146 true,
4147 false,
4148 false,
4149 true,
4150 true,
4151 false,
4152 true,
4153 true,
4154 false,
4155 false,
4156 false,
4157 true,
4158 false,
4159 false,
4160 false,
4161 false,
4162 true,
4163 true,
4164 false,
4165 false,
4166 true,
4167 false,
4168 true,
4169 true,
4170 false,
4171 false,
4172 false,
4173 false,
4174 false,
4175 false,
4176 true,
4177 false,
4178 false,
4179 false,
4180 false,
4181 false,
4182 false,
4183 true,
4184 false,
4185 false,
4186 false,
4187 false,
4188 true,
4189 false,
4190 false,
4191 false,
4192 false,
4193 false,
4194 false,
4195 true,
4196 true,
4197 true,
4198 false,
4199 true,
4200 true,
4201 false,
4202 false,
4203 false,
4204 false,
4205 false,
4206 true,
4207 true,
4208 false,
4209 false,
4210 false,
4211 true,
4212 false,
4213 false,
4214 true,
4215 true,
4216 true,
4217 false,
4218 false,
4219 true,
4220 false,
4221 true,
4222 true,
4223 true,
4224 true,
4225 false,
4226 true,
4227 false,
4228 false,
4229 false,
4230 true,
4231 false,
4232 false,
4233 false,
4234 false,
4235 false,
4236 false,
4237 false,
4238 true,
4239 false,
4240 false,
4241 false,
4242 true,
4243 true,
4244 true,
4245 true,
4246 false,
4247 true,
4248 true,
4249 false,
4250 false,
4251 false,
4252 true,
4253 false,
4254 false,
4255 true,
4256 true,
4257 false,
4258 true,
4259 false,
4260 true,
4261 true,
4262 false,
4263 false,
4264 false,
4265 false,
4266 true,
4267 false,
4268 true,
4269 true,
4270 false,
4271 false,
4272 true,
4273 true,
4274 true,
4275 false,
4276 true,
4277 false,
4278 false,
4279 true,
4280 true,
4281 false,
4282 true,
4283 false,
4284 true,
4285 true,
4286 true,
4287 true,
4288 true,
4289 true,
4290 true,
4291 true,
4292 true,
4293 true,
4294 false,
4295 true,
4296 false,
4297 true,
4298 false,
4299 true,
4300 true,
4301 false,
4302 true,
4303 false,
4304 true,
4305 false,
4306 true,
4307 true,
4308 false,
4309 true,
4310 true,
4311 true,
4312 false,
4313 false,
4314 false,
4315 false,
4316 true,
4317 true,
4318 true,
4319 true,
4320 true,
4321 true,
4322 true,
4323 true,
4324 true,
4325 false,
4326 true,
4327 false,
4328 false,
4329 true,
4330 false,
4331 false,
4332 false,
4333 false,
4334 false,
4335 false,
4336 false,
4337 false,
4338 false,
4339 false,
4340 false,
4341 true,
4342 true,
4343 false,
4344 false,
4345 false,
4346 false,
4347 false,
4348 true,
4349 true,
4350 true,
4351 true,
4352 false,
4353 false,
4354 false,
4355 false,
4356 true,
4357 true,
4358 false,
4359 false,
4360 false,
4361 true,
4362 true,
4363 false,
4364 false,
4365 false,
4366 false,
4367 false,
4368 true,
4369 true,
4370 false,
4371 true,
4372 true,
4373 false,
4374 true,
4375 true,
4376 false,
4377 true,
4378 true,
4379 false,
4380 true,
4381 true,
4382 false,
4383 true,
4384 false,
4385 true,
4386 true,
4387 true,
4388 true,
4389 false,
4390 false,
4391 false,
4392 true,
4393 true,
4394 true,
4395 true,
4396 false,
4397 true,
4398 true,
4399 true,
4400 false,
4401 false,
4402 true,
4403 false,
4404 false,
4405 false,
4406 true,
4407 true,
4408 true,
4409 false,
4410 true,
4411 false,
4412 false,
4413 false,
4414 true,
4415 false,
4416 false,
4417 true,
4418 true,
4419 true,
4420 true,
4421 false,
4422 true,
4423 true,
4424 false,
4425 false,
4426 false,
4427 true,
4428 false,
4429 true,
4430 true,
4431 false,
4432 false,
4433 false,
4434 false,
4435 true,
4436 false,
4437 true,
4438 false,
4439 false,
4440 false,
4441 false,
4442 true,
4443 false,
4444 false,
4445 true,
4446 true,
4447 true,
4448 false,
4449 true,
4450 true,
4451 false,
4452 true,
4453 false,
4454 true,
4455 false,
4456 false,
4457 false,
4458 true,
4459 false,
4460 false,
4461 false,
4462 true,
4463 true,
4464 true,
4465 true,
4466 true,
4467 false,
4468 false,
4469 false,
4470 false,
4471 false,
4472 false,
4473 true,
4474 true,
4475 true,
4476 true,
4477 true,
4478 false,
4479 true,
4480 true,
4481 false,
4482 true,
4483 false,
4484 true,
4485 false,
4486 true,
4487 false,
4488 false,
4489 false,
4490 true,
4491 false,
4492 false,
4493 false,
4494 true,
4495 true,
4496 false,
4497 false,
4498 true,
4499 false,
4500 true,
4501 false,
4502 false,
4503 false,
4504 true,
4505 true,
4506 true,
4507 true,
4508 false,
4509 false,
4510 true,
4511 });
4512
4513 Vector512Bool vec = zig_ret_vector_512_bool();
4514 assert_or_panic(vec[0] == true);
4515 assert_or_panic(vec[1] == true);
4516 assert_or_panic(vec[2] == true);
4517 assert_or_panic(vec[3] == true);
4518 assert_or_panic(vec[4] == false);
4519 assert_or_panic(vec[5] == true);
4520 assert_or_panic(vec[6] == false);
4521 assert_or_panic(vec[7] == true);
4522 assert_or_panic(vec[8] == true);
4523 assert_or_panic(vec[9] == true);
4524 assert_or_panic(vec[10] == false);
4525 assert_or_panic(vec[11] == true);
4526 assert_or_panic(vec[12] == false);
4527 assert_or_panic(vec[13] == false);
4528 assert_or_panic(vec[14] == false);
4529 assert_or_panic(vec[15] == true);
4530 assert_or_panic(vec[16] == true);
4531 assert_or_panic(vec[17] == false);
4532 assert_or_panic(vec[18] == false);
4533 assert_or_panic(vec[19] == false);
4534 assert_or_panic(vec[20] == true);
4535 assert_or_panic(vec[21] == true);
4536 assert_or_panic(vec[22] == false);
4537 assert_or_panic(vec[23] == false);
4538 assert_or_panic(vec[24] == false);
4539 assert_or_panic(vec[25] == false);
4540 assert_or_panic(vec[26] == true);
4541 assert_or_panic(vec[27] == false);
4542 assert_or_panic(vec[28] == false);
4543 assert_or_panic(vec[29] == false);
4544 assert_or_panic(vec[30] == true);
4545 assert_or_panic(vec[31] == true);
4546 assert_or_panic(vec[32] == true);
4547 assert_or_panic(vec[33] == true);
4548 assert_or_panic(vec[34] == false);
4549 assert_or_panic(vec[35] == false);
4550 assert_or_panic(vec[36] == false);
4551 assert_or_panic(vec[37] == true);
4552 assert_or_panic(vec[38] == true);
4553 assert_or_panic(vec[39] == true);
4554 assert_or_panic(vec[40] == false);
4555 assert_or_panic(vec[41] == false);
4556 assert_or_panic(vec[42] == true);
4557 assert_or_panic(vec[43] == false);
4558 assert_or_panic(vec[44] == false);
4559 assert_or_panic(vec[45] == true);
4560 assert_or_panic(vec[46] == false);
4561 assert_or_panic(vec[47] == false);
4562 assert_or_panic(vec[48] == true);
4563 assert_or_panic(vec[49] == true);
4564 assert_or_panic(vec[50] == true);
4565 assert_or_panic(vec[51] == true);
4566 assert_or_panic(vec[52] == false);
4567 assert_or_panic(vec[53] == false);
4568 assert_or_panic(vec[54] == false);
4569 assert_or_panic(vec[55] == true);
4570 assert_or_panic(vec[56] == false);
4571 assert_or_panic(vec[57] == true);
4572 assert_or_panic(vec[58] == false);
4573 assert_or_panic(vec[59] == true);
4574 assert_or_panic(vec[60] == true);
4575 assert_or_panic(vec[61] == false);
4576 assert_or_panic(vec[62] == false);
4577 assert_or_panic(vec[63] == true);
4578 assert_or_panic(vec[64] == true);
4579 assert_or_panic(vec[65] == false);
4580 assert_or_panic(vec[66] == true);
4581 assert_or_panic(vec[67] == false);
4582 assert_or_panic(vec[68] == false);
4583 assert_or_panic(vec[69] == false);
4584 assert_or_panic(vec[70] == true);
4585 assert_or_panic(vec[71] == true);
4586 assert_or_panic(vec[72] == true);
4587 assert_or_panic(vec[73] == true);
4588 assert_or_panic(vec[74] == true);
4589 assert_or_panic(vec[75] == false);
4590 assert_or_panic(vec[76] == true);
4591 assert_or_panic(vec[77] == false);
4592 assert_or_panic(vec[78] == true);
4593 assert_or_panic(vec[79] == true);
4594 assert_or_panic(vec[80] == true);
4595 assert_or_panic(vec[81] == true);
4596 assert_or_panic(vec[82] == true);
4597 assert_or_panic(vec[83] == false);
4598 assert_or_panic(vec[84] == true);
4599 assert_or_panic(vec[85] == true);
4600 assert_or_panic(vec[86] == false);
4601 assert_or_panic(vec[87] == true);
4602 assert_or_panic(vec[88] == false);
4603 assert_or_panic(vec[89] == false);
4604 assert_or_panic(vec[90] == true);
4605 assert_or_panic(vec[91] == false);
4606 assert_or_panic(vec[92] == true);
4607 assert_or_panic(vec[93] == false);
4608 assert_or_panic(vec[94] == false);
4609 assert_or_panic(vec[95] == false);
4610 assert_or_panic(vec[96] == true);
4611 assert_or_panic(vec[97] == true);
4612 assert_or_panic(vec[98] == false);
4613 assert_or_panic(vec[99] == true);
4614 assert_or_panic(vec[100] == true);
4615 assert_or_panic(vec[101] == false);
4616 assert_or_panic(vec[102] == true);
4617 assert_or_panic(vec[103] == false);
4618 assert_or_panic(vec[104] == true);
4619 assert_or_panic(vec[105] == false);
4620 assert_or_panic(vec[106] == true);
4621 assert_or_panic(vec[107] == false);
4622 assert_or_panic(vec[108] == false);
4623 assert_or_panic(vec[109] == true);
4624 assert_or_panic(vec[110] == false);
4625 assert_or_panic(vec[111] == false);
4626 assert_or_panic(vec[112] == true);
4627 assert_or_panic(vec[113] == false);
4628 assert_or_panic(vec[114] == true);
4629 assert_or_panic(vec[115] == false);
4630 assert_or_panic(vec[116] == true);
4631 assert_or_panic(vec[117] == false);
4632 assert_or_panic(vec[118] == false);
4633 assert_or_panic(vec[119] == true);
4634 assert_or_panic(vec[120] == true);
4635 assert_or_panic(vec[121] == true);
4636 assert_or_panic(vec[122] == false);
4637 assert_or_panic(vec[123] == true);
4638 assert_or_panic(vec[124] == false);
4639 assert_or_panic(vec[125] == false);
4640 assert_or_panic(vec[126] == true);
4641 assert_or_panic(vec[127] == true);
4642 assert_or_panic(vec[128] == false);
4643 assert_or_panic(vec[129] == true);
4644 assert_or_panic(vec[130] == true);
4645 assert_or_panic(vec[131] == false);
4646 assert_or_panic(vec[132] == true);
4647 assert_or_panic(vec[133] == true);
4648 assert_or_panic(vec[134] == false);
4649 assert_or_panic(vec[135] == true);
4650 assert_or_panic(vec[136] == true);
4651 assert_or_panic(vec[137] == false);
4652 assert_or_panic(vec[138] == false);
4653 assert_or_panic(vec[139] == false);
4654 assert_or_panic(vec[140] == true);
4655 assert_or_panic(vec[141] == false);
4656 assert_or_panic(vec[142] == true);
4657 assert_or_panic(vec[143] == false);
4658 assert_or_panic(vec[144] == false);
4659 assert_or_panic(vec[145] == false);
4660 assert_or_panic(vec[146] == true);
4661 assert_or_panic(vec[147] == false);
4662 assert_or_panic(vec[148] == true);
4663 assert_or_panic(vec[149] == false);
4664 assert_or_panic(vec[150] == false);
4665 assert_or_panic(vec[151] == true);
4666 assert_or_panic(vec[152] == false);
4667 assert_or_panic(vec[153] == true);
4668 assert_or_panic(vec[154] == true);
4669 assert_or_panic(vec[155] == false);
4670 assert_or_panic(vec[156] == true);
4671 assert_or_panic(vec[157] == true);
4672 assert_or_panic(vec[158] == false);
4673 assert_or_panic(vec[159] == true);
4674 assert_or_panic(vec[160] == true);
4675 assert_or_panic(vec[161] == false);
4676 assert_or_panic(vec[162] == false);
4677 assert_or_panic(vec[163] == false);
4678 assert_or_panic(vec[164] == true);
4679 assert_or_panic(vec[165] == false);
4680 assert_or_panic(vec[166] == true);
4681 assert_or_panic(vec[167] == true);
4682 assert_or_panic(vec[168] == true);
4683 assert_or_panic(vec[169] == true);
4684 assert_or_panic(vec[170] == false);
4685 assert_or_panic(vec[171] == true);
4686 assert_or_panic(vec[172] == false);
4687 assert_or_panic(vec[173] == false);
4688 assert_or_panic(vec[174] == true);
4689 assert_or_panic(vec[175] == true);
4690 assert_or_panic(vec[176] == true);
4691 assert_or_panic(vec[177] == false);
4692 assert_or_panic(vec[178] == false);
4693 assert_or_panic(vec[179] == false);
4694 assert_or_panic(vec[180] == true);
4695 assert_or_panic(vec[181] == false);
4696 assert_or_panic(vec[182] == false);
4697 assert_or_panic(vec[183] == true);
4698 assert_or_panic(vec[184] == true);
4699 assert_or_panic(vec[185] == false);
4700 assert_or_panic(vec[186] == true);
4701 assert_or_panic(vec[187] == false);
4702 assert_or_panic(vec[188] == true);
4703 assert_or_panic(vec[189] == true);
4704 assert_or_panic(vec[190] == true);
4705 assert_or_panic(vec[191] == true);
4706 assert_or_panic(vec[192] == true);
4707 assert_or_panic(vec[193] == true);
4708 assert_or_panic(vec[194] == true);
4709 assert_or_panic(vec[195] == false);
4710 assert_or_panic(vec[196] == false);
4711 assert_or_panic(vec[197] == false);
4712 assert_or_panic(vec[198] == false);
4713 assert_or_panic(vec[199] == false);
4714 assert_or_panic(vec[200] == true);
4715 assert_or_panic(vec[201] == false);
4716 assert_or_panic(vec[202] == true);
4717 assert_or_panic(vec[203] == false);
4718 assert_or_panic(vec[204] == true);
4719 assert_or_panic(vec[205] == true);
4720 assert_or_panic(vec[206] == false);
4721 assert_or_panic(vec[207] == false);
4722 assert_or_panic(vec[208] == false);
4723 assert_or_panic(vec[209] == true);
4724 assert_or_panic(vec[210] == true);
4725 assert_or_panic(vec[211] == true);
4726 assert_or_panic(vec[212] == false);
4727 assert_or_panic(vec[213] == false);
4728 assert_or_panic(vec[214] == true);
4729 assert_or_panic(vec[215] == true);
4730 assert_or_panic(vec[216] == true);
4731 assert_or_panic(vec[217] == false);
4732 assert_or_panic(vec[218] == false);
4733 assert_or_panic(vec[219] == true);
4734 assert_or_panic(vec[220] == false);
4735 assert_or_panic(vec[221] == true);
4736 assert_or_panic(vec[222] == true);
4737 assert_or_panic(vec[223] == false);
4738 assert_or_panic(vec[224] == true);
4739 assert_or_panic(vec[225] == false);
4740 assert_or_panic(vec[226] == false);
4741 assert_or_panic(vec[227] == true);
4742 assert_or_panic(vec[228] == false);
4743 assert_or_panic(vec[229] == false);
4744 assert_or_panic(vec[230] == true);
4745 assert_or_panic(vec[231] == true);
4746 assert_or_panic(vec[232] == false);
4747 assert_or_panic(vec[233] == true);
4748 assert_or_panic(vec[234] == true);
4749 assert_or_panic(vec[235] == true);
4750 assert_or_panic(vec[236] == true);
4751 assert_or_panic(vec[237] == true);
4752 assert_or_panic(vec[238] == false);
4753 assert_or_panic(vec[239] == true);
4754 assert_or_panic(vec[240] == false);
4755 assert_or_panic(vec[241] == false);
4756 assert_or_panic(vec[242] == true);
4757 assert_or_panic(vec[243] == false);
4758 assert_or_panic(vec[244] == true);
4759 assert_or_panic(vec[245] == false);
4760 assert_or_panic(vec[246] == true);
4761 assert_or_panic(vec[247] == false);
4762 assert_or_panic(vec[248] == true);
4763 assert_or_panic(vec[249] == true);
4764 assert_or_panic(vec[250] == true);
4765 assert_or_panic(vec[251] == true);
4766 assert_or_panic(vec[252] == true);
4767 assert_or_panic(vec[253] == false);
4768 assert_or_panic(vec[254] == false);
4769 assert_or_panic(vec[255] == false);
4770 assert_or_panic(vec[256] == false);
4771 assert_or_panic(vec[257] == false);
4772 assert_or_panic(vec[258] == false);
4773 assert_or_panic(vec[259] == true);
4774 assert_or_panic(vec[260] == true);
4775 assert_or_panic(vec[261] == true);
4776 assert_or_panic(vec[262] == true);
4777 assert_or_panic(vec[263] == false);
4778 assert_or_panic(vec[264] == false);
4779 assert_or_panic(vec[265] == false);
4780 assert_or_panic(vec[266] == true);
4781 assert_or_panic(vec[267] == false);
4782 assert_or_panic(vec[268] == true);
4783 assert_or_panic(vec[269] == false);
4784 assert_or_panic(vec[270] == true);
4785 assert_or_panic(vec[271] == true);
4786 assert_or_panic(vec[272] == true);
4787 assert_or_panic(vec[273] == true);
4788 assert_or_panic(vec[274] == true);
4789 assert_or_panic(vec[275] == true);
4790 assert_or_panic(vec[276] == false);
4791 assert_or_panic(vec[277] == false);
4792 assert_or_panic(vec[278] == true);
4793 assert_or_panic(vec[279] == true);
4794 assert_or_panic(vec[280] == false);
4795 assert_or_panic(vec[281] == false);
4796 assert_or_panic(vec[282] == false);
4797 assert_or_panic(vec[283] == false);
4798 assert_or_panic(vec[284] == true);
4799 assert_or_panic(vec[285] == true);
4800 assert_or_panic(vec[286] == true);
4801 assert_or_panic(vec[287] == false);
4802 assert_or_panic(vec[288] == false);
4803 assert_or_panic(vec[289] == false);
4804 assert_or_panic(vec[290] == true);
4805 assert_or_panic(vec[291] == false);
4806 assert_or_panic(vec[292] == true);
4807 assert_or_panic(vec[293] == true);
4808 assert_or_panic(vec[294] == false);
4809 assert_or_panic(vec[295] == true);
4810 assert_or_panic(vec[296] == true);
4811 assert_or_panic(vec[297] == true);
4812 assert_or_panic(vec[298] == false);
4813 assert_or_panic(vec[299] == true);
4814 assert_or_panic(vec[300] == true);
4815 assert_or_panic(vec[301] == false);
4816 assert_or_panic(vec[302] == false);
4817 assert_or_panic(vec[303] == true);
4818 assert_or_panic(vec[304] == false);
4819 assert_or_panic(vec[305] == false);
4820 assert_or_panic(vec[306] == true);
4821 assert_or_panic(vec[307] == true);
4822 assert_or_panic(vec[308] == true);
4823 assert_or_panic(vec[309] == true);
4824 assert_or_panic(vec[310] == false);
4825 assert_or_panic(vec[311] == false);
4826 assert_or_panic(vec[312] == false);
4827 assert_or_panic(vec[313] == false);
4828 assert_or_panic(vec[314] == false);
4829 assert_or_panic(vec[315] == true);
4830 assert_or_panic(vec[316] == false);
4831 assert_or_panic(vec[317] == false);
4832 assert_or_panic(vec[318] == true);
4833 assert_or_panic(vec[319] == false);
4834 assert_or_panic(vec[320] == false);
4835 assert_or_panic(vec[321] == true);
4836 assert_or_panic(vec[322] == true);
4837 assert_or_panic(vec[323] == true);
4838 assert_or_panic(vec[324] == true);
4839 assert_or_panic(vec[325] == false);
4840 assert_or_panic(vec[326] == false);
4841 assert_or_panic(vec[327] == false);
4842 assert_or_panic(vec[328] == true);
4843 assert_or_panic(vec[329] == true);
4844 assert_or_panic(vec[330] == false);
4845 assert_or_panic(vec[331] == true);
4846 assert_or_panic(vec[332] == true);
4847 assert_or_panic(vec[333] == false);
4848 assert_or_panic(vec[334] == false);
4849 assert_or_panic(vec[335] == true);
4850 assert_or_panic(vec[336] == true);
4851 assert_or_panic(vec[337] == false);
4852 assert_or_panic(vec[338] == true);
4853 assert_or_panic(vec[339] == true);
4854 assert_or_panic(vec[340] == true);
4855 assert_or_panic(vec[341] == false);
4856 assert_or_panic(vec[342] == false);
4857 assert_or_panic(vec[343] == false);
4858 assert_or_panic(vec[344] == true);
4859 assert_or_panic(vec[345] == true);
4860 assert_or_panic(vec[346] == false);
4861 assert_or_panic(vec[347] == true);
4862 assert_or_panic(vec[348] == false);
4863 assert_or_panic(vec[349] == true);
4864 assert_or_panic(vec[350] == false);
4865 assert_or_panic(vec[351] == false);
4866 assert_or_panic(vec[352] == true);
4867 assert_or_panic(vec[353] == false);
4868 assert_or_panic(vec[354] == true);
4869 assert_or_panic(vec[355] == false);
4870 assert_or_panic(vec[356] == false);
4871 assert_or_panic(vec[357] == false);
4872 assert_or_panic(vec[358] == false);
4873 assert_or_panic(vec[359] == false);
4874 assert_or_panic(vec[360] == true);
4875 assert_or_panic(vec[361] == true);
4876 assert_or_panic(vec[362] == false);
4877 assert_or_panic(vec[363] == false);
4878 assert_or_panic(vec[364] == false);
4879 assert_or_panic(vec[365] == false);
4880 assert_or_panic(vec[366] == true);
4881 assert_or_panic(vec[367] == false);
4882 assert_or_panic(vec[368] == true);
4883 assert_or_panic(vec[369] == false);
4884 assert_or_panic(vec[370] == true);
4885 assert_or_panic(vec[371] == true);
4886 assert_or_panic(vec[372] == false);
4887 assert_or_panic(vec[373] == true);
4888 assert_or_panic(vec[374] == true);
4889 assert_or_panic(vec[375] == true);
4890 assert_or_panic(vec[376] == true);
4891 assert_or_panic(vec[377] == true);
4892 assert_or_panic(vec[378] == false);
4893 assert_or_panic(vec[379] == true);
4894 assert_or_panic(vec[380] == false);
4895 assert_or_panic(vec[381] == true);
4896 assert_or_panic(vec[382] == true);
4897 assert_or_panic(vec[383] == true);
4898 assert_or_panic(vec[384] == true);
4899 assert_or_panic(vec[385] == true);
4900 assert_or_panic(vec[386] == false);
4901 assert_or_panic(vec[387] == true);
4902 assert_or_panic(vec[388] == true);
4903 assert_or_panic(vec[389] == false);
4904 assert_or_panic(vec[390] == true);
4905 assert_or_panic(vec[391] == false);
4906 assert_or_panic(vec[392] == true);
4907 assert_or_panic(vec[393] == false);
4908 assert_or_panic(vec[394] == true);
4909 assert_or_panic(vec[395] == false);
4910 assert_or_panic(vec[396] == true);
4911 assert_or_panic(vec[397] == false);
4912 assert_or_panic(vec[398] == false);
4913 assert_or_panic(vec[399] == true);
4914 assert_or_panic(vec[400] == true);
4915 assert_or_panic(vec[401] == true);
4916 assert_or_panic(vec[402] == true);
4917 assert_or_panic(vec[403] == false);
4918 assert_or_panic(vec[404] == false);
4919 assert_or_panic(vec[405] == true);
4920 assert_or_panic(vec[406] == false);
4921 assert_or_panic(vec[407] == false);
4922 assert_or_panic(vec[408] == false);
4923 assert_or_panic(vec[409] == true);
4924 assert_or_panic(vec[410] == false);
4925 assert_or_panic(vec[411] == true);
4926 assert_or_panic(vec[412] == true);
4927 assert_or_panic(vec[413] == false);
4928 assert_or_panic(vec[414] == true);
4929 assert_or_panic(vec[415] == true);
4930 assert_or_panic(vec[416] == false);
4931 assert_or_panic(vec[417] == true);
4932 assert_or_panic(vec[418] == true);
4933 assert_or_panic(vec[419] == false);
4934 assert_or_panic(vec[420] == false);
4935 assert_or_panic(vec[421] == true);
4936 assert_or_panic(vec[422] == false);
4937 assert_or_panic(vec[423] == false);
4938 assert_or_panic(vec[424] == true);
4939 assert_or_panic(vec[425] == false);
4940 assert_or_panic(vec[426] == true);
4941 assert_or_panic(vec[427] == false);
4942 assert_or_panic(vec[428] == false);
4943 assert_or_panic(vec[429] == true);
4944 assert_or_panic(vec[430] == false);
4945 assert_or_panic(vec[431] == true);
4946 assert_or_panic(vec[432] == true);
4947 assert_or_panic(vec[433] == false);
4948 assert_or_panic(vec[434] == true);
4949 assert_or_panic(vec[435] == false);
4950 assert_or_panic(vec[436] == true);
4951 assert_or_panic(vec[437] == false);
4952 assert_or_panic(vec[438] == true);
4953 assert_or_panic(vec[439] == false);
4954 assert_or_panic(vec[440] == false);
4955 assert_or_panic(vec[441] == true);
4956 assert_or_panic(vec[442] == true);
4957 assert_or_panic(vec[443] == false);
4958 assert_or_panic(vec[444] == true);
4959 assert_or_panic(vec[445] == true);
4960 assert_or_panic(vec[446] == false);
4961 assert_or_panic(vec[447] == true);
4962 assert_or_panic(vec[448] == true);
4963 assert_or_panic(vec[449] == false);
4964 assert_or_panic(vec[450] == false);
4965 assert_or_panic(vec[451] == false);
4966 assert_or_panic(vec[452] == false);
4967 assert_or_panic(vec[453] == false);
4968 assert_or_panic(vec[454] == true);
4969 assert_or_panic(vec[455] == false);
4970 assert_or_panic(vec[456] == false);
4971 assert_or_panic(vec[457] == true);
4972 assert_or_panic(vec[458] == false);
4973 assert_or_panic(vec[459] == true);
4974 assert_or_panic(vec[460] == false);
4975 assert_or_panic(vec[461] == false);
4976 assert_or_panic(vec[462] == false);
4977 assert_or_panic(vec[463] == true);
4978 assert_or_panic(vec[464] == false);
4979 assert_or_panic(vec[465] == true);
4980 assert_or_panic(vec[466] == false);
4981 assert_or_panic(vec[467] == false);
4982 assert_or_panic(vec[468] == false);
4983 assert_or_panic(vec[469] == false);
4984 assert_or_panic(vec[470] == true);
4985 assert_or_panic(vec[471] == true);
4986 assert_or_panic(vec[472] == false);
4987 assert_or_panic(vec[473] == true);
4988 assert_or_panic(vec[474] == true);
4989 assert_or_panic(vec[475] == false);
4990 assert_or_panic(vec[476] == false);
4991 assert_or_panic(vec[477] == true);
4992 assert_or_panic(vec[478] == true);
4993 assert_or_panic(vec[479] == true);
4994 assert_or_panic(vec[480] == false);
4995 assert_or_panic(vec[481] == false);
4996 assert_or_panic(vec[482] == true);
4997 assert_or_panic(vec[483] == false);
4998 assert_or_panic(vec[484] == false);
4999 assert_or_panic(vec[485] == false);
5000 assert_or_panic(vec[486] == true);
5001 assert_or_panic(vec[487] == true);
5002 assert_or_panic(vec[488] == false);
5003 assert_or_panic(vec[489] == false);
5004 assert_or_panic(vec[490] == false);
5005 assert_or_panic(vec[491] == false);
5006 assert_or_panic(vec[492] == false);
5007 assert_or_panic(vec[493] == true);
5008 assert_or_panic(vec[494] == true);
5009 assert_or_panic(vec[495] == true);
5010 assert_or_panic(vec[496] == true);
5011 assert_or_panic(vec[497] == false);
5012 assert_or_panic(vec[498] == false);
5013 assert_or_panic(vec[499] == false);
5014 assert_or_panic(vec[500] == true);
5015 assert_or_panic(vec[501] == false);
5016 assert_or_panic(vec[502] == true);
5017 assert_or_panic(vec[503] == true);
5018 assert_or_panic(vec[504] == true);
5019 assert_or_panic(vec[505] == true);
5020 assert_or_panic(vec[506] == false);
5021 assert_or_panic(vec[507] == false);
5022 assert_or_panic(vec[508] == true);
5023 assert_or_panic(vec[509] == true);
5024 assert_or_panic(vec[510] == false);
5025 assert_or_panic(vec[511] == false);
5026 }
5027#endif
5028}
5029
5030void c_u8(uint8_t x) {
5031 assert_or_panic(x == 0xff);
5032}
5033
5034void c_u16(uint16_t x) {
5035 assert_or_panic(x == 0xfffe);
5036}
5037
5038void c_u32(uint32_t x) {
5039 assert_or_panic(x == 0xfffffffd);
5040}
5041
5042void c_u64(uint64_t x) {
5043 assert_or_panic(x == 0xfffffffffffffffcULL);
5044}
5045
5046#ifndef ZIG_NO_I128
5047void c_struct_u128(struct u128 x) {
5048 assert_or_panic(x.value == 0xfffffffffffffffcULL);
5049}
5050#endif
5051
5052void c_i8(int8_t x) {
5053 assert_or_panic(x == -1);
5054}
5055
5056void c_i16(int16_t x) {
5057 assert_or_panic(x == -2);
5058}
5059
5060void c_i32(int32_t x) {
5061 assert_or_panic(x == -3);
5062}
5063
5064void c_i64(int64_t x) {
5065 assert_or_panic(x == -4);
5066}
5067
5068#ifndef ZIG_NO_I128
5069void c_struct_i128(struct i128 x) {
5070 assert_or_panic(x.value == -6);
5071}
5072#endif
5073
5074void c_f32(float x) {
5075 assert_or_panic(x == 12.34f);
5076}
5077
5078void c_f64(double x) {
5079 assert_or_panic(x == 56.78);
5080}
5081
5082void c_long_double(long double x) {
5083 assert_or_panic(x == 12.34l);
5084}
5085
5086void c_ptr(void *x) {
5087 assert_or_panic(x == (void *)0xdeadbeefL);
5088}
5089
5090void c_bool(bool x) {
5091 assert_or_panic(x);
5092}
5093
5094void c_five_integers(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e) {
5095 assert_or_panic(a == 12);
5096 assert_or_panic(b == 34);
5097 assert_or_panic(c == 56);
5098 assert_or_panic(d == 78);
5099 assert_or_panic(e == 90);
5100}
5101
5102void c_five_floats(float a, float b, float c, float d, float e) {
5103 assert_or_panic(a == 1.0);
5104 assert_or_panic(b == 2.0);
5105 assert_or_panic(c == 3.0);
5106 assert_or_panic(d == 4.0);
5107 assert_or_panic(e == 5.0);
5108}
5109
5110float complex c_cmultf_comp(float a_r, float a_i, float b_r, float b_i) {
5111 assert_or_panic(a_r == 1.25f);
5112 assert_or_panic(a_i == 2.6f);
5113 assert_or_panic(b_r == 11.3f);
5114 assert_or_panic(b_i == -1.5f);
5115
5116 return 1.5f + I * 13.5f;
5117}
5118
5119double complex c_cmultd_comp(double a_r, double a_i, double b_r, double b_i) {
5120 assert_or_panic(a_r == 1.25);
5121 assert_or_panic(a_i == 2.6);
5122 assert_or_panic(b_r == 11.3);
5123 assert_or_panic(b_i == -1.5);
5124
5125 return 1.5 + I * 13.5;
5126}
5127
5128float complex c_cmultf(float complex a, float complex b) {
5129 assert_or_panic(creal(a) == 1.25f);
5130 assert_or_panic(cimag(a) == 2.6f);
5131 assert_or_panic(creal(b) == 11.3f);
5132 assert_or_panic(cimag(b) == -1.5f);
5133
5134 return 1.5f + I * 13.5f;
5135}
5136
5137double complex c_cmultd(double complex a, double complex b) {
5138 assert_or_panic(creal(a) == 1.25);
5139 assert_or_panic(cimag(a) == 2.6);
5140 assert_or_panic(creal(b) == 11.3);
5141 assert_or_panic(cimag(b) == -1.5);
5142
5143 return 1.5 + I * 13.5;
5144}
5145
5146struct Struct_i32_i32 c_mut_struct_i32_i32(struct Struct_i32_i32 s) {
5147 assert_or_panic(s.a == 1);
5148 assert_or_panic(s.b == 2);
5149 s.a += 100;
5150 s.b += 250;
5151 assert_or_panic(s.a == 101);
5152 assert_or_panic(s.b == 252);
5153 return s;
5154}
5155
5156void c_struct_i32_i32(struct Struct_i32_i32 s) {
5157 assert_or_panic(s.a == 1);
5158 assert_or_panic(s.b == 2);
5159}
5160
5161void c_big_struct(struct BigStruct x) {
5162 assert_or_panic(x.a == 1);
5163 assert_or_panic(x.b == 2);
5164 assert_or_panic(x.c == 3);
5165 assert_or_panic(x.d == 4);
5166 assert_or_panic(x.e == 5);
5167}
5168
5169void c_big_union(union BigUnion x) {
5170 assert_or_panic(x.a.a == 1);
5171 assert_or_panic(x.a.b == 2);
5172 assert_or_panic(x.a.c == 3);
5173 assert_or_panic(x.a.d == 4);
5174}
5175
5176void c_small_struct_ints(struct SmallStructInts x) {
5177 assert_or_panic(x.a == 1);
5178 assert_or_panic(x.b == 2);
5179 assert_or_panic(x.c == 3);
5180 assert_or_panic(x.d == 4);
5181
5182 struct SmallStructInts y = zig_ret_small_struct_ints();
5183
5184 assert_or_panic(y.a == 1);
5185 assert_or_panic(y.b == 2);
5186 assert_or_panic(y.c == 3);
5187 assert_or_panic(y.d == 4);
5188}
5189
5190struct SmallStructInts c_ret_small_struct_ints() {
5191 struct SmallStructInts s = {
5192 .a = 1,
5193 .b = 2,
5194 .c = 3,
5195 .d = 4,
5196 };
5197 return s;
5198}
5199
5200void c_med_struct_ints(struct MedStructInts s) {
5201 assert_or_panic(s.x == 1);
5202 assert_or_panic(s.y == 2);
5203 assert_or_panic(s.z == 3);
5204
5205 struct MedStructInts s2 = zig_ret_med_struct_ints();
5206
5207 assert_or_panic(s2.x == 1);
5208 assert_or_panic(s2.y == 2);
5209 assert_or_panic(s2.z == 3);
5210}
5211
5212struct MedStructInts c_ret_med_struct_ints() {
5213 struct MedStructInts s = {
5214 .x = 1,
5215 .y = 2,
5216 .z = 3,
5217 };
5218 return s;
5219}
5220
5221void c_med_struct_mixed(struct MedStructMixed x) {
5222 assert_or_panic(x.a == 1234);
5223 assert_or_panic(x.b == 100.0f);
5224 assert_or_panic(x.c == 1337.0f);
5225
5226 struct MedStructMixed y = zig_ret_med_struct_mixed();
5227
5228 assert_or_panic(y.a == 1234);
5229 assert_or_panic(y.b == 100.0f);
5230 assert_or_panic(y.c == 1337.0f);
5231}
5232
5233struct MedStructMixed c_ret_med_struct_mixed() {
5234 struct MedStructMixed s = {
5235 .a = 1234,
5236 .b = 100.0,
5237 .c = 1337.0,
5238 };
5239 return s;
5240}
5241
5242void c_split_struct_ints(struct SplitStructInts x) {
5243 assert_or_panic(x.a == 1234);
5244 assert_or_panic(x.b == 100);
5245 assert_or_panic(x.c == 1337);
5246}
5247
5248void c_split_struct_mixed(struct SplitStructMixed x) {
5249 assert_or_panic(x.a == 1234);
5250 assert_or_panic(x.b == 100);
5251 assert_or_panic(x.c == 1337.0f);
5252 struct SplitStructMixed y = zig_ret_split_struct_mixed();
5253
5254 assert_or_panic(y.a == 1234);
5255 assert_or_panic(y.b == 100);
5256 assert_or_panic(y.c == 1337.0f);
5257}
5258
5259uint8_t c_ret_small_packed_struct() {
5260 uint8_t s = 0;
5261 s |= 0 << 0;
5262 s |= 1 << 2;
5263 s |= 2 << 4;
5264 s |= 3 << 6;
5265 return s;
5266}
5267
5268void c_small_packed_struct(uint8_t x) {
5269 assert_or_panic(((x >> 0) & 0x3) == 0);
5270 assert_or_panic(((x >> 2) & 0x3) == 1);
5271 assert_or_panic(((x >> 4) & 0x3) == 2);
5272 assert_or_panic(((x >> 6) & 0x3) == 3);
5273}
5274
5275#ifndef ZIG_NO_I128
5276__int128 c_ret_big_packed_struct() {
5277 __int128 s = 0;
5278 s |= 1 << 0;
5279 s |= (__int128)2 << 64;
5280 return s;
5281}
5282
5283void c_big_packed_struct(__int128 x) {
5284 assert_or_panic(((x >> 0) & 0xFFFFFFFFFFFFFFFF) == 1);
5285 assert_or_panic(((x >> 64) & 0xFFFFFFFFFFFFFFFF) == 2);
5286}
5287#endif
5288
5289struct SplitStructMixed c_ret_split_struct_mixed() {
5290 struct SplitStructMixed s = {
5291 .a = 1234,
5292 .b = 100,
5293 .c = 1337.0f,
5294 };
5295 return s;
5296}
5297
5298struct BigStruct c_big_struct_both(struct BigStruct x) {
5299 assert_or_panic(x.a == 1);
5300 assert_or_panic(x.b == 2);
5301 assert_or_panic(x.c == 3);
5302 assert_or_panic(x.d == 4);
5303 assert_or_panic(x.e == 5);
5304 struct BigStruct y = {10, 11, 12, 13, 14};
5305 return y;
5306}
5307
5308void c_small_struct_floats(Vector3 vec) {
5309 assert_or_panic(vec.x == 3.0);
5310 assert_or_panic(vec.y == 6.0);
5311 assert_or_panic(vec.z == 12.0);
5312}
5313
5314void c_small_struct_floats_extra(Vector3 vec, const char *str) {
5315 assert_or_panic(vec.x == 3.0);
5316 assert_or_panic(vec.y == 6.0);
5317 assert_or_panic(vec.z == 12.0);
5318 assert_or_panic(!strcmp(str, "hello"));
5319}
5320
5321void c_big_struct_floats(Vector5 vec) {
5322 assert_or_panic(vec.x == 76.0);
5323 assert_or_panic(vec.y == -1.0);
5324 assert_or_panic(vec.z == -12.0);
5325 assert_or_panic(vec.w == 69);
5326 assert_or_panic(vec.q == 55);
5327}
5328
5329void c_multiple_struct_ints(Rect x, Rect y) {
5330 assert_or_panic(x.left == 1);
5331 assert_or_panic(x.right == 21);
5332 assert_or_panic(x.top == 16);
5333 assert_or_panic(x.bottom == 4);
5334 assert_or_panic(y.left == 178);
5335 assert_or_panic(y.right == 189);
5336 assert_or_panic(y.top == 21);
5337 assert_or_panic(y.bottom == 15);
5338}
5339
5340void c_multiple_struct_floats(FloatRect x, FloatRect y) {
5341 assert_or_panic(x.left == 1);
5342 assert_or_panic(x.right == 21);
5343 assert_or_panic(x.top == 16);
5344 assert_or_panic(x.bottom == 4);
5345 assert_or_panic(y.left == 178);
5346 assert_or_panic(y.right == 189);
5347 assert_or_panic(y.top == 21);
5348 assert_or_panic(y.bottom == 15);
5349}
5350
5351bool c_ret_bool() {
5352 return 1;
5353}
5354uint8_t c_ret_u8() {
5355 return 0xff;
5356}
5357uint16_t c_ret_u16() {
5358 return 0xffff;
5359}
5360uint32_t c_ret_u32() {
5361 return 0xffffffff;
5362}
5363uint64_t c_ret_u64() {
5364 return 0xffffffffffffffff;
5365}
5366int8_t c_ret_i8() {
5367 return -1;
5368}
5369int16_t c_ret_i16() {
5370 return -1;
5371}
5372int32_t c_ret_i32() {
5373 return -1;
5374}
5375int64_t c_ret_i64() {
5376 return -1;
5377}
5378
5379typedef struct {
5380 uint32_t a;
5381 uint8_t padding[4];
5382 uint64_t b;
5383} StructWithArray;
5384
5385void c_struct_with_array(StructWithArray x) {
5386 assert_or_panic(x.a == 1);
5387 assert_or_panic(x.b == 2);
5388}
5389
5390StructWithArray c_ret_struct_with_array() {
5391 return (StructWithArray){4, {}, 155};
5392}
5393
5394typedef struct {
5395 struct Point {
5396 double x;
5397 double y;
5398 } origin;
5399 struct Size {
5400 double width;
5401 double height;
5402 } size;
5403} FloatArrayStruct;
5404
5405void c_float_array_struct(FloatArrayStruct x) {
5406 assert_or_panic(x.origin.x == 5);
5407 assert_or_panic(x.origin.y == 6);
5408 assert_or_panic(x.size.width == 7);
5409 assert_or_panic(x.size.height == 8);
5410}
5411
5412FloatArrayStruct c_ret_float_array_struct() {
5413 FloatArrayStruct x;
5414 x.origin.x = 1;
5415 x.origin.y = 2;
5416 x.size.width = 3;
5417 x.size.height = 4;
5418 return x;
5419}
5420
5421typedef uint32_t SmallVec __attribute__((vector_size(2 * sizeof(uint32_t))));
5422
5423void c_small_vec(SmallVec vec) {
5424 assert_or_panic(vec[0] == 1);
5425 assert_or_panic(vec[1] == 2);
5426}
5427
5428SmallVec c_ret_small_vec(void) {
5429 return (SmallVec){3, 4};
5430}
5431
5432typedef size_t MediumVec __attribute__((vector_size(4 * sizeof(size_t))));
5433
5434void c_medium_vec(MediumVec vec) {
5435 assert_or_panic(vec[0] == 1);
5436 assert_or_panic(vec[1] == 2);
5437 assert_or_panic(vec[2] == 3);
5438 assert_or_panic(vec[3] == 4);
5439}
5440
5441MediumVec c_ret_medium_vec(void) {
5442 return (MediumVec){5, 6, 7, 8};
5443}
5444
5445typedef size_t BigVec __attribute__((vector_size(8 * sizeof(size_t))));
5446
5447void c_big_vec(BigVec vec) {
5448 assert_or_panic(vec[0] == 1);
5449 assert_or_panic(vec[1] == 2);
5450 assert_or_panic(vec[2] == 3);
5451 assert_or_panic(vec[3] == 4);
5452 assert_or_panic(vec[4] == 5);
5453 assert_or_panic(vec[5] == 6);
5454 assert_or_panic(vec[6] == 7);
5455 assert_or_panic(vec[7] == 8);
5456}
5457
5458BigVec c_ret_big_vec(void) {
5459 return (BigVec){9, 10, 11, 12, 13, 14, 15, 16};
5460}
5461
5462typedef struct {
5463 float x, y;
5464} Vector2;
5465
5466void c_ptr_size_float_struct(Vector2 vec) {
5467 assert_or_panic(vec.x == 1);
5468 assert_or_panic(vec.y == 2);
5469}
5470Vector2 c_ret_ptr_size_float_struct(void) {
5471 return (Vector2){3, 4};
5472}
5473
5474/// Tests for Double + Char struct
5475struct DC { double v1; char v2; };
5476
5477int c_assert_DC(struct DC lv){
5478 if (lv.v1 != -0.25) return 1;
5479 if (lv.v2 != 15) return 2;
5480 return 0;
5481}
5482struct DC c_ret_DC(){
5483 struct DC lv = { .v1 = -0.25, .v2 = 15 };
5484 return lv;
5485}
5486int zig_assert_DC(struct DC);
5487int c_send_DC(){
5488 return zig_assert_DC(c_ret_DC());
5489}
5490struct DC zig_ret_DC();
5491int c_assert_ret_DC(){
5492 return c_assert_DC(zig_ret_DC());
5493}
5494
5495/// Tests for Char + Float + Float struct
5496struct CFF { char v1; float v2; float v3; };
5497
5498int c_assert_CFF(struct CFF lv){
5499 if (lv.v1 != 39) return 1;
5500 if (lv.v2 != 0.875) return 2;
5501 if (lv.v3 != 1.0) return 3;
5502 return 0;
5503}
5504struct CFF c_ret_CFF(){
5505 struct CFF lv = { .v1 = 39, .v2 = 0.875, .v3 = 1.0 };
5506 return lv;
5507}
5508int zig_assert_CFF(struct CFF);
5509int c_send_CFF(){
5510 return zig_assert_CFF(c_ret_CFF());
5511}
5512struct CFF zig_ret_CFF();
5513int c_assert_ret_CFF(){
5514 return c_assert_CFF(zig_ret_CFF());
5515}
5516
5517struct PD { void* v1; double v2; };
5518
5519int c_assert_PD(struct PD lv){
5520 if (lv.v1 != 0) return 1;
5521 if (lv.v2 != 0.5) return 2;
5522 return 0;
5523}
5524struct PD c_ret_PD(){
5525 struct PD lv = { .v1 = 0, .v2 = 0.5 };
5526 return lv;
5527}
5528int zig_assert_PD(struct PD);
5529int c_send_PD(){
5530 return zig_assert_PD(c_ret_PD());
5531}
5532struct PD zig_ret_PD();
5533int c_assert_ret_PD(){
5534 return c_assert_PD(zig_ret_PD());
5535}
5536
5537struct ByRef {
5538 int val;
5539 int arr[15];
5540};
5541struct ByRef c_modify_by_ref_param(struct ByRef in) {
5542 in.val = 42;
5543 return in;
5544}
5545
5546struct ByVal {
5547 struct {
5548 unsigned long x;
5549 unsigned long y;
5550 unsigned long z;
5551 } origin;
5552 struct {
5553 unsigned long width;
5554 unsigned long height;
5555 unsigned long depth;
5556 } size;
5557};
5558
5559void c_func_ptr_byval(void *a, void *b, struct ByVal in, unsigned long c, void *d, unsigned long e) {
5560 assert_or_panic((intptr_t)a == 1);
5561 assert_or_panic((intptr_t)b == 2);
5562
5563 assert_or_panic(in.origin.x == 9);
5564 assert_or_panic(in.origin.y == 10);
5565 assert_or_panic(in.origin.z == 11);
5566 assert_or_panic(in.size.width == 12);
5567 assert_or_panic(in.size.height == 13);
5568 assert_or_panic(in.size.depth == 14);
5569
5570 assert_or_panic(c == 3);
5571 assert_or_panic((intptr_t)d == 4);
5572 assert_or_panic(e == 5);
5573}
5574
5575#ifndef ZIG_NO_RAW_F16
5576__fp16 c_f16(__fp16 a) {
5577 assert_or_panic(a == 12);
5578 return 34;
5579}
5580#endif
5581
5582typedef struct {
5583 __fp16 a;
5584} f16_struct;
5585f16_struct c_f16_struct(f16_struct a) {
5586 assert_or_panic(a.a == 12);
5587 return (f16_struct){34};
5588}
5589
5590#if defined __x86_64__ || defined __i386__
5591typedef long double f80;
5592f80 c_f80(f80 a) {
5593 assert_or_panic((double)a == 12.34);
5594 return 56.78;
5595}
5596typedef struct {
5597 f80 a;
5598} f80_struct;
5599f80_struct c_f80_struct(f80_struct a) {
5600 assert_or_panic((double)a.a == 12.34);
5601 return (f80_struct){56.78};
5602}
5603typedef struct {
5604 f80 a;
5605 int b;
5606} f80_extra_struct;
5607f80_extra_struct c_f80_extra_struct(f80_extra_struct a) {
5608 assert_or_panic((double)a.a == 12.34);
5609 assert_or_panic(a.b == 42);
5610 return (f80_extra_struct){56.78, 24};
5611}
5612#endif
5613
5614#ifndef ZIG_NO_F128
5615__float128 zig_f128(__float128 a);
5616__float128 c_f128(__float128 a) {
5617 assert_or_panic((double)a == 12.34);
5618 assert_or_panic(zig_f128(12) == 34);
5619 return 56.78;
5620}
5621typedef struct {
5622 __float128 a;
5623} f128_struct;
5624f128_struct zig_f128_struct(f128_struct a);
5625f128_struct c_f128_struct(f128_struct a) {
5626 assert_or_panic((double)a.a == 12.34);
5627 f128_struct b = zig_f128_struct((f128_struct){12345});
5628 assert_or_panic(b.a == 98765);
5629 return (f128_struct){56.78};
5630}
5631
5632typedef struct {
5633 __float128 a, b;
5634} f128_f128_struct;
5635f128_f128_struct zig_f128_f128_struct(f128_f128_struct a);
5636f128_f128_struct c_f128_f128_struct(f128_f128_struct a) {
5637 assert_or_panic((double)a.a == 12.34);
5638 assert_or_panic((double)a.b == 87.65);
5639 f128_f128_struct b = zig_f128_f128_struct((f128_f128_struct){13, 57});
5640 assert_or_panic((double)b.a == 24);
5641 assert_or_panic((double)b.b == 68);
5642 return (f128_f128_struct){56.78, 43.21};
5643}
5644#endif
5645
5646void __attribute__((stdcall)) stdcall_scalars(char a, short b, int c, float d, double e) {
5647 assert_or_panic(a == 1);
5648 assert_or_panic(b == 2);
5649 assert_or_panic(c == 3);
5650 assert_or_panic(d == 4.0);
5651 assert_or_panic(e == 5.0);
5652}
5653
5654typedef struct {
5655 short x;
5656 short y;
5657} Coord2;
5658
5659Coord2 __attribute__((stdcall)) stdcall_coord2(Coord2 a, Coord2 b, Coord2 c) {
5660 assert_or_panic(a.x == 0x1111);
5661 assert_or_panic(a.y == 0x2222);
5662 assert_or_panic(b.x == 0x3333);
5663 assert_or_panic(b.y == 0x4444);
5664 assert_or_panic(c.x == 0x5555);
5665 assert_or_panic(c.y == 0x6666);
5666 return (Coord2){123, 456};
5667}
5668
5669void __attribute__((stdcall)) stdcall_big_union(union BigUnion x) {
5670 assert_or_panic(x.a.a == 1);
5671 assert_or_panic(x.a.b == 2);
5672 assert_or_panic(x.a.c == 3);
5673 assert_or_panic(x.a.d == 4);
5674}
5675
5676#ifdef __x86_64__
5677struct ByRef __attribute__((ms_abi)) c_explict_win64(struct ByRef in) {
5678 in.val = 42;
5679 return in;
5680}
5681
5682struct ByRef __attribute__((sysv_abi)) c_explict_sys_v(struct ByRef in) {
5683 in.val = 42;
5684 return in;
5685}
5686#endif
5687
5688
5689struct byval_tail_callsite_attr_Point {
5690 double x;
5691 double y;
5692} Point;
5693struct byval_tail_callsite_attr_Size {
5694 double width;
5695 double height;
5696} Size;
5697struct byval_tail_callsite_attr_Rect {
5698 struct byval_tail_callsite_attr_Point origin;
5699 struct byval_tail_callsite_attr_Size size;
5700};
5701double c_byval_tail_callsite_attr(struct byval_tail_callsite_attr_Rect in) {
5702 return in.size.width;
5703}