1#include <complex.h>
2#include <inttypes.h>
3#include <stdalign.h>
4#include <stdbool.h>
5#include <stdlib.h>
6#include <string.h>
7
8void zig_panic(void);
9
10static void assert_or_panic(bool ok) {
11 if (!ok) {
12 zig_panic();
13 }
14}
15
16#if defined(__mips64__)
17# define ZIG_MIPS64
18#elif defined(__mips__)
19# define ZIG_MIPS32
20#endif
21
22#if defined(_ARCH_PPC64)
23# define ZIG_PPC64
24#elif defined(__powerpc__)
25# define ZIG_PPC32
26#endif
27
28#ifdef __riscv
29# ifdef _ILP32
30# define ZIG_RISCV32
31# else
32# define ZIG_RISCV64
33# endif
34#endif
35
36#ifdef __i386__
37# define ZIG_NO_I128
38#endif
39
40#ifdef __arm__
41# define ZIG_NO_I128
42#endif
43
44#ifdef __hexagon__
45# define ZIG_NO_I128
46#endif
47
48#ifdef __mips__
49# define ZIG_NO_I128
50#endif
51
52#ifdef ZIG_PPC32
53# define ZIG_NO_I128
54#endif
55
56#ifdef ZIG_RISCV32
57# define ZIG_NO_I128
58#endif
59
60#ifdef __i386__
61# define ZIG_NO_COMPLEX
62#endif
63
64#ifdef __mips__
65# define ZIG_NO_COMPLEX
66#endif
67
68#ifdef __arm__
69# define ZIG_NO_COMPLEX
70#endif
71
72#ifdef __hexagon__
73# define ZIG_NO_COMPLEX
74#endif
75
76#if defined(__loongarch__) && defined(__loongarch_soft_float)
77# define ZIG_NO_COMPLEX
78#endif
79
80#ifdef __powerpc__
81# define ZIG_NO_COMPLEX
82#endif
83
84#ifdef __riscv
85# define ZIG_NO_COMPLEX
86#endif
87
88#ifdef __s390x__
89# define ZIG_NO_COMPLEX
90#endif
91
92#ifdef __x86_64__
93#define ZIG_NO_RAW_F16
94#endif
95
96#ifdef __i386__
97#define ZIG_NO_RAW_F16
98#endif
99
100#ifdef __hexagon__
101#define ZIG_NO_RAW_F16
102#endif
103
104#ifdef __loongarch__
105#define ZIG_NO_RAW_F16
106#endif
107
108#ifdef __mips__
109#define ZIG_NO_RAW_F16
110#endif
111
112#ifdef __riscv
113#define ZIG_NO_RAW_F16
114#endif
115
116#ifdef __s390x__
117#define ZIG_NO_RAW_F16
118#endif
119
120#ifdef __wasm__
121#define ZIG_NO_RAW_F16
122#endif
123
124#ifdef __powerpc__
125#define ZIG_NO_RAW_F16
126#endif
127
128#ifdef __aarch64__
129#define ZIG_NO_F128
130#endif
131
132#ifdef __arm__
133#define ZIG_NO_F128
134#endif
135
136#ifdef __hexagon__
137#define ZIG_NO_F128
138#endif
139
140#ifdef __loongarch__
141#define ZIG_NO_F128
142#endif
143
144#ifdef __mips__
145#define ZIG_NO_F128
146#endif
147
148#ifdef __riscv
149#define ZIG_NO_F128
150#endif
151
152#ifdef __powerpc__
153#define ZIG_NO_F128
154#endif
155
156#ifdef __s390x__
157#define ZIG_NO_F128
158#endif
159
160#ifdef __APPLE__
161#define ZIG_NO_F128
162#endif
163
164#ifdef _MSC_VER
165#define ZIG_NO_F128
166#endif
167
168#ifndef ZIG_NO_I128
169struct i128 {
170 __int128 value;
171};
172
173struct u128 {
174 unsigned __int128 value;
175};
176#endif
177
178void zig_u8(uint8_t);
179void zig_u16(uint16_t);
180void zig_u32(uint32_t);
181void zig_u64(uint64_t);
182#ifndef ZIG_NO_I128
183void zig_struct_u128(struct u128);
184#endif
185void zig_i8(int8_t);
186void zig_i16(int16_t);
187void zig_i32(int32_t);
188void zig_i64(int64_t);
189#ifndef ZIG_NO_I128
190void zig_struct_i128(struct i128);
191#endif
192void zig_five_integers(int32_t, int32_t, int32_t, int32_t, int32_t);
193
194void zig_five_floats(float, float, float, float, float);
195
196bool zig_ret_bool();
197uint8_t zig_ret_u8();
198uint16_t zig_ret_u16();
199uint32_t zig_ret_u32();
200uint64_t zig_ret_u64();
201int8_t zig_ret_i8();
202int16_t zig_ret_i16();
203int32_t zig_ret_i32();
204int64_t zig_ret_i64();
205
206void zig_ptr(void *);
207
208void zig_bool(bool);
209
210#ifndef ZIG_NO_COMPLEX
211// Note: These two functions match the signature of __mulsc3 and __muldc3 in compiler-rt (and libgcc)
212float complex zig_cmultf_comp(float a_r, float a_i, float b_r, float b_i);
213double complex zig_cmultd_comp(double a_r, double a_i, double b_r, double b_i);
214
215float complex zig_cmultf(float complex a, float complex b);
216double complex zig_cmultd(double complex a, double complex b);
217#endif
218
219float zig_ret_f32(void);
220void zig_f32(float, size_t);
221void zig_1_f32(size_t, float, size_t);
222void zig_2_f32(size_t, size_t, float, size_t);
223void zig_3_f32(size_t, size_t, size_t, float, size_t);
224void zig_4_f32(size_t, size_t, size_t, size_t, float, size_t);
225void zig_5_f32(size_t, size_t, size_t, size_t, size_t, float, size_t);
226void zig_6_f32(size_t, size_t, size_t, size_t, size_t, size_t, float, size_t);
227void zig_7_f32(size_t, size_t, size_t, size_t, size_t, size_t, size_t, float, size_t);
228void zig_8_f32(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, float, size_t);
229
230float c_ret_f32(void) {
231 return 11;
232}
233void c_f32(float f, size_t i) {
234 assert_or_panic(f == 12);
235 assert_or_panic(i == 1);
236}
237void c_1_f32(size_t a0, float f, size_t i) {
238 assert_or_panic(f == 13);
239 assert_or_panic(i == 2);
240}
241void c_2_f32(size_t a0, size_t a1, float f, size_t i) {
242 assert_or_panic(f == 14);
243 assert_or_panic(i == 3);
244}
245void c_3_f32(size_t a0, size_t a1, size_t a2, float f, size_t i) {
246 assert_or_panic(f == 15);
247 assert_or_panic(i == 4);
248}
249void c_4_f32(size_t a0, size_t a1, size_t a2, size_t a3, float f, size_t i) {
250 assert_or_panic(f == 16);
251 assert_or_panic(i == 5);
252}
253void c_5_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, float f, size_t i) {
254 assert_or_panic(f == 17);
255 assert_or_panic(i == 6);
256}
257void c_6_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, float f, size_t i) {
258 assert_or_panic(f == 18);
259 assert_or_panic(i == 7);
260}
261void c_7_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, float f, size_t i) {
262 assert_or_panic(f == 19);
263 assert_or_panic(i == 8);
264}
265void c_8_f32(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, float f, size_t i) {
266 assert_or_panic(f == 20);
267 assert_or_panic(i == 9);
268}
269void c_test_f32(void) {
270 float f = zig_ret_f32();
271 assert_or_panic(f == 1);
272 zig_f32(2, 1);
273 zig_1_f32(0, 3, 2);
274 zig_2_f32(0, 1, 4, 3);
275 zig_3_f32(0, 1, 2, 5, 4);
276 zig_4_f32(0, 1, 2, 3, 6, 5);
277 zig_5_f32(0, 1, 2, 3, 4, 7, 6);
278 zig_6_f32(0, 1, 2, 3, 4, 5, 8, 7);
279 zig_7_f32(0, 1, 2, 3, 4, 5, 6, 9, 8);
280 zig_8_f32(0, 1, 2, 3, 4, 5, 6, 7, 10, 9);
281}
282
283double zig_ret_f64(void);
284void zig_f64(double, size_t);
285void zig_1_f64(size_t, double, size_t);
286void zig_2_f64(size_t, size_t, double, size_t);
287void zig_3_f64(size_t, size_t, size_t, double, size_t);
288void zig_4_f64(size_t, size_t, size_t, size_t, double, size_t);
289void zig_5_f64(size_t, size_t, size_t, size_t, size_t, double, size_t);
290void zig_6_f64(size_t, size_t, size_t, size_t, size_t, size_t, double, size_t);
291void zig_7_f64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, double, size_t);
292void zig_8_f64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, double, size_t);
293
294double c_ret_f64(void) {
295 return 11;
296}
297void c_f64(double f, size_t i) {
298 assert_or_panic(f == 12);
299 assert_or_panic(i == 1);
300}
301void c_1_f64(size_t a0, double f, size_t i) {
302 assert_or_panic(f == 13);
303 assert_or_panic(i == 2);
304}
305void c_2_f64(size_t a0, size_t a1, double f, size_t i) {
306 assert_or_panic(f == 14);
307 assert_or_panic(i == 3);
308}
309void c_3_f64(size_t a0, size_t a1, size_t a2, double f, size_t i) {
310 assert_or_panic(f == 15);
311 assert_or_panic(i == 4);
312}
313void c_4_f64(size_t a0, size_t a1, size_t a2, size_t a3, double f, size_t i) {
314 assert_or_panic(f == 16);
315 assert_or_panic(i == 5);
316}
317void c_5_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, double f, size_t i) {
318 assert_or_panic(f == 17);
319 assert_or_panic(i == 6);
320}
321void c_6_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, double f, size_t i) {
322 assert_or_panic(f == 18);
323 assert_or_panic(i == 7);
324}
325void c_7_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, double f, size_t i) {
326 assert_or_panic(f == 19);
327 assert_or_panic(i == 8);
328}
329void c_8_f64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, double f, size_t i) {
330 assert_or_panic(f == 20);
331 assert_or_panic(i == 9);
332}
333void c_test_f64(void) {
334 double f = zig_ret_f64();
335 assert_or_panic(f == 1);
336 zig_f64(2, 1);
337 zig_1_f64(0, 3, 2);
338 zig_2_f64(0, 1, 4, 3);
339 zig_3_f64(0, 1, 2, 5, 4);
340 zig_4_f64(0, 1, 2, 3, 6, 5);
341 zig_5_f64(0, 1, 2, 3, 4, 7, 6);
342 zig_6_f64(0, 1, 2, 3, 4, 5, 8, 7);
343 zig_7_f64(0, 1, 2, 3, 4, 5, 6, 9, 8);
344 zig_8_f64(0, 1, 2, 3, 4, 5, 6, 7, 10, 9);
345}
346
347long double zig_ret_longdouble(void);
348void zig_longdouble(long double, size_t);
349void zig_1_longdouble(size_t, long double, size_t);
350void zig_2_longdouble(size_t, size_t, long double, size_t);
351void zig_3_longdouble(size_t, size_t, size_t, long double, size_t);
352void zig_4_longdouble(size_t, size_t, size_t, size_t, long double, size_t);
353void zig_5_longdouble(size_t, size_t, size_t, size_t, size_t, long double, size_t);
354void zig_6_longdouble(size_t, size_t, size_t, size_t, size_t, size_t, long double, size_t);
355void zig_7_longdouble(size_t, size_t, size_t, size_t, size_t, size_t, size_t, long double, size_t);
356void zig_8_longdouble(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, long double, size_t);
357
358long double c_ret_longdouble(void) {
359 return 11;
360}
361void c_longdouble(long double f, size_t i) {
362 assert_or_panic(f == 12);
363 assert_or_panic(i == 1);
364}
365void c_1_longdouble(size_t a0, long double f, size_t i) {
366 assert_or_panic(f == 13);
367 assert_or_panic(i == 2);
368}
369void c_2_longdouble(size_t a0, size_t a1, long double f, size_t i) {
370 assert_or_panic(f == 14);
371 assert_or_panic(i == 3);
372}
373void c_3_longdouble(size_t a0, size_t a1, size_t a2, long double f, size_t i) {
374 assert_or_panic(f == 15);
375 assert_or_panic(i == 4);
376}
377void c_4_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, long double f, size_t i) {
378 assert_or_panic(f == 16);
379 assert_or_panic(i == 5);
380}
381void c_5_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, long double f, size_t i) {
382 assert_or_panic(f == 17);
383 assert_or_panic(i == 6);
384}
385void c_6_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, long double f, size_t i) {
386 assert_or_panic(f == 18);
387 assert_or_panic(i == 7);
388}
389void c_7_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, long double f, size_t i) {
390 assert_or_panic(f == 19);
391 assert_or_panic(i == 8);
392}
393void c_8_longdouble(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, long double f, size_t i) {
394 assert_or_panic(f == 20);
395 assert_or_panic(i == 9);
396}
397void c_test_longdouble(void) {
398 long double f = zig_ret_longdouble();
399 assert_or_panic(f == 1);
400 zig_longdouble(2, 1);
401 zig_1_longdouble(0, 3, 2);
402 zig_2_longdouble(0, 1, 4, 3);
403 zig_3_longdouble(0, 1, 2, 5, 4);
404 zig_4_longdouble(0, 1, 2, 3, 6, 5);
405 zig_5_longdouble(0, 1, 2, 3, 4, 7, 6);
406 zig_6_longdouble(0, 1, 2, 3, 4, 5, 8, 7);
407 zig_7_longdouble(0, 1, 2, 3, 4, 5, 6, 9, 8);
408 zig_8_longdouble(0, 1, 2, 3, 4, 5, 6, 7, 10, 9);
409}
410
411#ifndef __hexagon__
412#ifndef __loongarch__
413#ifndef __mips__
414#ifndef ZIG_PPC64
415#if !(defined(__i386__) && defined(_WIN32))
416
417typedef bool Vector_2_bool __attribute__((ext_vector_type(2)));
418
419Vector_2_bool zig_ret_vector_2_bool(void);
420void zig_vector_2_bool(Vector_2_bool vec);
421
422Vector_2_bool c_ret_vector_2_bool(void) {
423 return (Vector_2_bool){
424 true,
425 false,
426 };
427}
428void c_vector_2_bool(Vector_2_bool vec) {
429 assert_or_panic(vec[0] == true);
430 assert_or_panic(vec[1] == true);
431}
432void c_test_vector_2_bool(void) {
433 Vector_2_bool vec = zig_ret_vector_2_bool();
434 assert_or_panic(vec[0] == false);
435 assert_or_panic(vec[1] == false);
436 zig_vector_2_bool((Vector_2_bool){
437 false,
438 true,
439 });
440}
441
442typedef bool Vector_4_bool __attribute__((ext_vector_type(4)));
443
444Vector_4_bool zig_ret_vector_4_bool(void);
445void zig_vector_4_bool(Vector_4_bool vec);
446
447Vector_4_bool c_ret_vector_4_bool(void) {
448 return (Vector_4_bool){
449 true,
450 false,
451 true,
452 false,
453 };
454}
455void c_vector_4_bool(Vector_4_bool vec) {
456 assert_or_panic(vec[0] == true);
457 assert_or_panic(vec[1] == true);
458 assert_or_panic(vec[2] == false);
459 assert_or_panic(vec[3] == true);
460}
461void c_test_vector_4_bool(void) {
462 Vector_4_bool vec = zig_ret_vector_4_bool();
463 assert_or_panic(vec[0] == false);
464 assert_or_panic(vec[1] == true);
465 assert_or_panic(vec[2] == true);
466 assert_or_panic(vec[3] == true);
467 zig_vector_4_bool((Vector_4_bool){
468 false,
469 false,
470 false,
471 false,
472 });
473}
474
475typedef bool Vector_8_bool __attribute__((ext_vector_type(8)));
476
477Vector_8_bool zig_ret_vector_8_bool(void);
478void zig_vector_8_bool(Vector_8_bool vec);
479
480Vector_8_bool c_ret_vector_8_bool(void) {
481 return (Vector_8_bool){
482 false,
483 true,
484 false,
485 false,
486 true,
487 false,
488 false,
489 true,
490 };
491}
492void c_vector_8_bool(Vector_8_bool vec) {
493 assert_or_panic(vec[0] == true);
494 assert_or_panic(vec[1] == false);
495 assert_or_panic(vec[2] == true);
496 assert_or_panic(vec[3] == true);
497 assert_or_panic(vec[4] == true);
498 assert_or_panic(vec[5] == true);
499 assert_or_panic(vec[6] == false);
500 assert_or_panic(vec[7] == true);
501}
502void c_test_vector_8_bool(void) {
503 Vector_8_bool vec = zig_ret_vector_8_bool();
504 assert_or_panic(vec[0] == false);
505 assert_or_panic(vec[1] == false);
506 assert_or_panic(vec[2] == false);
507 assert_or_panic(vec[3] == false);
508 assert_or_panic(vec[4] == true);
509 assert_or_panic(vec[5] == false);
510 assert_or_panic(vec[6] == false);
511 assert_or_panic(vec[7] == false);
512 zig_vector_8_bool((Vector_8_bool){
513 true,
514 true,
515 false,
516 true,
517 false,
518 true,
519 true,
520 false,
521 });
522}
523
524typedef bool Vector_16_bool __attribute__((ext_vector_type(16)));
525
526Vector_16_bool zig_ret_vector_16_bool(void);
527void zig_vector_16_bool(Vector_16_bool vec);
528
529Vector_16_bool c_ret_vector_16_bool(void) {
530 return (Vector_16_bool){
531 true,
532 true,
533 false,
534 false,
535 false,
536 false,
537 true,
538 false,
539 true,
540 false,
541 false,
542 true,
543 true,
544 false,
545 true,
546 true,
547 };
548}
549void c_vector_16_bool(Vector_16_bool vec) {
550 assert_or_panic(vec[0] == true);
551 assert_or_panic(vec[1] == false);
552 assert_or_panic(vec[2] == false);
553 assert_or_panic(vec[3] == false);
554 assert_or_panic(vec[4] == true);
555 assert_or_panic(vec[5] == false);
556 assert_or_panic(vec[6] == true);
557 assert_or_panic(vec[7] == true);
558 assert_or_panic(vec[8] == true);
559 assert_or_panic(vec[9] == true);
560 assert_or_panic(vec[10] == true);
561 assert_or_panic(vec[11] == true);
562 assert_or_panic(vec[12] == false);
563 assert_or_panic(vec[13] == false);
564 assert_or_panic(vec[14] == false);
565 assert_or_panic(vec[15] == false);
566}
567void c_test_vector_16_bool(void) {
568 Vector_16_bool vec = zig_ret_vector_16_bool();
569 assert_or_panic(vec[0] == false);
570 assert_or_panic(vec[1] == true);
571 assert_or_panic(vec[2] == false);
572 assert_or_panic(vec[3] == false);
573 assert_or_panic(vec[4] == false);
574 assert_or_panic(vec[5] == true);
575 assert_or_panic(vec[6] == false);
576 assert_or_panic(vec[7] == false);
577 assert_or_panic(vec[8] == true);
578 assert_or_panic(vec[9] == false);
579 assert_or_panic(vec[10] == false);
580 assert_or_panic(vec[11] == false);
581 assert_or_panic(vec[12] == false);
582 assert_or_panic(vec[13] == true);
583 assert_or_panic(vec[14] == false);
584 assert_or_panic(vec[15] == false);
585 zig_vector_16_bool((Vector_16_bool){
586 true,
587 false,
588 true,
589 true,
590 true,
591 false,
592 false,
593 false,
594 true,
595 true,
596 true,
597 true,
598 false,
599 false,
600 false,
601 true,
602 });
603}
604
605typedef bool Vector_32_bool __attribute__((ext_vector_type(32)));
606
607Vector_32_bool zig_ret_vector_32_bool(void);
608void zig_vector_32_bool(Vector_32_bool vec);
609
610Vector_32_bool c_ret_vector_32_bool(void) {
611 return (Vector_32_bool){
612 true,
613 false,
614 true,
615 true,
616 true,
617 false,
618 true,
619 false,
620 true,
621 true,
622 true,
623 false,
624 true,
625 true,
626 false,
627 false,
628 true,
629 false,
630 false,
631 false,
632 false,
633 true,
634 true,
635 true,
636 false,
637 true,
638 false,
639 false,
640 true,
641 false,
642 false,
643 false,
644 };
645}
646void c_vector_32_bool(Vector_32_bool vec) {
647 assert_or_panic(vec[0] == true);
648 assert_or_panic(vec[1] == false);
649 assert_or_panic(vec[2] == true);
650 assert_or_panic(vec[3] == true);
651 assert_or_panic(vec[4] == false);
652 assert_or_panic(vec[5] == false);
653 assert_or_panic(vec[6] == true);
654 assert_or_panic(vec[7] == false);
655 assert_or_panic(vec[8] == true);
656 assert_or_panic(vec[9] == false);
657 assert_or_panic(vec[10] == true);
658 assert_or_panic(vec[11] == true);
659 assert_or_panic(vec[12] == true);
660 assert_or_panic(vec[13] == false);
661 assert_or_panic(vec[14] == false);
662 assert_or_panic(vec[15] == true);
663 assert_or_panic(vec[16] == false);
664 assert_or_panic(vec[17] == true);
665 assert_or_panic(vec[18] == false);
666 assert_or_panic(vec[19] == true);
667 assert_or_panic(vec[20] == true);
668 assert_or_panic(vec[21] == true);
669 assert_or_panic(vec[22] == true);
670 assert_or_panic(vec[23] == true);
671 assert_or_panic(vec[24] == false);
672 assert_or_panic(vec[25] == true);
673 assert_or_panic(vec[26] == true);
674 assert_or_panic(vec[27] == true);
675 assert_or_panic(vec[28] == false);
676 assert_or_panic(vec[29] == true);
677 assert_or_panic(vec[30] == true);
678 assert_or_panic(vec[31] == false);
679}
680void c_test_vector_32_bool(void) {
681 Vector_32_bool vec = zig_ret_vector_32_bool();
682 assert_or_panic(vec[0] == false);
683 assert_or_panic(vec[1] == true);
684 assert_or_panic(vec[2] == false);
685 assert_or_panic(vec[3] == false);
686 assert_or_panic(vec[4] == true);
687 assert_or_panic(vec[5] == false);
688 assert_or_panic(vec[6] == true);
689 assert_or_panic(vec[7] == true);
690 assert_or_panic(vec[8] == true);
691 assert_or_panic(vec[9] == true);
692 assert_or_panic(vec[10] == true);
693 assert_or_panic(vec[11] == true);
694 assert_or_panic(vec[12] == false);
695 assert_or_panic(vec[13] == false);
696 assert_or_panic(vec[14] == false);
697 assert_or_panic(vec[15] == false);
698 assert_or_panic(vec[16] == false);
699 assert_or_panic(vec[17] == false);
700 assert_or_panic(vec[18] == true);
701 assert_or_panic(vec[19] == true);
702 assert_or_panic(vec[20] == true);
703 assert_or_panic(vec[21] == false);
704 assert_or_panic(vec[22] == true);
705 assert_or_panic(vec[23] == false);
706 assert_or_panic(vec[24] == true);
707 assert_or_panic(vec[25] == false);
708 assert_or_panic(vec[26] == false);
709 assert_or_panic(vec[27] == true);
710 assert_or_panic(vec[28] == false);
711 assert_or_panic(vec[29] == false);
712 assert_or_panic(vec[30] == true);
713 assert_or_panic(vec[31] == true);
714 zig_vector_32_bool((Vector_32_bool){
715 false,
716 false,
717 false,
718 true,
719 true,
720 false,
721 false,
722 true,
723 false,
724 true,
725 true,
726 true,
727 false,
728 false,
729 true,
730 true,
731 true,
732 true,
733 true,
734 false,
735 true,
736 true,
737 true,
738 false,
739 false,
740 true,
741 true,
742 false,
743 true,
744 true,
745 false,
746 true,
747 });
748}
749
750typedef bool Vector_64_bool __attribute__((ext_vector_type(64)));
751
752Vector_64_bool zig_ret_vector_64_bool(void);
753void zig_vector_64_bool(Vector_64_bool vec);
754
755Vector_64_bool c_ret_vector_64_bool(void) {
756 return (Vector_64_bool){
757 false,
758 true,
759 false,
760 true,
761 true,
762 true,
763 false,
764 true,
765 true,
766 true,
767 true,
768 true,
769 true,
770 false,
771 true,
772 true,
773 true,
774 false,
775 false,
776 false,
777 true,
778 true,
779 false,
780 true,
781 false,
782 true,
783 false,
784 true,
785 false,
786 true,
787 false,
788 true,
789 false,
790 false,
791 true,
792 true,
793 false,
794 false,
795 false,
796 true,
797 true,
798 true,
799 true,
800 false,
801 false,
802 false,
803 true,
804 true,
805 false,
806 false,
807 true,
808 false,
809 false,
810 false,
811 false,
812 true,
813 false,
814 false,
815 false,
816 true,
817 true,
818 true,
819 true,
820 true,
821 };
822}
823void c_vector_64_bool(Vector_64_bool vec) {
824 assert_or_panic(vec[0] == true);
825 assert_or_panic(vec[1] == true);
826 assert_or_panic(vec[2] == true);
827 assert_or_panic(vec[3] == false);
828 assert_or_panic(vec[4] == true);
829 assert_or_panic(vec[5] == false);
830 assert_or_panic(vec[6] == false);
831 assert_or_panic(vec[7] == false);
832 assert_or_panic(vec[8] == true);
833 assert_or_panic(vec[9] == false);
834 assert_or_panic(vec[10] == false);
835 assert_or_panic(vec[11] == false);
836 assert_or_panic(vec[12] == false);
837 assert_or_panic(vec[13] == true);
838 assert_or_panic(vec[14] == true);
839 assert_or_panic(vec[15] == true);
840 assert_or_panic(vec[16] == true);
841 assert_or_panic(vec[17] == false);
842 assert_or_panic(vec[18] == false);
843 assert_or_panic(vec[19] == true);
844 assert_or_panic(vec[20] == false);
845 assert_or_panic(vec[21] == true);
846 assert_or_panic(vec[22] == false);
847 assert_or_panic(vec[23] == true);
848 assert_or_panic(vec[24] == true);
849 assert_or_panic(vec[25] == true);
850 assert_or_panic(vec[26] == true);
851 assert_or_panic(vec[27] == true);
852 assert_or_panic(vec[28] == true);
853 assert_or_panic(vec[29] == true);
854 assert_or_panic(vec[30] == false);
855 assert_or_panic(vec[31] == false);
856 assert_or_panic(vec[32] == true);
857 assert_or_panic(vec[33] == true);
858 assert_or_panic(vec[34] == false);
859 assert_or_panic(vec[35] == true);
860 assert_or_panic(vec[36] == false);
861 assert_or_panic(vec[37] == false);
862 assert_or_panic(vec[38] == true);
863 assert_or_panic(vec[39] == true);
864 assert_or_panic(vec[40] == true);
865 assert_or_panic(vec[41] == false);
866 assert_or_panic(vec[42] == false);
867 assert_or_panic(vec[43] == true);
868 assert_or_panic(vec[44] == true);
869 assert_or_panic(vec[45] == false);
870 assert_or_panic(vec[46] == true);
871 assert_or_panic(vec[47] == false);
872 assert_or_panic(vec[48] == true);
873 assert_or_panic(vec[49] == false);
874 assert_or_panic(vec[50] == false);
875 assert_or_panic(vec[51] == true);
876 assert_or_panic(vec[52] == false);
877 assert_or_panic(vec[53] == true);
878 assert_or_panic(vec[54] == true);
879 assert_or_panic(vec[55] == true);
880 assert_or_panic(vec[56] == true);
881 assert_or_panic(vec[57] == true);
882 assert_or_panic(vec[58] == false);
883 assert_or_panic(vec[59] == false);
884 assert_or_panic(vec[60] == true);
885 assert_or_panic(vec[61] == false);
886 assert_or_panic(vec[62] == true);
887 assert_or_panic(vec[63] == false);
888}
889void c_test_vector_64_bool(void) {
890 Vector_64_bool vec = zig_ret_vector_64_bool();
891 assert_or_panic(vec[0] == true);
892 assert_or_panic(vec[1] == false);
893 assert_or_panic(vec[2] == true);
894 assert_or_panic(vec[3] == false);
895 assert_or_panic(vec[4] == false);
896 assert_or_panic(vec[5] == true);
897 assert_or_panic(vec[6] == false);
898 assert_or_panic(vec[7] == true);
899 assert_or_panic(vec[8] == true);
900 assert_or_panic(vec[9] == false);
901 assert_or_panic(vec[10] == true);
902 assert_or_panic(vec[11] == false);
903 assert_or_panic(vec[12] == true);
904 assert_or_panic(vec[13] == false);
905 assert_or_panic(vec[14] == false);
906 assert_or_panic(vec[15] == true);
907 assert_or_panic(vec[16] == false);
908 assert_or_panic(vec[17] == false);
909 assert_or_panic(vec[18] == true);
910 assert_or_panic(vec[19] == true);
911 assert_or_panic(vec[20] == false);
912 assert_or_panic(vec[21] == false);
913 assert_or_panic(vec[22] == true);
914 assert_or_panic(vec[23] == false);
915 assert_or_panic(vec[24] == false);
916 assert_or_panic(vec[25] == true);
917 assert_or_panic(vec[26] == true);
918 assert_or_panic(vec[27] == true);
919 assert_or_panic(vec[28] == true);
920 assert_or_panic(vec[29] == true);
921 assert_or_panic(vec[30] == false);
922 assert_or_panic(vec[31] == false);
923 assert_or_panic(vec[32] == true);
924 assert_or_panic(vec[33] == true);
925 assert_or_panic(vec[34] == true);
926 assert_or_panic(vec[35] == true);
927 assert_or_panic(vec[36] == false);
928 assert_or_panic(vec[37] == true);
929 assert_or_panic(vec[38] == false);
930 assert_or_panic(vec[39] == true);
931 assert_or_panic(vec[40] == true);
932 assert_or_panic(vec[41] == true);
933 assert_or_panic(vec[42] == true);
934 assert_or_panic(vec[43] == true);
935 assert_or_panic(vec[44] == false);
936 assert_or_panic(vec[45] == false);
937 assert_or_panic(vec[46] == false);
938 assert_or_panic(vec[47] == true);
939 assert_or_panic(vec[48] == true);
940 assert_or_panic(vec[49] == true);
941 assert_or_panic(vec[50] == false);
942 assert_or_panic(vec[51] == true);
943 assert_or_panic(vec[52] == true);
944 assert_or_panic(vec[53] == true);
945 assert_or_panic(vec[54] == false);
946 assert_or_panic(vec[55] == false);
947 assert_or_panic(vec[56] == false);
948 assert_or_panic(vec[57] == true);
949 assert_or_panic(vec[58] == false);
950 assert_or_panic(vec[59] == false);
951 assert_or_panic(vec[60] == true);
952 assert_or_panic(vec[61] == false);
953 assert_or_panic(vec[62] == true);
954 assert_or_panic(vec[63] == false);
955 zig_vector_64_bool((Vector_64_bool){
956 true,
957 true,
958 false,
959 true,
960 false,
961 true,
962 false,
963 false,
964 true,
965 true,
966 true,
967 true,
968 true,
969 true,
970 true,
971 false,
972 false,
973 true,
974 true,
975 false,
976 true,
977 true,
978 true,
979 true,
980 false,
981 false,
982 true,
983 false,
984 false,
985 true,
986 false,
987 true,
988 false,
989 true,
990 true,
991 false,
992 true,
993 true,
994 false,
995 false,
996 true,
997 true,
998 true,
999 true,
1000 true,
1001 false,
1002 true,
1003 false,
1004 false,
1005 false,
1006 false,
1007 false,
1008 true,
1009 false,
1010 false,
1011 true,
1012 true,
1013 false,
1014 false,
1015 false,
1016 true,
1017 true,
1018 true,
1019 true,
1020 });
1021}
1022
1023typedef bool Vector_128_bool __attribute__((ext_vector_type(128)));
1024
1025Vector_128_bool zig_ret_vector_128_bool(void);
1026void zig_vector_128_bool(Vector_128_bool vec);
1027
1028Vector_128_bool c_ret_vector_128_bool(void) {
1029 return (Vector_128_bool){
1030 false,
1031 true,
1032 true,
1033 false,
1034 true,
1035 false,
1036 false,
1037 true,
1038 true,
1039 false,
1040 true,
1041 false,
1042 false,
1043 false,
1044 true,
1045 false,
1046 true,
1047 false,
1048 false,
1049 true,
1050 false,
1051 true,
1052 false,
1053 false,
1054 false,
1055 true,
1056 true,
1057 true,
1058 false,
1059 false,
1060 false,
1061 false,
1062 true,
1063 true,
1064 true,
1065 false,
1066 true,
1067 true,
1068 false,
1069 false,
1070 false,
1071 false,
1072 true,
1073 true,
1074 true,
1075 false,
1076 false,
1077 false,
1078 false,
1079 true,
1080 false,
1081 false,
1082 true,
1083 false,
1084 false,
1085 false,
1086 false,
1087 false,
1088 true,
1089 true,
1090 true,
1091 false,
1092 true,
1093 true,
1094 false,
1095 false,
1096 false,
1097 false,
1098 false,
1099 false,
1100 false,
1101 false,
1102 true,
1103 true,
1104 true,
1105 true,
1106 true,
1107 false,
1108 false,
1109 false,
1110 false,
1111 false,
1112 false,
1113 true,
1114 false,
1115 true,
1116 false,
1117 true,
1118 false,
1119 true,
1120 false,
1121 true,
1122 true,
1123 true,
1124 true,
1125 false,
1126 false,
1127 true,
1128 false,
1129 false,
1130 true,
1131 true,
1132 true,
1133 true,
1134 false,
1135 true,
1136 true,
1137 true,
1138 false,
1139 false,
1140 true,
1141 false,
1142 false,
1143 true,
1144 true,
1145 false,
1146 true,
1147 false,
1148 true,
1149 true,
1150 true,
1151 true,
1152 true,
1153 false,
1154 false,
1155 true,
1156 false,
1157 true,
1158 };
1159}
1160void c_vector_128_bool(Vector_128_bool vec) {
1161 assert_or_panic(vec[0] == false);
1162 assert_or_panic(vec[1] == false);
1163 assert_or_panic(vec[2] == false);
1164 assert_or_panic(vec[3] == false);
1165 assert_or_panic(vec[4] == false);
1166 assert_or_panic(vec[5] == true);
1167 assert_or_panic(vec[6] == true);
1168 assert_or_panic(vec[7] == false);
1169 assert_or_panic(vec[8] == true);
1170 assert_or_panic(vec[9] == true);
1171 assert_or_panic(vec[10] == false);
1172 assert_or_panic(vec[11] == true);
1173 assert_or_panic(vec[12] == true);
1174 assert_or_panic(vec[13] == false);
1175 assert_or_panic(vec[14] == true);
1176 assert_or_panic(vec[15] == true);
1177 assert_or_panic(vec[16] == true);
1178 assert_or_panic(vec[17] == false);
1179 assert_or_panic(vec[18] == false);
1180 assert_or_panic(vec[19] == false);
1181 assert_or_panic(vec[20] == false);
1182 assert_or_panic(vec[21] == true);
1183 assert_or_panic(vec[22] == true);
1184 assert_or_panic(vec[23] == false);
1185 assert_or_panic(vec[24] == false);
1186 assert_or_panic(vec[25] == false);
1187 assert_or_panic(vec[26] == true);
1188 assert_or_panic(vec[27] == true);
1189 assert_or_panic(vec[28] == false);
1190 assert_or_panic(vec[29] == true);
1191 assert_or_panic(vec[30] == false);
1192 assert_or_panic(vec[31] == false);
1193 assert_or_panic(vec[32] == true);
1194 assert_or_panic(vec[33] == false);
1195 assert_or_panic(vec[34] == false);
1196 assert_or_panic(vec[35] == true);
1197 assert_or_panic(vec[36] == true);
1198 assert_or_panic(vec[37] == true);
1199 assert_or_panic(vec[38] == true);
1200 assert_or_panic(vec[39] == true);
1201 assert_or_panic(vec[40] == false);
1202 assert_or_panic(vec[41] == true);
1203 assert_or_panic(vec[42] == true);
1204 assert_or_panic(vec[43] == true);
1205 assert_or_panic(vec[44] == false);
1206 assert_or_panic(vec[45] == false);
1207 assert_or_panic(vec[46] == false);
1208 assert_or_panic(vec[47] == false);
1209 assert_or_panic(vec[48] == true);
1210 assert_or_panic(vec[49] == true);
1211 assert_or_panic(vec[50] == false);
1212 assert_or_panic(vec[51] == true);
1213 assert_or_panic(vec[52] == true);
1214 assert_or_panic(vec[53] == true);
1215 assert_or_panic(vec[54] == true);
1216 assert_or_panic(vec[55] == true);
1217 assert_or_panic(vec[56] == false);
1218 assert_or_panic(vec[57] == true);
1219 assert_or_panic(vec[58] == true);
1220 assert_or_panic(vec[59] == false);
1221 assert_or_panic(vec[60] == true);
1222 assert_or_panic(vec[61] == false);
1223 assert_or_panic(vec[62] == false);
1224 assert_or_panic(vec[63] == true);
1225 assert_or_panic(vec[64] == true);
1226 assert_or_panic(vec[65] == false);
1227 assert_or_panic(vec[66] == true);
1228 assert_or_panic(vec[67] == true);
1229 assert_or_panic(vec[68] == false);
1230 assert_or_panic(vec[69] == true);
1231 assert_or_panic(vec[70] == false);
1232 assert_or_panic(vec[71] == false);
1233 assert_or_panic(vec[72] == true);
1234 assert_or_panic(vec[73] == true);
1235 assert_or_panic(vec[74] == false);
1236 assert_or_panic(vec[75] == true);
1237 assert_or_panic(vec[76] == true);
1238 assert_or_panic(vec[77] == true);
1239 assert_or_panic(vec[78] == false);
1240 assert_or_panic(vec[79] == true);
1241 assert_or_panic(vec[80] == false);
1242 assert_or_panic(vec[81] == false);
1243 assert_or_panic(vec[82] == false);
1244 assert_or_panic(vec[83] == false);
1245 assert_or_panic(vec[84] == true);
1246 assert_or_panic(vec[85] == false);
1247 assert_or_panic(vec[86] == false);
1248 assert_or_panic(vec[87] == false);
1249 assert_or_panic(vec[88] == true);
1250 assert_or_panic(vec[89] == true);
1251 assert_or_panic(vec[90] == false);
1252 assert_or_panic(vec[91] == false);
1253 assert_or_panic(vec[92] == true);
1254 assert_or_panic(vec[93] == true);
1255 assert_or_panic(vec[94] == true);
1256 assert_or_panic(vec[95] == true);
1257 assert_or_panic(vec[96] == false);
1258 assert_or_panic(vec[97] == false);
1259 assert_or_panic(vec[98] == false);
1260 assert_or_panic(vec[99] == false);
1261 assert_or_panic(vec[100] == false);
1262 assert_or_panic(vec[101] == true);
1263 assert_or_panic(vec[102] == false);
1264 assert_or_panic(vec[103] == false);
1265 assert_or_panic(vec[104] == false);
1266 assert_or_panic(vec[105] == false);
1267 assert_or_panic(vec[106] == true);
1268 assert_or_panic(vec[107] == true);
1269 assert_or_panic(vec[108] == true);
1270 assert_or_panic(vec[109] == true);
1271 assert_or_panic(vec[110] == true);
1272 assert_or_panic(vec[111] == false);
1273 assert_or_panic(vec[112] == false);
1274 assert_or_panic(vec[113] == true);
1275 assert_or_panic(vec[114] == false);
1276 assert_or_panic(vec[115] == true);
1277 assert_or_panic(vec[116] == false);
1278 assert_or_panic(vec[117] == false);
1279 assert_or_panic(vec[118] == true);
1280 assert_or_panic(vec[119] == false);
1281 assert_or_panic(vec[120] == true);
1282 assert_or_panic(vec[121] == false);
1283 assert_or_panic(vec[122] == true);
1284 assert_or_panic(vec[123] == true);
1285 assert_or_panic(vec[124] == true);
1286 assert_or_panic(vec[125] == true);
1287 assert_or_panic(vec[126] == true);
1288 assert_or_panic(vec[127] == true);
1289}
1290void c_test_vector_128_bool(void) {
1291 Vector_128_bool vec = zig_ret_vector_128_bool();
1292 assert_or_panic(vec[0] == true);
1293 assert_or_panic(vec[1] == true);
1294 assert_or_panic(vec[2] == false);
1295 assert_or_panic(vec[3] == false);
1296 assert_or_panic(vec[4] == false);
1297 assert_or_panic(vec[5] == true);
1298 assert_or_panic(vec[6] == true);
1299 assert_or_panic(vec[7] == false);
1300 assert_or_panic(vec[8] == false);
1301 assert_or_panic(vec[9] == true);
1302 assert_or_panic(vec[10] == false);
1303 assert_or_panic(vec[11] == false);
1304 assert_or_panic(vec[12] == false);
1305 assert_or_panic(vec[13] == true);
1306 assert_or_panic(vec[14] == false);
1307 assert_or_panic(vec[15] == true);
1308 assert_or_panic(vec[16] == true);
1309 assert_or_panic(vec[17] == false);
1310 assert_or_panic(vec[18] == false);
1311 assert_or_panic(vec[19] == true);
1312 assert_or_panic(vec[20] == true);
1313 assert_or_panic(vec[21] == true);
1314 assert_or_panic(vec[22] == true);
1315 assert_or_panic(vec[23] == true);
1316 assert_or_panic(vec[24] == false);
1317 assert_or_panic(vec[25] == false);
1318 assert_or_panic(vec[26] == true);
1319 assert_or_panic(vec[27] == true);
1320 assert_or_panic(vec[28] == true);
1321 assert_or_panic(vec[29] == false);
1322 assert_or_panic(vec[30] == false);
1323 assert_or_panic(vec[31] == true);
1324 assert_or_panic(vec[32] == true);
1325 assert_or_panic(vec[33] == false);
1326 assert_or_panic(vec[34] == true);
1327 assert_or_panic(vec[35] == true);
1328 assert_or_panic(vec[36] == true);
1329 assert_or_panic(vec[37] == false);
1330 assert_or_panic(vec[38] == true);
1331 assert_or_panic(vec[39] == true);
1332 assert_or_panic(vec[40] == true);
1333 assert_or_panic(vec[41] == false);
1334 assert_or_panic(vec[42] == true);
1335 assert_or_panic(vec[43] == true);
1336 assert_or_panic(vec[44] == false);
1337 assert_or_panic(vec[45] == false);
1338 assert_or_panic(vec[46] == false);
1339 assert_or_panic(vec[47] == true);
1340 assert_or_panic(vec[48] == false);
1341 assert_or_panic(vec[49] == false);
1342 assert_or_panic(vec[50] == false);
1343 assert_or_panic(vec[51] == false);
1344 assert_or_panic(vec[52] == true);
1345 assert_or_panic(vec[53] == false);
1346 assert_or_panic(vec[54] == true);
1347 assert_or_panic(vec[55] == false);
1348 assert_or_panic(vec[56] == true);
1349 assert_or_panic(vec[57] == false);
1350 assert_or_panic(vec[58] == false);
1351 assert_or_panic(vec[59] == true);
1352 assert_or_panic(vec[60] == true);
1353 assert_or_panic(vec[61] == true);
1354 assert_or_panic(vec[62] == true);
1355 assert_or_panic(vec[63] == true);
1356 assert_or_panic(vec[64] == false);
1357 assert_or_panic(vec[65] == false);
1358 assert_or_panic(vec[66] == false);
1359 assert_or_panic(vec[67] == true);
1360 assert_or_panic(vec[68] == true);
1361 assert_or_panic(vec[69] == false);
1362 assert_or_panic(vec[70] == true);
1363 assert_or_panic(vec[71] == true);
1364 assert_or_panic(vec[72] == false);
1365 assert_or_panic(vec[73] == true);
1366 assert_or_panic(vec[74] == true);
1367 assert_or_panic(vec[75] == false);
1368 assert_or_panic(vec[76] == false);
1369 assert_or_panic(vec[77] == true);
1370 assert_or_panic(vec[78] == false);
1371 assert_or_panic(vec[79] == true);
1372 assert_or_panic(vec[80] == false);
1373 assert_or_panic(vec[81] == false);
1374 assert_or_panic(vec[82] == true);
1375 assert_or_panic(vec[83] == true);
1376 assert_or_panic(vec[84] == false);
1377 assert_or_panic(vec[85] == true);
1378 assert_or_panic(vec[86] == false);
1379 assert_or_panic(vec[87] == false);
1380 assert_or_panic(vec[88] == true);
1381 assert_or_panic(vec[89] == true);
1382 assert_or_panic(vec[90] == true);
1383 assert_or_panic(vec[91] == true);
1384 assert_or_panic(vec[92] == true);
1385 assert_or_panic(vec[93] == false);
1386 assert_or_panic(vec[94] == false);
1387 assert_or_panic(vec[95] == true);
1388 assert_or_panic(vec[96] == false);
1389 assert_or_panic(vec[97] == false);
1390 assert_or_panic(vec[98] == true);
1391 assert_or_panic(vec[99] == true);
1392 assert_or_panic(vec[100] == true);
1393 assert_or_panic(vec[101] == true);
1394 assert_or_panic(vec[102] == true);
1395 assert_or_panic(vec[103] == true);
1396 assert_or_panic(vec[104] == true);
1397 assert_or_panic(vec[105] == false);
1398 assert_or_panic(vec[106] == false);
1399 assert_or_panic(vec[107] == true);
1400 assert_or_panic(vec[108] == false);
1401 assert_or_panic(vec[109] == false);
1402 assert_or_panic(vec[110] == true);
1403 assert_or_panic(vec[111] == false);
1404 assert_or_panic(vec[112] == false);
1405 assert_or_panic(vec[113] == true);
1406 assert_or_panic(vec[114] == false);
1407 assert_or_panic(vec[115] == false);
1408 assert_or_panic(vec[116] == false);
1409 assert_or_panic(vec[117] == false);
1410 assert_or_panic(vec[118] == false);
1411 assert_or_panic(vec[119] == false);
1412 assert_or_panic(vec[120] == true);
1413 assert_or_panic(vec[121] == true);
1414 assert_or_panic(vec[122] == true);
1415 assert_or_panic(vec[123] == false);
1416 assert_or_panic(vec[124] == true);
1417 assert_or_panic(vec[125] == false);
1418 assert_or_panic(vec[126] == false);
1419 assert_or_panic(vec[127] == true);
1420 zig_vector_128_bool((Vector_128_bool){
1421 true,
1422 true,
1423 false,
1424 true,
1425 true,
1426 false,
1427 false,
1428 true,
1429 true,
1430 true,
1431 true,
1432 true,
1433 false,
1434 false,
1435 false,
1436 true,
1437 false,
1438 true,
1439 false,
1440 false,
1441 true,
1442 false,
1443 true,
1444 false,
1445 false,
1446 false,
1447 true,
1448 false,
1449 true,
1450 true,
1451 false,
1452 true,
1453 false,
1454 true,
1455 true,
1456 false,
1457 false,
1458 false,
1459 false,
1460 true,
1461 true,
1462 false,
1463 true,
1464 false,
1465 false,
1466 true,
1467 false,
1468 false,
1469 true,
1470 true,
1471 false,
1472 false,
1473 true,
1474 false,
1475 false,
1476 true,
1477 true,
1478 true,
1479 true,
1480 true,
1481 true,
1482 true,
1483 true,
1484 false,
1485 false,
1486 true,
1487 false,
1488 true,
1489 true,
1490 true,
1491 true,
1492 false,
1493 false,
1494 false,
1495 true,
1496 true,
1497 false,
1498 true,
1499 true,
1500 true,
1501 true,
1502 false,
1503 true,
1504 true,
1505 true,
1506 true,
1507 true,
1508 true,
1509 false,
1510 true,
1511 true,
1512 true,
1513 true,
1514 true,
1515 true,
1516 false,
1517 false,
1518 false,
1519 true,
1520 true,
1521 true,
1522 true,
1523 true,
1524 true,
1525 true,
1526 false,
1527 false,
1528 false,
1529 false,
1530 false,
1531 true,
1532 true,
1533 true,
1534 false,
1535 false,
1536 false,
1537 false,
1538 false,
1539 true,
1540 false,
1541 false,
1542 false,
1543 false,
1544 true,
1545 true,
1546 false,
1547 true,
1548 false,
1549 });
1550}
1551
1552typedef bool Vector_256_bool __attribute__((ext_vector_type(256)));
1553
1554Vector_256_bool zig_ret_vector_256_bool(void);
1555void zig_vector_256_bool(Vector_256_bool vec);
1556
1557Vector_256_bool c_ret_vector_256_bool(void) {
1558 return (Vector_256_bool){
1559 true,
1560 false,
1561 true,
1562 true,
1563 false,
1564 false,
1565 false,
1566 false,
1567 false,
1568 true,
1569 false,
1570 true,
1571 false,
1572 true,
1573 false,
1574 false,
1575 true,
1576 true,
1577 true,
1578 false,
1579 false,
1580 false,
1581 true,
1582 false,
1583 true,
1584 false,
1585 false,
1586 true,
1587 true,
1588 true,
1589 false,
1590 false,
1591 true,
1592 true,
1593 true,
1594 false,
1595 true,
1596 true,
1597 true,
1598 false,
1599 true,
1600 false,
1601 true,
1602 true,
1603 false,
1604 true,
1605 false,
1606 true,
1607 true,
1608 false,
1609 false,
1610 true,
1611 true,
1612 false,
1613 false,
1614 true,
1615 false,
1616 true,
1617 true,
1618 true,
1619 false,
1620 true,
1621 true,
1622 false,
1623 true,
1624 true,
1625 false,
1626 true,
1627 false,
1628 true,
1629 true,
1630 true,
1631 false,
1632 true,
1633 true,
1634 false,
1635 true,
1636 true,
1637 true,
1638 true,
1639 false,
1640 true,
1641 false,
1642 true,
1643 true,
1644 true,
1645 false,
1646 true,
1647 false,
1648 true,
1649 false,
1650 false,
1651 true,
1652 false,
1653 false,
1654 false,
1655 true,
1656 true,
1657 false,
1658 false,
1659 false,
1660 true,
1661 true,
1662 true,
1663 false,
1664 false,
1665 false,
1666 true,
1667 false,
1668 true,
1669 true,
1670 true,
1671 true,
1672 true,
1673 true,
1674 true,
1675 true,
1676 false,
1677 true,
1678 false,
1679 true,
1680 false,
1681 false,
1682 true,
1683 true,
1684 false,
1685 true,
1686 false,
1687 false,
1688 false,
1689 false,
1690 true,
1691 false,
1692 false,
1693 true,
1694 false,
1695 false,
1696 false,
1697 false,
1698 false,
1699 false,
1700 true,
1701 false,
1702 true,
1703 false,
1704 true,
1705 true,
1706 true,
1707 false,
1708 true,
1709 true,
1710 false,
1711 true,
1712 true,
1713 false,
1714 true,
1715 true,
1716 true,
1717 true,
1718 true,
1719 true,
1720 true,
1721 false,
1722 false,
1723 false,
1724 true,
1725 false,
1726 false,
1727 true,
1728 false,
1729 true,
1730 true,
1731 true,
1732 false,
1733 false,
1734 true,
1735 true,
1736 true,
1737 true,
1738 false,
1739 true,
1740 true,
1741 false,
1742 true,
1743 false,
1744 false,
1745 false,
1746 true,
1747 true,
1748 true,
1749 true,
1750 true,
1751 true,
1752 true,
1753 true,
1754 false,
1755 false,
1756 true,
1757 false,
1758 false,
1759 false,
1760 true,
1761 true,
1762 true,
1763 true,
1764 true,
1765 true,
1766 false,
1767 false,
1768 false,
1769 true,
1770 true,
1771 true,
1772 false,
1773 true,
1774 false,
1775 true,
1776 false,
1777 true,
1778 false,
1779 true,
1780 true,
1781 true,
1782 false,
1783 true,
1784 false,
1785 true,
1786 false,
1787 true,
1788 false,
1789 true,
1790 false,
1791 false,
1792 true,
1793 false,
1794 true,
1795 true,
1796 false,
1797 false,
1798 true,
1799 false,
1800 false,
1801 false,
1802 true,
1803 true,
1804 false,
1805 false,
1806 false,
1807 false,
1808 false,
1809 true,
1810 false,
1811 true,
1812 false,
1813 false,
1814 false,
1815 };
1816}
1817// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target.
1818#ifndef __wasm__
1819void c_vector_256_bool(Vector_256_bool vec) {
1820 assert_or_panic(vec[0] == false);
1821 assert_or_panic(vec[1] == true);
1822 assert_or_panic(vec[2] == true);
1823 assert_or_panic(vec[3] == false);
1824 assert_or_panic(vec[4] == false);
1825 assert_or_panic(vec[5] == true);
1826 assert_or_panic(vec[6] == true);
1827 assert_or_panic(vec[7] == true);
1828 assert_or_panic(vec[8] == false);
1829 assert_or_panic(vec[9] == true);
1830 assert_or_panic(vec[10] == true);
1831 assert_or_panic(vec[11] == true);
1832 assert_or_panic(vec[12] == false);
1833 assert_or_panic(vec[13] == true);
1834 assert_or_panic(vec[14] == false);
1835 assert_or_panic(vec[15] == true);
1836 assert_or_panic(vec[16] == false);
1837 assert_or_panic(vec[17] == false);
1838 assert_or_panic(vec[18] == true);
1839 assert_or_panic(vec[19] == true);
1840 assert_or_panic(vec[20] == false);
1841 assert_or_panic(vec[21] == true);
1842 assert_or_panic(vec[22] == false);
1843 assert_or_panic(vec[23] == false);
1844 assert_or_panic(vec[24] == false);
1845 assert_or_panic(vec[25] == true);
1846 assert_or_panic(vec[26] == true);
1847 assert_or_panic(vec[27] == false);
1848 assert_or_panic(vec[28] == false);
1849 assert_or_panic(vec[29] == true);
1850 assert_or_panic(vec[30] == true);
1851 assert_or_panic(vec[31] == false);
1852 assert_or_panic(vec[32] == true);
1853 assert_or_panic(vec[33] == false);
1854 assert_or_panic(vec[34] == false);
1855 assert_or_panic(vec[35] == true);
1856 assert_or_panic(vec[36] == false);
1857 assert_or_panic(vec[37] == true);
1858 assert_or_panic(vec[38] == false);
1859 assert_or_panic(vec[39] == true);
1860 assert_or_panic(vec[40] == true);
1861 assert_or_panic(vec[41] == true);
1862 assert_or_panic(vec[42] == true);
1863 assert_or_panic(vec[43] == false);
1864 assert_or_panic(vec[44] == false);
1865 assert_or_panic(vec[45] == true);
1866 assert_or_panic(vec[46] == false);
1867 assert_or_panic(vec[47] == false);
1868 assert_or_panic(vec[48] == false);
1869 assert_or_panic(vec[49] == false);
1870 assert_or_panic(vec[50] == false);
1871 assert_or_panic(vec[51] == false);
1872 assert_or_panic(vec[52] == true);
1873 assert_or_panic(vec[53] == true);
1874 assert_or_panic(vec[54] == true);
1875 assert_or_panic(vec[55] == true);
1876 assert_or_panic(vec[56] == true);
1877 assert_or_panic(vec[57] == true);
1878 assert_or_panic(vec[58] == false);
1879 assert_or_panic(vec[59] == true);
1880 assert_or_panic(vec[60] == true);
1881 assert_or_panic(vec[61] == false);
1882 assert_or_panic(vec[62] == false);
1883 assert_or_panic(vec[63] == true);
1884 assert_or_panic(vec[64] == false);
1885 assert_or_panic(vec[65] == false);
1886 assert_or_panic(vec[66] == false);
1887 assert_or_panic(vec[67] == false);
1888 assert_or_panic(vec[68] == false);
1889 assert_or_panic(vec[69] == false);
1890 assert_or_panic(vec[70] == true);
1891 assert_or_panic(vec[71] == true);
1892 assert_or_panic(vec[72] == true);
1893 assert_or_panic(vec[73] == false);
1894 assert_or_panic(vec[74] == false);
1895 assert_or_panic(vec[75] == false);
1896 assert_or_panic(vec[76] == true);
1897 assert_or_panic(vec[77] == false);
1898 assert_or_panic(vec[78] == true);
1899 assert_or_panic(vec[79] == true);
1900 assert_or_panic(vec[80] == false);
1901 assert_or_panic(vec[81] == false);
1902 assert_or_panic(vec[82] == true);
1903 assert_or_panic(vec[83] == true);
1904 assert_or_panic(vec[84] == false);
1905 assert_or_panic(vec[85] == true);
1906 assert_or_panic(vec[86] == true);
1907 assert_or_panic(vec[87] == true);
1908 assert_or_panic(vec[88] == true);
1909 assert_or_panic(vec[89] == true);
1910 assert_or_panic(vec[90] == true);
1911 assert_or_panic(vec[91] == true);
1912 assert_or_panic(vec[92] == false);
1913 assert_or_panic(vec[93] == true);
1914 assert_or_panic(vec[94] == true);
1915 assert_or_panic(vec[95] == false);
1916 assert_or_panic(vec[96] == false);
1917 assert_or_panic(vec[97] == true);
1918 assert_or_panic(vec[98] == true);
1919 assert_or_panic(vec[99] == false);
1920 assert_or_panic(vec[100] == true);
1921 assert_or_panic(vec[101] == false);
1922 assert_or_panic(vec[102] == false);
1923 assert_or_panic(vec[103] == true);
1924 assert_or_panic(vec[104] == false);
1925 assert_or_panic(vec[105] == true);
1926 assert_or_panic(vec[106] == true);
1927 assert_or_panic(vec[107] == true);
1928 assert_or_panic(vec[108] == true);
1929 assert_or_panic(vec[109] == true);
1930 assert_or_panic(vec[110] == false);
1931 assert_or_panic(vec[111] == false);
1932 assert_or_panic(vec[112] == false);
1933 assert_or_panic(vec[113] == false);
1934 assert_or_panic(vec[114] == true);
1935 assert_or_panic(vec[115] == true);
1936 assert_or_panic(vec[116] == false);
1937 assert_or_panic(vec[117] == true);
1938 assert_or_panic(vec[118] == false);
1939 assert_or_panic(vec[119] == false);
1940 assert_or_panic(vec[120] == true);
1941 assert_or_panic(vec[121] == false);
1942 assert_or_panic(vec[122] == false);
1943 assert_or_panic(vec[123] == true);
1944 assert_or_panic(vec[124] == false);
1945 assert_or_panic(vec[125] == true);
1946 assert_or_panic(vec[126] == true);
1947 assert_or_panic(vec[127] == true);
1948 assert_or_panic(vec[128] == true);
1949 assert_or_panic(vec[129] == false);
1950 assert_or_panic(vec[130] == true);
1951 assert_or_panic(vec[131] == true);
1952 assert_or_panic(vec[132] == false);
1953 assert_or_panic(vec[133] == false);
1954 assert_or_panic(vec[134] == true);
1955 assert_or_panic(vec[135] == false);
1956 assert_or_panic(vec[136] == false);
1957 assert_or_panic(vec[137] == true);
1958 assert_or_panic(vec[138] == false);
1959 assert_or_panic(vec[139] == true);
1960 assert_or_panic(vec[140] == false);
1961 assert_or_panic(vec[141] == true);
1962 assert_or_panic(vec[142] == true);
1963 assert_or_panic(vec[143] == true);
1964 assert_or_panic(vec[144] == true);
1965 assert_or_panic(vec[145] == false);
1966 assert_or_panic(vec[146] == true);
1967 assert_or_panic(vec[147] == false);
1968 assert_or_panic(vec[148] == false);
1969 assert_or_panic(vec[149] == false);
1970 assert_or_panic(vec[150] == true);
1971 assert_or_panic(vec[151] == true);
1972 assert_or_panic(vec[152] == true);
1973 assert_or_panic(vec[153] == true);
1974 assert_or_panic(vec[154] == true);
1975 assert_or_panic(vec[155] == false);
1976 assert_or_panic(vec[156] == true);
1977 assert_or_panic(vec[157] == false);
1978 assert_or_panic(vec[158] == false);
1979 assert_or_panic(vec[159] == false);
1980 assert_or_panic(vec[160] == true);
1981 assert_or_panic(vec[161] == true);
1982 assert_or_panic(vec[162] == false);
1983 assert_or_panic(vec[163] == true);
1984 assert_or_panic(vec[164] == true);
1985 assert_or_panic(vec[165] == false);
1986 assert_or_panic(vec[166] == false);
1987 assert_or_panic(vec[167] == false);
1988 assert_or_panic(vec[168] == false);
1989 assert_or_panic(vec[169] == true);
1990 assert_or_panic(vec[170] == false);
1991 assert_or_panic(vec[171] == true);
1992 assert_or_panic(vec[172] == false);
1993 assert_or_panic(vec[173] == false);
1994 assert_or_panic(vec[174] == false);
1995 assert_or_panic(vec[175] == false);
1996 assert_or_panic(vec[176] == true);
1997 assert_or_panic(vec[177] == true);
1998 assert_or_panic(vec[178] == true);
1999 assert_or_panic(vec[179] == false);
2000 assert_or_panic(vec[180] == true);
2001 assert_or_panic(vec[181] == false);
2002 assert_or_panic(vec[182] == true);
2003 assert_or_panic(vec[183] == true);
2004 assert_or_panic(vec[184] == false);
2005 assert_or_panic(vec[185] == false);
2006 assert_or_panic(vec[186] == true);
2007 assert_or_panic(vec[187] == false);
2008 assert_or_panic(vec[188] == false);
2009 assert_or_panic(vec[189] == false);
2010 assert_or_panic(vec[190] == false);
2011 assert_or_panic(vec[191] == true);
2012 assert_or_panic(vec[192] == true);
2013 assert_or_panic(vec[193] == true);
2014 assert_or_panic(vec[194] == true);
2015 assert_or_panic(vec[195] == true);
2016 assert_or_panic(vec[196] == true);
2017 assert_or_panic(vec[197] == true);
2018 assert_or_panic(vec[198] == false);
2019 assert_or_panic(vec[199] == true);
2020 assert_or_panic(vec[200] == false);
2021 assert_or_panic(vec[201] == false);
2022 assert_or_panic(vec[202] == true);
2023 assert_or_panic(vec[203] == false);
2024 assert_or_panic(vec[204] == true);
2025 assert_or_panic(vec[205] == true);
2026 assert_or_panic(vec[206] == true);
2027 assert_or_panic(vec[207] == false);
2028 assert_or_panic(vec[208] == false);
2029 assert_or_panic(vec[209] == true);
2030 assert_or_panic(vec[210] == true);
2031 assert_or_panic(vec[211] == true);
2032 assert_or_panic(vec[212] == false);
2033 assert_or_panic(vec[213] == true);
2034 assert_or_panic(vec[214] == true);
2035 assert_or_panic(vec[215] == true);
2036 assert_or_panic(vec[216] == true);
2037 assert_or_panic(vec[217] == true);
2038 assert_or_panic(vec[218] == false);
2039 assert_or_panic(vec[219] == false);
2040 assert_or_panic(vec[220] == false);
2041 assert_or_panic(vec[221] == false);
2042 assert_or_panic(vec[222] == false);
2043 assert_or_panic(vec[223] == true);
2044 assert_or_panic(vec[224] == true);
2045 assert_or_panic(vec[225] == false);
2046 assert_or_panic(vec[226] == true);
2047 assert_or_panic(vec[227] == false);
2048 assert_or_panic(vec[228] == false);
2049 assert_or_panic(vec[229] == true);
2050 assert_or_panic(vec[230] == false);
2051 assert_or_panic(vec[231] == true);
2052 assert_or_panic(vec[232] == false);
2053 assert_or_panic(vec[233] == false);
2054 assert_or_panic(vec[234] == false);
2055 assert_or_panic(vec[235] == true);
2056 assert_or_panic(vec[236] == false);
2057 assert_or_panic(vec[237] == false);
2058 assert_or_panic(vec[238] == false);
2059 assert_or_panic(vec[239] == true);
2060 assert_or_panic(vec[240] == true);
2061 assert_or_panic(vec[241] == true);
2062 assert_or_panic(vec[242] == true);
2063 assert_or_panic(vec[243] == true);
2064 assert_or_panic(vec[244] == true);
2065 assert_or_panic(vec[245] == false);
2066 assert_or_panic(vec[246] == false);
2067 assert_or_panic(vec[247] == true);
2068 assert_or_panic(vec[248] == false);
2069 assert_or_panic(vec[249] == true);
2070 assert_or_panic(vec[250] == true);
2071 assert_or_panic(vec[251] == false);
2072 assert_or_panic(vec[252] == true);
2073 assert_or_panic(vec[253] == true);
2074 assert_or_panic(vec[254] == true);
2075 assert_or_panic(vec[255] == false);
2076}
2077#endif
2078void c_test_vector_256_bool(void) {
2079 Vector_256_bool vec = zig_ret_vector_256_bool();
2080 assert_or_panic(vec[0] == true);
2081 assert_or_panic(vec[1] == true);
2082 assert_or_panic(vec[2] == true);
2083 assert_or_panic(vec[3] == false);
2084 assert_or_panic(vec[4] == true);
2085 assert_or_panic(vec[5] == false);
2086 assert_or_panic(vec[6] == false);
2087 assert_or_panic(vec[7] == true);
2088 assert_or_panic(vec[8] == false);
2089 assert_or_panic(vec[9] == false);
2090 assert_or_panic(vec[10] == false);
2091 assert_or_panic(vec[11] == false);
2092 assert_or_panic(vec[12] == false);
2093 assert_or_panic(vec[13] == false);
2094 assert_or_panic(vec[14] == false);
2095 assert_or_panic(vec[15] == false);
2096 assert_or_panic(vec[16] == true);
2097 assert_or_panic(vec[17] == false);
2098 assert_or_panic(vec[18] == true);
2099 assert_or_panic(vec[19] == false);
2100 assert_or_panic(vec[20] == false);
2101 assert_or_panic(vec[21] == true);
2102 assert_or_panic(vec[22] == true);
2103 assert_or_panic(vec[23] == false);
2104 assert_or_panic(vec[24] == false);
2105 assert_or_panic(vec[25] == true);
2106 assert_or_panic(vec[26] == true);
2107 assert_or_panic(vec[27] == false);
2108 assert_or_panic(vec[28] == true);
2109 assert_or_panic(vec[29] == true);
2110 assert_or_panic(vec[30] == true);
2111 assert_or_panic(vec[31] == false);
2112 assert_or_panic(vec[32] == true);
2113 assert_or_panic(vec[33] == false);
2114 assert_or_panic(vec[34] == true);
2115 assert_or_panic(vec[35] == false);
2116 assert_or_panic(vec[36] == true);
2117 assert_or_panic(vec[37] == false);
2118 assert_or_panic(vec[38] == true);
2119 assert_or_panic(vec[39] == false);
2120 assert_or_panic(vec[40] == false);
2121 assert_or_panic(vec[41] == false);
2122 assert_or_panic(vec[42] == true);
2123 assert_or_panic(vec[43] == true);
2124 assert_or_panic(vec[44] == true);
2125 assert_or_panic(vec[45] == false);
2126 assert_or_panic(vec[46] == false);
2127 assert_or_panic(vec[47] == false);
2128 assert_or_panic(vec[48] == true);
2129 assert_or_panic(vec[49] == false);
2130 assert_or_panic(vec[50] == true);
2131 assert_or_panic(vec[51] == false);
2132 assert_or_panic(vec[52] == true);
2133 assert_or_panic(vec[53] == false);
2134 assert_or_panic(vec[54] == true);
2135 assert_or_panic(vec[55] == true);
2136 assert_or_panic(vec[56] == false);
2137 assert_or_panic(vec[57] == false);
2138 assert_or_panic(vec[58] == false);
2139 assert_or_panic(vec[59] == true);
2140 assert_or_panic(vec[60] == true);
2141 assert_or_panic(vec[61] == true);
2142 assert_or_panic(vec[62] == false);
2143 assert_or_panic(vec[63] == true);
2144 assert_or_panic(vec[64] == false);
2145 assert_or_panic(vec[65] == true);
2146 assert_or_panic(vec[66] == false);
2147 assert_or_panic(vec[67] == true);
2148 assert_or_panic(vec[68] == true);
2149 assert_or_panic(vec[69] == false);
2150 assert_or_panic(vec[70] == true);
2151 assert_or_panic(vec[71] == false);
2152 assert_or_panic(vec[72] == true);
2153 assert_or_panic(vec[73] == true);
2154 assert_or_panic(vec[74] == false);
2155 assert_or_panic(vec[75] == false);
2156 assert_or_panic(vec[76] == false);
2157 assert_or_panic(vec[77] == false);
2158 assert_or_panic(vec[78] == false);
2159 assert_or_panic(vec[79] == false);
2160 assert_or_panic(vec[80] == false);
2161 assert_or_panic(vec[81] == false);
2162 assert_or_panic(vec[82] == false);
2163 assert_or_panic(vec[83] == true);
2164 assert_or_panic(vec[84] == false);
2165 assert_or_panic(vec[85] == false);
2166 assert_or_panic(vec[86] == false);
2167 assert_or_panic(vec[87] == true);
2168 assert_or_panic(vec[88] == false);
2169 assert_or_panic(vec[89] == true);
2170 assert_or_panic(vec[90] == true);
2171 assert_or_panic(vec[91] == false);
2172 assert_or_panic(vec[92] == false);
2173 assert_or_panic(vec[93] == true);
2174 assert_or_panic(vec[94] == true);
2175 assert_or_panic(vec[95] == false);
2176 assert_or_panic(vec[96] == false);
2177 assert_or_panic(vec[97] == true);
2178 assert_or_panic(vec[98] == false);
2179 assert_or_panic(vec[99] == false);
2180 assert_or_panic(vec[100] == false);
2181 assert_or_panic(vec[101] == false);
2182 assert_or_panic(vec[102] == false);
2183 assert_or_panic(vec[103] == false);
2184 assert_or_panic(vec[104] == false);
2185 assert_or_panic(vec[105] == true);
2186 assert_or_panic(vec[106] == true);
2187 assert_or_panic(vec[107] == false);
2188 assert_or_panic(vec[108] == true);
2189 assert_or_panic(vec[109] == false);
2190 assert_or_panic(vec[110] == true);
2191 assert_or_panic(vec[111] == true);
2192 assert_or_panic(vec[112] == false);
2193 assert_or_panic(vec[113] == false);
2194 assert_or_panic(vec[114] == false);
2195 assert_or_panic(vec[115] == false);
2196 assert_or_panic(vec[116] == false);
2197 assert_or_panic(vec[117] == false);
2198 assert_or_panic(vec[118] == false);
2199 assert_or_panic(vec[119] == true);
2200 assert_or_panic(vec[120] == true);
2201 assert_or_panic(vec[121] == true);
2202 assert_or_panic(vec[122] == false);
2203 assert_or_panic(vec[123] == true);
2204 assert_or_panic(vec[124] == true);
2205 assert_or_panic(vec[125] == false);
2206 assert_or_panic(vec[126] == false);
2207 assert_or_panic(vec[127] == true);
2208 assert_or_panic(vec[128] == true);
2209 assert_or_panic(vec[129] == true);
2210 assert_or_panic(vec[130] == true);
2211 assert_or_panic(vec[131] == true);
2212 assert_or_panic(vec[132] == false);
2213 assert_or_panic(vec[133] == true);
2214 assert_or_panic(vec[134] == true);
2215 assert_or_panic(vec[135] == false);
2216 assert_or_panic(vec[136] == false);
2217 assert_or_panic(vec[137] == true);
2218 assert_or_panic(vec[138] == true);
2219 assert_or_panic(vec[139] == false);
2220 assert_or_panic(vec[140] == true);
2221 assert_or_panic(vec[141] == false);
2222 assert_or_panic(vec[142] == true);
2223 assert_or_panic(vec[143] == false);
2224 assert_or_panic(vec[144] == true);
2225 assert_or_panic(vec[145] == true);
2226 assert_or_panic(vec[146] == true);
2227 assert_or_panic(vec[147] == true);
2228 assert_or_panic(vec[148] == false);
2229 assert_or_panic(vec[149] == false);
2230 assert_or_panic(vec[150] == false);
2231 assert_or_panic(vec[151] == true);
2232 assert_or_panic(vec[152] == false);
2233 assert_or_panic(vec[153] == true);
2234 assert_or_panic(vec[154] == false);
2235 assert_or_panic(vec[155] == true);
2236 assert_or_panic(vec[156] == true);
2237 assert_or_panic(vec[157] == false);
2238 assert_or_panic(vec[158] == true);
2239 assert_or_panic(vec[159] == true);
2240 assert_or_panic(vec[160] == true);
2241 assert_or_panic(vec[161] == true);
2242 assert_or_panic(vec[162] == true);
2243 assert_or_panic(vec[163] == false);
2244 assert_or_panic(vec[164] == false);
2245 assert_or_panic(vec[165] == true);
2246 assert_or_panic(vec[166] == false);
2247 assert_or_panic(vec[167] == true);
2248 assert_or_panic(vec[168] == true);
2249 assert_or_panic(vec[169] == true);
2250 assert_or_panic(vec[170] == true);
2251 assert_or_panic(vec[171] == false);
2252 assert_or_panic(vec[172] == true);
2253 assert_or_panic(vec[173] == true);
2254 assert_or_panic(vec[174] == true);
2255 assert_or_panic(vec[175] == true);
2256 assert_or_panic(vec[176] == true);
2257 assert_or_panic(vec[177] == true);
2258 assert_or_panic(vec[178] == true);
2259 assert_or_panic(vec[179] == false);
2260 assert_or_panic(vec[180] == true);
2261 assert_or_panic(vec[181] == false);
2262 assert_or_panic(vec[182] == false);
2263 assert_or_panic(vec[183] == false);
2264 assert_or_panic(vec[184] == true);
2265 assert_or_panic(vec[185] == false);
2266 assert_or_panic(vec[186] == true);
2267 assert_or_panic(vec[187] == true);
2268 assert_or_panic(vec[188] == false);
2269 assert_or_panic(vec[189] == true);
2270 assert_or_panic(vec[190] == false);
2271 assert_or_panic(vec[191] == true);
2272 assert_or_panic(vec[192] == false);
2273 assert_or_panic(vec[193] == true);
2274 assert_or_panic(vec[194] == false);
2275 assert_or_panic(vec[195] == false);
2276 assert_or_panic(vec[196] == true);
2277 assert_or_panic(vec[197] == true);
2278 assert_or_panic(vec[198] == true);
2279 assert_or_panic(vec[199] == true);
2280 assert_or_panic(vec[200] == true);
2281 assert_or_panic(vec[201] == true);
2282 assert_or_panic(vec[202] == true);
2283 assert_or_panic(vec[203] == false);
2284 assert_or_panic(vec[204] == true);
2285 assert_or_panic(vec[205] == false);
2286 assert_or_panic(vec[206] == false);
2287 assert_or_panic(vec[207] == true);
2288 assert_or_panic(vec[208] == true);
2289 assert_or_panic(vec[209] == false);
2290 assert_or_panic(vec[210] == false);
2291 assert_or_panic(vec[211] == false);
2292 assert_or_panic(vec[212] == true);
2293 assert_or_panic(vec[213] == true);
2294 assert_or_panic(vec[214] == true);
2295 assert_or_panic(vec[215] == false);
2296 assert_or_panic(vec[216] == false);
2297 assert_or_panic(vec[217] == true);
2298 assert_or_panic(vec[218] == true);
2299 assert_or_panic(vec[219] == true);
2300 assert_or_panic(vec[220] == true);
2301 assert_or_panic(vec[221] == false);
2302 assert_or_panic(vec[222] == true);
2303 assert_or_panic(vec[223] == false);
2304 assert_or_panic(vec[224] == true);
2305 assert_or_panic(vec[225] == true);
2306 assert_or_panic(vec[226] == true);
2307 assert_or_panic(vec[227] == false);
2308 assert_or_panic(vec[228] == false);
2309 assert_or_panic(vec[229] == false);
2310 assert_or_panic(vec[230] == false);
2311 assert_or_panic(vec[231] == false);
2312 assert_or_panic(vec[232] == true);
2313 assert_or_panic(vec[233] == true);
2314 assert_or_panic(vec[234] == false);
2315 assert_or_panic(vec[235] == false);
2316 assert_or_panic(vec[236] == false);
2317 assert_or_panic(vec[237] == true);
2318 assert_or_panic(vec[238] == true);
2319 assert_or_panic(vec[239] == false);
2320 assert_or_panic(vec[240] == true);
2321 assert_or_panic(vec[241] == true);
2322 assert_or_panic(vec[242] == true);
2323 assert_or_panic(vec[243] == false);
2324 assert_or_panic(vec[244] == true);
2325 assert_or_panic(vec[245] == true);
2326 assert_or_panic(vec[246] == false);
2327 assert_or_panic(vec[247] == true);
2328 assert_or_panic(vec[248] == false);
2329 assert_or_panic(vec[249] == false);
2330 assert_or_panic(vec[250] == true);
2331 assert_or_panic(vec[251] == true);
2332 assert_or_panic(vec[252] == false);
2333 assert_or_panic(vec[253] == true);
2334 assert_or_panic(vec[254] == false);
2335 assert_or_panic(vec[255] == true);
2336 zig_vector_256_bool((Vector_256_bool){
2337 false,
2338 false,
2339 false,
2340 false,
2341 true,
2342 true,
2343 false,
2344 false,
2345 false,
2346 true,
2347 true,
2348 false,
2349 true,
2350 false,
2351 false,
2352 false,
2353 false,
2354 true,
2355 true,
2356 true,
2357 false,
2358 true,
2359 true,
2360 false,
2361 true,
2362 false,
2363 false,
2364 true,
2365 true,
2366 true,
2367 false,
2368 true,
2369 false,
2370 true,
2371 false,
2372 false,
2373 false,
2374 true,
2375 false,
2376 false,
2377 true,
2378 true,
2379 false,
2380 true,
2381 true,
2382 false,
2383 true,
2384 false,
2385 true,
2386 false,
2387 true,
2388 false,
2389 true,
2390 true,
2391 true,
2392 false,
2393 false,
2394 true,
2395 true,
2396 false,
2397 false,
2398 true,
2399 true,
2400 false,
2401 false,
2402 false,
2403 true,
2404 true,
2405 false,
2406 true,
2407 false,
2408 true,
2409 false,
2410 true,
2411 false,
2412 false,
2413 true,
2414 false,
2415 false,
2416 false,
2417 false,
2418 false,
2419 true,
2420 false,
2421 false,
2422 false,
2423 true,
2424 true,
2425 true,
2426 false,
2427 true,
2428 false,
2429 true,
2430 false,
2431 true,
2432 true,
2433 true,
2434 true,
2435 false,
2436 true,
2437 false,
2438 true,
2439 true,
2440 false,
2441 false,
2442 true,
2443 false,
2444 true,
2445 false,
2446 false,
2447 false,
2448 false,
2449 false,
2450 false,
2451 false,
2452 false,
2453 false,
2454 false,
2455 false,
2456 false,
2457 false,
2458 false,
2459 true,
2460 true,
2461 false,
2462 false,
2463 false,
2464 true,
2465 true,
2466 true,
2467 true,
2468 false,
2469 false,
2470 false,
2471 true,
2472 true,
2473 false,
2474 false,
2475 true,
2476 true,
2477 true,
2478 true,
2479 true,
2480 false,
2481 true,
2482 true,
2483 true,
2484 false,
2485 false,
2486 false,
2487 false,
2488 false,
2489 false,
2490 false,
2491 true,
2492 false,
2493 false,
2494 false,
2495 true,
2496 true,
2497 false,
2498 true,
2499 false,
2500 false,
2501 false,
2502 true,
2503 false,
2504 true,
2505 false,
2506 false,
2507 false,
2508 false,
2509 true,
2510 true,
2511 true,
2512 true,
2513 true,
2514 true,
2515 false,
2516 true,
2517 true,
2518 false,
2519 true,
2520 false,
2521 true,
2522 false,
2523 true,
2524 false,
2525 true,
2526 false,
2527 false,
2528 false,
2529 false,
2530 true,
2531 true,
2532 true,
2533 false,
2534 false,
2535 true,
2536 false,
2537 false,
2538 true,
2539 true,
2540 false,
2541 true,
2542 false,
2543 true,
2544 false,
2545 false,
2546 false,
2547 true,
2548 true,
2549 false,
2550 false,
2551 false,
2552 true,
2553 false,
2554 true,
2555 true,
2556 true,
2557 false,
2558 true,
2559 false,
2560 true,
2561 false,
2562 false,
2563 false,
2564 true,
2565 true,
2566 false,
2567 false,
2568 false,
2569 false,
2570 false,
2571 true,
2572 false,
2573 false,
2574 false,
2575 true,
2576 false,
2577 true,
2578 true,
2579 true,
2580 false,
2581 false,
2582 true,
2583 false,
2584 false,
2585 false,
2586 true,
2587 false,
2588 false,
2589 true,
2590 true,
2591 true,
2592 true,
2593 });
2594}
2595
2596typedef bool Vector_512_bool __attribute__((ext_vector_type(512)));
2597
2598Vector_512_bool zig_ret_vector_512_bool(void);
2599void zig_vector_512_bool(Vector_512_bool vec);
2600
2601Vector_512_bool c_ret_vector_512_bool(void) {
2602 return (Vector_512_bool){
2603 false,
2604 true,
2605 false,
2606 false,
2607 false,
2608 true,
2609 false,
2610 false,
2611 false,
2612 true,
2613 false,
2614 false,
2615 false,
2616 true,
2617 false,
2618 true,
2619 false,
2620 false,
2621 false,
2622 false,
2623 false,
2624 false,
2625 true,
2626 true,
2627 false,
2628 false,
2629 false,
2630 false,
2631 true,
2632 true,
2633 false,
2634 true,
2635 false,
2636 true,
2637 true,
2638 true,
2639 false,
2640 false,
2641 true,
2642 true,
2643 false,
2644 false,
2645 false,
2646 false,
2647 false,
2648 true,
2649 false,
2650 true,
2651 true,
2652 false,
2653 true,
2654 true,
2655 true,
2656 true,
2657 false,
2658 false,
2659 false,
2660 true,
2661 true,
2662 false,
2663 false,
2664 false,
2665 false,
2666 true,
2667 true,
2668 true,
2669 true,
2670 true,
2671 false,
2672 false,
2673 false,
2674 false,
2675 false,
2676 true,
2677 false,
2678 true,
2679 false,
2680 false,
2681 true,
2682 true,
2683 false,
2684 false,
2685 false,
2686 true,
2687 false,
2688 true,
2689 true,
2690 true,
2691 false,
2692 true,
2693 false,
2694 false,
2695 true,
2696 true,
2697 false,
2698 true,
2699 true,
2700 false,
2701 true,
2702 false,
2703 true,
2704 true,
2705 false,
2706 true,
2707 true,
2708 false,
2709 false,
2710 false,
2711 true,
2712 false,
2713 false,
2714 false,
2715 true,
2716 true,
2717 true,
2718 false,
2719 true,
2720 false,
2721 true,
2722 false,
2723 true,
2724 true,
2725 false,
2726 true,
2727 false,
2728 true,
2729 true,
2730 true,
2731 false,
2732 true,
2733 false,
2734 false,
2735 false,
2736 false,
2737 false,
2738 false,
2739 true,
2740 false,
2741 true,
2742 false,
2743 true,
2744 true,
2745 false,
2746 true,
2747 false,
2748 false,
2749 true,
2750 false,
2751 false,
2752 true,
2753 false,
2754 true,
2755 false,
2756 true,
2757 false,
2758 false,
2759 true,
2760 false,
2761 true,
2762 true,
2763 true,
2764 false,
2765 false,
2766 true,
2767 false,
2768 false,
2769 false,
2770 true,
2771 true,
2772 true,
2773 false,
2774 true,
2775 false,
2776 false,
2777 false,
2778 false,
2779 false,
2780 true,
2781 true,
2782 false,
2783 false,
2784 true,
2785 false,
2786 false,
2787 false,
2788 false,
2789 false,
2790 true,
2791 true,
2792 false,
2793 false,
2794 false,
2795 false,
2796 false,
2797 false,
2798 true,
2799 true,
2800 false,
2801 true,
2802 true,
2803 true,
2804 true,
2805 true,
2806 true,
2807 false,
2808 false,
2809 false,
2810 false,
2811 true,
2812 false,
2813 true,
2814 true,
2815 true,
2816 true,
2817 false,
2818 false,
2819 false,
2820 true,
2821 true,
2822 false,
2823 true,
2824 true,
2825 false,
2826 false,
2827 false,
2828 true,
2829 true,
2830 true,
2831 true,
2832 false,
2833 true,
2834 false,
2835 true,
2836 true,
2837 true,
2838 true,
2839 false,
2840 true,
2841 false,
2842 true,
2843 false,
2844 true,
2845 false,
2846 false,
2847 false,
2848 true,
2849 true,
2850 false,
2851 true,
2852 false,
2853 false,
2854 false,
2855 true,
2856 true,
2857 true,
2858 true,
2859 true,
2860 false,
2861 true,
2862 true,
2863 true,
2864 true,
2865 false,
2866 true,
2867 false,
2868 false,
2869 true,
2870 false,
2871 true,
2872 false,
2873 false,
2874 true,
2875 true,
2876 false,
2877 true,
2878 false,
2879 false,
2880 true,
2881 false,
2882 false,
2883 true,
2884 true,
2885 true,
2886 false,
2887 false,
2888 true,
2889 true,
2890 true,
2891 false,
2892 false,
2893 false,
2894 false,
2895 false,
2896 false,
2897 true,
2898 false,
2899 true,
2900 false,
2901 true,
2902 true,
2903 false,
2904 false,
2905 false,
2906 false,
2907 true,
2908 true,
2909 true,
2910 true,
2911 true,
2912 false,
2913 true,
2914 true,
2915 true,
2916 true,
2917 true,
2918 false,
2919 true,
2920 true,
2921 true,
2922 false,
2923 true,
2924 false,
2925 true,
2926 true,
2927 true,
2928 false,
2929 false,
2930 true,
2931 true,
2932 true,
2933 false,
2934 false,
2935 true,
2936 true,
2937 false,
2938 true,
2939 true,
2940 true,
2941 true,
2942 true,
2943 true,
2944 false,
2945 true,
2946 false,
2947 true,
2948 false,
2949 false,
2950 false,
2951 false,
2952 true,
2953 true,
2954 true,
2955 true,
2956 false,
2957 true,
2958 false,
2959 true,
2960 true,
2961 false,
2962 true,
2963 false,
2964 false,
2965 true,
2966 false,
2967 false,
2968 false,
2969 false,
2970 false,
2971 false,
2972 false,
2973 true,
2974 false,
2975 true,
2976 true,
2977 false,
2978 false,
2979 true,
2980 false,
2981 false,
2982 true,
2983 false,
2984 false,
2985 true,
2986 false,
2987 false,
2988 false,
2989 false,
2990 true,
2991 true,
2992 true,
2993 true,
2994 true,
2995 true,
2996 true,
2997 false,
2998 true,
2999 true,
3000 false,
3001 false,
3002 false,
3003 true,
3004 false,
3005 true,
3006 true,
3007 false,
3008 true,
3009 true,
3010 true,
3011 true,
3012 false,
3013 false,
3014 false,
3015 true,
3016 true,
3017 false,
3018 true,
3019 false,
3020 true,
3021 false,
3022 false,
3023 false,
3024 false,
3025 true,
3026 true,
3027 true,
3028 false,
3029 true,
3030 false,
3031 false,
3032 false,
3033 true,
3034 true,
3035 false,
3036 true,
3037 false,
3038 false,
3039 true,
3040 true,
3041 true,
3042 true,
3043 true,
3044 true,
3045 false,
3046 false,
3047 false,
3048 true,
3049 true,
3050 true,
3051 false,
3052 false,
3053 false,
3054 false,
3055 false,
3056 false,
3057 false,
3058 false,
3059 false,
3060 false,
3061 false,
3062 true,
3063 false,
3064 false,
3065 false,
3066 true,
3067 false,
3068 false,
3069 false,
3070 false,
3071 true,
3072 true,
3073 true,
3074 true,
3075 true,
3076 false,
3077 false,
3078 true,
3079 true,
3080 true,
3081 false,
3082 true,
3083 true,
3084 true,
3085 false,
3086 true,
3087 false,
3088 true,
3089 false,
3090 true,
3091 false,
3092 true,
3093 true,
3094 true,
3095 true,
3096 false,
3097 true,
3098 true,
3099 false,
3100 true,
3101 false,
3102 false,
3103 false,
3104 false,
3105 false,
3106 false,
3107 false,
3108 false,
3109 false,
3110 true,
3111 true,
3112 false,
3113 true,
3114 false,
3115 };
3116}
3117// WASM: The following vector functions define too many Wasm locals for wasmtime in debug mode and are therefore disabled for the wasm target.
3118#ifndef __wasm__
3119void c_vector_512_bool(Vector_512_bool vec) {
3120 assert_or_panic(vec[0] == true);
3121 assert_or_panic(vec[1] == true);
3122 assert_or_panic(vec[2] == true);
3123 assert_or_panic(vec[3] == true);
3124 assert_or_panic(vec[4] == true);
3125 assert_or_panic(vec[5] == false);
3126 assert_or_panic(vec[6] == false);
3127 assert_or_panic(vec[7] == true);
3128 assert_or_panic(vec[8] == true);
3129 assert_or_panic(vec[9] == true);
3130 assert_or_panic(vec[10] == true);
3131 assert_or_panic(vec[11] == false);
3132 assert_or_panic(vec[12] == true);
3133 assert_or_panic(vec[13] == true);
3134 assert_or_panic(vec[14] == false);
3135 assert_or_panic(vec[15] == false);
3136 assert_or_panic(vec[16] == false);
3137 assert_or_panic(vec[17] == true);
3138 assert_or_panic(vec[18] == true);
3139 assert_or_panic(vec[19] == true);
3140 assert_or_panic(vec[20] == true);
3141 assert_or_panic(vec[21] == true);
3142 assert_or_panic(vec[22] == false);
3143 assert_or_panic(vec[23] == false);
3144 assert_or_panic(vec[24] == true);
3145 assert_or_panic(vec[25] == true);
3146 assert_or_panic(vec[26] == false);
3147 assert_or_panic(vec[27] == false);
3148 assert_or_panic(vec[28] == false);
3149 assert_or_panic(vec[29] == false);
3150 assert_or_panic(vec[30] == false);
3151 assert_or_panic(vec[31] == true);
3152 assert_or_panic(vec[32] == true);
3153 assert_or_panic(vec[33] == false);
3154 assert_or_panic(vec[34] == true);
3155 assert_or_panic(vec[35] == true);
3156 assert_or_panic(vec[36] == true);
3157 assert_or_panic(vec[37] == true);
3158 assert_or_panic(vec[38] == true);
3159 assert_or_panic(vec[39] == true);
3160 assert_or_panic(vec[40] == false);
3161 assert_or_panic(vec[41] == true);
3162 assert_or_panic(vec[42] == true);
3163 assert_or_panic(vec[43] == false);
3164 assert_or_panic(vec[44] == false);
3165 assert_or_panic(vec[45] == false);
3166 assert_or_panic(vec[46] == true);
3167 assert_or_panic(vec[47] == true);
3168 assert_or_panic(vec[48] == false);
3169 assert_or_panic(vec[49] == true);
3170 assert_or_panic(vec[50] == false);
3171 assert_or_panic(vec[51] == true);
3172 assert_or_panic(vec[52] == true);
3173 assert_or_panic(vec[53] == false);
3174 assert_or_panic(vec[54] == true);
3175 assert_or_panic(vec[55] == false);
3176 assert_or_panic(vec[56] == false);
3177 assert_or_panic(vec[57] == true);
3178 assert_or_panic(vec[58] == true);
3179 assert_or_panic(vec[59] == false);
3180 assert_or_panic(vec[60] == true);
3181 assert_or_panic(vec[61] == true);
3182 assert_or_panic(vec[62] == false);
3183 assert_or_panic(vec[63] == true);
3184 assert_or_panic(vec[64] == false);
3185 assert_or_panic(vec[65] == true);
3186 assert_or_panic(vec[66] == true);
3187 assert_or_panic(vec[67] == true);
3188 assert_or_panic(vec[68] == true);
3189 assert_or_panic(vec[69] == true);
3190 assert_or_panic(vec[70] == true);
3191 assert_or_panic(vec[71] == true);
3192 assert_or_panic(vec[72] == true);
3193 assert_or_panic(vec[73] == true);
3194 assert_or_panic(vec[74] == false);
3195 assert_or_panic(vec[75] == true);
3196 assert_or_panic(vec[76] == false);
3197 assert_or_panic(vec[77] == true);
3198 assert_or_panic(vec[78] == false);
3199 assert_or_panic(vec[79] == false);
3200 assert_or_panic(vec[80] == false);
3201 assert_or_panic(vec[81] == true);
3202 assert_or_panic(vec[82] == false);
3203 assert_or_panic(vec[83] == true);
3204 assert_or_panic(vec[84] == true);
3205 assert_or_panic(vec[85] == false);
3206 assert_or_panic(vec[86] == true);
3207 assert_or_panic(vec[87] == true);
3208 assert_or_panic(vec[88] == true);
3209 assert_or_panic(vec[89] == false);
3210 assert_or_panic(vec[90] == true);
3211 assert_or_panic(vec[91] == true);
3212 assert_or_panic(vec[92] == false);
3213 assert_or_panic(vec[93] == true);
3214 assert_or_panic(vec[94] == false);
3215 assert_or_panic(vec[95] == true);
3216 assert_or_panic(vec[96] == true);
3217 assert_or_panic(vec[97] == false);
3218 assert_or_panic(vec[98] == false);
3219 assert_or_panic(vec[99] == false);
3220 assert_or_panic(vec[100] == true);
3221 assert_or_panic(vec[101] == true);
3222 assert_or_panic(vec[102] == false);
3223 assert_or_panic(vec[103] == true);
3224 assert_or_panic(vec[104] == false);
3225 assert_or_panic(vec[105] == false);
3226 assert_or_panic(vec[106] == true);
3227 assert_or_panic(vec[107] == false);
3228 assert_or_panic(vec[108] == false);
3229 assert_or_panic(vec[109] == true);
3230 assert_or_panic(vec[110] == false);
3231 assert_or_panic(vec[111] == false);
3232 assert_or_panic(vec[112] == false);
3233 assert_or_panic(vec[113] == false);
3234 assert_or_panic(vec[114] == false);
3235 assert_or_panic(vec[115] == true);
3236 assert_or_panic(vec[116] == true);
3237 assert_or_panic(vec[117] == false);
3238 assert_or_panic(vec[118] == false);
3239 assert_or_panic(vec[119] == false);
3240 assert_or_panic(vec[120] == false);
3241 assert_or_panic(vec[121] == true);
3242 assert_or_panic(vec[122] == false);
3243 assert_or_panic(vec[123] == false);
3244 assert_or_panic(vec[124] == true);
3245 assert_or_panic(vec[125] == true);
3246 assert_or_panic(vec[126] == false);
3247 assert_or_panic(vec[127] == true);
3248 assert_or_panic(vec[128] == false);
3249 assert_or_panic(vec[129] == true);
3250 assert_or_panic(vec[130] == true);
3251 assert_or_panic(vec[131] == false);
3252 assert_or_panic(vec[132] == true);
3253 assert_or_panic(vec[133] == false);
3254 assert_or_panic(vec[134] == false);
3255 assert_or_panic(vec[135] == false);
3256 assert_or_panic(vec[136] == false);
3257 assert_or_panic(vec[137] == true);
3258 assert_or_panic(vec[138] == true);
3259 assert_or_panic(vec[139] == false);
3260 assert_or_panic(vec[140] == false);
3261 assert_or_panic(vec[141] == false);
3262 assert_or_panic(vec[142] == true);
3263 assert_or_panic(vec[143] == true);
3264 assert_or_panic(vec[144] == false);
3265 assert_or_panic(vec[145] == false);
3266 assert_or_panic(vec[146] == true);
3267 assert_or_panic(vec[147] == true);
3268 assert_or_panic(vec[148] == true);
3269 assert_or_panic(vec[149] == true);
3270 assert_or_panic(vec[150] == true);
3271 assert_or_panic(vec[151] == true);
3272 assert_or_panic(vec[152] == true);
3273 assert_or_panic(vec[153] == false);
3274 assert_or_panic(vec[154] == true);
3275 assert_or_panic(vec[155] == false);
3276 assert_or_panic(vec[156] == false);
3277 assert_or_panic(vec[157] == true);
3278 assert_or_panic(vec[158] == false);
3279 assert_or_panic(vec[159] == true);
3280 assert_or_panic(vec[160] == false);
3281 assert_or_panic(vec[161] == true);
3282 assert_or_panic(vec[162] == true);
3283 assert_or_panic(vec[163] == true);
3284 assert_or_panic(vec[164] == true);
3285 assert_or_panic(vec[165] == true);
3286 assert_or_panic(vec[166] == true);
3287 assert_or_panic(vec[167] == true);
3288 assert_or_panic(vec[168] == true);
3289 assert_or_panic(vec[169] == false);
3290 assert_or_panic(vec[170] == true);
3291 assert_or_panic(vec[171] == true);
3292 assert_or_panic(vec[172] == false);
3293 assert_or_panic(vec[173] == true);
3294 assert_or_panic(vec[174] == true);
3295 assert_or_panic(vec[175] == false);
3296 assert_or_panic(vec[176] == false);
3297 assert_or_panic(vec[177] == false);
3298 assert_or_panic(vec[178] == true);
3299 assert_or_panic(vec[179] == false);
3300 assert_or_panic(vec[180] == false);
3301 assert_or_panic(vec[181] == true);
3302 assert_or_panic(vec[182] == true);
3303 assert_or_panic(vec[183] == true);
3304 assert_or_panic(vec[184] == true);
3305 assert_or_panic(vec[185] == true);
3306 assert_or_panic(vec[186] == true);
3307 assert_or_panic(vec[187] == true);
3308 assert_or_panic(vec[188] == true);
3309 assert_or_panic(vec[189] == true);
3310 assert_or_panic(vec[190] == false);
3311 assert_or_panic(vec[191] == true);
3312 assert_or_panic(vec[192] == true);
3313 assert_or_panic(vec[193] == false);
3314 assert_or_panic(vec[194] == false);
3315 assert_or_panic(vec[195] == true);
3316 assert_or_panic(vec[196] == true);
3317 assert_or_panic(vec[197] == false);
3318 assert_or_panic(vec[198] == true);
3319 assert_or_panic(vec[199] == true);
3320 assert_or_panic(vec[200] == false);
3321 assert_or_panic(vec[201] == true);
3322 assert_or_panic(vec[202] == true);
3323 assert_or_panic(vec[203] == false);
3324 assert_or_panic(vec[204] == true);
3325 assert_or_panic(vec[205] == true);
3326 assert_or_panic(vec[206] == true);
3327 assert_or_panic(vec[207] == true);
3328 assert_or_panic(vec[208] == false);
3329 assert_or_panic(vec[209] == true);
3330 assert_or_panic(vec[210] == false);
3331 assert_or_panic(vec[211] == true);
3332 assert_or_panic(vec[212] == true);
3333 assert_or_panic(vec[213] == false);
3334 assert_or_panic(vec[214] == true);
3335 assert_or_panic(vec[215] == false);
3336 assert_or_panic(vec[216] == true);
3337 assert_or_panic(vec[217] == false);
3338 assert_or_panic(vec[218] == true);
3339 assert_or_panic(vec[219] == false);
3340 assert_or_panic(vec[220] == false);
3341 assert_or_panic(vec[221] == true);
3342 assert_or_panic(vec[222] == false);
3343 assert_or_panic(vec[223] == false);
3344 assert_or_panic(vec[224] == false);
3345 assert_or_panic(vec[225] == true);
3346 assert_or_panic(vec[226] == true);
3347 assert_or_panic(vec[227] == false);
3348 assert_or_panic(vec[228] == false);
3349 assert_or_panic(vec[229] == false);
3350 assert_or_panic(vec[230] == true);
3351 assert_or_panic(vec[231] == false);
3352 assert_or_panic(vec[232] == true);
3353 assert_or_panic(vec[233] == false);
3354 assert_or_panic(vec[234] == false);
3355 assert_or_panic(vec[235] == false);
3356 assert_or_panic(vec[236] == true);
3357 assert_or_panic(vec[237] == true);
3358 assert_or_panic(vec[238] == false);
3359 assert_or_panic(vec[239] == false);
3360 assert_or_panic(vec[240] == false);
3361 assert_or_panic(vec[241] == false);
3362 assert_or_panic(vec[242] == false);
3363 assert_or_panic(vec[243] == true);
3364 assert_or_panic(vec[244] == true);
3365 assert_or_panic(vec[245] == false);
3366 assert_or_panic(vec[246] == true);
3367 assert_or_panic(vec[247] == false);
3368 assert_or_panic(vec[248] == false);
3369 assert_or_panic(vec[249] == true);
3370 assert_or_panic(vec[250] == false);
3371 assert_or_panic(vec[251] == false);
3372 assert_or_panic(vec[252] == false);
3373 assert_or_panic(vec[253] == true);
3374 assert_or_panic(vec[254] == false);
3375 assert_or_panic(vec[255] == false);
3376 assert_or_panic(vec[256] == false);
3377 assert_or_panic(vec[257] == false);
3378 assert_or_panic(vec[258] == true);
3379 assert_or_panic(vec[259] == true);
3380 assert_or_panic(vec[260] == true);
3381 assert_or_panic(vec[261] == true);
3382 assert_or_panic(vec[262] == false);
3383 assert_or_panic(vec[263] == true);
3384 assert_or_panic(vec[264] == false);
3385 assert_or_panic(vec[265] == false);
3386 assert_or_panic(vec[266] == false);
3387 assert_or_panic(vec[267] == true);
3388 assert_or_panic(vec[268] == false);
3389 assert_or_panic(vec[269] == false);
3390 assert_or_panic(vec[270] == true);
3391 assert_or_panic(vec[271] == true);
3392 assert_or_panic(vec[272] == false);
3393 assert_or_panic(vec[273] == false);
3394 assert_or_panic(vec[274] == false);
3395 assert_or_panic(vec[275] == false);
3396 assert_or_panic(vec[276] == false);
3397 assert_or_panic(vec[277] == true);
3398 assert_or_panic(vec[278] == false);
3399 assert_or_panic(vec[279] == true);
3400 assert_or_panic(vec[280] == true);
3401 assert_or_panic(vec[281] == true);
3402 assert_or_panic(vec[282] == true);
3403 assert_or_panic(vec[283] == true);
3404 assert_or_panic(vec[284] == false);
3405 assert_or_panic(vec[285] == false);
3406 assert_or_panic(vec[286] == false);
3407 assert_or_panic(vec[287] == false);
3408 assert_or_panic(vec[288] == false);
3409 assert_or_panic(vec[289] == false);
3410 assert_or_panic(vec[290] == false);
3411 assert_or_panic(vec[291] == false);
3412 assert_or_panic(vec[292] == false);
3413 assert_or_panic(vec[293] == true);
3414 assert_or_panic(vec[294] == true);
3415 assert_or_panic(vec[295] == true);
3416 assert_or_panic(vec[296] == true);
3417 assert_or_panic(vec[297] == true);
3418 assert_or_panic(vec[298] == true);
3419 assert_or_panic(vec[299] == false);
3420 assert_or_panic(vec[300] == true);
3421 assert_or_panic(vec[301] == false);
3422 assert_or_panic(vec[302] == true);
3423 assert_or_panic(vec[303] == true);
3424 assert_or_panic(vec[304] == true);
3425 assert_or_panic(vec[305] == false);
3426 assert_or_panic(vec[306] == false);
3427 assert_or_panic(vec[307] == true);
3428 assert_or_panic(vec[308] == true);
3429 assert_or_panic(vec[309] == true);
3430 assert_or_panic(vec[310] == false);
3431 assert_or_panic(vec[311] == true);
3432 assert_or_panic(vec[312] == true);
3433 assert_or_panic(vec[313] == true);
3434 assert_or_panic(vec[314] == false);
3435 assert_or_panic(vec[315] == true);
3436 assert_or_panic(vec[316] == true);
3437 assert_or_panic(vec[317] == true);
3438 assert_or_panic(vec[318] == false);
3439 assert_or_panic(vec[319] == true);
3440 assert_or_panic(vec[320] == true);
3441 assert_or_panic(vec[321] == false);
3442 assert_or_panic(vec[322] == false);
3443 assert_or_panic(vec[323] == true);
3444 assert_or_panic(vec[324] == false);
3445 assert_or_panic(vec[325] == false);
3446 assert_or_panic(vec[326] == false);
3447 assert_or_panic(vec[327] == false);
3448 assert_or_panic(vec[328] == true);
3449 assert_or_panic(vec[329] == false);
3450 assert_or_panic(vec[330] == true);
3451 assert_or_panic(vec[331] == true);
3452 assert_or_panic(vec[332] == true);
3453 assert_or_panic(vec[333] == true);
3454 assert_or_panic(vec[334] == false);
3455 assert_or_panic(vec[335] == false);
3456 assert_or_panic(vec[336] == true);
3457 assert_or_panic(vec[337] == false);
3458 assert_or_panic(vec[338] == true);
3459 assert_or_panic(vec[339] == false);
3460 assert_or_panic(vec[340] == false);
3461 assert_or_panic(vec[341] == false);
3462 assert_or_panic(vec[342] == true);
3463 assert_or_panic(vec[343] == false);
3464 assert_or_panic(vec[344] == true);
3465 assert_or_panic(vec[345] == false);
3466 assert_or_panic(vec[346] == false);
3467 assert_or_panic(vec[347] == true);
3468 assert_or_panic(vec[348] == true);
3469 assert_or_panic(vec[349] == true);
3470 assert_or_panic(vec[350] == true);
3471 assert_or_panic(vec[351] == false);
3472 assert_or_panic(vec[352] == false);
3473 assert_or_panic(vec[353] == false);
3474 assert_or_panic(vec[354] == true);
3475 assert_or_panic(vec[355] == true);
3476 assert_or_panic(vec[356] == false);
3477 assert_or_panic(vec[357] == true);
3478 assert_or_panic(vec[358] == false);
3479 assert_or_panic(vec[359] == false);
3480 assert_or_panic(vec[360] == true);
3481 assert_or_panic(vec[361] == false);
3482 assert_or_panic(vec[362] == true);
3483 assert_or_panic(vec[363] == false);
3484 assert_or_panic(vec[364] == true);
3485 assert_or_panic(vec[365] == true);
3486 assert_or_panic(vec[366] == false);
3487 assert_or_panic(vec[367] == false);
3488 assert_or_panic(vec[368] == true);
3489 assert_or_panic(vec[369] == true);
3490 assert_or_panic(vec[370] == true);
3491 assert_or_panic(vec[371] == true);
3492 assert_or_panic(vec[372] == false);
3493 assert_or_panic(vec[373] == false);
3494 assert_or_panic(vec[374] == true);
3495 assert_or_panic(vec[375] == false);
3496 assert_or_panic(vec[376] == true);
3497 assert_or_panic(vec[377] == true);
3498 assert_or_panic(vec[378] == false);
3499 assert_or_panic(vec[379] == true);
3500 assert_or_panic(vec[380] == true);
3501 assert_or_panic(vec[381] == false);
3502 assert_or_panic(vec[382] == true);
3503 assert_or_panic(vec[383] == true);
3504 assert_or_panic(vec[384] == true);
3505 assert_or_panic(vec[385] == false);
3506 assert_or_panic(vec[386] == true);
3507 assert_or_panic(vec[387] == true);
3508 assert_or_panic(vec[388] == true);
3509 assert_or_panic(vec[389] == false);
3510 assert_or_panic(vec[390] == false);
3511 assert_or_panic(vec[391] == true);
3512 assert_or_panic(vec[392] == false);
3513 assert_or_panic(vec[393] == true);
3514 assert_or_panic(vec[394] == true);
3515 assert_or_panic(vec[395] == true);
3516 assert_or_panic(vec[396] == false);
3517 assert_or_panic(vec[397] == false);
3518 assert_or_panic(vec[398] == false);
3519 assert_or_panic(vec[399] == false);
3520 assert_or_panic(vec[400] == false);
3521 assert_or_panic(vec[401] == true);
3522 assert_or_panic(vec[402] == false);
3523 assert_or_panic(vec[403] == false);
3524 assert_or_panic(vec[404] == false);
3525 assert_or_panic(vec[405] == false);
3526 assert_or_panic(vec[406] == true);
3527 assert_or_panic(vec[407] == false);
3528 assert_or_panic(vec[408] == false);
3529 assert_or_panic(vec[409] == true);
3530 assert_or_panic(vec[410] == true);
3531 assert_or_panic(vec[411] == false);
3532 assert_or_panic(vec[412] == false);
3533 assert_or_panic(vec[413] == false);
3534 assert_or_panic(vec[414] == false);
3535 assert_or_panic(vec[415] == true);
3536 assert_or_panic(vec[416] == true);
3537 assert_or_panic(vec[417] == true);
3538 assert_or_panic(vec[418] == true);
3539 assert_or_panic(vec[419] == true);
3540 assert_or_panic(vec[420] == false);
3541 assert_or_panic(vec[421] == false);
3542 assert_or_panic(vec[422] == false);
3543 assert_or_panic(vec[423] == true);
3544 assert_or_panic(vec[424] == false);
3545 assert_or_panic(vec[425] == false);
3546 assert_or_panic(vec[426] == false);
3547 assert_or_panic(vec[427] == false);
3548 assert_or_panic(vec[428] == true);
3549 assert_or_panic(vec[429] == false);
3550 assert_or_panic(vec[430] == true);
3551 assert_or_panic(vec[431] == false);
3552 assert_or_panic(vec[432] == true);
3553 assert_or_panic(vec[433] == true);
3554 assert_or_panic(vec[434] == true);
3555 assert_or_panic(vec[435] == true);
3556 assert_or_panic(vec[436] == false);
3557 assert_or_panic(vec[437] == false);
3558 assert_or_panic(vec[438] == false);
3559 assert_or_panic(vec[439] == false);
3560 assert_or_panic(vec[440] == false);
3561 assert_or_panic(vec[441] == true);
3562 assert_or_panic(vec[442] == true);
3563 assert_or_panic(vec[443] == true);
3564 assert_or_panic(vec[444] == true);
3565 assert_or_panic(vec[445] == true);
3566 assert_or_panic(vec[446] == true);
3567 assert_or_panic(vec[447] == true);
3568 assert_or_panic(vec[448] == true);
3569 assert_or_panic(vec[449] == true);
3570 assert_or_panic(vec[450] == false);
3571 assert_or_panic(vec[451] == false);
3572 assert_or_panic(vec[452] == true);
3573 assert_or_panic(vec[453] == false);
3574 assert_or_panic(vec[454] == true);
3575 assert_or_panic(vec[455] == false);
3576 assert_or_panic(vec[456] == false);
3577 assert_or_panic(vec[457] == true);
3578 assert_or_panic(vec[458] == false);
3579 assert_or_panic(vec[459] == false);
3580 assert_or_panic(vec[460] == true);
3581 assert_or_panic(vec[461] == true);
3582 assert_or_panic(vec[462] == true);
3583 assert_or_panic(vec[463] == true);
3584 assert_or_panic(vec[464] == true);
3585 assert_or_panic(vec[465] == true);
3586 assert_or_panic(vec[466] == false);
3587 assert_or_panic(vec[467] == true);
3588 assert_or_panic(vec[468] == false);
3589 assert_or_panic(vec[469] == false);
3590 assert_or_panic(vec[470] == false);
3591 assert_or_panic(vec[471] == true);
3592 assert_or_panic(vec[472] == true);
3593 assert_or_panic(vec[473] == false);
3594 assert_or_panic(vec[474] == true);
3595 assert_or_panic(vec[475] == true);
3596 assert_or_panic(vec[476] == false);
3597 assert_or_panic(vec[477] == false);
3598 assert_or_panic(vec[478] == true);
3599 assert_or_panic(vec[479] == true);
3600 assert_or_panic(vec[480] == false);
3601 assert_or_panic(vec[481] == false);
3602 assert_or_panic(vec[482] == true);
3603 assert_or_panic(vec[483] == true);
3604 assert_or_panic(vec[484] == false);
3605 assert_or_panic(vec[485] == true);
3606 assert_or_panic(vec[486] == false);
3607 assert_or_panic(vec[487] == true);
3608 assert_or_panic(vec[488] == true);
3609 assert_or_panic(vec[489] == true);
3610 assert_or_panic(vec[490] == true);
3611 assert_or_panic(vec[491] == true);
3612 assert_or_panic(vec[492] == true);
3613 assert_or_panic(vec[493] == true);
3614 assert_or_panic(vec[494] == true);
3615 assert_or_panic(vec[495] == true);
3616 assert_or_panic(vec[496] == false);
3617 assert_or_panic(vec[497] == true);
3618 assert_or_panic(vec[498] == true);
3619 assert_or_panic(vec[499] == true);
3620 assert_or_panic(vec[500] == false);
3621 assert_or_panic(vec[501] == false);
3622 assert_or_panic(vec[502] == true);
3623 assert_or_panic(vec[503] == false);
3624 assert_or_panic(vec[504] == false);
3625 assert_or_panic(vec[505] == false);
3626 assert_or_panic(vec[506] == true);
3627 assert_or_panic(vec[507] == true);
3628 assert_or_panic(vec[508] == false);
3629 assert_or_panic(vec[509] == true);
3630 assert_or_panic(vec[510] == false);
3631 assert_or_panic(vec[511] == true);
3632}
3633#endif
3634void c_test_vector_512_bool(void) {
3635 Vector_512_bool vec = zig_ret_vector_512_bool();
3636 assert_or_panic(vec[0] == true);
3637 assert_or_panic(vec[1] == true);
3638 assert_or_panic(vec[2] == true);
3639 assert_or_panic(vec[3] == true);
3640 assert_or_panic(vec[4] == false);
3641 assert_or_panic(vec[5] == true);
3642 assert_or_panic(vec[6] == false);
3643 assert_or_panic(vec[7] == true);
3644 assert_or_panic(vec[8] == true);
3645 assert_or_panic(vec[9] == true);
3646 assert_or_panic(vec[10] == false);
3647 assert_or_panic(vec[11] == true);
3648 assert_or_panic(vec[12] == false);
3649 assert_or_panic(vec[13] == false);
3650 assert_or_panic(vec[14] == false);
3651 assert_or_panic(vec[15] == true);
3652 assert_or_panic(vec[16] == true);
3653 assert_or_panic(vec[17] == false);
3654 assert_or_panic(vec[18] == false);
3655 assert_or_panic(vec[19] == false);
3656 assert_or_panic(vec[20] == true);
3657 assert_or_panic(vec[21] == true);
3658 assert_or_panic(vec[22] == false);
3659 assert_or_panic(vec[23] == false);
3660 assert_or_panic(vec[24] == false);
3661 assert_or_panic(vec[25] == false);
3662 assert_or_panic(vec[26] == true);
3663 assert_or_panic(vec[27] == false);
3664 assert_or_panic(vec[28] == false);
3665 assert_or_panic(vec[29] == false);
3666 assert_or_panic(vec[30] == true);
3667 assert_or_panic(vec[31] == true);
3668 assert_or_panic(vec[32] == true);
3669 assert_or_panic(vec[33] == true);
3670 assert_or_panic(vec[34] == false);
3671 assert_or_panic(vec[35] == false);
3672 assert_or_panic(vec[36] == false);
3673 assert_or_panic(vec[37] == true);
3674 assert_or_panic(vec[38] == true);
3675 assert_or_panic(vec[39] == true);
3676 assert_or_panic(vec[40] == false);
3677 assert_or_panic(vec[41] == false);
3678 assert_or_panic(vec[42] == true);
3679 assert_or_panic(vec[43] == false);
3680 assert_or_panic(vec[44] == false);
3681 assert_or_panic(vec[45] == true);
3682 assert_or_panic(vec[46] == false);
3683 assert_or_panic(vec[47] == false);
3684 assert_or_panic(vec[48] == true);
3685 assert_or_panic(vec[49] == true);
3686 assert_or_panic(vec[50] == true);
3687 assert_or_panic(vec[51] == true);
3688 assert_or_panic(vec[52] == false);
3689 assert_or_panic(vec[53] == false);
3690 assert_or_panic(vec[54] == false);
3691 assert_or_panic(vec[55] == true);
3692 assert_or_panic(vec[56] == false);
3693 assert_or_panic(vec[57] == true);
3694 assert_or_panic(vec[58] == false);
3695 assert_or_panic(vec[59] == true);
3696 assert_or_panic(vec[60] == true);
3697 assert_or_panic(vec[61] == false);
3698 assert_or_panic(vec[62] == false);
3699 assert_or_panic(vec[63] == true);
3700 assert_or_panic(vec[64] == true);
3701 assert_or_panic(vec[65] == false);
3702 assert_or_panic(vec[66] == true);
3703 assert_or_panic(vec[67] == false);
3704 assert_or_panic(vec[68] == false);
3705 assert_or_panic(vec[69] == false);
3706 assert_or_panic(vec[70] == true);
3707 assert_or_panic(vec[71] == true);
3708 assert_or_panic(vec[72] == true);
3709 assert_or_panic(vec[73] == true);
3710 assert_or_panic(vec[74] == true);
3711 assert_or_panic(vec[75] == false);
3712 assert_or_panic(vec[76] == true);
3713 assert_or_panic(vec[77] == false);
3714 assert_or_panic(vec[78] == true);
3715 assert_or_panic(vec[79] == true);
3716 assert_or_panic(vec[80] == true);
3717 assert_or_panic(vec[81] == true);
3718 assert_or_panic(vec[82] == true);
3719 assert_or_panic(vec[83] == false);
3720 assert_or_panic(vec[84] == true);
3721 assert_or_panic(vec[85] == true);
3722 assert_or_panic(vec[86] == false);
3723 assert_or_panic(vec[87] == true);
3724 assert_or_panic(vec[88] == false);
3725 assert_or_panic(vec[89] == false);
3726 assert_or_panic(vec[90] == true);
3727 assert_or_panic(vec[91] == false);
3728 assert_or_panic(vec[92] == true);
3729 assert_or_panic(vec[93] == false);
3730 assert_or_panic(vec[94] == false);
3731 assert_or_panic(vec[95] == false);
3732 assert_or_panic(vec[96] == true);
3733 assert_or_panic(vec[97] == true);
3734 assert_or_panic(vec[98] == false);
3735 assert_or_panic(vec[99] == true);
3736 assert_or_panic(vec[100] == true);
3737 assert_or_panic(vec[101] == false);
3738 assert_or_panic(vec[102] == true);
3739 assert_or_panic(vec[103] == false);
3740 assert_or_panic(vec[104] == true);
3741 assert_or_panic(vec[105] == false);
3742 assert_or_panic(vec[106] == true);
3743 assert_or_panic(vec[107] == false);
3744 assert_or_panic(vec[108] == false);
3745 assert_or_panic(vec[109] == true);
3746 assert_or_panic(vec[110] == false);
3747 assert_or_panic(vec[111] == false);
3748 assert_or_panic(vec[112] == true);
3749 assert_or_panic(vec[113] == false);
3750 assert_or_panic(vec[114] == true);
3751 assert_or_panic(vec[115] == false);
3752 assert_or_panic(vec[116] == true);
3753 assert_or_panic(vec[117] == false);
3754 assert_or_panic(vec[118] == false);
3755 assert_or_panic(vec[119] == true);
3756 assert_or_panic(vec[120] == true);
3757 assert_or_panic(vec[121] == true);
3758 assert_or_panic(vec[122] == false);
3759 assert_or_panic(vec[123] == true);
3760 assert_or_panic(vec[124] == false);
3761 assert_or_panic(vec[125] == false);
3762 assert_or_panic(vec[126] == true);
3763 assert_or_panic(vec[127] == true);
3764 assert_or_panic(vec[128] == false);
3765 assert_or_panic(vec[129] == true);
3766 assert_or_panic(vec[130] == true);
3767 assert_or_panic(vec[131] == false);
3768 assert_or_panic(vec[132] == true);
3769 assert_or_panic(vec[133] == true);
3770 assert_or_panic(vec[134] == false);
3771 assert_or_panic(vec[135] == true);
3772 assert_or_panic(vec[136] == true);
3773 assert_or_panic(vec[137] == false);
3774 assert_or_panic(vec[138] == false);
3775 assert_or_panic(vec[139] == false);
3776 assert_or_panic(vec[140] == true);
3777 assert_or_panic(vec[141] == false);
3778 assert_or_panic(vec[142] == true);
3779 assert_or_panic(vec[143] == false);
3780 assert_or_panic(vec[144] == false);
3781 assert_or_panic(vec[145] == false);
3782 assert_or_panic(vec[146] == true);
3783 assert_or_panic(vec[147] == false);
3784 assert_or_panic(vec[148] == true);
3785 assert_or_panic(vec[149] == false);
3786 assert_or_panic(vec[150] == false);
3787 assert_or_panic(vec[151] == true);
3788 assert_or_panic(vec[152] == false);
3789 assert_or_panic(vec[153] == true);
3790 assert_or_panic(vec[154] == true);
3791 assert_or_panic(vec[155] == false);
3792 assert_or_panic(vec[156] == true);
3793 assert_or_panic(vec[157] == true);
3794 assert_or_panic(vec[158] == false);
3795 assert_or_panic(vec[159] == true);
3796 assert_or_panic(vec[160] == true);
3797 assert_or_panic(vec[161] == false);
3798 assert_or_panic(vec[162] == false);
3799 assert_or_panic(vec[163] == false);
3800 assert_or_panic(vec[164] == true);
3801 assert_or_panic(vec[165] == false);
3802 assert_or_panic(vec[166] == true);
3803 assert_or_panic(vec[167] == true);
3804 assert_or_panic(vec[168] == true);
3805 assert_or_panic(vec[169] == true);
3806 assert_or_panic(vec[170] == false);
3807 assert_or_panic(vec[171] == true);
3808 assert_or_panic(vec[172] == false);
3809 assert_or_panic(vec[173] == false);
3810 assert_or_panic(vec[174] == true);
3811 assert_or_panic(vec[175] == true);
3812 assert_or_panic(vec[176] == true);
3813 assert_or_panic(vec[177] == false);
3814 assert_or_panic(vec[178] == false);
3815 assert_or_panic(vec[179] == false);
3816 assert_or_panic(vec[180] == true);
3817 assert_or_panic(vec[181] == false);
3818 assert_or_panic(vec[182] == false);
3819 assert_or_panic(vec[183] == true);
3820 assert_or_panic(vec[184] == true);
3821 assert_or_panic(vec[185] == false);
3822 assert_or_panic(vec[186] == true);
3823 assert_or_panic(vec[187] == false);
3824 assert_or_panic(vec[188] == true);
3825 assert_or_panic(vec[189] == true);
3826 assert_or_panic(vec[190] == true);
3827 assert_or_panic(vec[191] == true);
3828 assert_or_panic(vec[192] == true);
3829 assert_or_panic(vec[193] == true);
3830 assert_or_panic(vec[194] == true);
3831 assert_or_panic(vec[195] == false);
3832 assert_or_panic(vec[196] == false);
3833 assert_or_panic(vec[197] == false);
3834 assert_or_panic(vec[198] == false);
3835 assert_or_panic(vec[199] == false);
3836 assert_or_panic(vec[200] == true);
3837 assert_or_panic(vec[201] == false);
3838 assert_or_panic(vec[202] == true);
3839 assert_or_panic(vec[203] == false);
3840 assert_or_panic(vec[204] == true);
3841 assert_or_panic(vec[205] == true);
3842 assert_or_panic(vec[206] == false);
3843 assert_or_panic(vec[207] == false);
3844 assert_or_panic(vec[208] == false);
3845 assert_or_panic(vec[209] == true);
3846 assert_or_panic(vec[210] == true);
3847 assert_or_panic(vec[211] == true);
3848 assert_or_panic(vec[212] == false);
3849 assert_or_panic(vec[213] == false);
3850 assert_or_panic(vec[214] == true);
3851 assert_or_panic(vec[215] == true);
3852 assert_or_panic(vec[216] == true);
3853 assert_or_panic(vec[217] == false);
3854 assert_or_panic(vec[218] == false);
3855 assert_or_panic(vec[219] == true);
3856 assert_or_panic(vec[220] == false);
3857 assert_or_panic(vec[221] == true);
3858 assert_or_panic(vec[222] == true);
3859 assert_or_panic(vec[223] == false);
3860 assert_or_panic(vec[224] == true);
3861 assert_or_panic(vec[225] == false);
3862 assert_or_panic(vec[226] == false);
3863 assert_or_panic(vec[227] == true);
3864 assert_or_panic(vec[228] == false);
3865 assert_or_panic(vec[229] == false);
3866 assert_or_panic(vec[230] == true);
3867 assert_or_panic(vec[231] == true);
3868 assert_or_panic(vec[232] == false);
3869 assert_or_panic(vec[233] == true);
3870 assert_or_panic(vec[234] == true);
3871 assert_or_panic(vec[235] == true);
3872 assert_or_panic(vec[236] == true);
3873 assert_or_panic(vec[237] == true);
3874 assert_or_panic(vec[238] == false);
3875 assert_or_panic(vec[239] == true);
3876 assert_or_panic(vec[240] == false);
3877 assert_or_panic(vec[241] == false);
3878 assert_or_panic(vec[242] == true);
3879 assert_or_panic(vec[243] == false);
3880 assert_or_panic(vec[244] == true);
3881 assert_or_panic(vec[245] == false);
3882 assert_or_panic(vec[246] == true);
3883 assert_or_panic(vec[247] == false);
3884 assert_or_panic(vec[248] == true);
3885 assert_or_panic(vec[249] == true);
3886 assert_or_panic(vec[250] == true);
3887 assert_or_panic(vec[251] == true);
3888 assert_or_panic(vec[252] == true);
3889 assert_or_panic(vec[253] == false);
3890 assert_or_panic(vec[254] == false);
3891 assert_or_panic(vec[255] == false);
3892 assert_or_panic(vec[256] == false);
3893 assert_or_panic(vec[257] == false);
3894 assert_or_panic(vec[258] == false);
3895 assert_or_panic(vec[259] == true);
3896 assert_or_panic(vec[260] == true);
3897 assert_or_panic(vec[261] == true);
3898 assert_or_panic(vec[262] == true);
3899 assert_or_panic(vec[263] == false);
3900 assert_or_panic(vec[264] == false);
3901 assert_or_panic(vec[265] == false);
3902 assert_or_panic(vec[266] == true);
3903 assert_or_panic(vec[267] == false);
3904 assert_or_panic(vec[268] == true);
3905 assert_or_panic(vec[269] == false);
3906 assert_or_panic(vec[270] == true);
3907 assert_or_panic(vec[271] == true);
3908 assert_or_panic(vec[272] == true);
3909 assert_or_panic(vec[273] == true);
3910 assert_or_panic(vec[274] == true);
3911 assert_or_panic(vec[275] == true);
3912 assert_or_panic(vec[276] == false);
3913 assert_or_panic(vec[277] == false);
3914 assert_or_panic(vec[278] == true);
3915 assert_or_panic(vec[279] == true);
3916 assert_or_panic(vec[280] == false);
3917 assert_or_panic(vec[281] == false);
3918 assert_or_panic(vec[282] == false);
3919 assert_or_panic(vec[283] == false);
3920 assert_or_panic(vec[284] == true);
3921 assert_or_panic(vec[285] == true);
3922 assert_or_panic(vec[286] == true);
3923 assert_or_panic(vec[287] == false);
3924 assert_or_panic(vec[288] == false);
3925 assert_or_panic(vec[289] == false);
3926 assert_or_panic(vec[290] == true);
3927 assert_or_panic(vec[291] == false);
3928 assert_or_panic(vec[292] == true);
3929 assert_or_panic(vec[293] == true);
3930 assert_or_panic(vec[294] == false);
3931 assert_or_panic(vec[295] == true);
3932 assert_or_panic(vec[296] == true);
3933 assert_or_panic(vec[297] == true);
3934 assert_or_panic(vec[298] == false);
3935 assert_or_panic(vec[299] == true);
3936 assert_or_panic(vec[300] == true);
3937 assert_or_panic(vec[301] == false);
3938 assert_or_panic(vec[302] == false);
3939 assert_or_panic(vec[303] == true);
3940 assert_or_panic(vec[304] == false);
3941 assert_or_panic(vec[305] == false);
3942 assert_or_panic(vec[306] == true);
3943 assert_or_panic(vec[307] == true);
3944 assert_or_panic(vec[308] == true);
3945 assert_or_panic(vec[309] == true);
3946 assert_or_panic(vec[310] == false);
3947 assert_or_panic(vec[311] == false);
3948 assert_or_panic(vec[312] == false);
3949 assert_or_panic(vec[313] == false);
3950 assert_or_panic(vec[314] == false);
3951 assert_or_panic(vec[315] == true);
3952 assert_or_panic(vec[316] == false);
3953 assert_or_panic(vec[317] == false);
3954 assert_or_panic(vec[318] == true);
3955 assert_or_panic(vec[319] == false);
3956 assert_or_panic(vec[320] == false);
3957 assert_or_panic(vec[321] == true);
3958 assert_or_panic(vec[322] == true);
3959 assert_or_panic(vec[323] == true);
3960 assert_or_panic(vec[324] == true);
3961 assert_or_panic(vec[325] == false);
3962 assert_or_panic(vec[326] == false);
3963 assert_or_panic(vec[327] == false);
3964 assert_or_panic(vec[328] == true);
3965 assert_or_panic(vec[329] == true);
3966 assert_or_panic(vec[330] == false);
3967 assert_or_panic(vec[331] == true);
3968 assert_or_panic(vec[332] == true);
3969 assert_or_panic(vec[333] == false);
3970 assert_or_panic(vec[334] == false);
3971 assert_or_panic(vec[335] == true);
3972 assert_or_panic(vec[336] == true);
3973 assert_or_panic(vec[337] == false);
3974 assert_or_panic(vec[338] == true);
3975 assert_or_panic(vec[339] == true);
3976 assert_or_panic(vec[340] == true);
3977 assert_or_panic(vec[341] == false);
3978 assert_or_panic(vec[342] == false);
3979 assert_or_panic(vec[343] == false);
3980 assert_or_panic(vec[344] == true);
3981 assert_or_panic(vec[345] == true);
3982 assert_or_panic(vec[346] == false);
3983 assert_or_panic(vec[347] == true);
3984 assert_or_panic(vec[348] == false);
3985 assert_or_panic(vec[349] == true);
3986 assert_or_panic(vec[350] == false);
3987 assert_or_panic(vec[351] == false);
3988 assert_or_panic(vec[352] == true);
3989 assert_or_panic(vec[353] == false);
3990 assert_or_panic(vec[354] == true);
3991 assert_or_panic(vec[355] == false);
3992 assert_or_panic(vec[356] == false);
3993 assert_or_panic(vec[357] == false);
3994 assert_or_panic(vec[358] == false);
3995 assert_or_panic(vec[359] == false);
3996 assert_or_panic(vec[360] == true);
3997 assert_or_panic(vec[361] == true);
3998 assert_or_panic(vec[362] == false);
3999 assert_or_panic(vec[363] == false);
4000 assert_or_panic(vec[364] == false);
4001 assert_or_panic(vec[365] == false);
4002 assert_or_panic(vec[366] == true);
4003 assert_or_panic(vec[367] == false);
4004 assert_or_panic(vec[368] == true);
4005 assert_or_panic(vec[369] == false);
4006 assert_or_panic(vec[370] == true);
4007 assert_or_panic(vec[371] == true);
4008 assert_or_panic(vec[372] == false);
4009 assert_or_panic(vec[373] == true);
4010 assert_or_panic(vec[374] == true);
4011 assert_or_panic(vec[375] == true);
4012 assert_or_panic(vec[376] == true);
4013 assert_or_panic(vec[377] == true);
4014 assert_or_panic(vec[378] == false);
4015 assert_or_panic(vec[379] == true);
4016 assert_or_panic(vec[380] == false);
4017 assert_or_panic(vec[381] == true);
4018 assert_or_panic(vec[382] == true);
4019 assert_or_panic(vec[383] == true);
4020 assert_or_panic(vec[384] == true);
4021 assert_or_panic(vec[385] == true);
4022 assert_or_panic(vec[386] == false);
4023 assert_or_panic(vec[387] == true);
4024 assert_or_panic(vec[388] == true);
4025 assert_or_panic(vec[389] == false);
4026 assert_or_panic(vec[390] == true);
4027 assert_or_panic(vec[391] == false);
4028 assert_or_panic(vec[392] == true);
4029 assert_or_panic(vec[393] == false);
4030 assert_or_panic(vec[394] == true);
4031 assert_or_panic(vec[395] == false);
4032 assert_or_panic(vec[396] == true);
4033 assert_or_panic(vec[397] == false);
4034 assert_or_panic(vec[398] == false);
4035 assert_or_panic(vec[399] == true);
4036 assert_or_panic(vec[400] == true);
4037 assert_or_panic(vec[401] == true);
4038 assert_or_panic(vec[402] == true);
4039 assert_or_panic(vec[403] == false);
4040 assert_or_panic(vec[404] == false);
4041 assert_or_panic(vec[405] == true);
4042 assert_or_panic(vec[406] == false);
4043 assert_or_panic(vec[407] == false);
4044 assert_or_panic(vec[408] == false);
4045 assert_or_panic(vec[409] == true);
4046 assert_or_panic(vec[410] == false);
4047 assert_or_panic(vec[411] == true);
4048 assert_or_panic(vec[412] == true);
4049 assert_or_panic(vec[413] == false);
4050 assert_or_panic(vec[414] == true);
4051 assert_or_panic(vec[415] == true);
4052 assert_or_panic(vec[416] == false);
4053 assert_or_panic(vec[417] == true);
4054 assert_or_panic(vec[418] == true);
4055 assert_or_panic(vec[419] == false);
4056 assert_or_panic(vec[420] == false);
4057 assert_or_panic(vec[421] == true);
4058 assert_or_panic(vec[422] == false);
4059 assert_or_panic(vec[423] == false);
4060 assert_or_panic(vec[424] == true);
4061 assert_or_panic(vec[425] == false);
4062 assert_or_panic(vec[426] == true);
4063 assert_or_panic(vec[427] == false);
4064 assert_or_panic(vec[428] == false);
4065 assert_or_panic(vec[429] == true);
4066 assert_or_panic(vec[430] == false);
4067 assert_or_panic(vec[431] == true);
4068 assert_or_panic(vec[432] == true);
4069 assert_or_panic(vec[433] == false);
4070 assert_or_panic(vec[434] == true);
4071 assert_or_panic(vec[435] == false);
4072 assert_or_panic(vec[436] == true);
4073 assert_or_panic(vec[437] == false);
4074 assert_or_panic(vec[438] == true);
4075 assert_or_panic(vec[439] == false);
4076 assert_or_panic(vec[440] == false);
4077 assert_or_panic(vec[441] == true);
4078 assert_or_panic(vec[442] == true);
4079 assert_or_panic(vec[443] == false);
4080 assert_or_panic(vec[444] == true);
4081 assert_or_panic(vec[445] == true);
4082 assert_or_panic(vec[446] == false);
4083 assert_or_panic(vec[447] == true);
4084 assert_or_panic(vec[448] == true);
4085 assert_or_panic(vec[449] == false);
4086 assert_or_panic(vec[450] == false);
4087 assert_or_panic(vec[451] == false);
4088 assert_or_panic(vec[452] == false);
4089 assert_or_panic(vec[453] == false);
4090 assert_or_panic(vec[454] == true);
4091 assert_or_panic(vec[455] == false);
4092 assert_or_panic(vec[456] == false);
4093 assert_or_panic(vec[457] == true);
4094 assert_or_panic(vec[458] == false);
4095 assert_or_panic(vec[459] == true);
4096 assert_or_panic(vec[460] == false);
4097 assert_or_panic(vec[461] == false);
4098 assert_or_panic(vec[462] == false);
4099 assert_or_panic(vec[463] == true);
4100 assert_or_panic(vec[464] == false);
4101 assert_or_panic(vec[465] == true);
4102 assert_or_panic(vec[466] == false);
4103 assert_or_panic(vec[467] == false);
4104 assert_or_panic(vec[468] == false);
4105 assert_or_panic(vec[469] == false);
4106 assert_or_panic(vec[470] == true);
4107 assert_or_panic(vec[471] == true);
4108 assert_or_panic(vec[472] == false);
4109 assert_or_panic(vec[473] == true);
4110 assert_or_panic(vec[474] == true);
4111 assert_or_panic(vec[475] == false);
4112 assert_or_panic(vec[476] == false);
4113 assert_or_panic(vec[477] == true);
4114 assert_or_panic(vec[478] == true);
4115 assert_or_panic(vec[479] == true);
4116 assert_or_panic(vec[480] == false);
4117 assert_or_panic(vec[481] == false);
4118 assert_or_panic(vec[482] == true);
4119 assert_or_panic(vec[483] == false);
4120 assert_or_panic(vec[484] == false);
4121 assert_or_panic(vec[485] == false);
4122 assert_or_panic(vec[486] == true);
4123 assert_or_panic(vec[487] == true);
4124 assert_or_panic(vec[488] == false);
4125 assert_or_panic(vec[489] == false);
4126 assert_or_panic(vec[490] == false);
4127 assert_or_panic(vec[491] == false);
4128 assert_or_panic(vec[492] == false);
4129 assert_or_panic(vec[493] == true);
4130 assert_or_panic(vec[494] == true);
4131 assert_or_panic(vec[495] == true);
4132 assert_or_panic(vec[496] == true);
4133 assert_or_panic(vec[497] == false);
4134 assert_or_panic(vec[498] == false);
4135 assert_or_panic(vec[499] == false);
4136 assert_or_panic(vec[500] == true);
4137 assert_or_panic(vec[501] == false);
4138 assert_or_panic(vec[502] == true);
4139 assert_or_panic(vec[503] == true);
4140 assert_or_panic(vec[504] == true);
4141 assert_or_panic(vec[505] == true);
4142 assert_or_panic(vec[506] == false);
4143 assert_or_panic(vec[507] == false);
4144 assert_or_panic(vec[508] == true);
4145 assert_or_panic(vec[509] == true);
4146 assert_or_panic(vec[510] == false);
4147 assert_or_panic(vec[511] == false);
4148 zig_vector_512_bool((Vector_512_bool){
4149 false,
4150 true,
4151 true,
4152 false,
4153 true,
4154 false,
4155 true,
4156 false,
4157 false,
4158 false,
4159 false,
4160 false,
4161 true,
4162 false,
4163 true,
4164 false,
4165 false,
4166 false,
4167 true,
4168 true,
4169 true,
4170 true,
4171 false,
4172 false,
4173 false,
4174 true,
4175 true,
4176 false,
4177 true,
4178 true,
4179 false,
4180 false,
4181 true,
4182 true,
4183 false,
4184 false,
4185 false,
4186 false,
4187 false,
4188 false,
4189 false,
4190 true,
4191 true,
4192 true,
4193 false,
4194 true,
4195 true,
4196 true,
4197 true,
4198 true,
4199 false,
4200 true,
4201 true,
4202 true,
4203 false,
4204 true,
4205 false,
4206 false,
4207 true,
4208 false,
4209 true,
4210 true,
4211 false,
4212 false,
4213 false,
4214 true,
4215 true,
4216 true,
4217 true,
4218 false,
4219 false,
4220 true,
4221 true,
4222 false,
4223 true,
4224 true,
4225 false,
4226 false,
4227 true,
4228 false,
4229 false,
4230 false,
4231 true,
4232 true,
4233 true,
4234 false,
4235 false,
4236 true,
4237 false,
4238 true,
4239 false,
4240 false,
4241 true,
4242 false,
4243 false,
4244 true,
4245 true,
4246 false,
4247 false,
4248 false,
4249 false,
4250 true,
4251 false,
4252 false,
4253 false,
4254 false,
4255 false,
4256 false,
4257 true,
4258 true,
4259 true,
4260 true,
4261 true,
4262 false,
4263 false,
4264 false,
4265 false,
4266 true,
4267 true,
4268 false,
4269 true,
4270 true,
4271 false,
4272 false,
4273 true,
4274 false,
4275 false,
4276 false,
4277 false,
4278 true,
4279 true,
4280 true,
4281 true,
4282 false,
4283 false,
4284 false,
4285 false,
4286 true,
4287 false,
4288 false,
4289 false,
4290 false,
4291 true,
4292 true,
4293 false,
4294 true,
4295 false,
4296 true,
4297 false,
4298 false,
4299 true,
4300 true,
4301 false,
4302 true,
4303 true,
4304 false,
4305 false,
4306 false,
4307 true,
4308 false,
4309 false,
4310 false,
4311 false,
4312 true,
4313 true,
4314 false,
4315 false,
4316 true,
4317 false,
4318 true,
4319 true,
4320 false,
4321 false,
4322 false,
4323 false,
4324 false,
4325 false,
4326 true,
4327 false,
4328 false,
4329 false,
4330 false,
4331 false,
4332 false,
4333 true,
4334 false,
4335 false,
4336 false,
4337 false,
4338 true,
4339 false,
4340 false,
4341 false,
4342 false,
4343 false,
4344 false,
4345 true,
4346 true,
4347 true,
4348 false,
4349 true,
4350 true,
4351 false,
4352 false,
4353 false,
4354 false,
4355 false,
4356 true,
4357 true,
4358 false,
4359 false,
4360 false,
4361 true,
4362 false,
4363 false,
4364 true,
4365 true,
4366 true,
4367 false,
4368 false,
4369 true,
4370 false,
4371 true,
4372 true,
4373 true,
4374 true,
4375 false,
4376 true,
4377 false,
4378 false,
4379 false,
4380 true,
4381 false,
4382 false,
4383 false,
4384 false,
4385 false,
4386 false,
4387 false,
4388 true,
4389 false,
4390 false,
4391 false,
4392 true,
4393 true,
4394 true,
4395 true,
4396 false,
4397 true,
4398 true,
4399 false,
4400 false,
4401 false,
4402 true,
4403 false,
4404 false,
4405 true,
4406 true,
4407 false,
4408 true,
4409 false,
4410 true,
4411 true,
4412 false,
4413 false,
4414 false,
4415 false,
4416 true,
4417 false,
4418 true,
4419 true,
4420 false,
4421 false,
4422 true,
4423 true,
4424 true,
4425 false,
4426 true,
4427 false,
4428 false,
4429 true,
4430 true,
4431 false,
4432 true,
4433 false,
4434 true,
4435 true,
4436 true,
4437 true,
4438 true,
4439 true,
4440 true,
4441 true,
4442 true,
4443 true,
4444 false,
4445 true,
4446 false,
4447 true,
4448 false,
4449 true,
4450 true,
4451 false,
4452 true,
4453 false,
4454 true,
4455 false,
4456 true,
4457 true,
4458 false,
4459 true,
4460 true,
4461 true,
4462 false,
4463 false,
4464 false,
4465 false,
4466 true,
4467 true,
4468 true,
4469 true,
4470 true,
4471 true,
4472 true,
4473 true,
4474 true,
4475 false,
4476 true,
4477 false,
4478 false,
4479 true,
4480 false,
4481 false,
4482 false,
4483 false,
4484 false,
4485 false,
4486 false,
4487 false,
4488 false,
4489 false,
4490 false,
4491 true,
4492 true,
4493 false,
4494 false,
4495 false,
4496 false,
4497 false,
4498 true,
4499 true,
4500 true,
4501 true,
4502 false,
4503 false,
4504 false,
4505 false,
4506 true,
4507 true,
4508 false,
4509 false,
4510 false,
4511 true,
4512 true,
4513 false,
4514 false,
4515 false,
4516 false,
4517 false,
4518 true,
4519 true,
4520 false,
4521 true,
4522 true,
4523 false,
4524 true,
4525 true,
4526 false,
4527 true,
4528 true,
4529 false,
4530 true,
4531 true,
4532 false,
4533 true,
4534 false,
4535 true,
4536 true,
4537 true,
4538 true,
4539 false,
4540 false,
4541 false,
4542 true,
4543 true,
4544 true,
4545 true,
4546 false,
4547 true,
4548 true,
4549 true,
4550 false,
4551 false,
4552 true,
4553 false,
4554 false,
4555 false,
4556 true,
4557 true,
4558 true,
4559 false,
4560 true,
4561 false,
4562 false,
4563 false,
4564 true,
4565 false,
4566 false,
4567 true,
4568 true,
4569 true,
4570 true,
4571 false,
4572 true,
4573 true,
4574 false,
4575 false,
4576 false,
4577 true,
4578 false,
4579 true,
4580 true,
4581 false,
4582 false,
4583 false,
4584 false,
4585 true,
4586 false,
4587 true,
4588 false,
4589 false,
4590 false,
4591 false,
4592 true,
4593 false,
4594 false,
4595 true,
4596 true,
4597 true,
4598 false,
4599 true,
4600 true,
4601 false,
4602 true,
4603 false,
4604 true,
4605 false,
4606 false,
4607 false,
4608 true,
4609 false,
4610 false,
4611 false,
4612 true,
4613 true,
4614 true,
4615 true,
4616 true,
4617 false,
4618 false,
4619 false,
4620 false,
4621 false,
4622 false,
4623 true,
4624 true,
4625 true,
4626 true,
4627 true,
4628 false,
4629 true,
4630 true,
4631 false,
4632 true,
4633 false,
4634 true,
4635 false,
4636 true,
4637 false,
4638 false,
4639 false,
4640 true,
4641 false,
4642 false,
4643 false,
4644 true,
4645 true,
4646 false,
4647 false,
4648 true,
4649 false,
4650 true,
4651 false,
4652 false,
4653 false,
4654 true,
4655 true,
4656 true,
4657 true,
4658 false,
4659 false,
4660 true,
4661 });
4662}
4663
4664#endif
4665#endif
4666#endif
4667#endif
4668#endif
4669
4670typedef uint8_t Vector_1_u8 __attribute__((vector_size(1 * sizeof(uint8_t))));
4671
4672Vector_1_u8 zig_ret_vector_1_u8(void);
4673void zig_vector_1_u8(Vector_1_u8, size_t);
4674
4675Vector_1_u8 c_ret_vector_1_u8(void) {
4676 return (Vector_1_u8){ 3 };
4677}
4678void c_vector_1_u8(Vector_1_u8 v, size_t i) {
4679 assert_or_panic(v[0] == 4);
4680 assert_or_panic(i == 1);
4681}
4682void c_test_vector_1_u8(void) {
4683 Vector_1_u8 v = zig_ret_vector_1_u8();
4684 assert_or_panic(v[0] == 1);
4685 zig_vector_1_u8((Vector_1_u8){ 2 }, 1);
4686}
4687
4688typedef uint8_t Vector_2_u8 __attribute__((vector_size(2 * sizeof(uint8_t))));
4689
4690Vector_2_u8 zig_ret_vector_2_u8(void);
4691void zig_vector_2_u8(Vector_2_u8, size_t);
4692
4693Vector_2_u8 c_ret_vector_2_u8(void) {
4694 return (Vector_2_u8){ 9, 10 };
4695}
4696void c_vector_2_u8(Vector_2_u8 v, size_t i) {
4697 assert_or_panic(v[0] == 11);
4698 assert_or_panic(v[1] == 12);
4699 assert_or_panic(i == 2);
4700}
4701void c_test_vector_2_u8(void) {
4702 Vector_2_u8 v = zig_ret_vector_2_u8();
4703 assert_or_panic(v[0] == 5);
4704 assert_or_panic(v[1] == 6);
4705 zig_vector_2_u8((Vector_2_u8){ 7, 8 }, 2);
4706}
4707
4708typedef uint8_t Vector_3_u8 __attribute__((vector_size(3 * sizeof(uint8_t))));
4709
4710Vector_3_u8 zig_ret_vector_3_u8(void);
4711void zig_vector_3_u8(Vector_3_u8, size_t);
4712
4713Vector_3_u8 c_ret_vector_3_u8(void) {
4714 return (Vector_3_u8){ 19, 20, 21 };
4715}
4716void c_vector_3_u8(Vector_3_u8 v, size_t i) {
4717 assert_or_panic(v[0] == 22);
4718 assert_or_panic(v[1] == 23);
4719 assert_or_panic(v[2] == 24);
4720 assert_or_panic(i == 3);
4721}
4722void c_test_vector_3_u8(void) {
4723 Vector_3_u8 v = zig_ret_vector_3_u8();
4724 assert_or_panic(v[0] == 13);
4725 assert_or_panic(v[1] == 14);
4726 assert_or_panic(v[2] == 15);
4727 zig_vector_3_u8((Vector_3_u8){ 16, 17, 18 }, 3);
4728}
4729
4730typedef uint8_t Vector_4_u8 __attribute__((vector_size(4 * sizeof(uint8_t))));
4731
4732Vector_4_u8 zig_ret_vector_4_u8(void);
4733void zig_vector_4_u8(Vector_4_u8, size_t);
4734void zig_vector_4_u8_vector_4_u8(Vector_4_u8, Vector_4_u8, size_t);
4735
4736Vector_4_u8 c_ret_vector_4_u8(void) {
4737 return (Vector_4_u8){ 41, 42, 43, 44 };
4738}
4739void c_vector_4_u8(Vector_4_u8 v, size_t i) {
4740 assert_or_panic(v[0] == 45);
4741 assert_or_panic(v[1] == 46);
4742 assert_or_panic(v[2] == 47);
4743 assert_or_panic(v[3] == 48);
4744 assert_or_panic(i == 4);
4745}
4746void c_vector_4_u8_vector_4_u8(Vector_4_u8 v0, Vector_4_u8 v1, size_t i) {
4747 assert_or_panic(v0[0] == 49);
4748 assert_or_panic(v0[1] == 50);
4749 assert_or_panic(v0[2] == 51);
4750 assert_or_panic(v0[3] == 52);
4751 assert_or_panic(v1[0] == 53);
4752 assert_or_panic(v1[1] == 54);
4753 assert_or_panic(v1[2] == 55);
4754 assert_or_panic(v1[3] == 56);
4755 assert_or_panic(i == 8);
4756}
4757void c_test_vector_4_u8(void) {
4758 Vector_4_u8 v = zig_ret_vector_4_u8();
4759 assert_or_panic(v[0] == 25);
4760 assert_or_panic(v[1] == 26);
4761 assert_or_panic(v[2] == 27);
4762 assert_or_panic(v[3] == 28);
4763 zig_vector_4_u8((Vector_4_u8){ 29, 30, 31, 32 }, 4);
4764 zig_vector_4_u8_vector_4_u8((Vector_4_u8){ 33, 34, 35, 36 }, (Vector_4_u8){ 37, 38, 39, 40 }, 8);
4765}
4766
4767typedef uint8_t Vector_6_u8 __attribute__((vector_size(6 * sizeof(uint8_t))));
4768
4769Vector_6_u8 zig_ret_vector_6_u8(void);
4770void zig_vector_6_u8(Vector_6_u8, size_t);
4771
4772Vector_6_u8 c_ret_vector_6_u8(void) {
4773 return (Vector_6_u8){ 53, 54, 55, 56, 57, 58 };
4774}
4775void c_vector_6_u8(Vector_6_u8 v, size_t i) {
4776 assert_or_panic(v[0] == 59);
4777 assert_or_panic(v[1] == 60);
4778 assert_or_panic(v[2] == 61);
4779 assert_or_panic(v[3] == 62);
4780 assert_or_panic(v[4] == 63);
4781 assert_or_panic(v[5] == 64);
4782 assert_or_panic(i == 6);
4783}
4784void c_test_vector_6_u8(void) {
4785 Vector_6_u8 v = zig_ret_vector_6_u8();
4786 assert_or_panic(v[0] == 41);
4787 assert_or_panic(v[1] == 42);
4788 assert_or_panic(v[2] == 43);
4789 assert_or_panic(v[3] == 44);
4790 assert_or_panic(v[4] == 45);
4791 assert_or_panic(v[5] == 46);
4792 zig_vector_6_u8((Vector_6_u8){ 47, 48, 49, 50, 51, 52 }, 6);
4793}
4794
4795typedef uint8_t Vector_8_u8 __attribute__((vector_size(8 * sizeof(uint8_t))));
4796
4797Vector_8_u8 zig_ret_vector_8_u8(void);
4798void zig_vector_8_u8(Vector_8_u8, size_t);
4799
4800Vector_8_u8 c_ret_vector_8_u8(void) {
4801 return (Vector_8_u8){ 81, 82, 83, 84, 85, 86, 87, 88 };
4802}
4803void c_vector_8_u8(Vector_8_u8 v, size_t i) {
4804 assert_or_panic(v[0] == 89);
4805 assert_or_panic(v[1] == 90);
4806 assert_or_panic(v[2] == 91);
4807 assert_or_panic(v[3] == 92);
4808 assert_or_panic(v[4] == 93);
4809 assert_or_panic(v[5] == 94);
4810 assert_or_panic(v[6] == 95);
4811 assert_or_panic(v[7] == 96);
4812 assert_or_panic(i == 8);
4813}
4814void c_test_vector_8_u8(void) {
4815 Vector_8_u8 v = zig_ret_vector_8_u8();
4816 assert_or_panic(v[0] == 65);
4817 assert_or_panic(v[1] == 66);
4818 assert_or_panic(v[2] == 67);
4819 assert_or_panic(v[3] == 68);
4820 assert_or_panic(v[4] == 69);
4821 assert_or_panic(v[5] == 70);
4822 assert_or_panic(v[6] == 71);
4823 assert_or_panic(v[7] == 72);
4824 zig_vector_8_u8((Vector_8_u8){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
4825}
4826
4827typedef uint8_t Vector_12_u8 __attribute__((vector_size(12 * sizeof(uint8_t))));
4828
4829Vector_12_u8 zig_ret_vector_12_u8(void);
4830void zig_vector_12_u8(Vector_12_u8, size_t);
4831
4832Vector_12_u8 c_ret_vector_12_u8(void) {
4833 return (Vector_12_u8){ 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32 };
4834}
4835void c_vector_12_u8(Vector_12_u8 v, size_t i) {
4836 assert_or_panic(v[0] == 33);
4837 assert_or_panic(v[1] == 34);
4838 assert_or_panic(v[2] == 35);
4839 assert_or_panic(v[3] == 36);
4840 assert_or_panic(v[4] == 37);
4841 assert_or_panic(v[5] == 38);
4842 assert_or_panic(v[6] == 39);
4843 assert_or_panic(v[7] == 40);
4844 assert_or_panic(v[8] == 41);
4845 assert_or_panic(v[9] == 42);
4846 assert_or_panic(v[10] == 43);
4847 assert_or_panic(v[11] == 44);
4848 assert_or_panic(i == 12);
4849}
4850void c_test_vector_12_u8(void) {
4851 Vector_12_u8 v = zig_ret_vector_12_u8();
4852 assert_or_panic(v[0] == 97);
4853 assert_or_panic(v[1] == 98);
4854 assert_or_panic(v[2] == 99);
4855 assert_or_panic(v[3] == 0);
4856 assert_or_panic(v[4] == 1);
4857 assert_or_panic(v[5] == 2);
4858 assert_or_panic(v[6] == 3);
4859 assert_or_panic(v[7] == 4);
4860 assert_or_panic(v[8] == 5);
4861 assert_or_panic(v[9] == 6);
4862 assert_or_panic(v[10] == 7);
4863 assert_or_panic(v[11] == 8);
4864 zig_vector_12_u8((Vector_12_u8){ 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 }, 12);
4865}
4866
4867typedef uint8_t Vector_16_u8 __attribute__((vector_size(16 * sizeof(uint8_t))));
4868
4869Vector_16_u8 zig_ret_vector_16_u8(void);
4870void zig_vector_16_u8(Vector_16_u8, size_t);
4871
4872Vector_16_u8 c_ret_vector_16_u8(void) {
4873 return (Vector_16_u8){ 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92 };
4874}
4875void c_vector_16_u8(Vector_16_u8 v, size_t i) {
4876 assert_or_panic(v[0] == 93);
4877 assert_or_panic(v[1] == 94);
4878 assert_or_panic(v[2] == 95);
4879 assert_or_panic(v[3] == 96);
4880 assert_or_panic(v[4] == 97);
4881 assert_or_panic(v[5] == 98);
4882 assert_or_panic(v[6] == 99);
4883 assert_or_panic(v[7] == 0);
4884 assert_or_panic(v[8] == 1);
4885 assert_or_panic(v[9] == 2);
4886 assert_or_panic(v[10] == 3);
4887 assert_or_panic(v[11] == 4);
4888 assert_or_panic(v[12] == 5);
4889 assert_or_panic(v[13] == 6);
4890 assert_or_panic(v[14] == 7);
4891 assert_or_panic(v[15] == 8);
4892 assert_or_panic(i == 16);
4893}
4894void c_test_vector_16_u8(void) {
4895 Vector_16_u8 v = zig_ret_vector_16_u8();
4896 assert_or_panic(v[0] == 45);
4897 assert_or_panic(v[1] == 46);
4898 assert_or_panic(v[2] == 47);
4899 assert_or_panic(v[3] == 48);
4900 assert_or_panic(v[4] == 49);
4901 assert_or_panic(v[5] == 50);
4902 assert_or_panic(v[6] == 51);
4903 assert_or_panic(v[7] == 52);
4904 assert_or_panic(v[8] == 53);
4905 assert_or_panic(v[9] == 54);
4906 assert_or_panic(v[10] == 55);
4907 assert_or_panic(v[11] == 56);
4908 assert_or_panic(v[12] == 57);
4909 assert_or_panic(v[13] == 58);
4910 assert_or_panic(v[14] == 59);
4911 assert_or_panic(v[15] == 60);
4912 zig_vector_16_u8((Vector_16_u8){ 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76 }, 16);
4913}
4914
4915typedef uint8_t Vector_24_u8 __attribute__((vector_size(24 * sizeof(uint8_t))));
4916
4917Vector_24_u8 zig_ret_vector_24_u8(void);
4918void zig_vector_24_u8(Vector_24_u8, size_t);
4919
4920Vector_24_u8 c_ret_vector_24_u8(void) {
4921 return (Vector_24_u8){
4922 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72,
4923 73, 74, 75, 76, 77, 78, 79, 80,
4924 };
4925}
4926void c_vector_24_u8(Vector_24_u8 v, size_t i) {
4927 assert_or_panic(v[0] == 81);
4928 assert_or_panic(v[1] == 82);
4929 assert_or_panic(v[2] == 83);
4930 assert_or_panic(v[3] == 84);
4931 assert_or_panic(v[4] == 85);
4932 assert_or_panic(v[5] == 86);
4933 assert_or_panic(v[6] == 87);
4934 assert_or_panic(v[7] == 88);
4935 assert_or_panic(v[8] == 89);
4936 assert_or_panic(v[9] == 90);
4937 assert_or_panic(v[10] == 91);
4938 assert_or_panic(v[11] == 92);
4939 assert_or_panic(v[12] == 93);
4940 assert_or_panic(v[13] == 94);
4941 assert_or_panic(v[14] == 95);
4942 assert_or_panic(v[15] == 96);
4943 assert_or_panic(v[16] == 97);
4944 assert_or_panic(v[17] == 98);
4945 assert_or_panic(v[18] == 99);
4946 assert_or_panic(v[19] == 0);
4947 assert_or_panic(v[20] == 1);
4948 assert_or_panic(v[21] == 2);
4949 assert_or_panic(v[22] == 3);
4950 assert_or_panic(v[23] == 4);
4951 assert_or_panic(i == 24);
4952}
4953void c_test_vector_24_u8(void) {
4954 Vector_24_u8 v = zig_ret_vector_24_u8();
4955 assert_or_panic(v[0] == 9);
4956 assert_or_panic(v[1] == 10);
4957 assert_or_panic(v[2] == 11);
4958 assert_or_panic(v[3] == 12);
4959 assert_or_panic(v[4] == 13);
4960 assert_or_panic(v[5] == 14);
4961 assert_or_panic(v[6] == 15);
4962 assert_or_panic(v[7] == 16);
4963 assert_or_panic(v[8] == 17);
4964 assert_or_panic(v[9] == 18);
4965 assert_or_panic(v[10] == 19);
4966 assert_or_panic(v[11] == 20);
4967 assert_or_panic(v[12] == 21);
4968 assert_or_panic(v[13] == 22);
4969 assert_or_panic(v[14] == 23);
4970 assert_or_panic(v[15] == 24);
4971 assert_or_panic(v[16] == 25);
4972 assert_or_panic(v[17] == 26);
4973 assert_or_panic(v[18] == 27);
4974 assert_or_panic(v[19] == 28);
4975 assert_or_panic(v[20] == 29);
4976 assert_or_panic(v[21] == 30);
4977 assert_or_panic(v[22] == 31);
4978 assert_or_panic(v[23] == 32);
4979 zig_vector_24_u8((Vector_24_u8){
4980 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
4981 49, 50, 51, 52, 53, 54, 55, 56,
4982 }, 24);
4983}
4984
4985typedef uint8_t Vector_32_u8 __attribute__((vector_size(32 * sizeof(uint8_t))));
4986
4987Vector_32_u8 zig_ret_vector_32_u8(void);
4988void zig_vector_32_u8(Vector_32_u8, size_t);
4989
4990Vector_32_u8 c_ret_vector_32_u8(void) {
4991 return (Vector_32_u8){
4992 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
4993 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0,
4994 };
4995}
4996void c_vector_32_u8(Vector_32_u8 v, size_t i) {
4997 assert_or_panic(v[0] == 1);
4998 assert_or_panic(v[1] == 2);
4999 assert_or_panic(v[2] == 3);
5000 assert_or_panic(v[3] == 4);
5001 assert_or_panic(v[4] == 5);
5002 assert_or_panic(v[5] == 6);
5003 assert_or_panic(v[6] == 7);
5004 assert_or_panic(v[7] == 8);
5005 assert_or_panic(v[8] == 9);
5006 assert_or_panic(v[9] == 10);
5007 assert_or_panic(v[10] == 11);
5008 assert_or_panic(v[11] == 12);
5009 assert_or_panic(v[12] == 13);
5010 assert_or_panic(v[13] == 14);
5011 assert_or_panic(v[14] == 15);
5012 assert_or_panic(v[15] == 16);
5013 assert_or_panic(v[16] == 17);
5014 assert_or_panic(v[17] == 18);
5015 assert_or_panic(v[18] == 19);
5016 assert_or_panic(v[19] == 20);
5017 assert_or_panic(v[20] == 21);
5018 assert_or_panic(v[21] == 22);
5019 assert_or_panic(v[22] == 23);
5020 assert_or_panic(v[23] == 24);
5021 assert_or_panic(v[24] == 25);
5022 assert_or_panic(v[25] == 26);
5023 assert_or_panic(v[26] == 27);
5024 assert_or_panic(v[27] == 28);
5025 assert_or_panic(v[28] == 29);
5026 assert_or_panic(v[29] == 30);
5027 assert_or_panic(v[30] == 31);
5028 assert_or_panic(v[31] == 32);
5029 assert_or_panic(i == 32);
5030}
5031void c_test_vector_32_u8(void) {
5032 Vector_32_u8 v = zig_ret_vector_32_u8();
5033 assert_or_panic(v[0] == 5);
5034 assert_or_panic(v[1] == 6);
5035 assert_or_panic(v[2] == 7);
5036 assert_or_panic(v[3] == 8);
5037 assert_or_panic(v[4] == 9);
5038 assert_or_panic(v[5] == 10);
5039 assert_or_panic(v[6] == 11);
5040 assert_or_panic(v[7] == 12);
5041 assert_or_panic(v[8] == 13);
5042 assert_or_panic(v[9] == 14);
5043 assert_or_panic(v[10] == 15);
5044 assert_or_panic(v[11] == 16);
5045 assert_or_panic(v[12] == 17);
5046 assert_or_panic(v[13] == 18);
5047 assert_or_panic(v[14] == 19);
5048 assert_or_panic(v[15] == 20);
5049 assert_or_panic(v[16] == 21);
5050 assert_or_panic(v[17] == 22);
5051 assert_or_panic(v[18] == 23);
5052 assert_or_panic(v[19] == 24);
5053 assert_or_panic(v[20] == 25);
5054 assert_or_panic(v[21] == 26);
5055 assert_or_panic(v[22] == 27);
5056 assert_or_panic(v[23] == 28);
5057 assert_or_panic(v[24] == 29);
5058 assert_or_panic(v[25] == 30);
5059 assert_or_panic(v[26] == 31);
5060 assert_or_panic(v[27] == 32);
5061 assert_or_panic(v[28] == 33);
5062 assert_or_panic(v[29] == 34);
5063 assert_or_panic(v[30] == 35);
5064 assert_or_panic(v[31] == 36);
5065 zig_vector_32_u8((Vector_32_u8){
5066 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
5067 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
5068 }, 32);
5069}
5070
5071typedef uint8_t Vector_48_u8 __attribute__((vector_size(48 * sizeof(uint8_t))));
5072
5073Vector_48_u8 zig_ret_vector_48_u8(void);
5074void zig_vector_48_u8(Vector_48_u8, size_t);
5075
5076Vector_48_u8 c_ret_vector_48_u8(void) {
5077 return (Vector_48_u8){
5078 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
5079 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60,
5080 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76,
5081 };
5082}
5083void c_vector_48_u8(Vector_48_u8 v, size_t i) {
5084 assert_or_panic(v[0] == 77);
5085 assert_or_panic(v[1] == 78);
5086 assert_or_panic(v[2] == 79);
5087 assert_or_panic(v[3] == 80);
5088 assert_or_panic(v[4] == 81);
5089 assert_or_panic(v[5] == 82);
5090 assert_or_panic(v[6] == 83);
5091 assert_or_panic(v[7] == 84);
5092 assert_or_panic(v[8] == 85);
5093 assert_or_panic(v[9] == 86);
5094 assert_or_panic(v[10] == 87);
5095 assert_or_panic(v[11] == 88);
5096 assert_or_panic(v[12] == 89);
5097 assert_or_panic(v[13] == 90);
5098 assert_or_panic(v[14] == 91);
5099 assert_or_panic(v[15] == 92);
5100 assert_or_panic(v[16] == 93);
5101 assert_or_panic(v[17] == 94);
5102 assert_or_panic(v[18] == 95);
5103 assert_or_panic(v[19] == 96);
5104 assert_or_panic(v[20] == 97);
5105 assert_or_panic(v[21] == 98);
5106 assert_or_panic(v[22] == 99);
5107 assert_or_panic(v[23] == 0);
5108 assert_or_panic(v[24] == 1);
5109 assert_or_panic(v[25] == 2);
5110 assert_or_panic(v[26] == 3);
5111 assert_or_panic(v[27] == 4);
5112 assert_or_panic(v[28] == 5);
5113 assert_or_panic(v[29] == 6);
5114 assert_or_panic(v[30] == 7);
5115 assert_or_panic(v[31] == 8);
5116 assert_or_panic(v[32] == 9);
5117 assert_or_panic(v[33] == 10);
5118 assert_or_panic(v[34] == 11);
5119 assert_or_panic(v[35] == 12);
5120 assert_or_panic(v[36] == 13);
5121 assert_or_panic(v[37] == 14);
5122 assert_or_panic(v[38] == 15);
5123 assert_or_panic(v[39] == 16);
5124 assert_or_panic(v[40] == 17);
5125 assert_or_panic(v[41] == 18);
5126 assert_or_panic(v[42] == 19);
5127 assert_or_panic(v[43] == 20);
5128 assert_or_panic(v[44] == 21);
5129 assert_or_panic(v[45] == 22);
5130 assert_or_panic(v[46] == 23);
5131 assert_or_panic(v[47] == 24);
5132 assert_or_panic(i == 48);
5133}
5134void c_test_vector_48_u8(void) {
5135 Vector_48_u8 v = zig_ret_vector_48_u8();
5136 assert_or_panic(v[0] == 33);
5137 assert_or_panic(v[1] == 34);
5138 assert_or_panic(v[2] == 35);
5139 assert_or_panic(v[3] == 36);
5140 assert_or_panic(v[4] == 37);
5141 assert_or_panic(v[5] == 38);
5142 assert_or_panic(v[6] == 39);
5143 assert_or_panic(v[7] == 40);
5144 assert_or_panic(v[8] == 41);
5145 assert_or_panic(v[9] == 42);
5146 assert_or_panic(v[10] == 43);
5147 assert_or_panic(v[11] == 44);
5148 assert_or_panic(v[12] == 45);
5149 assert_or_panic(v[13] == 46);
5150 assert_or_panic(v[14] == 47);
5151 assert_or_panic(v[15] == 48);
5152 assert_or_panic(v[16] == 49);
5153 assert_or_panic(v[17] == 50);
5154 assert_or_panic(v[18] == 51);
5155 assert_or_panic(v[19] == 52);
5156 assert_or_panic(v[20] == 53);
5157 assert_or_panic(v[21] == 54);
5158 assert_or_panic(v[22] == 55);
5159 assert_or_panic(v[23] == 56);
5160 assert_or_panic(v[24] == 57);
5161 assert_or_panic(v[25] == 58);
5162 assert_or_panic(v[26] == 59);
5163 assert_or_panic(v[27] == 60);
5164 assert_or_panic(v[28] == 61);
5165 assert_or_panic(v[29] == 62);
5166 assert_or_panic(v[30] == 63);
5167 assert_or_panic(v[31] == 64);
5168 assert_or_panic(v[32] == 65);
5169 assert_or_panic(v[33] == 66);
5170 assert_or_panic(v[34] == 67);
5171 assert_or_panic(v[35] == 68);
5172 assert_or_panic(v[36] == 69);
5173 assert_or_panic(v[37] == 70);
5174 assert_or_panic(v[38] == 71);
5175 assert_or_panic(v[39] == 72);
5176 assert_or_panic(v[40] == 73);
5177 assert_or_panic(v[41] == 74);
5178 assert_or_panic(v[42] == 75);
5179 assert_or_panic(v[43] == 76);
5180 assert_or_panic(v[44] == 77);
5181 assert_or_panic(v[45] == 78);
5182 assert_or_panic(v[46] == 79);
5183 assert_or_panic(v[47] == 80);
5184 zig_vector_48_u8((Vector_48_u8){
5185 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96,
5186 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
5187 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
5188 }, 48);
5189}
5190
5191typedef uint8_t Vector_64_u8 __attribute__((vector_size(64 * sizeof(uint8_t))));
5192
5193Vector_64_u8 zig_ret_vector_64_u8(void);
5194void zig_vector_64_u8(Vector_64_u8, size_t);
5195
5196Vector_64_u8 c_ret_vector_64_u8(void) {
5197 return (Vector_64_u8){
5198 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68,
5199 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
5200 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0,
5201 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
5202 };
5203}
5204void c_vector_64_u8(Vector_64_u8 v, size_t i) {
5205 assert_or_panic(v[0] == 17);
5206 assert_or_panic(v[1] == 18);
5207 assert_or_panic(v[2] == 19);
5208 assert_or_panic(v[3] == 20);
5209 assert_or_panic(v[4] == 21);
5210 assert_or_panic(v[5] == 22);
5211 assert_or_panic(v[6] == 23);
5212 assert_or_panic(v[7] == 24);
5213 assert_or_panic(v[8] == 25);
5214 assert_or_panic(v[9] == 26);
5215 assert_or_panic(v[10] == 27);
5216 assert_or_panic(v[11] == 28);
5217 assert_or_panic(v[12] == 29);
5218 assert_or_panic(v[13] == 30);
5219 assert_or_panic(v[14] == 31);
5220 assert_or_panic(v[15] == 32);
5221 assert_or_panic(v[16] == 33);
5222 assert_or_panic(v[17] == 34);
5223 assert_or_panic(v[18] == 35);
5224 assert_or_panic(v[19] == 36);
5225 assert_or_panic(v[20] == 37);
5226 assert_or_panic(v[21] == 38);
5227 assert_or_panic(v[22] == 39);
5228 assert_or_panic(v[23] == 40);
5229 assert_or_panic(v[24] == 41);
5230 assert_or_panic(v[25] == 42);
5231 assert_or_panic(v[26] == 43);
5232 assert_or_panic(v[27] == 44);
5233 assert_or_panic(v[28] == 45);
5234 assert_or_panic(v[29] == 46);
5235 assert_or_panic(v[30] == 47);
5236 assert_or_panic(v[31] == 48);
5237 assert_or_panic(v[32] == 49);
5238 assert_or_panic(v[33] == 50);
5239 assert_or_panic(v[34] == 51);
5240 assert_or_panic(v[35] == 52);
5241 assert_or_panic(v[36] == 53);
5242 assert_or_panic(v[37] == 54);
5243 assert_or_panic(v[38] == 55);
5244 assert_or_panic(v[39] == 56);
5245 assert_or_panic(v[40] == 57);
5246 assert_or_panic(v[41] == 58);
5247 assert_or_panic(v[42] == 59);
5248 assert_or_panic(v[43] == 60);
5249 assert_or_panic(v[44] == 61);
5250 assert_or_panic(v[45] == 62);
5251 assert_or_panic(v[46] == 63);
5252 assert_or_panic(v[47] == 64);
5253 assert_or_panic(v[48] == 65);
5254 assert_or_panic(v[49] == 66);
5255 assert_or_panic(v[50] == 67);
5256 assert_or_panic(v[51] == 68);
5257 assert_or_panic(v[52] == 69);
5258 assert_or_panic(v[53] == 70);
5259 assert_or_panic(v[54] == 71);
5260 assert_or_panic(v[55] == 72);
5261 assert_or_panic(v[56] == 73);
5262 assert_or_panic(v[57] == 74);
5263 assert_or_panic(v[58] == 75);
5264 assert_or_panic(v[59] == 76);
5265 assert_or_panic(v[60] == 77);
5266 assert_or_panic(v[61] == 78);
5267 assert_or_panic(v[62] == 79);
5268 assert_or_panic(v[63] == 80);
5269 assert_or_panic(i == 64);
5270}
5271void c_test_vector_64_u8(void) {
5272 Vector_64_u8 v = zig_ret_vector_64_u8();
5273 assert_or_panic(v[0] == 25);
5274 assert_or_panic(v[1] == 26);
5275 assert_or_panic(v[2] == 27);
5276 assert_or_panic(v[3] == 28);
5277 assert_or_panic(v[4] == 29);
5278 assert_or_panic(v[5] == 30);
5279 assert_or_panic(v[6] == 31);
5280 assert_or_panic(v[7] == 32);
5281 assert_or_panic(v[8] == 33);
5282 assert_or_panic(v[9] == 34);
5283 assert_or_panic(v[10] == 35);
5284 assert_or_panic(v[11] == 36);
5285 assert_or_panic(v[12] == 37);
5286 assert_or_panic(v[13] == 38);
5287 assert_or_panic(v[14] == 39);
5288 assert_or_panic(v[15] == 40);
5289 assert_or_panic(v[16] == 41);
5290 assert_or_panic(v[17] == 42);
5291 assert_or_panic(v[18] == 43);
5292 assert_or_panic(v[19] == 44);
5293 assert_or_panic(v[20] == 45);
5294 assert_or_panic(v[21] == 46);
5295 assert_or_panic(v[22] == 47);
5296 assert_or_panic(v[23] == 48);
5297 assert_or_panic(v[24] == 49);
5298 assert_or_panic(v[25] == 50);
5299 assert_or_panic(v[26] == 51);
5300 assert_or_panic(v[27] == 52);
5301 assert_or_panic(v[28] == 53);
5302 assert_or_panic(v[29] == 54);
5303 assert_or_panic(v[30] == 55);
5304 assert_or_panic(v[31] == 56);
5305 assert_or_panic(v[32] == 57);
5306 assert_or_panic(v[33] == 58);
5307 assert_or_panic(v[34] == 59);
5308 assert_or_panic(v[35] == 60);
5309 assert_or_panic(v[36] == 61);
5310 assert_or_panic(v[37] == 62);
5311 assert_or_panic(v[38] == 63);
5312 assert_or_panic(v[39] == 64);
5313 assert_or_panic(v[40] == 65);
5314 assert_or_panic(v[41] == 66);
5315 assert_or_panic(v[42] == 67);
5316 assert_or_panic(v[43] == 68);
5317 assert_or_panic(v[44] == 69);
5318 assert_or_panic(v[45] == 70);
5319 assert_or_panic(v[46] == 71);
5320 assert_or_panic(v[47] == 72);
5321 assert_or_panic(v[48] == 73);
5322 assert_or_panic(v[49] == 74);
5323 assert_or_panic(v[50] == 75);
5324 assert_or_panic(v[51] == 76);
5325 assert_or_panic(v[52] == 77);
5326 assert_or_panic(v[53] == 78);
5327 assert_or_panic(v[54] == 79);
5328 assert_or_panic(v[55] == 80);
5329 assert_or_panic(v[56] == 81);
5330 assert_or_panic(v[57] == 82);
5331 assert_or_panic(v[58] == 83);
5332 assert_or_panic(v[59] == 84);
5333 assert_or_panic(v[60] == 85);
5334 assert_or_panic(v[61] == 86);
5335 assert_or_panic(v[62] == 87);
5336 assert_or_panic(v[63] == 88);
5337 zig_vector_64_u8((Vector_64_u8){
5338 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4,
5339 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
5340 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
5341 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
5342 }, 64);
5343}
5344
5345typedef uint8_t Vector_96_u8 __attribute__((vector_size(96 * sizeof(uint8_t))));
5346
5347Vector_96_u8 zig_ret_vector_96_u8(void);
5348void zig_vector_96_u8(Vector_96_u8, size_t);
5349
5350Vector_96_u8 c_ret_vector_96_u8(void) {
5351 return (Vector_96_u8){
5352 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
5353 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
5354 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
5355 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
5356 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
5357 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
5358 };
5359}
5360void c_vector_96_u8(Vector_96_u8 v, size_t i) {
5361 assert_or_panic(v[0] == 78);
5362 assert_or_panic(v[1] == 79);
5363 assert_or_panic(v[2] == 80);
5364 assert_or_panic(v[3] == 81);
5365 assert_or_panic(v[4] == 82);
5366 assert_or_panic(v[5] == 83);
5367 assert_or_panic(v[6] == 84);
5368 assert_or_panic(v[7] == 85);
5369 assert_or_panic(v[8] == 86);
5370 assert_or_panic(v[9] == 87);
5371 assert_or_panic(v[10] == 88);
5372 assert_or_panic(v[11] == 89);
5373 assert_or_panic(v[12] == 90);
5374 assert_or_panic(v[13] == 91);
5375 assert_or_panic(v[14] == 92);
5376 assert_or_panic(v[15] == 93);
5377 assert_or_panic(v[16] == 94);
5378 assert_or_panic(v[17] == 95);
5379 assert_or_panic(v[18] == 96);
5380 assert_or_panic(v[19] == 97);
5381 assert_or_panic(v[20] == 98);
5382 assert_or_panic(v[21] == 99);
5383 assert_or_panic(v[22] == 0);
5384 assert_or_panic(v[23] == 1);
5385 assert_or_panic(v[24] == 2);
5386 assert_or_panic(v[25] == 3);
5387 assert_or_panic(v[26] == 4);
5388 assert_or_panic(v[27] == 5);
5389 assert_or_panic(v[28] == 6);
5390 assert_or_panic(v[29] == 7);
5391 assert_or_panic(v[30] == 8);
5392 assert_or_panic(v[31] == 9);
5393 assert_or_panic(v[32] == 10);
5394 assert_or_panic(v[33] == 11);
5395 assert_or_panic(v[34] == 12);
5396 assert_or_panic(v[35] == 13);
5397 assert_or_panic(v[36] == 14);
5398 assert_or_panic(v[37] == 15);
5399 assert_or_panic(v[38] == 16);
5400 assert_or_panic(v[39] == 17);
5401 assert_or_panic(v[40] == 18);
5402 assert_or_panic(v[41] == 19);
5403 assert_or_panic(v[42] == 20);
5404 assert_or_panic(v[43] == 21);
5405 assert_or_panic(v[44] == 22);
5406 assert_or_panic(v[45] == 23);
5407 assert_or_panic(v[46] == 24);
5408 assert_or_panic(v[47] == 25);
5409 assert_or_panic(v[48] == 26);
5410 assert_or_panic(v[49] == 27);
5411 assert_or_panic(v[50] == 28);
5412 assert_or_panic(v[51] == 29);
5413 assert_or_panic(v[52] == 30);
5414 assert_or_panic(v[53] == 31);
5415 assert_or_panic(v[54] == 32);
5416 assert_or_panic(v[55] == 33);
5417 assert_or_panic(v[56] == 34);
5418 assert_or_panic(v[57] == 35);
5419 assert_or_panic(v[58] == 36);
5420 assert_or_panic(v[59] == 37);
5421 assert_or_panic(v[60] == 38);
5422 assert_or_panic(v[61] == 39);
5423 assert_or_panic(v[62] == 40);
5424 assert_or_panic(v[63] == 41);
5425 assert_or_panic(v[64] == 42);
5426 assert_or_panic(v[65] == 43);
5427 assert_or_panic(v[66] == 44);
5428 assert_or_panic(v[67] == 45);
5429 assert_or_panic(v[68] == 46);
5430 assert_or_panic(v[69] == 47);
5431 assert_or_panic(v[70] == 48);
5432 assert_or_panic(v[71] == 49);
5433 assert_or_panic(v[72] == 50);
5434 assert_or_panic(v[73] == 51);
5435 assert_or_panic(v[74] == 52);
5436 assert_or_panic(v[75] == 53);
5437 assert_or_panic(v[76] == 54);
5438 assert_or_panic(v[77] == 55);
5439 assert_or_panic(v[80] == 58);
5440 assert_or_panic(v[81] == 59);
5441 assert_or_panic(v[82] == 60);
5442 assert_or_panic(v[83] == 61);
5443 assert_or_panic(v[84] == 62);
5444 assert_or_panic(v[85] == 63);
5445 assert_or_panic(v[86] == 64);
5446 assert_or_panic(v[87] == 65);
5447 assert_or_panic(v[88] == 66);
5448 assert_or_panic(v[89] == 67);
5449 assert_or_panic(v[90] == 68);
5450 assert_or_panic(v[91] == 69);
5451 assert_or_panic(v[92] == 70);
5452 assert_or_panic(v[93] == 71);
5453 assert_or_panic(v[94] == 72);
5454 assert_or_panic(v[95] == 73);
5455 assert_or_panic(i == 96);
5456}
5457void c_test_vector_96_u8(void) {
5458 Vector_96_u8 v = zig_ret_vector_96_u8();
5459 assert_or_panic(v[0] == 90);
5460 assert_or_panic(v[1] == 91);
5461 assert_or_panic(v[2] == 92);
5462 assert_or_panic(v[3] == 93);
5463 assert_or_panic(v[4] == 94);
5464 assert_or_panic(v[5] == 95);
5465 assert_or_panic(v[6] == 96);
5466 assert_or_panic(v[7] == 97);
5467 assert_or_panic(v[8] == 98);
5468 assert_or_panic(v[9] == 99);
5469 assert_or_panic(v[10] == 0);
5470 assert_or_panic(v[11] == 1);
5471 assert_or_panic(v[12] == 2);
5472 assert_or_panic(v[13] == 3);
5473 assert_or_panic(v[14] == 4);
5474 assert_or_panic(v[15] == 5);
5475 assert_or_panic(v[16] == 6);
5476 assert_or_panic(v[17] == 7);
5477 assert_or_panic(v[18] == 8);
5478 assert_or_panic(v[19] == 9);
5479 assert_or_panic(v[20] == 10);
5480 assert_or_panic(v[21] == 11);
5481 assert_or_panic(v[22] == 12);
5482 assert_or_panic(v[23] == 13);
5483 assert_or_panic(v[24] == 14);
5484 assert_or_panic(v[25] == 15);
5485 assert_or_panic(v[26] == 16);
5486 assert_or_panic(v[27] == 17);
5487 assert_or_panic(v[28] == 18);
5488 assert_or_panic(v[29] == 19);
5489 assert_or_panic(v[30] == 20);
5490 assert_or_panic(v[31] == 21);
5491 assert_or_panic(v[32] == 22);
5492 assert_or_panic(v[33] == 23);
5493 assert_or_panic(v[34] == 24);
5494 assert_or_panic(v[35] == 25);
5495 assert_or_panic(v[36] == 26);
5496 assert_or_panic(v[37] == 27);
5497 assert_or_panic(v[38] == 28);
5498 assert_or_panic(v[39] == 29);
5499 assert_or_panic(v[40] == 30);
5500 assert_or_panic(v[41] == 31);
5501 assert_or_panic(v[42] == 32);
5502 assert_or_panic(v[43] == 33);
5503 assert_or_panic(v[44] == 34);
5504 assert_or_panic(v[45] == 35);
5505 assert_or_panic(v[46] == 36);
5506 assert_or_panic(v[47] == 37);
5507 assert_or_panic(v[48] == 38);
5508 assert_or_panic(v[49] == 39);
5509 assert_or_panic(v[50] == 40);
5510 assert_or_panic(v[51] == 41);
5511 assert_or_panic(v[52] == 42);
5512 assert_or_panic(v[53] == 43);
5513 assert_or_panic(v[54] == 44);
5514 assert_or_panic(v[55] == 45);
5515 assert_or_panic(v[56] == 46);
5516 assert_or_panic(v[57] == 47);
5517 assert_or_panic(v[58] == 48);
5518 assert_or_panic(v[59] == 49);
5519 assert_or_panic(v[60] == 50);
5520 assert_or_panic(v[61] == 51);
5521 assert_or_panic(v[62] == 52);
5522 assert_or_panic(v[63] == 53);
5523 assert_or_panic(v[64] == 54);
5524 assert_or_panic(v[65] == 55);
5525 assert_or_panic(v[66] == 56);
5526 assert_or_panic(v[67] == 57);
5527 assert_or_panic(v[68] == 58);
5528 assert_or_panic(v[69] == 59);
5529 assert_or_panic(v[70] == 60);
5530 assert_or_panic(v[71] == 61);
5531 assert_or_panic(v[72] == 62);
5532 assert_or_panic(v[73] == 63);
5533 assert_or_panic(v[74] == 64);
5534 assert_or_panic(v[75] == 65);
5535 assert_or_panic(v[76] == 66);
5536 assert_or_panic(v[77] == 67);
5537 assert_or_panic(v[78] == 68);
5538 assert_or_panic(v[79] == 69);
5539 assert_or_panic(v[80] == 70);
5540 assert_or_panic(v[81] == 71);
5541 assert_or_panic(v[82] == 72);
5542 assert_or_panic(v[83] == 73);
5543 assert_or_panic(v[84] == 74);
5544 assert_or_panic(v[85] == 75);
5545 assert_or_panic(v[86] == 76);
5546 assert_or_panic(v[87] == 77);
5547 assert_or_panic(v[88] == 78);
5548 assert_or_panic(v[89] == 79);
5549 assert_or_panic(v[90] == 80);
5550 assert_or_panic(v[91] == 81);
5551 assert_or_panic(v[92] == 82);
5552 assert_or_panic(v[93] == 83);
5553 assert_or_panic(v[94] == 84);
5554 assert_or_panic(v[95] == 85);
5555 zig_vector_96_u8((Vector_96_u8){
5556 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
5557 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
5558 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
5559 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
5560 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
5561 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
5562 }, 96);
5563}
5564
5565typedef uint8_t Vector_128_u8 __attribute__((vector_size(128 * sizeof(uint8_t))));
5566
5567Vector_128_u8 zig_ret_vector_128_u8(void);
5568void zig_vector_128_u8(Vector_128_u8, size_t);
5569
5570Vector_128_u8 c_ret_vector_128_u8(void) {
5571 return (Vector_128_u8){
5572 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
5573 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
5574 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
5575 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
5576 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
5577 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
5578 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
5579 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
5580 };
5581}
5582void c_vector_128_u8(Vector_128_u8 v, size_t i) {
5583 assert_or_panic(v[0] == 58);
5584 assert_or_panic(v[1] == 59);
5585 assert_or_panic(v[2] == 60);
5586 assert_or_panic(v[3] == 61);
5587 assert_or_panic(v[4] == 62);
5588 assert_or_panic(v[5] == 63);
5589 assert_or_panic(v[6] == 64);
5590 assert_or_panic(v[7] == 65);
5591 assert_or_panic(v[8] == 66);
5592 assert_or_panic(v[9] == 67);
5593 assert_or_panic(v[10] == 68);
5594 assert_or_panic(v[11] == 69);
5595 assert_or_panic(v[12] == 70);
5596 assert_or_panic(v[13] == 71);
5597 assert_or_panic(v[14] == 72);
5598 assert_or_panic(v[15] == 73);
5599 assert_or_panic(v[16] == 74);
5600 assert_or_panic(v[17] == 75);
5601 assert_or_panic(v[18] == 76);
5602 assert_or_panic(v[19] == 77);
5603 assert_or_panic(v[20] == 78);
5604 assert_or_panic(v[21] == 79);
5605 assert_or_panic(v[22] == 80);
5606 assert_or_panic(v[23] == 81);
5607 assert_or_panic(v[24] == 82);
5608 assert_or_panic(v[25] == 83);
5609 assert_or_panic(v[26] == 84);
5610 assert_or_panic(v[27] == 85);
5611 assert_or_panic(v[28] == 86);
5612 assert_or_panic(v[29] == 87);
5613 assert_or_panic(v[30] == 88);
5614 assert_or_panic(v[31] == 89);
5615 assert_or_panic(v[32] == 90);
5616 assert_or_panic(v[33] == 91);
5617 assert_or_panic(v[34] == 92);
5618 assert_or_panic(v[35] == 93);
5619 assert_or_panic(v[36] == 94);
5620 assert_or_panic(v[37] == 95);
5621 assert_or_panic(v[38] == 96);
5622 assert_or_panic(v[39] == 97);
5623 assert_or_panic(v[40] == 98);
5624 assert_or_panic(v[41] == 99);
5625 assert_or_panic(v[42] == 0);
5626 assert_or_panic(v[43] == 1);
5627 assert_or_panic(v[44] == 2);
5628 assert_or_panic(v[45] == 3);
5629 assert_or_panic(v[46] == 4);
5630 assert_or_panic(v[47] == 5);
5631 assert_or_panic(v[48] == 6);
5632 assert_or_panic(v[49] == 7);
5633 assert_or_panic(v[50] == 8);
5634 assert_or_panic(v[51] == 9);
5635 assert_or_panic(v[52] == 10);
5636 assert_or_panic(v[53] == 11);
5637 assert_or_panic(v[54] == 12);
5638 assert_or_panic(v[55] == 13);
5639 assert_or_panic(v[56] == 14);
5640 assert_or_panic(v[57] == 15);
5641 assert_or_panic(v[58] == 16);
5642 assert_or_panic(v[59] == 17);
5643 assert_or_panic(v[60] == 18);
5644 assert_or_panic(v[61] == 19);
5645 assert_or_panic(v[62] == 20);
5646 assert_or_panic(v[63] == 21);
5647 assert_or_panic(v[64] == 22);
5648 assert_or_panic(v[65] == 23);
5649 assert_or_panic(v[66] == 24);
5650 assert_or_panic(v[67] == 25);
5651 assert_or_panic(v[68] == 26);
5652 assert_or_panic(v[69] == 27);
5653 assert_or_panic(v[70] == 28);
5654 assert_or_panic(v[71] == 29);
5655 assert_or_panic(v[72] == 30);
5656 assert_or_panic(v[73] == 31);
5657 assert_or_panic(v[74] == 32);
5658 assert_or_panic(v[75] == 33);
5659 assert_or_panic(v[76] == 34);
5660 assert_or_panic(v[77] == 35);
5661 assert_or_panic(v[78] == 36);
5662 assert_or_panic(v[79] == 37);
5663 assert_or_panic(v[80] == 38);
5664 assert_or_panic(v[81] == 39);
5665 assert_or_panic(v[82] == 40);
5666 assert_or_panic(v[83] == 41);
5667 assert_or_panic(v[84] == 42);
5668 assert_or_panic(v[85] == 43);
5669 assert_or_panic(v[86] == 44);
5670 assert_or_panic(v[87] == 45);
5671 assert_or_panic(v[88] == 46);
5672 assert_or_panic(v[89] == 47);
5673 assert_or_panic(v[90] == 48);
5674 assert_or_panic(v[91] == 49);
5675 assert_or_panic(v[92] == 50);
5676 assert_or_panic(v[93] == 51);
5677 assert_or_panic(v[94] == 52);
5678 assert_or_panic(v[95] == 53);
5679 assert_or_panic(v[96] == 54);
5680 assert_or_panic(v[97] == 55);
5681 assert_or_panic(v[98] == 56);
5682 assert_or_panic(v[99] == 57);
5683 assert_or_panic(v[100] == 58);
5684 assert_or_panic(v[101] == 59);
5685 assert_or_panic(v[102] == 60);
5686 assert_or_panic(v[103] == 61);
5687 assert_or_panic(v[104] == 62);
5688 assert_or_panic(v[105] == 63);
5689 assert_or_panic(v[106] == 64);
5690 assert_or_panic(v[107] == 65);
5691 assert_or_panic(v[108] == 66);
5692 assert_or_panic(v[109] == 67);
5693 assert_or_panic(v[110] == 68);
5694 assert_or_panic(v[111] == 69);
5695 assert_or_panic(v[112] == 70);
5696 assert_or_panic(v[113] == 71);
5697 assert_or_panic(v[114] == 72);
5698 assert_or_panic(v[115] == 73);
5699 assert_or_panic(v[116] == 74);
5700 assert_or_panic(v[117] == 75);
5701 assert_or_panic(v[118] == 76);
5702 assert_or_panic(v[119] == 77);
5703 assert_or_panic(v[120] == 78);
5704 assert_or_panic(v[121] == 79);
5705 assert_or_panic(v[122] == 80);
5706 assert_or_panic(v[123] == 81);
5707 assert_or_panic(v[124] == 82);
5708 assert_or_panic(v[125] == 83);
5709 assert_or_panic(v[126] == 84);
5710 assert_or_panic(v[127] == 85);
5711 assert_or_panic(i == 128);
5712}
5713void c_test_vector_128_u8(void) {
5714 Vector_128_u8 v = zig_ret_vector_128_u8();
5715 assert_or_panic(v[0] == 74);
5716 assert_or_panic(v[1] == 75);
5717 assert_or_panic(v[2] == 76);
5718 assert_or_panic(v[3] == 77);
5719 assert_or_panic(v[4] == 78);
5720 assert_or_panic(v[5] == 79);
5721 assert_or_panic(v[6] == 80);
5722 assert_or_panic(v[7] == 81);
5723 assert_or_panic(v[8] == 82);
5724 assert_or_panic(v[9] == 83);
5725 assert_or_panic(v[10] == 84);
5726 assert_or_panic(v[11] == 85);
5727 assert_or_panic(v[12] == 86);
5728 assert_or_panic(v[13] == 87);
5729 assert_or_panic(v[14] == 88);
5730 assert_or_panic(v[15] == 89);
5731 assert_or_panic(v[16] == 90);
5732 assert_or_panic(v[17] == 91);
5733 assert_or_panic(v[18] == 92);
5734 assert_or_panic(v[19] == 93);
5735 assert_or_panic(v[20] == 94);
5736 assert_or_panic(v[21] == 95);
5737 assert_or_panic(v[22] == 96);
5738 assert_or_panic(v[23] == 97);
5739 assert_or_panic(v[24] == 98);
5740 assert_or_panic(v[25] == 99);
5741 assert_or_panic(v[26] == 0);
5742 assert_or_panic(v[27] == 1);
5743 assert_or_panic(v[28] == 2);
5744 assert_or_panic(v[29] == 3);
5745 assert_or_panic(v[30] == 4);
5746 assert_or_panic(v[31] == 5);
5747 assert_or_panic(v[32] == 6);
5748 assert_or_panic(v[33] == 7);
5749 assert_or_panic(v[34] == 8);
5750 assert_or_panic(v[35] == 9);
5751 assert_or_panic(v[36] == 10);
5752 assert_or_panic(v[37] == 11);
5753 assert_or_panic(v[38] == 12);
5754 assert_or_panic(v[39] == 13);
5755 assert_or_panic(v[40] == 14);
5756 assert_or_panic(v[41] == 15);
5757 assert_or_panic(v[42] == 16);
5758 assert_or_panic(v[43] == 17);
5759 assert_or_panic(v[44] == 18);
5760 assert_or_panic(v[45] == 19);
5761 assert_or_panic(v[46] == 20);
5762 assert_or_panic(v[47] == 21);
5763 assert_or_panic(v[48] == 22);
5764 assert_or_panic(v[49] == 23);
5765 assert_or_panic(v[50] == 24);
5766 assert_or_panic(v[51] == 25);
5767 assert_or_panic(v[52] == 26);
5768 assert_or_panic(v[53] == 27);
5769 assert_or_panic(v[54] == 28);
5770 assert_or_panic(v[55] == 29);
5771 assert_or_panic(v[56] == 30);
5772 assert_or_panic(v[57] == 31);
5773 assert_or_panic(v[58] == 32);
5774 assert_or_panic(v[59] == 33);
5775 assert_or_panic(v[60] == 34);
5776 assert_or_panic(v[61] == 35);
5777 assert_or_panic(v[62] == 36);
5778 assert_or_panic(v[63] == 37);
5779 assert_or_panic(v[64] == 38);
5780 assert_or_panic(v[65] == 39);
5781 assert_or_panic(v[66] == 40);
5782 assert_or_panic(v[67] == 41);
5783 assert_or_panic(v[68] == 42);
5784 assert_or_panic(v[69] == 43);
5785 assert_or_panic(v[70] == 44);
5786 assert_or_panic(v[71] == 45);
5787 assert_or_panic(v[72] == 46);
5788 assert_or_panic(v[73] == 47);
5789 assert_or_panic(v[74] == 48);
5790 assert_or_panic(v[75] == 49);
5791 assert_or_panic(v[76] == 50);
5792 assert_or_panic(v[77] == 51);
5793 assert_or_panic(v[78] == 52);
5794 assert_or_panic(v[79] == 53);
5795 assert_or_panic(v[80] == 54);
5796 assert_or_panic(v[81] == 55);
5797 assert_or_panic(v[82] == 56);
5798 assert_or_panic(v[83] == 57);
5799 assert_or_panic(v[84] == 58);
5800 assert_or_panic(v[85] == 59);
5801 assert_or_panic(v[86] == 60);
5802 assert_or_panic(v[87] == 61);
5803 assert_or_panic(v[88] == 62);
5804 assert_or_panic(v[89] == 63);
5805 assert_or_panic(v[90] == 64);
5806 assert_or_panic(v[91] == 65);
5807 assert_or_panic(v[92] == 66);
5808 assert_or_panic(v[93] == 67);
5809 assert_or_panic(v[94] == 68);
5810 assert_or_panic(v[95] == 69);
5811 assert_or_panic(v[96] == 70);
5812 assert_or_panic(v[97] == 71);
5813 assert_or_panic(v[98] == 72);
5814 assert_or_panic(v[99] == 73);
5815 assert_or_panic(v[100] == 74);
5816 assert_or_panic(v[101] == 75);
5817 assert_or_panic(v[102] == 76);
5818 assert_or_panic(v[103] == 77);
5819 assert_or_panic(v[104] == 78);
5820 assert_or_panic(v[105] == 79);
5821 assert_or_panic(v[106] == 80);
5822 assert_or_panic(v[107] == 81);
5823 assert_or_panic(v[108] == 82);
5824 assert_or_panic(v[109] == 83);
5825 assert_or_panic(v[110] == 84);
5826 assert_or_panic(v[111] == 85);
5827 assert_or_panic(v[112] == 86);
5828 assert_or_panic(v[113] == 87);
5829 assert_or_panic(v[114] == 88);
5830 assert_or_panic(v[115] == 89);
5831 assert_or_panic(v[116] == 90);
5832 assert_or_panic(v[117] == 91);
5833 assert_or_panic(v[118] == 92);
5834 assert_or_panic(v[119] == 93);
5835 assert_or_panic(v[120] == 94);
5836 assert_or_panic(v[121] == 95);
5837 assert_or_panic(v[122] == 96);
5838 assert_or_panic(v[123] == 97);
5839 assert_or_panic(v[124] == 98);
5840 assert_or_panic(v[125] == 99);
5841 assert_or_panic(v[126] == 0);
5842 assert_or_panic(v[127] == 1);
5843 zig_vector_128_u8((Vector_128_u8){
5844 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
5845 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
5846 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
5847 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
5848 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
5849 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
5850 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
5851 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
5852 }, 128);
5853}
5854
5855typedef uint8_t Vector_192_u8 __attribute__((vector_size(192 * sizeof(uint8_t))));
5856
5857Vector_192_u8 zig_ret_vector_192_u8(void);
5858void zig_vector_192_u8(Vector_192_u8, size_t);
5859
5860Vector_192_u8 c_ret_vector_192_u8(void) {
5861 return (Vector_192_u8){
5862 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
5863 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
5864 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
5865 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
5866 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
5867 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
5868 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
5869 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
5870 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
5871 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
5872 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
5873 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
5874 };
5875}
5876void c_vector_192_u8(Vector_192_u8 v, size_t i) {
5877 assert_or_panic(v[0] == 62);
5878 assert_or_panic(v[1] == 63);
5879 assert_or_panic(v[2] == 64);
5880 assert_or_panic(v[3] == 65);
5881 assert_or_panic(v[4] == 66);
5882 assert_or_panic(v[5] == 67);
5883 assert_or_panic(v[6] == 68);
5884 assert_or_panic(v[7] == 69);
5885 assert_or_panic(v[8] == 70);
5886 assert_or_panic(v[9] == 71);
5887 assert_or_panic(v[10] == 72);
5888 assert_or_panic(v[11] == 73);
5889 assert_or_panic(v[12] == 74);
5890 assert_or_panic(v[13] == 75);
5891 assert_or_panic(v[14] == 76);
5892 assert_or_panic(v[15] == 77);
5893 assert_or_panic(v[16] == 78);
5894 assert_or_panic(v[17] == 79);
5895 assert_or_panic(v[18] == 80);
5896 assert_or_panic(v[19] == 81);
5897 assert_or_panic(v[20] == 82);
5898 assert_or_panic(v[21] == 83);
5899 assert_or_panic(v[22] == 84);
5900 assert_or_panic(v[23] == 85);
5901 assert_or_panic(v[24] == 86);
5902 assert_or_panic(v[25] == 87);
5903 assert_or_panic(v[26] == 88);
5904 assert_or_panic(v[27] == 89);
5905 assert_or_panic(v[28] == 90);
5906 assert_or_panic(v[29] == 91);
5907 assert_or_panic(v[30] == 92);
5908 assert_or_panic(v[31] == 93);
5909 assert_or_panic(v[32] == 94);
5910 assert_or_panic(v[33] == 95);
5911 assert_or_panic(v[34] == 96);
5912 assert_or_panic(v[35] == 97);
5913 assert_or_panic(v[36] == 98);
5914 assert_or_panic(v[37] == 99);
5915 assert_or_panic(v[38] == 0);
5916 assert_or_panic(v[39] == 1);
5917 assert_or_panic(v[40] == 2);
5918 assert_or_panic(v[41] == 3);
5919 assert_or_panic(v[42] == 4);
5920 assert_or_panic(v[43] == 5);
5921 assert_or_panic(v[44] == 6);
5922 assert_or_panic(v[45] == 7);
5923 assert_or_panic(v[46] == 8);
5924 assert_or_panic(v[47] == 9);
5925 assert_or_panic(v[48] == 10);
5926 assert_or_panic(v[49] == 11);
5927 assert_or_panic(v[50] == 12);
5928 assert_or_panic(v[51] == 13);
5929 assert_or_panic(v[52] == 14);
5930 assert_or_panic(v[53] == 15);
5931 assert_or_panic(v[54] == 16);
5932 assert_or_panic(v[55] == 17);
5933 assert_or_panic(v[56] == 18);
5934 assert_or_panic(v[57] == 19);
5935 assert_or_panic(v[58] == 20);
5936 assert_or_panic(v[59] == 21);
5937 assert_or_panic(v[60] == 22);
5938 assert_or_panic(v[61] == 23);
5939 assert_or_panic(v[62] == 24);
5940 assert_or_panic(v[63] == 25);
5941 assert_or_panic(v[64] == 26);
5942 assert_or_panic(v[65] == 27);
5943 assert_or_panic(v[66] == 28);
5944 assert_or_panic(v[67] == 29);
5945 assert_or_panic(v[68] == 30);
5946 assert_or_panic(v[69] == 31);
5947 assert_or_panic(v[70] == 32);
5948 assert_or_panic(v[71] == 33);
5949 assert_or_panic(v[72] == 34);
5950 assert_or_panic(v[73] == 35);
5951 assert_or_panic(v[74] == 36);
5952 assert_or_panic(v[75] == 37);
5953 assert_or_panic(v[76] == 38);
5954 assert_or_panic(v[77] == 39);
5955 assert_or_panic(v[78] == 40);
5956 assert_or_panic(v[79] == 41);
5957 assert_or_panic(v[80] == 42);
5958 assert_or_panic(v[81] == 43);
5959 assert_or_panic(v[82] == 44);
5960 assert_or_panic(v[83] == 45);
5961 assert_or_panic(v[84] == 46);
5962 assert_or_panic(v[85] == 47);
5963 assert_or_panic(v[86] == 48);
5964 assert_or_panic(v[87] == 49);
5965 assert_or_panic(v[88] == 50);
5966 assert_or_panic(v[89] == 51);
5967 assert_or_panic(v[90] == 52);
5968 assert_or_panic(v[91] == 53);
5969 assert_or_panic(v[92] == 54);
5970 assert_or_panic(v[93] == 55);
5971 assert_or_panic(v[94] == 56);
5972 assert_or_panic(v[95] == 57);
5973 assert_or_panic(v[96] == 58);
5974 assert_or_panic(v[97] == 59);
5975 assert_or_panic(v[98] == 60);
5976 assert_or_panic(v[99] == 61);
5977 assert_or_panic(v[100] == 62);
5978 assert_or_panic(v[101] == 63);
5979 assert_or_panic(v[102] == 64);
5980 assert_or_panic(v[103] == 65);
5981 assert_or_panic(v[104] == 66);
5982 assert_or_panic(v[105] == 67);
5983 assert_or_panic(v[106] == 68);
5984 assert_or_panic(v[107] == 69);
5985 assert_or_panic(v[108] == 70);
5986 assert_or_panic(v[109] == 71);
5987 assert_or_panic(v[110] == 72);
5988 assert_or_panic(v[111] == 73);
5989 assert_or_panic(v[112] == 74);
5990 assert_or_panic(v[113] == 75);
5991 assert_or_panic(v[114] == 76);
5992 assert_or_panic(v[115] == 77);
5993 assert_or_panic(v[116] == 78);
5994 assert_or_panic(v[117] == 79);
5995 assert_or_panic(v[118] == 80);
5996 assert_or_panic(v[119] == 81);
5997 assert_or_panic(v[120] == 82);
5998 assert_or_panic(v[121] == 83);
5999 assert_or_panic(v[122] == 84);
6000 assert_or_panic(v[123] == 85);
6001 assert_or_panic(v[124] == 86);
6002 assert_or_panic(v[125] == 87);
6003 assert_or_panic(v[126] == 88);
6004 assert_or_panic(v[127] == 89);
6005 assert_or_panic(v[128] == 90);
6006 assert_or_panic(v[129] == 91);
6007 assert_or_panic(v[130] == 92);
6008 assert_or_panic(v[131] == 93);
6009 assert_or_panic(v[132] == 94);
6010 assert_or_panic(v[133] == 95);
6011 assert_or_panic(v[134] == 96);
6012 assert_or_panic(v[135] == 97);
6013 assert_or_panic(v[136] == 98);
6014 assert_or_panic(v[137] == 99);
6015 assert_or_panic(v[138] == 0);
6016 assert_or_panic(v[139] == 1);
6017 assert_or_panic(v[140] == 2);
6018 assert_or_panic(v[141] == 3);
6019 assert_or_panic(v[142] == 4);
6020 assert_or_panic(v[143] == 5);
6021 assert_or_panic(v[144] == 6);
6022 assert_or_panic(v[145] == 7);
6023 assert_or_panic(v[146] == 8);
6024 assert_or_panic(v[147] == 9);
6025 assert_or_panic(v[148] == 10);
6026 assert_or_panic(v[149] == 11);
6027 assert_or_panic(v[150] == 12);
6028 assert_or_panic(v[151] == 13);
6029 assert_or_panic(v[152] == 14);
6030 assert_or_panic(v[153] == 15);
6031 assert_or_panic(v[154] == 16);
6032 assert_or_panic(v[155] == 17);
6033 assert_or_panic(v[156] == 18);
6034 assert_or_panic(v[157] == 19);
6035 assert_or_panic(v[158] == 20);
6036 assert_or_panic(v[159] == 21);
6037 assert_or_panic(v[160] == 22);
6038 assert_or_panic(v[161] == 23);
6039 assert_or_panic(v[162] == 24);
6040 assert_or_panic(v[163] == 25);
6041 assert_or_panic(v[164] == 26);
6042 assert_or_panic(v[165] == 27);
6043 assert_or_panic(v[166] == 28);
6044 assert_or_panic(v[167] == 29);
6045 assert_or_panic(v[168] == 30);
6046 assert_or_panic(v[169] == 31);
6047 assert_or_panic(v[170] == 32);
6048 assert_or_panic(v[171] == 33);
6049 assert_or_panic(v[172] == 34);
6050 assert_or_panic(v[173] == 35);
6051 assert_or_panic(v[174] == 36);
6052 assert_or_panic(v[175] == 37);
6053 assert_or_panic(v[176] == 38);
6054 assert_or_panic(v[177] == 39);
6055 assert_or_panic(v[178] == 40);
6056 assert_or_panic(v[179] == 41);
6057 assert_or_panic(v[180] == 42);
6058 assert_or_panic(v[181] == 43);
6059 assert_or_panic(v[182] == 44);
6060 assert_or_panic(v[183] == 45);
6061 assert_or_panic(v[184] == 46);
6062 assert_or_panic(v[185] == 47);
6063 assert_or_panic(v[186] == 48);
6064 assert_or_panic(v[187] == 49);
6065 assert_or_panic(v[188] == 50);
6066 assert_or_panic(v[189] == 51);
6067 assert_or_panic(v[190] == 52);
6068 assert_or_panic(v[191] == 53);
6069 assert_or_panic(i == 192);
6070}
6071void c_test_vector_192_u8(void) {
6072 Vector_192_u8 v = zig_ret_vector_192_u8();
6073 assert_or_panic(v[0] == 86);
6074 assert_or_panic(v[1] == 87);
6075 assert_or_panic(v[2] == 88);
6076 assert_or_panic(v[3] == 89);
6077 assert_or_panic(v[4] == 90);
6078 assert_or_panic(v[5] == 91);
6079 assert_or_panic(v[6] == 92);
6080 assert_or_panic(v[7] == 93);
6081 assert_or_panic(v[8] == 94);
6082 assert_or_panic(v[9] == 95);
6083 assert_or_panic(v[10] == 96);
6084 assert_or_panic(v[11] == 97);
6085 assert_or_panic(v[12] == 98);
6086 assert_or_panic(v[13] == 99);
6087 assert_or_panic(v[14] == 0);
6088 assert_or_panic(v[15] == 1);
6089 assert_or_panic(v[16] == 2);
6090 assert_or_panic(v[17] == 3);
6091 assert_or_panic(v[18] == 4);
6092 assert_or_panic(v[19] == 5);
6093 assert_or_panic(v[20] == 6);
6094 assert_or_panic(v[21] == 7);
6095 assert_or_panic(v[22] == 8);
6096 assert_or_panic(v[23] == 9);
6097 assert_or_panic(v[24] == 10);
6098 assert_or_panic(v[25] == 11);
6099 assert_or_panic(v[26] == 12);
6100 assert_or_panic(v[27] == 13);
6101 assert_or_panic(v[28] == 14);
6102 assert_or_panic(v[29] == 15);
6103 assert_or_panic(v[30] == 16);
6104 assert_or_panic(v[31] == 17);
6105 assert_or_panic(v[32] == 18);
6106 assert_or_panic(v[33] == 19);
6107 assert_or_panic(v[34] == 20);
6108 assert_or_panic(v[35] == 21);
6109 assert_or_panic(v[36] == 22);
6110 assert_or_panic(v[37] == 23);
6111 assert_or_panic(v[38] == 24);
6112 assert_or_panic(v[39] == 25);
6113 assert_or_panic(v[40] == 26);
6114 assert_or_panic(v[41] == 27);
6115 assert_or_panic(v[42] == 28);
6116 assert_or_panic(v[43] == 29);
6117 assert_or_panic(v[44] == 30);
6118 assert_or_panic(v[45] == 31);
6119 assert_or_panic(v[46] == 32);
6120 assert_or_panic(v[47] == 33);
6121 assert_or_panic(v[48] == 34);
6122 assert_or_panic(v[49] == 35);
6123 assert_or_panic(v[50] == 36);
6124 assert_or_panic(v[51] == 37);
6125 assert_or_panic(v[52] == 38);
6126 assert_or_panic(v[53] == 39);
6127 assert_or_panic(v[54] == 40);
6128 assert_or_panic(v[55] == 41);
6129 assert_or_panic(v[56] == 42);
6130 assert_or_panic(v[57] == 43);
6131 assert_or_panic(v[58] == 44);
6132 assert_or_panic(v[59] == 45);
6133 assert_or_panic(v[60] == 46);
6134 assert_or_panic(v[61] == 47);
6135 assert_or_panic(v[62] == 48);
6136 assert_or_panic(v[63] == 49);
6137 assert_or_panic(v[64] == 50);
6138 assert_or_panic(v[65] == 51);
6139 assert_or_panic(v[66] == 52);
6140 assert_or_panic(v[67] == 53);
6141 assert_or_panic(v[68] == 54);
6142 assert_or_panic(v[69] == 55);
6143 assert_or_panic(v[70] == 56);
6144 assert_or_panic(v[71] == 57);
6145 assert_or_panic(v[72] == 58);
6146 assert_or_panic(v[73] == 59);
6147 assert_or_panic(v[74] == 60);
6148 assert_or_panic(v[75] == 61);
6149 assert_or_panic(v[76] == 62);
6150 assert_or_panic(v[77] == 63);
6151 assert_or_panic(v[78] == 64);
6152 assert_or_panic(v[79] == 65);
6153 assert_or_panic(v[80] == 66);
6154 assert_or_panic(v[81] == 67);
6155 assert_or_panic(v[82] == 68);
6156 assert_or_panic(v[83] == 69);
6157 assert_or_panic(v[84] == 70);
6158 assert_or_panic(v[85] == 71);
6159 assert_or_panic(v[86] == 72);
6160 assert_or_panic(v[87] == 73);
6161 assert_or_panic(v[88] == 74);
6162 assert_or_panic(v[89] == 75);
6163 assert_or_panic(v[90] == 76);
6164 assert_or_panic(v[91] == 77);
6165 assert_or_panic(v[92] == 78);
6166 assert_or_panic(v[93] == 79);
6167 assert_or_panic(v[94] == 80);
6168 assert_or_panic(v[95] == 81);
6169 assert_or_panic(v[96] == 82);
6170 assert_or_panic(v[97] == 83);
6171 assert_or_panic(v[98] == 84);
6172 assert_or_panic(v[99] == 85);
6173 assert_or_panic(v[100] == 86);
6174 assert_or_panic(v[101] == 87);
6175 assert_or_panic(v[102] == 88);
6176 assert_or_panic(v[103] == 89);
6177 assert_or_panic(v[104] == 90);
6178 assert_or_panic(v[105] == 91);
6179 assert_or_panic(v[106] == 92);
6180 assert_or_panic(v[107] == 93);
6181 assert_or_panic(v[108] == 94);
6182 assert_or_panic(v[109] == 95);
6183 assert_or_panic(v[110] == 96);
6184 assert_or_panic(v[111] == 97);
6185 assert_or_panic(v[112] == 98);
6186 assert_or_panic(v[113] == 99);
6187 assert_or_panic(v[114] == 0);
6188 assert_or_panic(v[115] == 1);
6189 assert_or_panic(v[116] == 2);
6190 assert_or_panic(v[117] == 3);
6191 assert_or_panic(v[118] == 4);
6192 assert_or_panic(v[119] == 5);
6193 assert_or_panic(v[120] == 6);
6194 assert_or_panic(v[121] == 7);
6195 assert_or_panic(v[122] == 8);
6196 assert_or_panic(v[123] == 9);
6197 assert_or_panic(v[124] == 10);
6198 assert_or_panic(v[125] == 11);
6199 assert_or_panic(v[126] == 12);
6200 assert_or_panic(v[127] == 13);
6201 assert_or_panic(v[128] == 14);
6202 assert_or_panic(v[129] == 15);
6203 assert_or_panic(v[130] == 16);
6204 assert_or_panic(v[131] == 17);
6205 assert_or_panic(v[132] == 18);
6206 assert_or_panic(v[133] == 19);
6207 assert_or_panic(v[134] == 20);
6208 assert_or_panic(v[135] == 21);
6209 assert_or_panic(v[136] == 22);
6210 assert_or_panic(v[137] == 23);
6211 assert_or_panic(v[138] == 24);
6212 assert_or_panic(v[139] == 25);
6213 assert_or_panic(v[140] == 26);
6214 assert_or_panic(v[141] == 27);
6215 assert_or_panic(v[142] == 28);
6216 assert_or_panic(v[143] == 29);
6217 assert_or_panic(v[144] == 30);
6218 assert_or_panic(v[145] == 31);
6219 assert_or_panic(v[146] == 32);
6220 assert_or_panic(v[147] == 33);
6221 assert_or_panic(v[148] == 34);
6222 assert_or_panic(v[149] == 35);
6223 assert_or_panic(v[150] == 36);
6224 assert_or_panic(v[151] == 37);
6225 assert_or_panic(v[152] == 38);
6226 assert_or_panic(v[153] == 39);
6227 assert_or_panic(v[154] == 40);
6228 assert_or_panic(v[155] == 41);
6229 assert_or_panic(v[156] == 42);
6230 assert_or_panic(v[157] == 43);
6231 assert_or_panic(v[158] == 44);
6232 assert_or_panic(v[159] == 45);
6233 assert_or_panic(v[160] == 46);
6234 assert_or_panic(v[161] == 47);
6235 assert_or_panic(v[162] == 48);
6236 assert_or_panic(v[163] == 49);
6237 assert_or_panic(v[164] == 50);
6238 assert_or_panic(v[165] == 51);
6239 assert_or_panic(v[166] == 52);
6240 assert_or_panic(v[167] == 53);
6241 assert_or_panic(v[168] == 54);
6242 assert_or_panic(v[169] == 55);
6243 assert_or_panic(v[170] == 56);
6244 assert_or_panic(v[171] == 57);
6245 assert_or_panic(v[172] == 58);
6246 assert_or_panic(v[173] == 59);
6247 assert_or_panic(v[174] == 60);
6248 assert_or_panic(v[175] == 61);
6249 assert_or_panic(v[176] == 62);
6250 assert_or_panic(v[177] == 63);
6251 assert_or_panic(v[178] == 64);
6252 assert_or_panic(v[179] == 65);
6253 assert_or_panic(v[180] == 66);
6254 assert_or_panic(v[181] == 67);
6255 assert_or_panic(v[182] == 68);
6256 assert_or_panic(v[183] == 69);
6257 assert_or_panic(v[184] == 70);
6258 assert_or_panic(v[185] == 71);
6259 assert_or_panic(v[186] == 72);
6260 assert_or_panic(v[187] == 73);
6261 assert_or_panic(v[188] == 74);
6262 assert_or_panic(v[189] == 75);
6263 assert_or_panic(v[190] == 76);
6264 assert_or_panic(v[191] == 77);
6265 zig_vector_192_u8((Vector_192_u8){
6266 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
6267 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
6268 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
6269 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
6270 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6271 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
6272 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6273 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
6274 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
6275 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
6276 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6277 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
6278 }, 192);
6279}
6280
6281typedef uint8_t Vector_256_u8 __attribute__((vector_size(256 * sizeof(uint8_t))));
6282
6283Vector_256_u8 zig_ret_vector_256_u8(void);
6284void zig_vector_256_u8(Vector_256_u8, size_t);
6285
6286Vector_256_u8 c_ret_vector_256_u8(void) {
6287 return (Vector_256_u8){
6288 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
6289 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
6290 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
6291 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
6292 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
6293 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
6294 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
6295 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
6296 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
6297 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
6298 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
6299 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6300 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
6301 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6302 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
6303 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
6304 };
6305}
6306void c_vector_256_u8(Vector_256_u8 v, size_t i) {
6307 assert_or_panic(v[0] == 22);
6308 assert_or_panic(v[1] == 23);
6309 assert_or_panic(v[2] == 24);
6310 assert_or_panic(v[3] == 25);
6311 assert_or_panic(v[4] == 26);
6312 assert_or_panic(v[5] == 27);
6313 assert_or_panic(v[6] == 28);
6314 assert_or_panic(v[7] == 29);
6315 assert_or_panic(v[8] == 30);
6316 assert_or_panic(v[9] == 31);
6317 assert_or_panic(v[10] == 32);
6318 assert_or_panic(v[11] == 33);
6319 assert_or_panic(v[12] == 34);
6320 assert_or_panic(v[13] == 35);
6321 assert_or_panic(v[14] == 36);
6322 assert_or_panic(v[15] == 37);
6323 assert_or_panic(v[16] == 38);
6324 assert_or_panic(v[17] == 39);
6325 assert_or_panic(v[18] == 40);
6326 assert_or_panic(v[19] == 41);
6327 assert_or_panic(v[20] == 42);
6328 assert_or_panic(v[21] == 43);
6329 assert_or_panic(v[22] == 44);
6330 assert_or_panic(v[23] == 45);
6331 assert_or_panic(v[24] == 46);
6332 assert_or_panic(v[25] == 47);
6333 assert_or_panic(v[26] == 48);
6334 assert_or_panic(v[27] == 49);
6335 assert_or_panic(v[28] == 50);
6336 assert_or_panic(v[29] == 51);
6337 assert_or_panic(v[30] == 52);
6338 assert_or_panic(v[31] == 53);
6339 assert_or_panic(v[32] == 54);
6340 assert_or_panic(v[33] == 55);
6341 assert_or_panic(v[34] == 56);
6342 assert_or_panic(v[35] == 57);
6343 assert_or_panic(v[36] == 58);
6344 assert_or_panic(v[37] == 59);
6345 assert_or_panic(v[38] == 60);
6346 assert_or_panic(v[39] == 61);
6347 assert_or_panic(v[40] == 62);
6348 assert_or_panic(v[41] == 63);
6349 assert_or_panic(v[42] == 64);
6350 assert_or_panic(v[43] == 65);
6351 assert_or_panic(v[44] == 66);
6352 assert_or_panic(v[45] == 67);
6353 assert_or_panic(v[46] == 68);
6354 assert_or_panic(v[47] == 69);
6355 assert_or_panic(v[48] == 70);
6356 assert_or_panic(v[49] == 71);
6357 assert_or_panic(v[50] == 72);
6358 assert_or_panic(v[51] == 73);
6359 assert_or_panic(v[52] == 74);
6360 assert_or_panic(v[53] == 75);
6361 assert_or_panic(v[54] == 76);
6362 assert_or_panic(v[55] == 77);
6363 assert_or_panic(v[56] == 78);
6364 assert_or_panic(v[57] == 79);
6365 assert_or_panic(v[58] == 80);
6366 assert_or_panic(v[59] == 81);
6367 assert_or_panic(v[60] == 82);
6368 assert_or_panic(v[61] == 83);
6369 assert_or_panic(v[62] == 84);
6370 assert_or_panic(v[63] == 85);
6371 assert_or_panic(v[64] == 86);
6372 assert_or_panic(v[65] == 87);
6373 assert_or_panic(v[66] == 88);
6374 assert_or_panic(v[67] == 89);
6375 assert_or_panic(v[68] == 90);
6376 assert_or_panic(v[69] == 91);
6377 assert_or_panic(v[70] == 92);
6378 assert_or_panic(v[71] == 93);
6379 assert_or_panic(v[72] == 94);
6380 assert_or_panic(v[73] == 95);
6381 assert_or_panic(v[74] == 96);
6382 assert_or_panic(v[75] == 97);
6383 assert_or_panic(v[76] == 98);
6384 assert_or_panic(v[77] == 99);
6385 assert_or_panic(v[78] == 0);
6386 assert_or_panic(v[79] == 1);
6387 assert_or_panic(v[80] == 2);
6388 assert_or_panic(v[81] == 3);
6389 assert_or_panic(v[82] == 4);
6390 assert_or_panic(v[83] == 5);
6391 assert_or_panic(v[84] == 6);
6392 assert_or_panic(v[85] == 7);
6393 assert_or_panic(v[86] == 8);
6394 assert_or_panic(v[87] == 9);
6395 assert_or_panic(v[88] == 10);
6396 assert_or_panic(v[89] == 11);
6397 assert_or_panic(v[90] == 12);
6398 assert_or_panic(v[91] == 13);
6399 assert_or_panic(v[92] == 14);
6400 assert_or_panic(v[93] == 15);
6401 assert_or_panic(v[94] == 16);
6402 assert_or_panic(v[95] == 17);
6403 assert_or_panic(v[96] == 18);
6404 assert_or_panic(v[97] == 19);
6405 assert_or_panic(v[98] == 20);
6406 assert_or_panic(v[99] == 21);
6407 assert_or_panic(v[100] == 22);
6408 assert_or_panic(v[101] == 23);
6409 assert_or_panic(v[102] == 24);
6410 assert_or_panic(v[103] == 25);
6411 assert_or_panic(v[104] == 26);
6412 assert_or_panic(v[105] == 27);
6413 assert_or_panic(v[106] == 28);
6414 assert_or_panic(v[107] == 29);
6415 assert_or_panic(v[108] == 30);
6416 assert_or_panic(v[109] == 31);
6417 assert_or_panic(v[110] == 32);
6418 assert_or_panic(v[111] == 33);
6419 assert_or_panic(v[112] == 34);
6420 assert_or_panic(v[113] == 35);
6421 assert_or_panic(v[114] == 36);
6422 assert_or_panic(v[115] == 37);
6423 assert_or_panic(v[116] == 38);
6424 assert_or_panic(v[117] == 39);
6425 assert_or_panic(v[118] == 40);
6426 assert_or_panic(v[119] == 41);
6427 assert_or_panic(v[120] == 42);
6428 assert_or_panic(v[121] == 43);
6429 assert_or_panic(v[122] == 44);
6430 assert_or_panic(v[123] == 45);
6431 assert_or_panic(v[124] == 46);
6432 assert_or_panic(v[125] == 47);
6433 assert_or_panic(v[126] == 48);
6434 assert_or_panic(v[127] == 49);
6435 assert_or_panic(v[128] == 50);
6436 assert_or_panic(v[129] == 51);
6437 assert_or_panic(v[130] == 52);
6438 assert_or_panic(v[131] == 53);
6439 assert_or_panic(v[132] == 54);
6440 assert_or_panic(v[133] == 55);
6441 assert_or_panic(v[134] == 56);
6442 assert_or_panic(v[135] == 57);
6443 assert_or_panic(v[136] == 58);
6444 assert_or_panic(v[137] == 59);
6445 assert_or_panic(v[138] == 60);
6446 assert_or_panic(v[139] == 61);
6447 assert_or_panic(v[140] == 62);
6448 assert_or_panic(v[141] == 63);
6449 assert_or_panic(v[142] == 64);
6450 assert_or_panic(v[143] == 65);
6451 assert_or_panic(v[144] == 66);
6452 assert_or_panic(v[145] == 67);
6453 assert_or_panic(v[146] == 68);
6454 assert_or_panic(v[147] == 69);
6455 assert_or_panic(v[148] == 70);
6456 assert_or_panic(v[149] == 71);
6457 assert_or_panic(v[150] == 72);
6458 assert_or_panic(v[151] == 73);
6459 assert_or_panic(v[152] == 74);
6460 assert_or_panic(v[153] == 75);
6461 assert_or_panic(v[154] == 76);
6462 assert_or_panic(v[155] == 77);
6463 assert_or_panic(v[156] == 78);
6464 assert_or_panic(v[157] == 79);
6465 assert_or_panic(v[158] == 80);
6466 assert_or_panic(v[159] == 81);
6467 assert_or_panic(v[160] == 82);
6468 assert_or_panic(v[161] == 83);
6469 assert_or_panic(v[162] == 84);
6470 assert_or_panic(v[163] == 85);
6471 assert_or_panic(v[164] == 86);
6472 assert_or_panic(v[165] == 87);
6473 assert_or_panic(v[166] == 88);
6474 assert_or_panic(v[167] == 89);
6475 assert_or_panic(v[168] == 90);
6476 assert_or_panic(v[169] == 91);
6477 assert_or_panic(v[170] == 92);
6478 assert_or_panic(v[171] == 93);
6479 assert_or_panic(v[172] == 94);
6480 assert_or_panic(v[173] == 95);
6481 assert_or_panic(v[174] == 96);
6482 assert_or_panic(v[175] == 97);
6483 assert_or_panic(v[176] == 98);
6484 assert_or_panic(v[177] == 99);
6485 assert_or_panic(v[178] == 0);
6486 assert_or_panic(v[179] == 1);
6487 assert_or_panic(v[180] == 2);
6488 assert_or_panic(v[181] == 3);
6489 assert_or_panic(v[182] == 4);
6490 assert_or_panic(v[183] == 5);
6491 assert_or_panic(v[184] == 6);
6492 assert_or_panic(v[185] == 7);
6493 assert_or_panic(v[186] == 8);
6494 assert_or_panic(v[187] == 9);
6495 assert_or_panic(v[188] == 10);
6496 assert_or_panic(v[189] == 11);
6497 assert_or_panic(v[190] == 12);
6498 assert_or_panic(v[191] == 13);
6499 assert_or_panic(v[192] == 14);
6500 assert_or_panic(v[193] == 15);
6501 assert_or_panic(v[194] == 16);
6502 assert_or_panic(v[195] == 17);
6503 assert_or_panic(v[196] == 18);
6504 assert_or_panic(v[197] == 19);
6505 assert_or_panic(v[198] == 20);
6506 assert_or_panic(v[199] == 21);
6507 assert_or_panic(v[200] == 22);
6508 assert_or_panic(v[201] == 23);
6509 assert_or_panic(v[202] == 24);
6510 assert_or_panic(v[203] == 25);
6511 assert_or_panic(v[204] == 26);
6512 assert_or_panic(v[205] == 27);
6513 assert_or_panic(v[206] == 28);
6514 assert_or_panic(v[207] == 29);
6515 assert_or_panic(v[208] == 30);
6516 assert_or_panic(v[209] == 31);
6517 assert_or_panic(v[210] == 32);
6518 assert_or_panic(v[211] == 33);
6519 assert_or_panic(v[212] == 34);
6520 assert_or_panic(v[213] == 35);
6521 assert_or_panic(v[214] == 36);
6522 assert_or_panic(v[215] == 37);
6523 assert_or_panic(v[216] == 38);
6524 assert_or_panic(v[217] == 39);
6525 assert_or_panic(v[218] == 40);
6526 assert_or_panic(v[219] == 41);
6527 assert_or_panic(v[220] == 42);
6528 assert_or_panic(v[221] == 43);
6529 assert_or_panic(v[222] == 44);
6530 assert_or_panic(v[223] == 45);
6531 assert_or_panic(v[224] == 46);
6532 assert_or_panic(v[225] == 47);
6533 assert_or_panic(v[226] == 48);
6534 assert_or_panic(v[227] == 49);
6535 assert_or_panic(v[228] == 50);
6536 assert_or_panic(v[229] == 51);
6537 assert_or_panic(v[230] == 52);
6538 assert_or_panic(v[231] == 53);
6539 assert_or_panic(v[232] == 54);
6540 assert_or_panic(v[233] == 55);
6541 assert_or_panic(v[234] == 56);
6542 assert_or_panic(v[235] == 57);
6543 assert_or_panic(v[236] == 58);
6544 assert_or_panic(v[237] == 59);
6545 assert_or_panic(v[238] == 60);
6546 assert_or_panic(v[239] == 61);
6547 assert_or_panic(v[240] == 62);
6548 assert_or_panic(v[241] == 63);
6549 assert_or_panic(v[242] == 64);
6550 assert_or_panic(v[243] == 65);
6551 assert_or_panic(v[244] == 66);
6552 assert_or_panic(v[245] == 67);
6553 assert_or_panic(v[246] == 68);
6554 assert_or_panic(v[247] == 69);
6555 assert_or_panic(v[248] == 70);
6556 assert_or_panic(v[249] == 71);
6557 assert_or_panic(v[250] == 72);
6558 assert_or_panic(v[251] == 73);
6559 assert_or_panic(v[252] == 74);
6560 assert_or_panic(v[253] == 75);
6561 assert_or_panic(v[254] == 76);
6562 assert_or_panic(v[255] == 77);
6563 assert_or_panic(i == 256);
6564}
6565void c_test_vector_256_u8(void) {
6566 Vector_256_u8 v = zig_ret_vector_256_u8();
6567 assert_or_panic(v[0] == 54);
6568 assert_or_panic(v[1] == 55);
6569 assert_or_panic(v[2] == 56);
6570 assert_or_panic(v[3] == 57);
6571 assert_or_panic(v[4] == 58);
6572 assert_or_panic(v[5] == 59);
6573 assert_or_panic(v[6] == 60);
6574 assert_or_panic(v[7] == 61);
6575 assert_or_panic(v[8] == 62);
6576 assert_or_panic(v[9] == 63);
6577 assert_or_panic(v[10] == 64);
6578 assert_or_panic(v[11] == 65);
6579 assert_or_panic(v[12] == 66);
6580 assert_or_panic(v[13] == 67);
6581 assert_or_panic(v[14] == 68);
6582 assert_or_panic(v[15] == 69);
6583 assert_or_panic(v[16] == 70);
6584 assert_or_panic(v[17] == 71);
6585 assert_or_panic(v[18] == 72);
6586 assert_or_panic(v[19] == 73);
6587 assert_or_panic(v[20] == 74);
6588 assert_or_panic(v[21] == 75);
6589 assert_or_panic(v[22] == 76);
6590 assert_or_panic(v[23] == 77);
6591 assert_or_panic(v[24] == 78);
6592 assert_or_panic(v[25] == 79);
6593 assert_or_panic(v[26] == 80);
6594 assert_or_panic(v[27] == 81);
6595 assert_or_panic(v[28] == 82);
6596 assert_or_panic(v[29] == 83);
6597 assert_or_panic(v[30] == 84);
6598 assert_or_panic(v[31] == 85);
6599 assert_or_panic(v[32] == 86);
6600 assert_or_panic(v[33] == 87);
6601 assert_or_panic(v[34] == 88);
6602 assert_or_panic(v[35] == 89);
6603 assert_or_panic(v[36] == 90);
6604 assert_or_panic(v[37] == 91);
6605 assert_or_panic(v[38] == 92);
6606 assert_or_panic(v[39] == 93);
6607 assert_or_panic(v[40] == 94);
6608 assert_or_panic(v[41] == 95);
6609 assert_or_panic(v[42] == 96);
6610 assert_or_panic(v[43] == 97);
6611 assert_or_panic(v[44] == 98);
6612 assert_or_panic(v[45] == 99);
6613 assert_or_panic(v[46] == 0);
6614 assert_or_panic(v[47] == 1);
6615 assert_or_panic(v[48] == 2);
6616 assert_or_panic(v[49] == 3);
6617 assert_or_panic(v[50] == 4);
6618 assert_or_panic(v[51] == 5);
6619 assert_or_panic(v[52] == 6);
6620 assert_or_panic(v[53] == 7);
6621 assert_or_panic(v[54] == 8);
6622 assert_or_panic(v[55] == 9);
6623 assert_or_panic(v[56] == 10);
6624 assert_or_panic(v[57] == 11);
6625 assert_or_panic(v[58] == 12);
6626 assert_or_panic(v[59] == 13);
6627 assert_or_panic(v[60] == 14);
6628 assert_or_panic(v[61] == 15);
6629 assert_or_panic(v[62] == 16);
6630 assert_or_panic(v[63] == 17);
6631 assert_or_panic(v[64] == 18);
6632 assert_or_panic(v[65] == 19);
6633 assert_or_panic(v[66] == 20);
6634 assert_or_panic(v[67] == 21);
6635 assert_or_panic(v[68] == 22);
6636 assert_or_panic(v[69] == 23);
6637 assert_or_panic(v[70] == 24);
6638 assert_or_panic(v[71] == 25);
6639 assert_or_panic(v[72] == 26);
6640 assert_or_panic(v[73] == 27);
6641 assert_or_panic(v[74] == 28);
6642 assert_or_panic(v[75] == 29);
6643 assert_or_panic(v[76] == 30);
6644 assert_or_panic(v[77] == 31);
6645 assert_or_panic(v[78] == 32);
6646 assert_or_panic(v[79] == 33);
6647 assert_or_panic(v[80] == 34);
6648 assert_or_panic(v[81] == 35);
6649 assert_or_panic(v[82] == 36);
6650 assert_or_panic(v[83] == 37);
6651 assert_or_panic(v[84] == 38);
6652 assert_or_panic(v[85] == 39);
6653 assert_or_panic(v[86] == 40);
6654 assert_or_panic(v[87] == 41);
6655 assert_or_panic(v[88] == 42);
6656 assert_or_panic(v[89] == 43);
6657 assert_or_panic(v[90] == 44);
6658 assert_or_panic(v[91] == 45);
6659 assert_or_panic(v[92] == 46);
6660 assert_or_panic(v[93] == 47);
6661 assert_or_panic(v[94] == 48);
6662 assert_or_panic(v[95] == 49);
6663 assert_or_panic(v[96] == 50);
6664 assert_or_panic(v[97] == 51);
6665 assert_or_panic(v[98] == 52);
6666 assert_or_panic(v[99] == 53);
6667 assert_or_panic(v[100] == 54);
6668 assert_or_panic(v[101] == 55);
6669 assert_or_panic(v[102] == 56);
6670 assert_or_panic(v[103] == 57);
6671 assert_or_panic(v[104] == 58);
6672 assert_or_panic(v[105] == 59);
6673 assert_or_panic(v[106] == 60);
6674 assert_or_panic(v[107] == 61);
6675 assert_or_panic(v[108] == 62);
6676 assert_or_panic(v[109] == 63);
6677 assert_or_panic(v[110] == 64);
6678 assert_or_panic(v[111] == 65);
6679 assert_or_panic(v[112] == 66);
6680 assert_or_panic(v[113] == 67);
6681 assert_or_panic(v[114] == 68);
6682 assert_or_panic(v[115] == 69);
6683 assert_or_panic(v[116] == 70);
6684 assert_or_panic(v[117] == 71);
6685 assert_or_panic(v[118] == 72);
6686 assert_or_panic(v[119] == 73);
6687 assert_or_panic(v[120] == 74);
6688 assert_or_panic(v[121] == 75);
6689 assert_or_panic(v[122] == 76);
6690 assert_or_panic(v[123] == 77);
6691 assert_or_panic(v[124] == 78);
6692 assert_or_panic(v[125] == 79);
6693 assert_or_panic(v[126] == 80);
6694 assert_or_panic(v[127] == 81);
6695 assert_or_panic(v[128] == 82);
6696 assert_or_panic(v[129] == 83);
6697 assert_or_panic(v[130] == 84);
6698 assert_or_panic(v[131] == 85);
6699 assert_or_panic(v[132] == 86);
6700 assert_or_panic(v[133] == 87);
6701 assert_or_panic(v[134] == 88);
6702 assert_or_panic(v[135] == 89);
6703 assert_or_panic(v[136] == 90);
6704 assert_or_panic(v[137] == 91);
6705 assert_or_panic(v[138] == 92);
6706 assert_or_panic(v[139] == 93);
6707 assert_or_panic(v[140] == 94);
6708 assert_or_panic(v[141] == 95);
6709 assert_or_panic(v[142] == 96);
6710 assert_or_panic(v[143] == 97);
6711 assert_or_panic(v[144] == 98);
6712 assert_or_panic(v[145] == 99);
6713 assert_or_panic(v[146] == 0);
6714 assert_or_panic(v[147] == 1);
6715 assert_or_panic(v[148] == 2);
6716 assert_or_panic(v[149] == 3);
6717 assert_or_panic(v[150] == 4);
6718 assert_or_panic(v[151] == 5);
6719 assert_or_panic(v[152] == 6);
6720 assert_or_panic(v[153] == 7);
6721 assert_or_panic(v[154] == 8);
6722 assert_or_panic(v[155] == 9);
6723 assert_or_panic(v[156] == 10);
6724 assert_or_panic(v[157] == 11);
6725 assert_or_panic(v[158] == 12);
6726 assert_or_panic(v[159] == 13);
6727 assert_or_panic(v[160] == 14);
6728 assert_or_panic(v[161] == 15);
6729 assert_or_panic(v[162] == 16);
6730 assert_or_panic(v[163] == 17);
6731 assert_or_panic(v[164] == 18);
6732 assert_or_panic(v[165] == 19);
6733 assert_or_panic(v[166] == 20);
6734 assert_or_panic(v[167] == 21);
6735 assert_or_panic(v[168] == 22);
6736 assert_or_panic(v[169] == 23);
6737 assert_or_panic(v[170] == 24);
6738 assert_or_panic(v[171] == 25);
6739 assert_or_panic(v[172] == 26);
6740 assert_or_panic(v[173] == 27);
6741 assert_or_panic(v[174] == 28);
6742 assert_or_panic(v[175] == 29);
6743 assert_or_panic(v[176] == 30);
6744 assert_or_panic(v[177] == 31);
6745 assert_or_panic(v[178] == 32);
6746 assert_or_panic(v[179] == 33);
6747 assert_or_panic(v[180] == 34);
6748 assert_or_panic(v[181] == 35);
6749 assert_or_panic(v[182] == 36);
6750 assert_or_panic(v[183] == 37);
6751 assert_or_panic(v[184] == 38);
6752 assert_or_panic(v[185] == 39);
6753 assert_or_panic(v[186] == 40);
6754 assert_or_panic(v[187] == 41);
6755 assert_or_panic(v[188] == 42);
6756 assert_or_panic(v[189] == 43);
6757 assert_or_panic(v[190] == 44);
6758 assert_or_panic(v[191] == 45);
6759 assert_or_panic(v[192] == 46);
6760 assert_or_panic(v[193] == 47);
6761 assert_or_panic(v[194] == 48);
6762 assert_or_panic(v[195] == 49);
6763 assert_or_panic(v[196] == 50);
6764 assert_or_panic(v[197] == 51);
6765 assert_or_panic(v[198] == 52);
6766 assert_or_panic(v[199] == 53);
6767 assert_or_panic(v[200] == 54);
6768 assert_or_panic(v[201] == 55);
6769 assert_or_panic(v[202] == 56);
6770 assert_or_panic(v[203] == 57);
6771 assert_or_panic(v[204] == 58);
6772 assert_or_panic(v[205] == 59);
6773 assert_or_panic(v[206] == 60);
6774 assert_or_panic(v[207] == 61);
6775 assert_or_panic(v[208] == 62);
6776 assert_or_panic(v[209] == 63);
6777 assert_or_panic(v[210] == 64);
6778 assert_or_panic(v[211] == 65);
6779 assert_or_panic(v[212] == 66);
6780 assert_or_panic(v[213] == 67);
6781 assert_or_panic(v[214] == 68);
6782 assert_or_panic(v[215] == 69);
6783 assert_or_panic(v[216] == 70);
6784 assert_or_panic(v[217] == 71);
6785 assert_or_panic(v[218] == 72);
6786 assert_or_panic(v[219] == 73);
6787 assert_or_panic(v[220] == 74);
6788 assert_or_panic(v[221] == 75);
6789 assert_or_panic(v[222] == 76);
6790 assert_or_panic(v[223] == 77);
6791 assert_or_panic(v[224] == 78);
6792 assert_or_panic(v[225] == 79);
6793 assert_or_panic(v[226] == 80);
6794 assert_or_panic(v[227] == 81);
6795 assert_or_panic(v[228] == 82);
6796 assert_or_panic(v[229] == 83);
6797 assert_or_panic(v[230] == 84);
6798 assert_or_panic(v[231] == 85);
6799 assert_or_panic(v[232] == 86);
6800 assert_or_panic(v[233] == 87);
6801 assert_or_panic(v[234] == 88);
6802 assert_or_panic(v[235] == 89);
6803 assert_or_panic(v[236] == 90);
6804 assert_or_panic(v[237] == 91);
6805 assert_or_panic(v[238] == 92);
6806 assert_or_panic(v[239] == 93);
6807 assert_or_panic(v[240] == 94);
6808 assert_or_panic(v[241] == 95);
6809 assert_or_panic(v[242] == 96);
6810 assert_or_panic(v[243] == 97);
6811 assert_or_panic(v[244] == 98);
6812 assert_or_panic(v[245] == 99);
6813 assert_or_panic(v[246] == 0);
6814 assert_or_panic(v[247] == 1);
6815 assert_or_panic(v[248] == 2);
6816 assert_or_panic(v[249] == 3);
6817 assert_or_panic(v[250] == 4);
6818 assert_or_panic(v[251] == 5);
6819 assert_or_panic(v[252] == 6);
6820 assert_or_panic(v[253] == 7);
6821 assert_or_panic(v[254] == 8);
6822 assert_or_panic(v[255] == 9);
6823 zig_vector_256_u8((Vector_256_u8){
6824 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
6825 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
6826 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6827 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
6828 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6829 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
6830 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
6831 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
6832 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6833 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
6834 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
6835 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
6836 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
6837 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
6838 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
6839 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6840 }, 256);
6841}
6842
6843typedef uint8_t Vector_384_u8 __attribute__((vector_size(384 * sizeof(uint8_t))));
6844
6845Vector_384_u8 zig_ret_vector_384_u8(void);
6846void zig_vector_384_u8(Vector_384_u8, size_t);
6847
6848Vector_384_u8 c_ret_vector_384_u8(void) {
6849 return (Vector_384_u8){
6850 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
6851 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
6852 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
6853 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
6854 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
6855 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
6856 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
6857 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
6858 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
6859 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
6860 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
6861 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
6862 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
6863 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
6864 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
6865 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
6866 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
6867 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
6868 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
6869 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
6870 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
6871 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
6872 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
6873 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
6874 };
6875}
6876void c_vector_384_u8(Vector_384_u8 v, size_t i) {
6877 assert_or_panic(v[0] == 30);
6878 assert_or_panic(v[1] == 31);
6879 assert_or_panic(v[2] == 32);
6880 assert_or_panic(v[3] == 33);
6881 assert_or_panic(v[4] == 34);
6882 assert_or_panic(v[5] == 35);
6883 assert_or_panic(v[6] == 36);
6884 assert_or_panic(v[7] == 37);
6885 assert_or_panic(v[8] == 38);
6886 assert_or_panic(v[9] == 39);
6887 assert_or_panic(v[10] == 40);
6888 assert_or_panic(v[11] == 41);
6889 assert_or_panic(v[12] == 42);
6890 assert_or_panic(v[13] == 43);
6891 assert_or_panic(v[14] == 44);
6892 assert_or_panic(v[15] == 45);
6893 assert_or_panic(v[16] == 46);
6894 assert_or_panic(v[17] == 47);
6895 assert_or_panic(v[18] == 48);
6896 assert_or_panic(v[19] == 49);
6897 assert_or_panic(v[20] == 50);
6898 assert_or_panic(v[21] == 51);
6899 assert_or_panic(v[22] == 52);
6900 assert_or_panic(v[23] == 53);
6901 assert_or_panic(v[24] == 54);
6902 assert_or_panic(v[25] == 55);
6903 assert_or_panic(v[26] == 56);
6904 assert_or_panic(v[27] == 57);
6905 assert_or_panic(v[28] == 58);
6906 assert_or_panic(v[29] == 59);
6907 assert_or_panic(v[30] == 60);
6908 assert_or_panic(v[31] == 61);
6909 assert_or_panic(v[32] == 62);
6910 assert_or_panic(v[33] == 63);
6911 assert_or_panic(v[34] == 64);
6912 assert_or_panic(v[35] == 65);
6913 assert_or_panic(v[36] == 66);
6914 assert_or_panic(v[37] == 67);
6915 assert_or_panic(v[38] == 68);
6916 assert_or_panic(v[39] == 69);
6917 assert_or_panic(v[40] == 70);
6918 assert_or_panic(v[41] == 71);
6919 assert_or_panic(v[42] == 72);
6920 assert_or_panic(v[43] == 73);
6921 assert_or_panic(v[44] == 74);
6922 assert_or_panic(v[45] == 75);
6923 assert_or_panic(v[46] == 76);
6924 assert_or_panic(v[47] == 77);
6925 assert_or_panic(v[48] == 78);
6926 assert_or_panic(v[49] == 79);
6927 assert_or_panic(v[50] == 80);
6928 assert_or_panic(v[51] == 81);
6929 assert_or_panic(v[52] == 82);
6930 assert_or_panic(v[53] == 83);
6931 assert_or_panic(v[54] == 84);
6932 assert_or_panic(v[55] == 85);
6933 assert_or_panic(v[56] == 86);
6934 assert_or_panic(v[57] == 87);
6935 assert_or_panic(v[58] == 88);
6936 assert_or_panic(v[59] == 89);
6937 assert_or_panic(v[60] == 90);
6938 assert_or_panic(v[61] == 91);
6939 assert_or_panic(v[62] == 92);
6940 assert_or_panic(v[63] == 93);
6941 assert_or_panic(v[64] == 94);
6942 assert_or_panic(v[65] == 95);
6943 assert_or_panic(v[66] == 96);
6944 assert_or_panic(v[67] == 97);
6945 assert_or_panic(v[68] == 98);
6946 assert_or_panic(v[69] == 99);
6947 assert_or_panic(v[70] == 0);
6948 assert_or_panic(v[71] == 1);
6949 assert_or_panic(v[72] == 2);
6950 assert_or_panic(v[73] == 3);
6951 assert_or_panic(v[74] == 4);
6952 assert_or_panic(v[75] == 5);
6953 assert_or_panic(v[76] == 6);
6954 assert_or_panic(v[77] == 7);
6955 assert_or_panic(v[78] == 8);
6956 assert_or_panic(v[79] == 9);
6957 assert_or_panic(v[80] == 10);
6958 assert_or_panic(v[81] == 11);
6959 assert_or_panic(v[82] == 12);
6960 assert_or_panic(v[83] == 13);
6961 assert_or_panic(v[84] == 14);
6962 assert_or_panic(v[85] == 15);
6963 assert_or_panic(v[86] == 16);
6964 assert_or_panic(v[87] == 17);
6965 assert_or_panic(v[88] == 18);
6966 assert_or_panic(v[89] == 19);
6967 assert_or_panic(v[90] == 20);
6968 assert_or_panic(v[91] == 21);
6969 assert_or_panic(v[92] == 22);
6970 assert_or_panic(v[93] == 23);
6971 assert_or_panic(v[94] == 24);
6972 assert_or_panic(v[95] == 25);
6973 assert_or_panic(v[96] == 26);
6974 assert_or_panic(v[97] == 27);
6975 assert_or_panic(v[98] == 28);
6976 assert_or_panic(v[99] == 29);
6977 assert_or_panic(v[100] == 30);
6978 assert_or_panic(v[101] == 31);
6979 assert_or_panic(v[102] == 32);
6980 assert_or_panic(v[103] == 33);
6981 assert_or_panic(v[104] == 34);
6982 assert_or_panic(v[105] == 35);
6983 assert_or_panic(v[106] == 36);
6984 assert_or_panic(v[107] == 37);
6985 assert_or_panic(v[108] == 38);
6986 assert_or_panic(v[109] == 39);
6987 assert_or_panic(v[110] == 40);
6988 assert_or_panic(v[111] == 41);
6989 assert_or_panic(v[112] == 42);
6990 assert_or_panic(v[113] == 43);
6991 assert_or_panic(v[114] == 44);
6992 assert_or_panic(v[115] == 45);
6993 assert_or_panic(v[116] == 46);
6994 assert_or_panic(v[117] == 47);
6995 assert_or_panic(v[118] == 48);
6996 assert_or_panic(v[119] == 49);
6997 assert_or_panic(v[120] == 50);
6998 assert_or_panic(v[121] == 51);
6999 assert_or_panic(v[122] == 52);
7000 assert_or_panic(v[123] == 53);
7001 assert_or_panic(v[124] == 54);
7002 assert_or_panic(v[125] == 55);
7003 assert_or_panic(v[126] == 56);
7004 assert_or_panic(v[127] == 57);
7005 assert_or_panic(v[128] == 58);
7006 assert_or_panic(v[129] == 59);
7007 assert_or_panic(v[130] == 60);
7008 assert_or_panic(v[131] == 61);
7009 assert_or_panic(v[132] == 62);
7010 assert_or_panic(v[133] == 63);
7011 assert_or_panic(v[134] == 64);
7012 assert_or_panic(v[135] == 65);
7013 assert_or_panic(v[136] == 66);
7014 assert_or_panic(v[137] == 67);
7015 assert_or_panic(v[138] == 68);
7016 assert_or_panic(v[139] == 69);
7017 assert_or_panic(v[140] == 70);
7018 assert_or_panic(v[141] == 71);
7019 assert_or_panic(v[142] == 72);
7020 assert_or_panic(v[143] == 73);
7021 assert_or_panic(v[144] == 74);
7022 assert_or_panic(v[145] == 75);
7023 assert_or_panic(v[146] == 76);
7024 assert_or_panic(v[147] == 77);
7025 assert_or_panic(v[148] == 78);
7026 assert_or_panic(v[149] == 79);
7027 assert_or_panic(v[150] == 80);
7028 assert_or_panic(v[151] == 81);
7029 assert_or_panic(v[152] == 82);
7030 assert_or_panic(v[153] == 83);
7031 assert_or_panic(v[154] == 84);
7032 assert_or_panic(v[155] == 85);
7033 assert_or_panic(v[156] == 86);
7034 assert_or_panic(v[157] == 87);
7035 assert_or_panic(v[158] == 88);
7036 assert_or_panic(v[159] == 89);
7037 assert_or_panic(v[160] == 90);
7038 assert_or_panic(v[161] == 91);
7039 assert_or_panic(v[162] == 92);
7040 assert_or_panic(v[163] == 93);
7041 assert_or_panic(v[164] == 94);
7042 assert_or_panic(v[165] == 95);
7043 assert_or_panic(v[166] == 96);
7044 assert_or_panic(v[167] == 97);
7045 assert_or_panic(v[168] == 98);
7046 assert_or_panic(v[169] == 99);
7047 assert_or_panic(v[170] == 0);
7048 assert_or_panic(v[171] == 1);
7049 assert_or_panic(v[172] == 2);
7050 assert_or_panic(v[173] == 3);
7051 assert_or_panic(v[174] == 4);
7052 assert_or_panic(v[175] == 5);
7053 assert_or_panic(v[176] == 6);
7054 assert_or_panic(v[177] == 7);
7055 assert_or_panic(v[178] == 8);
7056 assert_or_panic(v[179] == 9);
7057 assert_or_panic(v[180] == 10);
7058 assert_or_panic(v[181] == 11);
7059 assert_or_panic(v[182] == 12);
7060 assert_or_panic(v[183] == 13);
7061 assert_or_panic(v[184] == 14);
7062 assert_or_panic(v[185] == 15);
7063 assert_or_panic(v[186] == 16);
7064 assert_or_panic(v[187] == 17);
7065 assert_or_panic(v[188] == 18);
7066 assert_or_panic(v[189] == 19);
7067 assert_or_panic(v[190] == 20);
7068 assert_or_panic(v[191] == 21);
7069 assert_or_panic(v[192] == 22);
7070 assert_or_panic(v[193] == 23);
7071 assert_or_panic(v[194] == 24);
7072 assert_or_panic(v[195] == 25);
7073 assert_or_panic(v[196] == 26);
7074 assert_or_panic(v[197] == 27);
7075 assert_or_panic(v[198] == 28);
7076 assert_or_panic(v[199] == 29);
7077 assert_or_panic(v[200] == 30);
7078 assert_or_panic(v[201] == 31);
7079 assert_or_panic(v[202] == 32);
7080 assert_or_panic(v[203] == 33);
7081 assert_or_panic(v[204] == 34);
7082 assert_or_panic(v[205] == 35);
7083 assert_or_panic(v[206] == 36);
7084 assert_or_panic(v[207] == 37);
7085 assert_or_panic(v[208] == 38);
7086 assert_or_panic(v[209] == 39);
7087 assert_or_panic(v[210] == 40);
7088 assert_or_panic(v[211] == 41);
7089 assert_or_panic(v[212] == 42);
7090 assert_or_panic(v[213] == 43);
7091 assert_or_panic(v[214] == 44);
7092 assert_or_panic(v[215] == 45);
7093 assert_or_panic(v[216] == 46);
7094 assert_or_panic(v[217] == 47);
7095 assert_or_panic(v[218] == 48);
7096 assert_or_panic(v[219] == 49);
7097 assert_or_panic(v[220] == 50);
7098 assert_or_panic(v[221] == 51);
7099 assert_or_panic(v[222] == 52);
7100 assert_or_panic(v[223] == 53);
7101 assert_or_panic(v[224] == 54);
7102 assert_or_panic(v[225] == 55);
7103 assert_or_panic(v[226] == 56);
7104 assert_or_panic(v[227] == 57);
7105 assert_or_panic(v[228] == 58);
7106 assert_or_panic(v[229] == 59);
7107 assert_or_panic(v[230] == 60);
7108 assert_or_panic(v[231] == 61);
7109 assert_or_panic(v[232] == 62);
7110 assert_or_panic(v[233] == 63);
7111 assert_or_panic(v[234] == 64);
7112 assert_or_panic(v[235] == 65);
7113 assert_or_panic(v[236] == 66);
7114 assert_or_panic(v[237] == 67);
7115 assert_or_panic(v[238] == 68);
7116 assert_or_panic(v[239] == 69);
7117 assert_or_panic(v[240] == 70);
7118 assert_or_panic(v[241] == 71);
7119 assert_or_panic(v[242] == 72);
7120 assert_or_panic(v[243] == 73);
7121 assert_or_panic(v[244] == 74);
7122 assert_or_panic(v[245] == 75);
7123 assert_or_panic(v[246] == 76);
7124 assert_or_panic(v[247] == 77);
7125 assert_or_panic(v[248] == 78);
7126 assert_or_panic(v[249] == 79);
7127 assert_or_panic(v[250] == 80);
7128 assert_or_panic(v[251] == 81);
7129 assert_or_panic(v[252] == 82);
7130 assert_or_panic(v[253] == 83);
7131 assert_or_panic(v[254] == 84);
7132 assert_or_panic(v[255] == 85);
7133 assert_or_panic(v[256] == 86);
7134 assert_or_panic(v[257] == 87);
7135 assert_or_panic(v[258] == 88);
7136 assert_or_panic(v[259] == 89);
7137 assert_or_panic(v[260] == 90);
7138 assert_or_panic(v[261] == 91);
7139 assert_or_panic(v[262] == 92);
7140 assert_or_panic(v[263] == 93);
7141 assert_or_panic(v[264] == 94);
7142 assert_or_panic(v[265] == 95);
7143 assert_or_panic(v[266] == 96);
7144 assert_or_panic(v[267] == 97);
7145 assert_or_panic(v[268] == 98);
7146 assert_or_panic(v[269] == 99);
7147 assert_or_panic(v[270] == 0);
7148 assert_or_panic(v[271] == 1);
7149 assert_or_panic(v[272] == 2);
7150 assert_or_panic(v[273] == 3);
7151 assert_or_panic(v[274] == 4);
7152 assert_or_panic(v[275] == 5);
7153 assert_or_panic(v[276] == 6);
7154 assert_or_panic(v[277] == 7);
7155 assert_or_panic(v[278] == 8);
7156 assert_or_panic(v[279] == 9);
7157 assert_or_panic(v[280] == 10);
7158 assert_or_panic(v[281] == 11);
7159 assert_or_panic(v[282] == 12);
7160 assert_or_panic(v[283] == 13);
7161 assert_or_panic(v[284] == 14);
7162 assert_or_panic(v[285] == 15);
7163 assert_or_panic(v[286] == 16);
7164 assert_or_panic(v[287] == 17);
7165 assert_or_panic(v[288] == 18);
7166 assert_or_panic(v[289] == 19);
7167 assert_or_panic(v[290] == 20);
7168 assert_or_panic(v[291] == 21);
7169 assert_or_panic(v[292] == 22);
7170 assert_or_panic(v[293] == 23);
7171 assert_or_panic(v[294] == 24);
7172 assert_or_panic(v[295] == 25);
7173 assert_or_panic(v[296] == 26);
7174 assert_or_panic(v[297] == 27);
7175 assert_or_panic(v[298] == 28);
7176 assert_or_panic(v[299] == 29);
7177 assert_or_panic(v[300] == 30);
7178 assert_or_panic(v[301] == 31);
7179 assert_or_panic(v[302] == 32);
7180 assert_or_panic(v[303] == 33);
7181 assert_or_panic(v[304] == 34);
7182 assert_or_panic(v[305] == 35);
7183 assert_or_panic(v[306] == 36);
7184 assert_or_panic(v[307] == 37);
7185 assert_or_panic(v[308] == 38);
7186 assert_or_panic(v[309] == 39);
7187 assert_or_panic(v[310] == 40);
7188 assert_or_panic(v[311] == 41);
7189 assert_or_panic(v[312] == 42);
7190 assert_or_panic(v[313] == 43);
7191 assert_or_panic(v[314] == 44);
7192 assert_or_panic(v[315] == 45);
7193 assert_or_panic(v[316] == 46);
7194 assert_or_panic(v[317] == 47);
7195 assert_or_panic(v[318] == 48);
7196 assert_or_panic(v[319] == 49);
7197 assert_or_panic(v[320] == 50);
7198 assert_or_panic(v[321] == 51);
7199 assert_or_panic(v[322] == 52);
7200 assert_or_panic(v[323] == 53);
7201 assert_or_panic(v[324] == 54);
7202 assert_or_panic(v[325] == 55);
7203 assert_or_panic(v[326] == 56);
7204 assert_or_panic(v[327] == 57);
7205 assert_or_panic(v[328] == 58);
7206 assert_or_panic(v[329] == 59);
7207 assert_or_panic(v[330] == 60);
7208 assert_or_panic(v[331] == 61);
7209 assert_or_panic(v[332] == 62);
7210 assert_or_panic(v[333] == 63);
7211 assert_or_panic(v[334] == 64);
7212 assert_or_panic(v[335] == 65);
7213 assert_or_panic(v[336] == 66);
7214 assert_or_panic(v[337] == 67);
7215 assert_or_panic(v[338] == 68);
7216 assert_or_panic(v[339] == 69);
7217 assert_or_panic(v[340] == 70);
7218 assert_or_panic(v[341] == 71);
7219 assert_or_panic(v[342] == 72);
7220 assert_or_panic(v[343] == 73);
7221 assert_or_panic(v[344] == 74);
7222 assert_or_panic(v[345] == 75);
7223 assert_or_panic(v[346] == 76);
7224 assert_or_panic(v[347] == 77);
7225 assert_or_panic(v[348] == 78);
7226 assert_or_panic(v[349] == 79);
7227 assert_or_panic(v[350] == 80);
7228 assert_or_panic(v[351] == 81);
7229 assert_or_panic(v[352] == 82);
7230 assert_or_panic(v[353] == 83);
7231 assert_or_panic(v[354] == 84);
7232 assert_or_panic(v[355] == 85);
7233 assert_or_panic(v[356] == 86);
7234 assert_or_panic(v[357] == 87);
7235 assert_or_panic(v[358] == 88);
7236 assert_or_panic(v[359] == 89);
7237 assert_or_panic(v[360] == 90);
7238 assert_or_panic(v[361] == 91);
7239 assert_or_panic(v[362] == 92);
7240 assert_or_panic(v[363] == 93);
7241 assert_or_panic(v[364] == 94);
7242 assert_or_panic(v[365] == 95);
7243 assert_or_panic(v[366] == 96);
7244 assert_or_panic(v[367] == 97);
7245 assert_or_panic(v[368] == 98);
7246 assert_or_panic(v[369] == 99);
7247 assert_or_panic(v[370] == 0);
7248 assert_or_panic(v[371] == 1);
7249 assert_or_panic(v[372] == 2);
7250 assert_or_panic(v[373] == 3);
7251 assert_or_panic(v[374] == 4);
7252 assert_or_panic(v[375] == 5);
7253 assert_or_panic(v[376] == 6);
7254 assert_or_panic(v[377] == 7);
7255 assert_or_panic(v[378] == 8);
7256 assert_or_panic(v[379] == 9);
7257 assert_or_panic(v[380] == 10);
7258 assert_or_panic(v[381] == 11);
7259 assert_or_panic(v[382] == 12);
7260 assert_or_panic(v[383] == 13);
7261 assert_or_panic(i == 384);
7262}
7263void c_test_vector_384_u8(void) {
7264 Vector_384_u8 v = zig_ret_vector_384_u8();
7265 assert_or_panic(v[0] == 78);
7266 assert_or_panic(v[1] == 79);
7267 assert_or_panic(v[2] == 80);
7268 assert_or_panic(v[3] == 81);
7269 assert_or_panic(v[4] == 82);
7270 assert_or_panic(v[5] == 83);
7271 assert_or_panic(v[6] == 84);
7272 assert_or_panic(v[7] == 85);
7273 assert_or_panic(v[8] == 86);
7274 assert_or_panic(v[9] == 87);
7275 assert_or_panic(v[10] == 88);
7276 assert_or_panic(v[11] == 89);
7277 assert_or_panic(v[12] == 90);
7278 assert_or_panic(v[13] == 91);
7279 assert_or_panic(v[14] == 92);
7280 assert_or_panic(v[15] == 93);
7281 assert_or_panic(v[16] == 94);
7282 assert_or_panic(v[17] == 95);
7283 assert_or_panic(v[18] == 96);
7284 assert_or_panic(v[19] == 97);
7285 assert_or_panic(v[20] == 98);
7286 assert_or_panic(v[21] == 99);
7287 assert_or_panic(v[22] == 0);
7288 assert_or_panic(v[23] == 1);
7289 assert_or_panic(v[24] == 2);
7290 assert_or_panic(v[25] == 3);
7291 assert_or_panic(v[26] == 4);
7292 assert_or_panic(v[27] == 5);
7293 assert_or_panic(v[28] == 6);
7294 assert_or_panic(v[29] == 7);
7295 assert_or_panic(v[30] == 8);
7296 assert_or_panic(v[31] == 9);
7297 assert_or_panic(v[32] == 10);
7298 assert_or_panic(v[33] == 11);
7299 assert_or_panic(v[34] == 12);
7300 assert_or_panic(v[35] == 13);
7301 assert_or_panic(v[36] == 14);
7302 assert_or_panic(v[37] == 15);
7303 assert_or_panic(v[38] == 16);
7304 assert_or_panic(v[39] == 17);
7305 assert_or_panic(v[40] == 18);
7306 assert_or_panic(v[41] == 19);
7307 assert_or_panic(v[42] == 20);
7308 assert_or_panic(v[43] == 21);
7309 assert_or_panic(v[44] == 22);
7310 assert_or_panic(v[45] == 23);
7311 assert_or_panic(v[46] == 24);
7312 assert_or_panic(v[47] == 25);
7313 assert_or_panic(v[48] == 26);
7314 assert_or_panic(v[49] == 27);
7315 assert_or_panic(v[50] == 28);
7316 assert_or_panic(v[51] == 29);
7317 assert_or_panic(v[52] == 30);
7318 assert_or_panic(v[53] == 31);
7319 assert_or_panic(v[54] == 32);
7320 assert_or_panic(v[55] == 33);
7321 assert_or_panic(v[56] == 34);
7322 assert_or_panic(v[57] == 35);
7323 assert_or_panic(v[58] == 36);
7324 assert_or_panic(v[59] == 37);
7325 assert_or_panic(v[60] == 38);
7326 assert_or_panic(v[61] == 39);
7327 assert_or_panic(v[62] == 40);
7328 assert_or_panic(v[63] == 41);
7329 assert_or_panic(v[64] == 42);
7330 assert_or_panic(v[65] == 43);
7331 assert_or_panic(v[66] == 44);
7332 assert_or_panic(v[67] == 45);
7333 assert_or_panic(v[68] == 46);
7334 assert_or_panic(v[69] == 47);
7335 assert_or_panic(v[70] == 48);
7336 assert_or_panic(v[71] == 49);
7337 assert_or_panic(v[72] == 50);
7338 assert_or_panic(v[73] == 51);
7339 assert_or_panic(v[74] == 52);
7340 assert_or_panic(v[75] == 53);
7341 assert_or_panic(v[76] == 54);
7342 assert_or_panic(v[77] == 55);
7343 assert_or_panic(v[78] == 56);
7344 assert_or_panic(v[79] == 57);
7345 assert_or_panic(v[80] == 58);
7346 assert_or_panic(v[81] == 59);
7347 assert_or_panic(v[82] == 60);
7348 assert_or_panic(v[83] == 61);
7349 assert_or_panic(v[84] == 62);
7350 assert_or_panic(v[85] == 63);
7351 assert_or_panic(v[86] == 64);
7352 assert_or_panic(v[87] == 65);
7353 assert_or_panic(v[88] == 66);
7354 assert_or_panic(v[89] == 67);
7355 assert_or_panic(v[90] == 68);
7356 assert_or_panic(v[91] == 69);
7357 assert_or_panic(v[92] == 70);
7358 assert_or_panic(v[93] == 71);
7359 assert_or_panic(v[94] == 72);
7360 assert_or_panic(v[95] == 73);
7361 assert_or_panic(v[96] == 74);
7362 assert_or_panic(v[97] == 75);
7363 assert_or_panic(v[98] == 76);
7364 assert_or_panic(v[99] == 77);
7365 assert_or_panic(v[100] == 78);
7366 assert_or_panic(v[101] == 79);
7367 assert_or_panic(v[102] == 80);
7368 assert_or_panic(v[103] == 81);
7369 assert_or_panic(v[104] == 82);
7370 assert_or_panic(v[105] == 83);
7371 assert_or_panic(v[106] == 84);
7372 assert_or_panic(v[107] == 85);
7373 assert_or_panic(v[108] == 86);
7374 assert_or_panic(v[109] == 87);
7375 assert_or_panic(v[110] == 88);
7376 assert_or_panic(v[111] == 89);
7377 assert_or_panic(v[112] == 90);
7378 assert_or_panic(v[113] == 91);
7379 assert_or_panic(v[114] == 92);
7380 assert_or_panic(v[115] == 93);
7381 assert_or_panic(v[116] == 94);
7382 assert_or_panic(v[117] == 95);
7383 assert_or_panic(v[118] == 96);
7384 assert_or_panic(v[119] == 97);
7385 assert_or_panic(v[120] == 98);
7386 assert_or_panic(v[121] == 99);
7387 assert_or_panic(v[122] == 0);
7388 assert_or_panic(v[123] == 1);
7389 assert_or_panic(v[124] == 2);
7390 assert_or_panic(v[125] == 3);
7391 assert_or_panic(v[126] == 4);
7392 assert_or_panic(v[127] == 5);
7393 assert_or_panic(v[128] == 6);
7394 assert_or_panic(v[129] == 7);
7395 assert_or_panic(v[130] == 8);
7396 assert_or_panic(v[131] == 9);
7397 assert_or_panic(v[132] == 10);
7398 assert_or_panic(v[133] == 11);
7399 assert_or_panic(v[134] == 12);
7400 assert_or_panic(v[135] == 13);
7401 assert_or_panic(v[136] == 14);
7402 assert_or_panic(v[137] == 15);
7403 assert_or_panic(v[138] == 16);
7404 assert_or_panic(v[139] == 17);
7405 assert_or_panic(v[140] == 18);
7406 assert_or_panic(v[141] == 19);
7407 assert_or_panic(v[142] == 20);
7408 assert_or_panic(v[143] == 21);
7409 assert_or_panic(v[144] == 22);
7410 assert_or_panic(v[145] == 23);
7411 assert_or_panic(v[146] == 24);
7412 assert_or_panic(v[147] == 25);
7413 assert_or_panic(v[148] == 26);
7414 assert_or_panic(v[149] == 27);
7415 assert_or_panic(v[150] == 28);
7416 assert_or_panic(v[151] == 29);
7417 assert_or_panic(v[152] == 30);
7418 assert_or_panic(v[153] == 31);
7419 assert_or_panic(v[154] == 32);
7420 assert_or_panic(v[155] == 33);
7421 assert_or_panic(v[156] == 34);
7422 assert_or_panic(v[157] == 35);
7423 assert_or_panic(v[158] == 36);
7424 assert_or_panic(v[159] == 37);
7425 assert_or_panic(v[160] == 38);
7426 assert_or_panic(v[161] == 39);
7427 assert_or_panic(v[162] == 40);
7428 assert_or_panic(v[163] == 41);
7429 assert_or_panic(v[164] == 42);
7430 assert_or_panic(v[165] == 43);
7431 assert_or_panic(v[166] == 44);
7432 assert_or_panic(v[167] == 45);
7433 assert_or_panic(v[168] == 46);
7434 assert_or_panic(v[169] == 47);
7435 assert_or_panic(v[170] == 48);
7436 assert_or_panic(v[171] == 49);
7437 assert_or_panic(v[172] == 50);
7438 assert_or_panic(v[173] == 51);
7439 assert_or_panic(v[174] == 52);
7440 assert_or_panic(v[175] == 53);
7441 assert_or_panic(v[176] == 54);
7442 assert_or_panic(v[177] == 55);
7443 assert_or_panic(v[178] == 56);
7444 assert_or_panic(v[179] == 57);
7445 assert_or_panic(v[180] == 58);
7446 assert_or_panic(v[181] == 59);
7447 assert_or_panic(v[182] == 60);
7448 assert_or_panic(v[183] == 61);
7449 assert_or_panic(v[184] == 62);
7450 assert_or_panic(v[185] == 63);
7451 assert_or_panic(v[186] == 64);
7452 assert_or_panic(v[187] == 65);
7453 assert_or_panic(v[188] == 66);
7454 assert_or_panic(v[189] == 67);
7455 assert_or_panic(v[190] == 68);
7456 assert_or_panic(v[191] == 69);
7457 assert_or_panic(v[192] == 70);
7458 assert_or_panic(v[193] == 71);
7459 assert_or_panic(v[194] == 72);
7460 assert_or_panic(v[195] == 73);
7461 assert_or_panic(v[196] == 74);
7462 assert_or_panic(v[197] == 75);
7463 assert_or_panic(v[198] == 76);
7464 assert_or_panic(v[199] == 77);
7465 assert_or_panic(v[200] == 78);
7466 assert_or_panic(v[201] == 79);
7467 assert_or_panic(v[202] == 80);
7468 assert_or_panic(v[203] == 81);
7469 assert_or_panic(v[204] == 82);
7470 assert_or_panic(v[205] == 83);
7471 assert_or_panic(v[206] == 84);
7472 assert_or_panic(v[207] == 85);
7473 assert_or_panic(v[208] == 86);
7474 assert_or_panic(v[209] == 87);
7475 assert_or_panic(v[210] == 88);
7476 assert_or_panic(v[211] == 89);
7477 assert_or_panic(v[212] == 90);
7478 assert_or_panic(v[213] == 91);
7479 assert_or_panic(v[214] == 92);
7480 assert_or_panic(v[215] == 93);
7481 assert_or_panic(v[216] == 94);
7482 assert_or_panic(v[217] == 95);
7483 assert_or_panic(v[218] == 96);
7484 assert_or_panic(v[219] == 97);
7485 assert_or_panic(v[220] == 98);
7486 assert_or_panic(v[221] == 99);
7487 assert_or_panic(v[222] == 0);
7488 assert_or_panic(v[223] == 1);
7489 assert_or_panic(v[224] == 2);
7490 assert_or_panic(v[225] == 3);
7491 assert_or_panic(v[226] == 4);
7492 assert_or_panic(v[227] == 5);
7493 assert_or_panic(v[228] == 6);
7494 assert_or_panic(v[229] == 7);
7495 assert_or_panic(v[230] == 8);
7496 assert_or_panic(v[231] == 9);
7497 assert_or_panic(v[232] == 10);
7498 assert_or_panic(v[233] == 11);
7499 assert_or_panic(v[234] == 12);
7500 assert_or_panic(v[235] == 13);
7501 assert_or_panic(v[236] == 14);
7502 assert_or_panic(v[237] == 15);
7503 assert_or_panic(v[238] == 16);
7504 assert_or_panic(v[239] == 17);
7505 assert_or_panic(v[240] == 18);
7506 assert_or_panic(v[241] == 19);
7507 assert_or_panic(v[242] == 20);
7508 assert_or_panic(v[243] == 21);
7509 assert_or_panic(v[244] == 22);
7510 assert_or_panic(v[245] == 23);
7511 assert_or_panic(v[246] == 24);
7512 assert_or_panic(v[247] == 25);
7513 assert_or_panic(v[248] == 26);
7514 assert_or_panic(v[249] == 27);
7515 assert_or_panic(v[250] == 28);
7516 assert_or_panic(v[251] == 29);
7517 assert_or_panic(v[252] == 30);
7518 assert_or_panic(v[253] == 31);
7519 assert_or_panic(v[254] == 32);
7520 assert_or_panic(v[255] == 33);
7521 assert_or_panic(v[256] == 34);
7522 assert_or_panic(v[257] == 35);
7523 assert_or_panic(v[258] == 36);
7524 assert_or_panic(v[259] == 37);
7525 assert_or_panic(v[260] == 38);
7526 assert_or_panic(v[261] == 39);
7527 assert_or_panic(v[262] == 40);
7528 assert_or_panic(v[263] == 41);
7529 assert_or_panic(v[264] == 42);
7530 assert_or_panic(v[265] == 43);
7531 assert_or_panic(v[266] == 44);
7532 assert_or_panic(v[267] == 45);
7533 assert_or_panic(v[268] == 46);
7534 assert_or_panic(v[269] == 47);
7535 assert_or_panic(v[270] == 48);
7536 assert_or_panic(v[271] == 49);
7537 assert_or_panic(v[272] == 50);
7538 assert_or_panic(v[273] == 51);
7539 assert_or_panic(v[274] == 52);
7540 assert_or_panic(v[275] == 53);
7541 assert_or_panic(v[276] == 54);
7542 assert_or_panic(v[277] == 55);
7543 assert_or_panic(v[278] == 56);
7544 assert_or_panic(v[279] == 57);
7545 assert_or_panic(v[280] == 58);
7546 assert_or_panic(v[281] == 59);
7547 assert_or_panic(v[282] == 60);
7548 assert_or_panic(v[283] == 61);
7549 assert_or_panic(v[284] == 62);
7550 assert_or_panic(v[285] == 63);
7551 assert_or_panic(v[286] == 64);
7552 assert_or_panic(v[287] == 65);
7553 assert_or_panic(v[288] == 66);
7554 assert_or_panic(v[289] == 67);
7555 assert_or_panic(v[290] == 68);
7556 assert_or_panic(v[291] == 69);
7557 assert_or_panic(v[292] == 70);
7558 assert_or_panic(v[293] == 71);
7559 assert_or_panic(v[294] == 72);
7560 assert_or_panic(v[295] == 73);
7561 assert_or_panic(v[296] == 74);
7562 assert_or_panic(v[297] == 75);
7563 assert_or_panic(v[298] == 76);
7564 assert_or_panic(v[299] == 77);
7565 assert_or_panic(v[300] == 78);
7566 assert_or_panic(v[301] == 79);
7567 assert_or_panic(v[302] == 80);
7568 assert_or_panic(v[303] == 81);
7569 assert_or_panic(v[304] == 82);
7570 assert_or_panic(v[305] == 83);
7571 assert_or_panic(v[306] == 84);
7572 assert_or_panic(v[307] == 85);
7573 assert_or_panic(v[308] == 86);
7574 assert_or_panic(v[309] == 87);
7575 assert_or_panic(v[310] == 88);
7576 assert_or_panic(v[311] == 89);
7577 assert_or_panic(v[312] == 90);
7578 assert_or_panic(v[313] == 91);
7579 assert_or_panic(v[314] == 92);
7580 assert_or_panic(v[315] == 93);
7581 assert_or_panic(v[316] == 94);
7582 assert_or_panic(v[317] == 95);
7583 assert_or_panic(v[318] == 96);
7584 assert_or_panic(v[319] == 97);
7585 assert_or_panic(v[320] == 98);
7586 assert_or_panic(v[321] == 99);
7587 assert_or_panic(v[322] == 0);
7588 assert_or_panic(v[323] == 1);
7589 assert_or_panic(v[324] == 2);
7590 assert_or_panic(v[325] == 3);
7591 assert_or_panic(v[326] == 4);
7592 assert_or_panic(v[327] == 5);
7593 assert_or_panic(v[328] == 6);
7594 assert_or_panic(v[329] == 7);
7595 assert_or_panic(v[330] == 8);
7596 assert_or_panic(v[331] == 9);
7597 assert_or_panic(v[332] == 10);
7598 assert_or_panic(v[333] == 11);
7599 assert_or_panic(v[334] == 12);
7600 assert_or_panic(v[335] == 13);
7601 assert_or_panic(v[336] == 14);
7602 assert_or_panic(v[337] == 15);
7603 assert_or_panic(v[338] == 16);
7604 assert_or_panic(v[339] == 17);
7605 assert_or_panic(v[340] == 18);
7606 assert_or_panic(v[341] == 19);
7607 assert_or_panic(v[342] == 20);
7608 assert_or_panic(v[343] == 21);
7609 assert_or_panic(v[344] == 22);
7610 assert_or_panic(v[345] == 23);
7611 assert_or_panic(v[346] == 24);
7612 assert_or_panic(v[347] == 25);
7613 assert_or_panic(v[348] == 26);
7614 assert_or_panic(v[349] == 27);
7615 assert_or_panic(v[350] == 28);
7616 assert_or_panic(v[351] == 29);
7617 assert_or_panic(v[352] == 30);
7618 assert_or_panic(v[353] == 31);
7619 assert_or_panic(v[354] == 32);
7620 assert_or_panic(v[355] == 33);
7621 assert_or_panic(v[356] == 34);
7622 assert_or_panic(v[357] == 35);
7623 assert_or_panic(v[358] == 36);
7624 assert_or_panic(v[359] == 37);
7625 assert_or_panic(v[360] == 38);
7626 assert_or_panic(v[361] == 39);
7627 assert_or_panic(v[362] == 40);
7628 assert_or_panic(v[363] == 41);
7629 assert_or_panic(v[364] == 42);
7630 assert_or_panic(v[365] == 43);
7631 assert_or_panic(v[366] == 44);
7632 assert_or_panic(v[367] == 45);
7633 assert_or_panic(v[368] == 46);
7634 assert_or_panic(v[369] == 47);
7635 assert_or_panic(v[370] == 48);
7636 assert_or_panic(v[371] == 49);
7637 assert_or_panic(v[372] == 50);
7638 assert_or_panic(v[373] == 51);
7639 assert_or_panic(v[374] == 52);
7640 assert_or_panic(v[375] == 53);
7641 assert_or_panic(v[376] == 54);
7642 assert_or_panic(v[377] == 55);
7643 assert_or_panic(v[378] == 56);
7644 assert_or_panic(v[379] == 57);
7645 assert_or_panic(v[380] == 58);
7646 assert_or_panic(v[381] == 59);
7647 assert_or_panic(v[382] == 60);
7648 assert_or_panic(v[383] == 61);
7649 zig_vector_384_u8((Vector_384_u8){
7650 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
7651 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
7652 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
7653 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
7654 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
7655 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7656 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
7657 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
7658 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
7659 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
7660 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
7661 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
7662 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
7663 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
7664 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
7665 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7666 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
7667 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
7668 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
7669 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
7670 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
7671 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
7672 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
7673 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
7674 }, 384);
7675}
7676
7677typedef uint8_t Vector_512_u8 __attribute__((vector_size(512 * sizeof(uint8_t))));
7678
7679Vector_512_u8 zig_ret_vector_512_u8(void);
7680void zig_vector_512_u8(Vector_512_u8, size_t);
7681
7682Vector_512_u8 c_ret_vector_512_u8(void) {
7683 return (Vector_512_u8){
7684 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
7685 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
7686 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
7687 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
7688 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7689 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
7690 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
7691 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
7692 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
7693 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
7694 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
7695 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
7696 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
7697 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
7698 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
7699 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
7700 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
7701 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
7702 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
7703 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
7704 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
7705 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
7706 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
7707 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
7708 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
7709 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
7710 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
7711 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
7712 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
7713 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
7714 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
7715 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
7716 };
7717}
7718void c_vector_512_u8(Vector_512_u8 v, size_t i) {
7719 assert_or_panic(v[0] == 50);
7720 assert_or_panic(v[1] == 51);
7721 assert_or_panic(v[2] == 52);
7722 assert_or_panic(v[3] == 53);
7723 assert_or_panic(v[4] == 54);
7724 assert_or_panic(v[5] == 55);
7725 assert_or_panic(v[6] == 56);
7726 assert_or_panic(v[7] == 57);
7727 assert_or_panic(v[8] == 58);
7728 assert_or_panic(v[9] == 59);
7729 assert_or_panic(v[10] == 60);
7730 assert_or_panic(v[11] == 61);
7731 assert_or_panic(v[12] == 62);
7732 assert_or_panic(v[13] == 63);
7733 assert_or_panic(v[14] == 64);
7734 assert_or_panic(v[15] == 65);
7735 assert_or_panic(v[16] == 66);
7736 assert_or_panic(v[17] == 67);
7737 assert_or_panic(v[18] == 68);
7738 assert_or_panic(v[19] == 69);
7739 assert_or_panic(v[20] == 70);
7740 assert_or_panic(v[21] == 71);
7741 assert_or_panic(v[22] == 72);
7742 assert_or_panic(v[23] == 73);
7743 assert_or_panic(v[24] == 74);
7744 assert_or_panic(v[25] == 75);
7745 assert_or_panic(v[26] == 76);
7746 assert_or_panic(v[27] == 77);
7747 assert_or_panic(v[28] == 78);
7748 assert_or_panic(v[29] == 79);
7749 assert_or_panic(v[30] == 80);
7750 assert_or_panic(v[31] == 81);
7751 assert_or_panic(v[32] == 82);
7752 assert_or_panic(v[33] == 83);
7753 assert_or_panic(v[34] == 84);
7754 assert_or_panic(v[35] == 85);
7755 assert_or_panic(v[36] == 86);
7756 assert_or_panic(v[37] == 87);
7757 assert_or_panic(v[38] == 88);
7758 assert_or_panic(v[39] == 89);
7759 assert_or_panic(v[40] == 90);
7760 assert_or_panic(v[41] == 91);
7761 assert_or_panic(v[42] == 92);
7762 assert_or_panic(v[43] == 93);
7763 assert_or_panic(v[44] == 94);
7764 assert_or_panic(v[45] == 95);
7765 assert_or_panic(v[46] == 96);
7766 assert_or_panic(v[47] == 97);
7767 assert_or_panic(v[48] == 98);
7768 assert_or_panic(v[49] == 99);
7769 assert_or_panic(v[50] == 0);
7770 assert_or_panic(v[51] == 1);
7771 assert_or_panic(v[52] == 2);
7772 assert_or_panic(v[53] == 3);
7773 assert_or_panic(v[54] == 4);
7774 assert_or_panic(v[55] == 5);
7775 assert_or_panic(v[56] == 6);
7776 assert_or_panic(v[57] == 7);
7777 assert_or_panic(v[58] == 8);
7778 assert_or_panic(v[59] == 9);
7779 assert_or_panic(v[60] == 10);
7780 assert_or_panic(v[61] == 11);
7781 assert_or_panic(v[62] == 12);
7782 assert_or_panic(v[63] == 13);
7783 assert_or_panic(v[64] == 14);
7784 assert_or_panic(v[65] == 15);
7785 assert_or_panic(v[66] == 16);
7786 assert_or_panic(v[67] == 17);
7787 assert_or_panic(v[68] == 18);
7788 assert_or_panic(v[69] == 19);
7789 assert_or_panic(v[70] == 20);
7790 assert_or_panic(v[71] == 21);
7791 assert_or_panic(v[72] == 22);
7792 assert_or_panic(v[73] == 23);
7793 assert_or_panic(v[74] == 24);
7794 assert_or_panic(v[75] == 25);
7795 assert_or_panic(v[76] == 26);
7796 assert_or_panic(v[77] == 27);
7797 assert_or_panic(v[78] == 28);
7798 assert_or_panic(v[79] == 29);
7799 assert_or_panic(v[80] == 30);
7800 assert_or_panic(v[81] == 31);
7801 assert_or_panic(v[82] == 32);
7802 assert_or_panic(v[83] == 33);
7803 assert_or_panic(v[84] == 34);
7804 assert_or_panic(v[85] == 35);
7805 assert_or_panic(v[86] == 36);
7806 assert_or_panic(v[87] == 37);
7807 assert_or_panic(v[88] == 38);
7808 assert_or_panic(v[89] == 39);
7809 assert_or_panic(v[90] == 40);
7810 assert_or_panic(v[91] == 41);
7811 assert_or_panic(v[92] == 42);
7812 assert_or_panic(v[93] == 43);
7813 assert_or_panic(v[94] == 44);
7814 assert_or_panic(v[95] == 45);
7815 assert_or_panic(v[96] == 46);
7816 assert_or_panic(v[97] == 47);
7817 assert_or_panic(v[98] == 48);
7818 assert_or_panic(v[99] == 49);
7819 assert_or_panic(v[100] == 50);
7820 assert_or_panic(v[101] == 51);
7821 assert_or_panic(v[102] == 52);
7822 assert_or_panic(v[103] == 53);
7823 assert_or_panic(v[104] == 54);
7824 assert_or_panic(v[105] == 55);
7825 assert_or_panic(v[106] == 56);
7826 assert_or_panic(v[107] == 57);
7827 assert_or_panic(v[108] == 58);
7828 assert_or_panic(v[109] == 59);
7829 assert_or_panic(v[110] == 60);
7830 assert_or_panic(v[111] == 61);
7831 assert_or_panic(v[112] == 62);
7832 assert_or_panic(v[113] == 63);
7833 assert_or_panic(v[114] == 64);
7834 assert_or_panic(v[115] == 65);
7835 assert_or_panic(v[116] == 66);
7836 assert_or_panic(v[117] == 67);
7837 assert_or_panic(v[118] == 68);
7838 assert_or_panic(v[119] == 69);
7839 assert_or_panic(v[120] == 70);
7840 assert_or_panic(v[121] == 71);
7841 assert_or_panic(v[122] == 72);
7842 assert_or_panic(v[123] == 73);
7843 assert_or_panic(v[124] == 74);
7844 assert_or_panic(v[125] == 75);
7845 assert_or_panic(v[126] == 76);
7846 assert_or_panic(v[127] == 77);
7847 assert_or_panic(v[128] == 78);
7848 assert_or_panic(v[129] == 79);
7849 assert_or_panic(v[130] == 80);
7850 assert_or_panic(v[131] == 81);
7851 assert_or_panic(v[132] == 82);
7852 assert_or_panic(v[133] == 83);
7853 assert_or_panic(v[134] == 84);
7854 assert_or_panic(v[135] == 85);
7855 assert_or_panic(v[136] == 86);
7856 assert_or_panic(v[137] == 87);
7857 assert_or_panic(v[138] == 88);
7858 assert_or_panic(v[139] == 89);
7859 assert_or_panic(v[140] == 90);
7860 assert_or_panic(v[141] == 91);
7861 assert_or_panic(v[142] == 92);
7862 assert_or_panic(v[143] == 93);
7863 assert_or_panic(v[144] == 94);
7864 assert_or_panic(v[145] == 95);
7865 assert_or_panic(v[146] == 96);
7866 assert_or_panic(v[147] == 97);
7867 assert_or_panic(v[148] == 98);
7868 assert_or_panic(v[149] == 99);
7869 assert_or_panic(v[150] == 0);
7870 assert_or_panic(v[151] == 1);
7871 assert_or_panic(v[152] == 2);
7872 assert_or_panic(v[153] == 3);
7873 assert_or_panic(v[154] == 4);
7874 assert_or_panic(v[155] == 5);
7875 assert_or_panic(v[156] == 6);
7876 assert_or_panic(v[157] == 7);
7877 assert_or_panic(v[158] == 8);
7878 assert_or_panic(v[159] == 9);
7879 assert_or_panic(v[160] == 10);
7880 assert_or_panic(v[161] == 11);
7881 assert_or_panic(v[162] == 12);
7882 assert_or_panic(v[163] == 13);
7883 assert_or_panic(v[164] == 14);
7884 assert_or_panic(v[165] == 15);
7885 assert_or_panic(v[166] == 16);
7886 assert_or_panic(v[167] == 17);
7887 assert_or_panic(v[168] == 18);
7888 assert_or_panic(v[169] == 19);
7889 assert_or_panic(v[170] == 20);
7890 assert_or_panic(v[171] == 21);
7891 assert_or_panic(v[172] == 22);
7892 assert_or_panic(v[173] == 23);
7893 assert_or_panic(v[174] == 24);
7894 assert_or_panic(v[175] == 25);
7895 assert_or_panic(v[176] == 26);
7896 assert_or_panic(v[177] == 27);
7897 assert_or_panic(v[178] == 28);
7898 assert_or_panic(v[179] == 29);
7899 assert_or_panic(v[180] == 30);
7900 assert_or_panic(v[181] == 31);
7901 assert_or_panic(v[182] == 32);
7902 assert_or_panic(v[183] == 33);
7903 assert_or_panic(v[184] == 34);
7904 assert_or_panic(v[185] == 35);
7905 assert_or_panic(v[186] == 36);
7906 assert_or_panic(v[187] == 37);
7907 assert_or_panic(v[188] == 38);
7908 assert_or_panic(v[189] == 39);
7909 assert_or_panic(v[190] == 40);
7910 assert_or_panic(v[191] == 41);
7911 assert_or_panic(v[192] == 42);
7912 assert_or_panic(v[193] == 43);
7913 assert_or_panic(v[194] == 44);
7914 assert_or_panic(v[195] == 45);
7915 assert_or_panic(v[196] == 46);
7916 assert_or_panic(v[197] == 47);
7917 assert_or_panic(v[198] == 48);
7918 assert_or_panic(v[199] == 49);
7919 assert_or_panic(v[200] == 50);
7920 assert_or_panic(v[201] == 51);
7921 assert_or_panic(v[202] == 52);
7922 assert_or_panic(v[203] == 53);
7923 assert_or_panic(v[204] == 54);
7924 assert_or_panic(v[205] == 55);
7925 assert_or_panic(v[206] == 56);
7926 assert_or_panic(v[207] == 57);
7927 assert_or_panic(v[208] == 58);
7928 assert_or_panic(v[209] == 59);
7929 assert_or_panic(v[210] == 60);
7930 assert_or_panic(v[211] == 61);
7931 assert_or_panic(v[212] == 62);
7932 assert_or_panic(v[213] == 63);
7933 assert_or_panic(v[214] == 64);
7934 assert_or_panic(v[215] == 65);
7935 assert_or_panic(v[216] == 66);
7936 assert_or_panic(v[217] == 67);
7937 assert_or_panic(v[218] == 68);
7938 assert_or_panic(v[219] == 69);
7939 assert_or_panic(v[220] == 70);
7940 assert_or_panic(v[221] == 71);
7941 assert_or_panic(v[222] == 72);
7942 assert_or_panic(v[223] == 73);
7943 assert_or_panic(v[224] == 74);
7944 assert_or_panic(v[225] == 75);
7945 assert_or_panic(v[226] == 76);
7946 assert_or_panic(v[227] == 77);
7947 assert_or_panic(v[228] == 78);
7948 assert_or_panic(v[229] == 79);
7949 assert_or_panic(v[230] == 80);
7950 assert_or_panic(v[231] == 81);
7951 assert_or_panic(v[232] == 82);
7952 assert_or_panic(v[233] == 83);
7953 assert_or_panic(v[234] == 84);
7954 assert_or_panic(v[235] == 85);
7955 assert_or_panic(v[236] == 86);
7956 assert_or_panic(v[237] == 87);
7957 assert_or_panic(v[238] == 88);
7958 assert_or_panic(v[239] == 89);
7959 assert_or_panic(v[240] == 90);
7960 assert_or_panic(v[241] == 91);
7961 assert_or_panic(v[242] == 92);
7962 assert_or_panic(v[243] == 93);
7963 assert_or_panic(v[244] == 94);
7964 assert_or_panic(v[245] == 95);
7965 assert_or_panic(v[246] == 96);
7966 assert_or_panic(v[247] == 97);
7967 assert_or_panic(v[248] == 98);
7968 assert_or_panic(v[249] == 99);
7969 assert_or_panic(v[250] == 0);
7970 assert_or_panic(v[251] == 1);
7971 assert_or_panic(v[252] == 2);
7972 assert_or_panic(v[253] == 3);
7973 assert_or_panic(v[254] == 4);
7974 assert_or_panic(v[255] == 5);
7975 assert_or_panic(v[256] == 6);
7976 assert_or_panic(v[257] == 7);
7977 assert_or_panic(v[258] == 8);
7978 assert_or_panic(v[259] == 9);
7979 assert_or_panic(v[260] == 10);
7980 assert_or_panic(v[261] == 11);
7981 assert_or_panic(v[262] == 12);
7982 assert_or_panic(v[263] == 13);
7983 assert_or_panic(v[264] == 14);
7984 assert_or_panic(v[265] == 15);
7985 assert_or_panic(v[266] == 16);
7986 assert_or_panic(v[267] == 17);
7987 assert_or_panic(v[268] == 18);
7988 assert_or_panic(v[269] == 19);
7989 assert_or_panic(v[270] == 20);
7990 assert_or_panic(v[271] == 21);
7991 assert_or_panic(v[272] == 22);
7992 assert_or_panic(v[273] == 23);
7993 assert_or_panic(v[274] == 24);
7994 assert_or_panic(v[275] == 25);
7995 assert_or_panic(v[276] == 26);
7996 assert_or_panic(v[277] == 27);
7997 assert_or_panic(v[278] == 28);
7998 assert_or_panic(v[279] == 29);
7999 assert_or_panic(v[280] == 30);
8000 assert_or_panic(v[281] == 31);
8001 assert_or_panic(v[282] == 32);
8002 assert_or_panic(v[283] == 33);
8003 assert_or_panic(v[284] == 34);
8004 assert_or_panic(v[285] == 35);
8005 assert_or_panic(v[286] == 36);
8006 assert_or_panic(v[287] == 37);
8007 assert_or_panic(v[288] == 38);
8008 assert_or_panic(v[289] == 39);
8009 assert_or_panic(v[290] == 40);
8010 assert_or_panic(v[291] == 41);
8011 assert_or_panic(v[292] == 42);
8012 assert_or_panic(v[293] == 43);
8013 assert_or_panic(v[294] == 44);
8014 assert_or_panic(v[295] == 45);
8015 assert_or_panic(v[296] == 46);
8016 assert_or_panic(v[297] == 47);
8017 assert_or_panic(v[298] == 48);
8018 assert_or_panic(v[299] == 49);
8019 assert_or_panic(v[300] == 50);
8020 assert_or_panic(v[301] == 51);
8021 assert_or_panic(v[302] == 52);
8022 assert_or_panic(v[303] == 53);
8023 assert_or_panic(v[304] == 54);
8024 assert_or_panic(v[305] == 55);
8025 assert_or_panic(v[306] == 56);
8026 assert_or_panic(v[307] == 57);
8027 assert_or_panic(v[308] == 58);
8028 assert_or_panic(v[309] == 59);
8029 assert_or_panic(v[310] == 60);
8030 assert_or_panic(v[311] == 61);
8031 assert_or_panic(v[312] == 62);
8032 assert_or_panic(v[313] == 63);
8033 assert_or_panic(v[314] == 64);
8034 assert_or_panic(v[315] == 65);
8035 assert_or_panic(v[316] == 66);
8036 assert_or_panic(v[317] == 67);
8037 assert_or_panic(v[318] == 68);
8038 assert_or_panic(v[319] == 69);
8039 assert_or_panic(v[320] == 70);
8040 assert_or_panic(v[321] == 71);
8041 assert_or_panic(v[322] == 72);
8042 assert_or_panic(v[323] == 73);
8043 assert_or_panic(v[324] == 74);
8044 assert_or_panic(v[325] == 75);
8045 assert_or_panic(v[326] == 76);
8046 assert_or_panic(v[327] == 77);
8047 assert_or_panic(v[328] == 78);
8048 assert_or_panic(v[329] == 79);
8049 assert_or_panic(v[330] == 80);
8050 assert_or_panic(v[331] == 81);
8051 assert_or_panic(v[332] == 82);
8052 assert_or_panic(v[333] == 83);
8053 assert_or_panic(v[334] == 84);
8054 assert_or_panic(v[335] == 85);
8055 assert_or_panic(v[336] == 86);
8056 assert_or_panic(v[337] == 87);
8057 assert_or_panic(v[338] == 88);
8058 assert_or_panic(v[339] == 89);
8059 assert_or_panic(v[340] == 90);
8060 assert_or_panic(v[341] == 91);
8061 assert_or_panic(v[342] == 92);
8062 assert_or_panic(v[343] == 93);
8063 assert_or_panic(v[344] == 94);
8064 assert_or_panic(v[345] == 95);
8065 assert_or_panic(v[346] == 96);
8066 assert_or_panic(v[347] == 97);
8067 assert_or_panic(v[348] == 98);
8068 assert_or_panic(v[349] == 99);
8069 assert_or_panic(v[350] == 0);
8070 assert_or_panic(v[351] == 1);
8071 assert_or_panic(v[352] == 2);
8072 assert_or_panic(v[353] == 3);
8073 assert_or_panic(v[354] == 4);
8074 assert_or_panic(v[355] == 5);
8075 assert_or_panic(v[356] == 6);
8076 assert_or_panic(v[357] == 7);
8077 assert_or_panic(v[358] == 8);
8078 assert_or_panic(v[359] == 9);
8079 assert_or_panic(v[360] == 10);
8080 assert_or_panic(v[361] == 11);
8081 assert_or_panic(v[362] == 12);
8082 assert_or_panic(v[363] == 13);
8083 assert_or_panic(v[364] == 14);
8084 assert_or_panic(v[365] == 15);
8085 assert_or_panic(v[366] == 16);
8086 assert_or_panic(v[367] == 17);
8087 assert_or_panic(v[368] == 18);
8088 assert_or_panic(v[369] == 19);
8089 assert_or_panic(v[370] == 20);
8090 assert_or_panic(v[371] == 21);
8091 assert_or_panic(v[372] == 22);
8092 assert_or_panic(v[373] == 23);
8093 assert_or_panic(v[374] == 24);
8094 assert_or_panic(v[375] == 25);
8095 assert_or_panic(v[376] == 26);
8096 assert_or_panic(v[377] == 27);
8097 assert_or_panic(v[378] == 28);
8098 assert_or_panic(v[379] == 29);
8099 assert_or_panic(v[380] == 30);
8100 assert_or_panic(v[381] == 31);
8101 assert_or_panic(v[382] == 32);
8102 assert_or_panic(v[383] == 33);
8103 assert_or_panic(v[384] == 34);
8104 assert_or_panic(v[385] == 35);
8105 assert_or_panic(v[386] == 36);
8106 assert_or_panic(v[387] == 37);
8107 assert_or_panic(v[388] == 38);
8108 assert_or_panic(v[389] == 39);
8109 assert_or_panic(v[390] == 40);
8110 assert_or_panic(v[391] == 41);
8111 assert_or_panic(v[392] == 42);
8112 assert_or_panic(v[393] == 43);
8113 assert_or_panic(v[394] == 44);
8114 assert_or_panic(v[395] == 45);
8115 assert_or_panic(v[396] == 46);
8116 assert_or_panic(v[397] == 47);
8117 assert_or_panic(v[398] == 48);
8118 assert_or_panic(v[399] == 49);
8119 assert_or_panic(v[400] == 50);
8120 assert_or_panic(v[401] == 51);
8121 assert_or_panic(v[402] == 52);
8122 assert_or_panic(v[403] == 53);
8123 assert_or_panic(v[404] == 54);
8124 assert_or_panic(v[405] == 55);
8125 assert_or_panic(v[406] == 56);
8126 assert_or_panic(v[407] == 57);
8127 assert_or_panic(v[408] == 58);
8128 assert_or_panic(v[409] == 59);
8129 assert_or_panic(v[410] == 60);
8130 assert_or_panic(v[411] == 61);
8131 assert_or_panic(v[412] == 62);
8132 assert_or_panic(v[413] == 63);
8133 assert_or_panic(v[414] == 64);
8134 assert_or_panic(v[415] == 65);
8135 assert_or_panic(v[416] == 66);
8136 assert_or_panic(v[417] == 67);
8137 assert_or_panic(v[418] == 68);
8138 assert_or_panic(v[419] == 69);
8139 assert_or_panic(v[420] == 70);
8140 assert_or_panic(v[421] == 71);
8141 assert_or_panic(v[422] == 72);
8142 assert_or_panic(v[423] == 73);
8143 assert_or_panic(v[424] == 74);
8144 assert_or_panic(v[425] == 75);
8145 assert_or_panic(v[426] == 76);
8146 assert_or_panic(v[427] == 77);
8147 assert_or_panic(v[428] == 78);
8148 assert_or_panic(v[429] == 79);
8149 assert_or_panic(v[430] == 80);
8150 assert_or_panic(v[431] == 81);
8151 assert_or_panic(v[432] == 82);
8152 assert_or_panic(v[433] == 83);
8153 assert_or_panic(v[434] == 84);
8154 assert_or_panic(v[435] == 85);
8155 assert_or_panic(v[436] == 86);
8156 assert_or_panic(v[437] == 87);
8157 assert_or_panic(v[438] == 88);
8158 assert_or_panic(v[439] == 89);
8159 assert_or_panic(v[440] == 90);
8160 assert_or_panic(v[441] == 91);
8161 assert_or_panic(v[442] == 92);
8162 assert_or_panic(v[443] == 93);
8163 assert_or_panic(v[444] == 94);
8164 assert_or_panic(v[445] == 95);
8165 assert_or_panic(v[446] == 96);
8166 assert_or_panic(v[447] == 97);
8167 assert_or_panic(v[448] == 98);
8168 assert_or_panic(v[449] == 99);
8169 assert_or_panic(v[450] == 0);
8170 assert_or_panic(v[451] == 1);
8171 assert_or_panic(v[452] == 2);
8172 assert_or_panic(v[453] == 3);
8173 assert_or_panic(v[454] == 4);
8174 assert_or_panic(v[455] == 5);
8175 assert_or_panic(v[456] == 6);
8176 assert_or_panic(v[457] == 7);
8177 assert_or_panic(v[458] == 8);
8178 assert_or_panic(v[459] == 9);
8179 assert_or_panic(v[460] == 10);
8180 assert_or_panic(v[461] == 11);
8181 assert_or_panic(v[462] == 12);
8182 assert_or_panic(v[463] == 13);
8183 assert_or_panic(v[464] == 14);
8184 assert_or_panic(v[465] == 15);
8185 assert_or_panic(v[466] == 16);
8186 assert_or_panic(v[467] == 17);
8187 assert_or_panic(v[468] == 18);
8188 assert_or_panic(v[469] == 19);
8189 assert_or_panic(v[470] == 20);
8190 assert_or_panic(v[471] == 21);
8191 assert_or_panic(v[472] == 22);
8192 assert_or_panic(v[473] == 23);
8193 assert_or_panic(v[474] == 24);
8194 assert_or_panic(v[475] == 25);
8195 assert_or_panic(v[476] == 26);
8196 assert_or_panic(v[477] == 27);
8197 assert_or_panic(v[478] == 28);
8198 assert_or_panic(v[479] == 29);
8199 assert_or_panic(v[480] == 30);
8200 assert_or_panic(v[481] == 31);
8201 assert_or_panic(v[482] == 32);
8202 assert_or_panic(v[483] == 33);
8203 assert_or_panic(v[484] == 34);
8204 assert_or_panic(v[485] == 35);
8205 assert_or_panic(v[486] == 36);
8206 assert_or_panic(v[487] == 37);
8207 assert_or_panic(v[488] == 38);
8208 assert_or_panic(v[489] == 39);
8209 assert_or_panic(v[490] == 40);
8210 assert_or_panic(v[491] == 41);
8211 assert_or_panic(v[492] == 42);
8212 assert_or_panic(v[493] == 43);
8213 assert_or_panic(v[494] == 44);
8214 assert_or_panic(v[495] == 45);
8215 assert_or_panic(v[496] == 46);
8216 assert_or_panic(v[497] == 47);
8217 assert_or_panic(v[498] == 48);
8218 assert_or_panic(v[499] == 49);
8219 assert_or_panic(v[500] == 50);
8220 assert_or_panic(v[501] == 51);
8221 assert_or_panic(v[502] == 52);
8222 assert_or_panic(v[503] == 53);
8223 assert_or_panic(v[504] == 54);
8224 assert_or_panic(v[505] == 55);
8225 assert_or_panic(v[506] == 56);
8226 assert_or_panic(v[507] == 57);
8227 assert_or_panic(v[508] == 58);
8228 assert_or_panic(v[509] == 59);
8229 assert_or_panic(v[510] == 60);
8230 assert_or_panic(v[511] == 61);
8231 assert_or_panic(i == 512);
8232}
8233void c_test_vector_512_u8(void) {
8234 Vector_512_u8 v = zig_ret_vector_512_u8();
8235 assert_or_panic(v[0] == 14);
8236 assert_or_panic(v[1] == 15);
8237 assert_or_panic(v[2] == 16);
8238 assert_or_panic(v[3] == 17);
8239 assert_or_panic(v[4] == 18);
8240 assert_or_panic(v[5] == 19);
8241 assert_or_panic(v[6] == 20);
8242 assert_or_panic(v[7] == 21);
8243 assert_or_panic(v[8] == 22);
8244 assert_or_panic(v[9] == 23);
8245 assert_or_panic(v[10] == 24);
8246 assert_or_panic(v[11] == 25);
8247 assert_or_panic(v[12] == 26);
8248 assert_or_panic(v[13] == 27);
8249 assert_or_panic(v[14] == 28);
8250 assert_or_panic(v[15] == 29);
8251 assert_or_panic(v[16] == 30);
8252 assert_or_panic(v[17] == 31);
8253 assert_or_panic(v[18] == 32);
8254 assert_or_panic(v[19] == 33);
8255 assert_or_panic(v[20] == 34);
8256 assert_or_panic(v[21] == 35);
8257 assert_or_panic(v[22] == 36);
8258 assert_or_panic(v[23] == 37);
8259 assert_or_panic(v[24] == 38);
8260 assert_or_panic(v[25] == 39);
8261 assert_or_panic(v[26] == 40);
8262 assert_or_panic(v[27] == 41);
8263 assert_or_panic(v[28] == 42);
8264 assert_or_panic(v[29] == 43);
8265 assert_or_panic(v[30] == 44);
8266 assert_or_panic(v[31] == 45);
8267 assert_or_panic(v[32] == 46);
8268 assert_or_panic(v[33] == 47);
8269 assert_or_panic(v[34] == 48);
8270 assert_or_panic(v[35] == 49);
8271 assert_or_panic(v[36] == 50);
8272 assert_or_panic(v[37] == 51);
8273 assert_or_panic(v[38] == 52);
8274 assert_or_panic(v[39] == 53);
8275 assert_or_panic(v[40] == 54);
8276 assert_or_panic(v[41] == 55);
8277 assert_or_panic(v[42] == 56);
8278 assert_or_panic(v[43] == 57);
8279 assert_or_panic(v[44] == 58);
8280 assert_or_panic(v[45] == 59);
8281 assert_or_panic(v[46] == 60);
8282 assert_or_panic(v[47] == 61);
8283 assert_or_panic(v[48] == 62);
8284 assert_or_panic(v[49] == 63);
8285 assert_or_panic(v[50] == 64);
8286 assert_or_panic(v[51] == 65);
8287 assert_or_panic(v[52] == 66);
8288 assert_or_panic(v[53] == 67);
8289 assert_or_panic(v[54] == 68);
8290 assert_or_panic(v[55] == 69);
8291 assert_or_panic(v[56] == 70);
8292 assert_or_panic(v[57] == 71);
8293 assert_or_panic(v[58] == 72);
8294 assert_or_panic(v[59] == 73);
8295 assert_or_panic(v[60] == 74);
8296 assert_or_panic(v[61] == 75);
8297 assert_or_panic(v[62] == 76);
8298 assert_or_panic(v[63] == 77);
8299 assert_or_panic(v[64] == 78);
8300 assert_or_panic(v[65] == 79);
8301 assert_or_panic(v[66] == 80);
8302 assert_or_panic(v[67] == 81);
8303 assert_or_panic(v[68] == 82);
8304 assert_or_panic(v[69] == 83);
8305 assert_or_panic(v[70] == 84);
8306 assert_or_panic(v[71] == 85);
8307 assert_or_panic(v[72] == 86);
8308 assert_or_panic(v[73] == 87);
8309 assert_or_panic(v[74] == 88);
8310 assert_or_panic(v[75] == 89);
8311 assert_or_panic(v[76] == 90);
8312 assert_or_panic(v[77] == 91);
8313 assert_or_panic(v[78] == 92);
8314 assert_or_panic(v[79] == 93);
8315 assert_or_panic(v[80] == 94);
8316 assert_or_panic(v[81] == 95);
8317 assert_or_panic(v[82] == 96);
8318 assert_or_panic(v[83] == 97);
8319 assert_or_panic(v[84] == 98);
8320 assert_or_panic(v[85] == 99);
8321 assert_or_panic(v[86] == 0);
8322 assert_or_panic(v[87] == 1);
8323 assert_or_panic(v[88] == 2);
8324 assert_or_panic(v[89] == 3);
8325 assert_or_panic(v[90] == 4);
8326 assert_or_panic(v[91] == 5);
8327 assert_or_panic(v[92] == 6);
8328 assert_or_panic(v[93] == 7);
8329 assert_or_panic(v[94] == 8);
8330 assert_or_panic(v[95] == 9);
8331 assert_or_panic(v[96] == 10);
8332 assert_or_panic(v[97] == 11);
8333 assert_or_panic(v[98] == 12);
8334 assert_or_panic(v[99] == 13);
8335 assert_or_panic(v[100] == 14);
8336 assert_or_panic(v[101] == 15);
8337 assert_or_panic(v[102] == 16);
8338 assert_or_panic(v[103] == 17);
8339 assert_or_panic(v[104] == 18);
8340 assert_or_panic(v[105] == 19);
8341 assert_or_panic(v[106] == 20);
8342 assert_or_panic(v[107] == 21);
8343 assert_or_panic(v[108] == 22);
8344 assert_or_panic(v[109] == 23);
8345 assert_or_panic(v[110] == 24);
8346 assert_or_panic(v[111] == 25);
8347 assert_or_panic(v[112] == 26);
8348 assert_or_panic(v[113] == 27);
8349 assert_or_panic(v[114] == 28);
8350 assert_or_panic(v[115] == 29);
8351 assert_or_panic(v[116] == 30);
8352 assert_or_panic(v[117] == 31);
8353 assert_or_panic(v[118] == 32);
8354 assert_or_panic(v[119] == 33);
8355 assert_or_panic(v[120] == 34);
8356 assert_or_panic(v[121] == 35);
8357 assert_or_panic(v[122] == 36);
8358 assert_or_panic(v[123] == 37);
8359 assert_or_panic(v[124] == 38);
8360 assert_or_panic(v[125] == 39);
8361 assert_or_panic(v[126] == 40);
8362 assert_or_panic(v[127] == 41);
8363 assert_or_panic(v[128] == 42);
8364 assert_or_panic(v[129] == 43);
8365 assert_or_panic(v[130] == 44);
8366 assert_or_panic(v[131] == 45);
8367 assert_or_panic(v[132] == 46);
8368 assert_or_panic(v[133] == 47);
8369 assert_or_panic(v[134] == 48);
8370 assert_or_panic(v[135] == 49);
8371 assert_or_panic(v[136] == 50);
8372 assert_or_panic(v[137] == 51);
8373 assert_or_panic(v[138] == 52);
8374 assert_or_panic(v[139] == 53);
8375 assert_or_panic(v[140] == 54);
8376 assert_or_panic(v[141] == 55);
8377 assert_or_panic(v[142] == 56);
8378 assert_or_panic(v[143] == 57);
8379 assert_or_panic(v[144] == 58);
8380 assert_or_panic(v[145] == 59);
8381 assert_or_panic(v[146] == 60);
8382 assert_or_panic(v[147] == 61);
8383 assert_or_panic(v[148] == 62);
8384 assert_or_panic(v[149] == 63);
8385 assert_or_panic(v[150] == 64);
8386 assert_or_panic(v[151] == 65);
8387 assert_or_panic(v[152] == 66);
8388 assert_or_panic(v[153] == 67);
8389 assert_or_panic(v[154] == 68);
8390 assert_or_panic(v[155] == 69);
8391 assert_or_panic(v[156] == 70);
8392 assert_or_panic(v[157] == 71);
8393 assert_or_panic(v[158] == 72);
8394 assert_or_panic(v[159] == 73);
8395 assert_or_panic(v[160] == 74);
8396 assert_or_panic(v[161] == 75);
8397 assert_or_panic(v[162] == 76);
8398 assert_or_panic(v[163] == 77);
8399 assert_or_panic(v[164] == 78);
8400 assert_or_panic(v[165] == 79);
8401 assert_or_panic(v[166] == 80);
8402 assert_or_panic(v[167] == 81);
8403 assert_or_panic(v[168] == 82);
8404 assert_or_panic(v[169] == 83);
8405 assert_or_panic(v[170] == 84);
8406 assert_or_panic(v[171] == 85);
8407 assert_or_panic(v[172] == 86);
8408 assert_or_panic(v[173] == 87);
8409 assert_or_panic(v[174] == 88);
8410 assert_or_panic(v[175] == 89);
8411 assert_or_panic(v[176] == 90);
8412 assert_or_panic(v[177] == 91);
8413 assert_or_panic(v[178] == 92);
8414 assert_or_panic(v[179] == 93);
8415 assert_or_panic(v[180] == 94);
8416 assert_or_panic(v[181] == 95);
8417 assert_or_panic(v[182] == 96);
8418 assert_or_panic(v[183] == 97);
8419 assert_or_panic(v[184] == 98);
8420 assert_or_panic(v[185] == 99);
8421 assert_or_panic(v[186] == 0);
8422 assert_or_panic(v[187] == 1);
8423 assert_or_panic(v[188] == 2);
8424 assert_or_panic(v[189] == 3);
8425 assert_or_panic(v[190] == 4);
8426 assert_or_panic(v[191] == 5);
8427 assert_or_panic(v[192] == 6);
8428 assert_or_panic(v[193] == 7);
8429 assert_or_panic(v[194] == 8);
8430 assert_or_panic(v[195] == 9);
8431 assert_or_panic(v[196] == 10);
8432 assert_or_panic(v[197] == 11);
8433 assert_or_panic(v[198] == 12);
8434 assert_or_panic(v[199] == 13);
8435 assert_or_panic(v[200] == 14);
8436 assert_or_panic(v[201] == 15);
8437 assert_or_panic(v[202] == 16);
8438 assert_or_panic(v[203] == 17);
8439 assert_or_panic(v[204] == 18);
8440 assert_or_panic(v[205] == 19);
8441 assert_or_panic(v[206] == 20);
8442 assert_or_panic(v[207] == 21);
8443 assert_or_panic(v[208] == 22);
8444 assert_or_panic(v[209] == 23);
8445 assert_or_panic(v[210] == 24);
8446 assert_or_panic(v[211] == 25);
8447 assert_or_panic(v[212] == 26);
8448 assert_or_panic(v[213] == 27);
8449 assert_or_panic(v[214] == 28);
8450 assert_or_panic(v[215] == 29);
8451 assert_or_panic(v[216] == 30);
8452 assert_or_panic(v[217] == 31);
8453 assert_or_panic(v[218] == 32);
8454 assert_or_panic(v[219] == 33);
8455 assert_or_panic(v[220] == 34);
8456 assert_or_panic(v[221] == 35);
8457 assert_or_panic(v[222] == 36);
8458 assert_or_panic(v[223] == 37);
8459 assert_or_panic(v[224] == 38);
8460 assert_or_panic(v[225] == 39);
8461 assert_or_panic(v[226] == 40);
8462 assert_or_panic(v[227] == 41);
8463 assert_or_panic(v[228] == 42);
8464 assert_or_panic(v[229] == 43);
8465 assert_or_panic(v[230] == 44);
8466 assert_or_panic(v[231] == 45);
8467 assert_or_panic(v[232] == 46);
8468 assert_or_panic(v[233] == 47);
8469 assert_or_panic(v[234] == 48);
8470 assert_or_panic(v[235] == 49);
8471 assert_or_panic(v[236] == 50);
8472 assert_or_panic(v[237] == 51);
8473 assert_or_panic(v[238] == 52);
8474 assert_or_panic(v[239] == 53);
8475 assert_or_panic(v[240] == 54);
8476 assert_or_panic(v[241] == 55);
8477 assert_or_panic(v[242] == 56);
8478 assert_or_panic(v[243] == 57);
8479 assert_or_panic(v[244] == 58);
8480 assert_or_panic(v[245] == 59);
8481 assert_or_panic(v[246] == 60);
8482 assert_or_panic(v[247] == 61);
8483 assert_or_panic(v[248] == 62);
8484 assert_or_panic(v[249] == 63);
8485 assert_or_panic(v[250] == 64);
8486 assert_or_panic(v[251] == 65);
8487 assert_or_panic(v[252] == 66);
8488 assert_or_panic(v[253] == 67);
8489 assert_or_panic(v[254] == 68);
8490 assert_or_panic(v[255] == 69);
8491 assert_or_panic(v[256] == 70);
8492 assert_or_panic(v[257] == 71);
8493 assert_or_panic(v[258] == 72);
8494 assert_or_panic(v[259] == 73);
8495 assert_or_panic(v[260] == 74);
8496 assert_or_panic(v[261] == 75);
8497 assert_or_panic(v[262] == 76);
8498 assert_or_panic(v[263] == 77);
8499 assert_or_panic(v[264] == 78);
8500 assert_or_panic(v[265] == 79);
8501 assert_or_panic(v[266] == 80);
8502 assert_or_panic(v[267] == 81);
8503 assert_or_panic(v[268] == 82);
8504 assert_or_panic(v[269] == 83);
8505 assert_or_panic(v[270] == 84);
8506 assert_or_panic(v[271] == 85);
8507 assert_or_panic(v[272] == 86);
8508 assert_or_panic(v[273] == 87);
8509 assert_or_panic(v[274] == 88);
8510 assert_or_panic(v[275] == 89);
8511 assert_or_panic(v[276] == 90);
8512 assert_or_panic(v[277] == 91);
8513 assert_or_panic(v[278] == 92);
8514 assert_or_panic(v[279] == 93);
8515 assert_or_panic(v[280] == 94);
8516 assert_or_panic(v[281] == 95);
8517 assert_or_panic(v[282] == 96);
8518 assert_or_panic(v[283] == 97);
8519 assert_or_panic(v[284] == 98);
8520 assert_or_panic(v[285] == 99);
8521 assert_or_panic(v[286] == 0);
8522 assert_or_panic(v[287] == 1);
8523 assert_or_panic(v[288] == 2);
8524 assert_or_panic(v[289] == 3);
8525 assert_or_panic(v[290] == 4);
8526 assert_or_panic(v[291] == 5);
8527 assert_or_panic(v[292] == 6);
8528 assert_or_panic(v[293] == 7);
8529 assert_or_panic(v[294] == 8);
8530 assert_or_panic(v[295] == 9);
8531 assert_or_panic(v[296] == 10);
8532 assert_or_panic(v[297] == 11);
8533 assert_or_panic(v[298] == 12);
8534 assert_or_panic(v[299] == 13);
8535 assert_or_panic(v[300] == 14);
8536 assert_or_panic(v[301] == 15);
8537 assert_or_panic(v[302] == 16);
8538 assert_or_panic(v[303] == 17);
8539 assert_or_panic(v[304] == 18);
8540 assert_or_panic(v[305] == 19);
8541 assert_or_panic(v[306] == 20);
8542 assert_or_panic(v[307] == 21);
8543 assert_or_panic(v[308] == 22);
8544 assert_or_panic(v[309] == 23);
8545 assert_or_panic(v[310] == 24);
8546 assert_or_panic(v[311] == 25);
8547 assert_or_panic(v[312] == 26);
8548 assert_or_panic(v[313] == 27);
8549 assert_or_panic(v[314] == 28);
8550 assert_or_panic(v[315] == 29);
8551 assert_or_panic(v[316] == 30);
8552 assert_or_panic(v[317] == 31);
8553 assert_or_panic(v[318] == 32);
8554 assert_or_panic(v[319] == 33);
8555 assert_or_panic(v[320] == 34);
8556 assert_or_panic(v[321] == 35);
8557 assert_or_panic(v[322] == 36);
8558 assert_or_panic(v[323] == 37);
8559 assert_or_panic(v[324] == 38);
8560 assert_or_panic(v[325] == 39);
8561 assert_or_panic(v[326] == 40);
8562 assert_or_panic(v[327] == 41);
8563 assert_or_panic(v[328] == 42);
8564 assert_or_panic(v[329] == 43);
8565 assert_or_panic(v[330] == 44);
8566 assert_or_panic(v[331] == 45);
8567 assert_or_panic(v[332] == 46);
8568 assert_or_panic(v[333] == 47);
8569 assert_or_panic(v[334] == 48);
8570 assert_or_panic(v[335] == 49);
8571 assert_or_panic(v[336] == 50);
8572 assert_or_panic(v[337] == 51);
8573 assert_or_panic(v[338] == 52);
8574 assert_or_panic(v[339] == 53);
8575 assert_or_panic(v[340] == 54);
8576 assert_or_panic(v[341] == 55);
8577 assert_or_panic(v[342] == 56);
8578 assert_or_panic(v[343] == 57);
8579 assert_or_panic(v[344] == 58);
8580 assert_or_panic(v[345] == 59);
8581 assert_or_panic(v[346] == 60);
8582 assert_or_panic(v[347] == 61);
8583 assert_or_panic(v[348] == 62);
8584 assert_or_panic(v[349] == 63);
8585 assert_or_panic(v[350] == 64);
8586 assert_or_panic(v[351] == 65);
8587 assert_or_panic(v[352] == 66);
8588 assert_or_panic(v[353] == 67);
8589 assert_or_panic(v[354] == 68);
8590 assert_or_panic(v[355] == 69);
8591 assert_or_panic(v[356] == 70);
8592 assert_or_panic(v[357] == 71);
8593 assert_or_panic(v[358] == 72);
8594 assert_or_panic(v[359] == 73);
8595 assert_or_panic(v[360] == 74);
8596 assert_or_panic(v[361] == 75);
8597 assert_or_panic(v[362] == 76);
8598 assert_or_panic(v[363] == 77);
8599 assert_or_panic(v[364] == 78);
8600 assert_or_panic(v[365] == 79);
8601 assert_or_panic(v[366] == 80);
8602 assert_or_panic(v[367] == 81);
8603 assert_or_panic(v[368] == 82);
8604 assert_or_panic(v[369] == 83);
8605 assert_or_panic(v[370] == 84);
8606 assert_or_panic(v[371] == 85);
8607 assert_or_panic(v[372] == 86);
8608 assert_or_panic(v[373] == 87);
8609 assert_or_panic(v[374] == 88);
8610 assert_or_panic(v[375] == 89);
8611 assert_or_panic(v[376] == 90);
8612 assert_or_panic(v[377] == 91);
8613 assert_or_panic(v[378] == 92);
8614 assert_or_panic(v[379] == 93);
8615 assert_or_panic(v[380] == 94);
8616 assert_or_panic(v[381] == 95);
8617 assert_or_panic(v[382] == 96);
8618 assert_or_panic(v[383] == 97);
8619 assert_or_panic(v[384] == 98);
8620 assert_or_panic(v[385] == 99);
8621 assert_or_panic(v[386] == 0);
8622 assert_or_panic(v[387] == 1);
8623 assert_or_panic(v[388] == 2);
8624 assert_or_panic(v[389] == 3);
8625 assert_or_panic(v[390] == 4);
8626 assert_or_panic(v[391] == 5);
8627 assert_or_panic(v[392] == 6);
8628 assert_or_panic(v[393] == 7);
8629 assert_or_panic(v[394] == 8);
8630 assert_or_panic(v[395] == 9);
8631 assert_or_panic(v[396] == 10);
8632 assert_or_panic(v[397] == 11);
8633 assert_or_panic(v[398] == 12);
8634 assert_or_panic(v[399] == 13);
8635 assert_or_panic(v[400] == 14);
8636 assert_or_panic(v[401] == 15);
8637 assert_or_panic(v[402] == 16);
8638 assert_or_panic(v[403] == 17);
8639 assert_or_panic(v[404] == 18);
8640 assert_or_panic(v[405] == 19);
8641 assert_or_panic(v[406] == 20);
8642 assert_or_panic(v[407] == 21);
8643 assert_or_panic(v[408] == 22);
8644 assert_or_panic(v[409] == 23);
8645 assert_or_panic(v[410] == 24);
8646 assert_or_panic(v[411] == 25);
8647 assert_or_panic(v[412] == 26);
8648 assert_or_panic(v[413] == 27);
8649 assert_or_panic(v[414] == 28);
8650 assert_or_panic(v[415] == 29);
8651 assert_or_panic(v[416] == 30);
8652 assert_or_panic(v[417] == 31);
8653 assert_or_panic(v[418] == 32);
8654 assert_or_panic(v[419] == 33);
8655 assert_or_panic(v[420] == 34);
8656 assert_or_panic(v[421] == 35);
8657 assert_or_panic(v[422] == 36);
8658 assert_or_panic(v[423] == 37);
8659 assert_or_panic(v[424] == 38);
8660 assert_or_panic(v[425] == 39);
8661 assert_or_panic(v[426] == 40);
8662 assert_or_panic(v[427] == 41);
8663 assert_or_panic(v[428] == 42);
8664 assert_or_panic(v[429] == 43);
8665 assert_or_panic(v[430] == 44);
8666 assert_or_panic(v[431] == 45);
8667 assert_or_panic(v[432] == 46);
8668 assert_or_panic(v[433] == 47);
8669 assert_or_panic(v[434] == 48);
8670 assert_or_panic(v[435] == 49);
8671 assert_or_panic(v[436] == 50);
8672 assert_or_panic(v[437] == 51);
8673 assert_or_panic(v[438] == 52);
8674 assert_or_panic(v[439] == 53);
8675 assert_or_panic(v[440] == 54);
8676 assert_or_panic(v[441] == 55);
8677 assert_or_panic(v[442] == 56);
8678 assert_or_panic(v[443] == 57);
8679 assert_or_panic(v[444] == 58);
8680 assert_or_panic(v[445] == 59);
8681 assert_or_panic(v[446] == 60);
8682 assert_or_panic(v[447] == 61);
8683 assert_or_panic(v[448] == 62);
8684 assert_or_panic(v[449] == 63);
8685 assert_or_panic(v[450] == 64);
8686 assert_or_panic(v[451] == 65);
8687 assert_or_panic(v[452] == 66);
8688 assert_or_panic(v[453] == 67);
8689 assert_or_panic(v[454] == 68);
8690 assert_or_panic(v[455] == 69);
8691 assert_or_panic(v[456] == 70);
8692 assert_or_panic(v[457] == 71);
8693 assert_or_panic(v[458] == 72);
8694 assert_or_panic(v[459] == 73);
8695 assert_or_panic(v[460] == 74);
8696 assert_or_panic(v[461] == 75);
8697 assert_or_panic(v[462] == 76);
8698 assert_or_panic(v[463] == 77);
8699 assert_or_panic(v[464] == 78);
8700 assert_or_panic(v[465] == 79);
8701 assert_or_panic(v[466] == 80);
8702 assert_or_panic(v[467] == 81);
8703 assert_or_panic(v[468] == 82);
8704 assert_or_panic(v[469] == 83);
8705 assert_or_panic(v[470] == 84);
8706 assert_or_panic(v[471] == 85);
8707 assert_or_panic(v[472] == 86);
8708 assert_or_panic(v[473] == 87);
8709 assert_or_panic(v[474] == 88);
8710 assert_or_panic(v[475] == 89);
8711 assert_or_panic(v[476] == 90);
8712 assert_or_panic(v[477] == 91);
8713 assert_or_panic(v[478] == 92);
8714 assert_or_panic(v[479] == 93);
8715 assert_or_panic(v[480] == 94);
8716 assert_or_panic(v[481] == 95);
8717 assert_or_panic(v[482] == 96);
8718 assert_or_panic(v[483] == 97);
8719 assert_or_panic(v[484] == 98);
8720 assert_or_panic(v[485] == 99);
8721 assert_or_panic(v[486] == 0);
8722 assert_or_panic(v[487] == 1);
8723 assert_or_panic(v[488] == 2);
8724 assert_or_panic(v[489] == 3);
8725 assert_or_panic(v[490] == 4);
8726 assert_or_panic(v[491] == 5);
8727 assert_or_panic(v[492] == 6);
8728 assert_or_panic(v[493] == 7);
8729 assert_or_panic(v[494] == 8);
8730 assert_or_panic(v[495] == 9);
8731 assert_or_panic(v[496] == 10);
8732 assert_or_panic(v[497] == 11);
8733 assert_or_panic(v[498] == 12);
8734 assert_or_panic(v[499] == 13);
8735 assert_or_panic(v[500] == 14);
8736 assert_or_panic(v[501] == 15);
8737 assert_or_panic(v[502] == 16);
8738 assert_or_panic(v[503] == 17);
8739 assert_or_panic(v[504] == 18);
8740 assert_or_panic(v[505] == 19);
8741 assert_or_panic(v[506] == 20);
8742 assert_or_panic(v[507] == 21);
8743 assert_or_panic(v[508] == 22);
8744 assert_or_panic(v[509] == 23);
8745 assert_or_panic(v[510] == 24);
8746 assert_or_panic(v[511] == 25);
8747 zig_vector_512_u8((Vector_512_u8){
8748 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
8749 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
8750 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
8751 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
8752 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
8753 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
8754 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
8755 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
8756 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69,
8757 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85,
8758 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1,
8759 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
8760 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
8761 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
8762 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
8763 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81,
8764 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
8765 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
8766 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
8767 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
8768 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61,
8769 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77,
8770 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93,
8771 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
8772 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
8773 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
8774 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57,
8775 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73,
8776 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89,
8777 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 0, 1, 2, 3, 4, 5,
8778 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
8779 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,
8780 }, 512);
8781}
8782
8783typedef uint16_t Vector_1_u16 __attribute__((vector_size(1 * sizeof(uint16_t))));
8784
8785Vector_1_u16 zig_ret_vector_1_u16(void);
8786void zig_vector_1_u16(Vector_1_u16, size_t);
8787
8788Vector_1_u16 c_ret_vector_1_u16(void) {
8789 return (Vector_1_u16){ 3 };
8790}
8791void c_vector_1_u16(Vector_1_u16 v, size_t i) {
8792 assert_or_panic(v[0] == 4);
8793 assert_or_panic(i == 1);
8794}
8795void c_test_vector_1_u16(void) {
8796 Vector_1_u16 v = zig_ret_vector_1_u16();
8797 assert_or_panic(v[0] == 1);
8798 zig_vector_1_u16((Vector_1_u16){ 2 }, 1);
8799}
8800
8801typedef uint16_t Vector_2_u16 __attribute__((vector_size(2 * sizeof(uint16_t))));
8802
8803Vector_2_u16 zig_ret_vector_2_u16(void);
8804void zig_vector_2_u16(Vector_2_u16, size_t);
8805
8806Vector_2_u16 c_ret_vector_2_u16(void) {
8807 return (Vector_2_u16){ 9, 10 };
8808}
8809void c_vector_2_u16(Vector_2_u16 v, size_t i) {
8810 assert_or_panic(v[0] == 11);
8811 assert_or_panic(v[1] == 12);
8812 assert_or_panic(i == 2);
8813}
8814void c_test_vector_2_u16(void) {
8815 Vector_2_u16 v = zig_ret_vector_2_u16();
8816 assert_or_panic(v[0] == 5);
8817 assert_or_panic(v[1] == 6);
8818 zig_vector_2_u16((Vector_2_u16){ 7, 8 }, 2);
8819}
8820
8821typedef uint16_t Vector_3_u16 __attribute__((vector_size(3 * sizeof(uint16_t))));
8822
8823Vector_3_u16 zig_ret_vector_3_u16(void);
8824void zig_vector_3_u16(Vector_3_u16, size_t);
8825
8826Vector_3_u16 c_ret_vector_3_u16(void) {
8827 return (Vector_3_u16){ 19, 20, 21 };
8828}
8829void c_vector_3_u16(Vector_3_u16 v, size_t i) {
8830 assert_or_panic(v[0] == 22);
8831 assert_or_panic(v[1] == 23);
8832 assert_or_panic(v[2] == 24);
8833 assert_or_panic(i == 3);
8834}
8835void c_test_vector_3_u16(void) {
8836 Vector_3_u16 v = zig_ret_vector_3_u16();
8837 assert_or_panic(v[0] == 13);
8838 assert_or_panic(v[1] == 14);
8839 assert_or_panic(v[2] == 15);
8840 zig_vector_3_u16((Vector_3_u16){ 16, 17, 18 }, 3);
8841}
8842
8843typedef uint16_t Vector_4_u16 __attribute__((vector_size(4 * sizeof(uint16_t))));
8844
8845Vector_4_u16 zig_ret_vector_4_u16(void);
8846
8847void zig_vector_4_u16(Vector_4_u16, size_t);
8848void zig_vector_4_u16_vector_4_u16(Vector_4_u16, Vector_4_u16, size_t);
8849
8850Vector_4_u16 c_ret_vector_4_u16(void) {
8851 return (Vector_4_u16){ 41, 42, 43, 44 };
8852}
8853void c_vector_4_u16(Vector_4_u16 v, size_t i) {
8854 assert_or_panic(v[0] == 45);
8855 assert_or_panic(v[1] == 46);
8856 assert_or_panic(v[2] == 47);
8857 assert_or_panic(v[3] == 48);
8858 assert_or_panic(i == 4);
8859}
8860void c_vector_4_u16_vector_4_u16(Vector_4_u16 v0, Vector_4_u16 v1, size_t i) {
8861 assert_or_panic(v0[0] == 49);
8862 assert_or_panic(v0[1] == 50);
8863 assert_or_panic(v0[2] == 51);
8864 assert_or_panic(v0[3] == 52);
8865 assert_or_panic(v1[0] == 53);
8866 assert_or_panic(v1[1] == 54);
8867 assert_or_panic(v1[2] == 55);
8868 assert_or_panic(v1[3] == 56);
8869 assert_or_panic(i == 8);
8870}
8871void c_test_vector_4_u16(void) {
8872 Vector_4_u16 v = zig_ret_vector_4_u16();
8873 assert_or_panic(v[0] == 25);
8874 assert_or_panic(v[1] == 26);
8875 assert_or_panic(v[2] == 27);
8876 assert_or_panic(v[3] == 28);
8877 zig_vector_4_u16((Vector_4_u16){ 29, 30, 31, 32 }, 4);
8878 zig_vector_4_u16_vector_4_u16((Vector_4_u16){ 33, 34, 35, 36 }, (Vector_4_u16){ 37, 38, 39, 40 }, 8);
8879}
8880
8881typedef uint16_t Vector_6_u16 __attribute__((vector_size(6 * sizeof(uint16_t))));
8882
8883Vector_6_u16 zig_ret_vector_6_u16(void);
8884void zig_vector_6_u16(Vector_6_u16, size_t);
8885
8886Vector_6_u16 c_ret_vector_6_u16(void) {
8887 return (Vector_6_u16){ 53, 54, 55, 56, 57, 58 };
8888}
8889void c_vector_6_u16(Vector_6_u16 v, size_t i) {
8890 assert_or_panic(v[0] == 59);
8891 assert_or_panic(v[1] == 60);
8892 assert_or_panic(v[2] == 61);
8893 assert_or_panic(v[3] == 62);
8894 assert_or_panic(v[4] == 63);
8895 assert_or_panic(v[5] == 64);
8896 assert_or_panic(i == 6);
8897}
8898void c_test_vector_6_u16(void) {
8899 Vector_6_u16 v = zig_ret_vector_6_u16();
8900 assert_or_panic(v[0] == 41);
8901 assert_or_panic(v[1] == 42);
8902 assert_or_panic(v[2] == 43);
8903 assert_or_panic(v[3] == 44);
8904 assert_or_panic(v[4] == 45);
8905 assert_or_panic(v[5] == 46);
8906 zig_vector_6_u16((Vector_6_u16){ 47, 48, 49, 50, 51, 52 }, 6);
8907}
8908
8909typedef uint16_t Vector_8_u16 __attribute__((vector_size(8 * sizeof(uint16_t))));
8910
8911Vector_8_u16 zig_ret_vector_8_u16(void);
8912void zig_vector_8_u16(Vector_8_u16, size_t);
8913
8914Vector_8_u16 c_ret_vector_8_u16(void) {
8915 return (Vector_8_u16){ 81, 82, 83, 84, 85, 86, 87, 88 };
8916}
8917void c_vector_8_u16(Vector_8_u16 v, size_t i) {
8918 assert_or_panic(v[0] == 89);
8919 assert_or_panic(v[1] == 90);
8920 assert_or_panic(v[2] == 91);
8921 assert_or_panic(v[3] == 92);
8922 assert_or_panic(v[4] == 93);
8923 assert_or_panic(v[5] == 94);
8924 assert_or_panic(v[6] == 95);
8925 assert_or_panic(v[7] == 96);
8926 assert_or_panic(i == 8);
8927}
8928void c_test_vector_8_u16(void) {
8929 Vector_8_u16 v = zig_ret_vector_8_u16();
8930 assert_or_panic(v[0] == 65);
8931 assert_or_panic(v[1] == 66);
8932 assert_or_panic(v[2] == 67);
8933 assert_or_panic(v[3] == 68);
8934 assert_or_panic(v[4] == 69);
8935 assert_or_panic(v[5] == 70);
8936 assert_or_panic(v[6] == 71);
8937 assert_or_panic(v[7] == 72);
8938 zig_vector_8_u16((Vector_8_u16){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
8939}
8940
8941typedef uint16_t Vector_12_u16 __attribute__((vector_size(12 * sizeof(uint16_t))));
8942
8943Vector_12_u16 zig_ret_vector_12_u16(void);
8944void zig_vector_12_u16(Vector_12_u16, size_t);
8945
8946Vector_12_u16 c_ret_vector_12_u16(void) {
8947 return (Vector_12_u16){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
8948}
8949void c_vector_12_u16(Vector_12_u16 v, size_t i) {
8950 assert_or_panic(v[0] == 133);
8951 assert_or_panic(v[1] == 134);
8952 assert_or_panic(v[2] == 135);
8953 assert_or_panic(v[3] == 136);
8954 assert_or_panic(v[4] == 137);
8955 assert_or_panic(v[5] == 138);
8956 assert_or_panic(v[6] == 139);
8957 assert_or_panic(v[7] == 140);
8958 assert_or_panic(v[8] == 141);
8959 assert_or_panic(v[9] == 142);
8960 assert_or_panic(v[10] == 143);
8961 assert_or_panic(v[11] == 144);
8962 assert_or_panic(i == 12);
8963}
8964void c_test_vector_12_u16(void) {
8965 Vector_12_u16 v = zig_ret_vector_12_u16();
8966 assert_or_panic(v[0] == 97);
8967 assert_or_panic(v[1] == 98);
8968 assert_or_panic(v[2] == 99);
8969 assert_or_panic(v[3] == 100);
8970 assert_or_panic(v[4] == 101);
8971 assert_or_panic(v[5] == 102);
8972 assert_or_panic(v[6] == 103);
8973 assert_or_panic(v[7] == 104);
8974 assert_or_panic(v[8] == 105);
8975 assert_or_panic(v[9] == 106);
8976 assert_or_panic(v[10] == 107);
8977 assert_or_panic(v[11] == 108);
8978 zig_vector_12_u16((Vector_12_u16){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
8979}
8980
8981typedef uint16_t Vector_16_u16 __attribute__((vector_size(16 * sizeof(uint16_t))));
8982
8983Vector_16_u16 zig_ret_vector_16_u16(void);
8984void zig_vector_16_u16(Vector_16_u16, size_t);
8985
8986Vector_16_u16 c_ret_vector_16_u16(void) {
8987 return (Vector_16_u16){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
8988}
8989void c_vector_16_u16(Vector_16_u16 v, size_t i) {
8990 assert_or_panic(v[0] == 193);
8991 assert_or_panic(v[1] == 194);
8992 assert_or_panic(v[2] == 195);
8993 assert_or_panic(v[3] == 196);
8994 assert_or_panic(v[4] == 197);
8995 assert_or_panic(v[5] == 198);
8996 assert_or_panic(v[6] == 199);
8997 assert_or_panic(v[7] == 200);
8998 assert_or_panic(v[8] == 201);
8999 assert_or_panic(v[9] == 202);
9000 assert_or_panic(v[10] == 203);
9001 assert_or_panic(v[11] == 204);
9002 assert_or_panic(v[12] == 205);
9003 assert_or_panic(v[13] == 206);
9004 assert_or_panic(v[14] == 207);
9005 assert_or_panic(v[15] == 208);
9006 assert_or_panic(i == 16);
9007}
9008void c_test_vector_16_u16(void) {
9009 Vector_16_u16 v = zig_ret_vector_16_u16();
9010 assert_or_panic(v[0] == 145);
9011 assert_or_panic(v[1] == 146);
9012 assert_or_panic(v[2] == 147);
9013 assert_or_panic(v[3] == 148);
9014 assert_or_panic(v[4] == 149);
9015 assert_or_panic(v[5] == 150);
9016 assert_or_panic(v[6] == 151);
9017 assert_or_panic(v[7] == 152);
9018 assert_or_panic(v[8] == 153);
9019 assert_or_panic(v[9] == 154);
9020 assert_or_panic(v[10] == 155);
9021 assert_or_panic(v[11] == 156);
9022 assert_or_panic(v[12] == 157);
9023 assert_or_panic(v[13] == 158);
9024 assert_or_panic(v[14] == 159);
9025 assert_or_panic(v[15] == 160);
9026 zig_vector_16_u16((Vector_16_u16){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
9027}
9028
9029typedef uint16_t Vector_24_u16 __attribute__((vector_size(24 * sizeof(uint16_t))));
9030
9031Vector_24_u16 zig_ret_vector_24_u16(void);
9032void zig_vector_24_u16(Vector_24_u16, size_t);
9033
9034Vector_24_u16 c_ret_vector_24_u16(void) {
9035 return (Vector_24_u16){
9036 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
9037 273, 274, 275, 276, 277, 278, 279, 280,
9038 };
9039}
9040void c_vector_24_u16(Vector_24_u16 v, size_t i) {
9041 assert_or_panic(v[0] == 281);
9042 assert_or_panic(v[1] == 282);
9043 assert_or_panic(v[2] == 283);
9044 assert_or_panic(v[3] == 284);
9045 assert_or_panic(v[4] == 285);
9046 assert_or_panic(v[5] == 286);
9047 assert_or_panic(v[6] == 287);
9048 assert_or_panic(v[7] == 288);
9049 assert_or_panic(v[8] == 289);
9050 assert_or_panic(v[9] == 290);
9051 assert_or_panic(v[10] == 291);
9052 assert_or_panic(v[11] == 292);
9053 assert_or_panic(v[12] == 293);
9054 assert_or_panic(v[13] == 294);
9055 assert_or_panic(v[14] == 295);
9056 assert_or_panic(v[15] == 296);
9057 assert_or_panic(v[16] == 297);
9058 assert_or_panic(v[17] == 298);
9059 assert_or_panic(v[18] == 299);
9060 assert_or_panic(v[19] == 300);
9061 assert_or_panic(v[20] == 301);
9062 assert_or_panic(v[21] == 302);
9063 assert_or_panic(v[22] == 303);
9064 assert_or_panic(v[23] == 304);
9065 assert_or_panic(i == 24);
9066}
9067void c_test_vector_24_u16(void) {
9068 Vector_24_u16 v = zig_ret_vector_24_u16();
9069 assert_or_panic(v[0] == 209);
9070 assert_or_panic(v[1] == 210);
9071 assert_or_panic(v[2] == 211);
9072 assert_or_panic(v[3] == 212);
9073 assert_or_panic(v[4] == 213);
9074 assert_or_panic(v[5] == 214);
9075 assert_or_panic(v[6] == 215);
9076 assert_or_panic(v[7] == 216);
9077 assert_or_panic(v[8] == 217);
9078 assert_or_panic(v[9] == 218);
9079 assert_or_panic(v[10] == 219);
9080 assert_or_panic(v[11] == 220);
9081 assert_or_panic(v[12] == 221);
9082 assert_or_panic(v[13] == 222);
9083 assert_or_panic(v[14] == 223);
9084 assert_or_panic(v[15] == 224);
9085 assert_or_panic(v[16] == 225);
9086 assert_or_panic(v[17] == 226);
9087 assert_or_panic(v[18] == 227);
9088 assert_or_panic(v[19] == 228);
9089 assert_or_panic(v[20] == 229);
9090 assert_or_panic(v[21] == 230);
9091 assert_or_panic(v[22] == 231);
9092 assert_or_panic(v[23] == 232);
9093 zig_vector_24_u16((Vector_24_u16){
9094 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
9095 249, 250, 251, 252, 253, 254, 255, 256,
9096 }, 24);
9097}
9098
9099typedef uint16_t Vector_32_u16 __attribute__((vector_size(32 * sizeof(uint16_t))));
9100
9101Vector_32_u16 zig_ret_vector_32_u16(void);
9102void zig_vector_32_u16(Vector_32_u16, size_t);
9103
9104Vector_32_u16 c_ret_vector_32_u16(void) {
9105 return (Vector_32_u16){
9106 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
9107 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
9108 };
9109}
9110void c_vector_32_u16(Vector_32_u16 v, size_t i) {
9111 assert_or_panic(v[0] == 401);
9112 assert_or_panic(v[1] == 402);
9113 assert_or_panic(v[2] == 403);
9114 assert_or_panic(v[3] == 404);
9115 assert_or_panic(v[4] == 405);
9116 assert_or_panic(v[5] == 406);
9117 assert_or_panic(v[6] == 407);
9118 assert_or_panic(v[7] == 408);
9119 assert_or_panic(v[8] == 409);
9120 assert_or_panic(v[9] == 410);
9121 assert_or_panic(v[10] == 411);
9122 assert_or_panic(v[11] == 412);
9123 assert_or_panic(v[12] == 413);
9124 assert_or_panic(v[13] == 414);
9125 assert_or_panic(v[14] == 415);
9126 assert_or_panic(v[15] == 416);
9127 assert_or_panic(v[16] == 417);
9128 assert_or_panic(v[17] == 418);
9129 assert_or_panic(v[18] == 419);
9130 assert_or_panic(v[19] == 420);
9131 assert_or_panic(v[20] == 421);
9132 assert_or_panic(v[21] == 422);
9133 assert_or_panic(v[22] == 423);
9134 assert_or_panic(v[23] == 424);
9135 assert_or_panic(v[24] == 425);
9136 assert_or_panic(v[25] == 426);
9137 assert_or_panic(v[26] == 427);
9138 assert_or_panic(v[27] == 428);
9139 assert_or_panic(v[28] == 429);
9140 assert_or_panic(v[29] == 430);
9141 assert_or_panic(v[30] == 431);
9142 assert_or_panic(v[31] == 432);
9143 assert_or_panic(i == 32);
9144}
9145void c_test_vector_32_u16(void) {
9146 Vector_32_u16 v = zig_ret_vector_32_u16();
9147 assert_or_panic(v[0] == 305);
9148 assert_or_panic(v[1] == 306);
9149 assert_or_panic(v[2] == 307);
9150 assert_or_panic(v[3] == 308);
9151 assert_or_panic(v[4] == 309);
9152 assert_or_panic(v[5] == 310);
9153 assert_or_panic(v[6] == 311);
9154 assert_or_panic(v[7] == 312);
9155 assert_or_panic(v[8] == 313);
9156 assert_or_panic(v[9] == 314);
9157 assert_or_panic(v[10] == 315);
9158 assert_or_panic(v[11] == 316);
9159 assert_or_panic(v[12] == 317);
9160 assert_or_panic(v[13] == 318);
9161 assert_or_panic(v[14] == 319);
9162 assert_or_panic(v[15] == 320);
9163 assert_or_panic(v[16] == 321);
9164 assert_or_panic(v[17] == 322);
9165 assert_or_panic(v[18] == 323);
9166 assert_or_panic(v[19] == 324);
9167 assert_or_panic(v[20] == 325);
9168 assert_or_panic(v[21] == 326);
9169 assert_or_panic(v[22] == 327);
9170 assert_or_panic(v[23] == 328);
9171 assert_or_panic(v[24] == 329);
9172 assert_or_panic(v[25] == 330);
9173 assert_or_panic(v[26] == 331);
9174 assert_or_panic(v[27] == 332);
9175 assert_or_panic(v[28] == 333);
9176 assert_or_panic(v[29] == 334);
9177 assert_or_panic(v[30] == 335);
9178 assert_or_panic(v[31] == 336);
9179 zig_vector_32_u16((Vector_32_u16){
9180 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
9181 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
9182 }, 32);
9183}
9184
9185typedef uint16_t Vector_48_u16 __attribute__((vector_size(48 * sizeof(uint16_t))));
9186
9187Vector_48_u16 zig_ret_vector_48_u16(void);
9188void zig_vector_48_u16(Vector_48_u16, size_t);
9189
9190Vector_48_u16 c_ret_vector_48_u16(void) {
9191 return (Vector_48_u16){
9192 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
9193 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
9194 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
9195 };
9196}
9197void c_vector_48_u16(Vector_48_u16 v, size_t i) {
9198 assert_or_panic(v[0] == 577);
9199 assert_or_panic(v[1] == 578);
9200 assert_or_panic(v[2] == 579);
9201 assert_or_panic(v[3] == 580);
9202 assert_or_panic(v[4] == 581);
9203 assert_or_panic(v[5] == 582);
9204 assert_or_panic(v[6] == 583);
9205 assert_or_panic(v[7] == 584);
9206 assert_or_panic(v[8] == 585);
9207 assert_or_panic(v[9] == 586);
9208 assert_or_panic(v[10] == 587);
9209 assert_or_panic(v[11] == 588);
9210 assert_or_panic(v[12] == 589);
9211 assert_or_panic(v[13] == 590);
9212 assert_or_panic(v[14] == 591);
9213 assert_or_panic(v[15] == 592);
9214 assert_or_panic(v[16] == 593);
9215 assert_or_panic(v[17] == 594);
9216 assert_or_panic(v[18] == 595);
9217 assert_or_panic(v[19] == 596);
9218 assert_or_panic(v[20] == 597);
9219 assert_or_panic(v[21] == 598);
9220 assert_or_panic(v[22] == 599);
9221 assert_or_panic(v[23] == 600);
9222 assert_or_panic(v[24] == 601);
9223 assert_or_panic(v[25] == 602);
9224 assert_or_panic(v[26] == 603);
9225 assert_or_panic(v[27] == 604);
9226 assert_or_panic(v[28] == 605);
9227 assert_or_panic(v[29] == 606);
9228 assert_or_panic(v[30] == 607);
9229 assert_or_panic(v[31] == 608);
9230 assert_or_panic(v[32] == 609);
9231 assert_or_panic(v[33] == 610);
9232 assert_or_panic(v[34] == 611);
9233 assert_or_panic(v[35] == 612);
9234 assert_or_panic(v[36] == 613);
9235 assert_or_panic(v[37] == 614);
9236 assert_or_panic(v[38] == 615);
9237 assert_or_panic(v[39] == 616);
9238 assert_or_panic(v[40] == 617);
9239 assert_or_panic(v[41] == 618);
9240 assert_or_panic(v[42] == 619);
9241 assert_or_panic(v[43] == 620);
9242 assert_or_panic(v[44] == 621);
9243 assert_or_panic(v[45] == 622);
9244 assert_or_panic(v[46] == 623);
9245 assert_or_panic(v[47] == 624);
9246 assert_or_panic(i == 48);
9247}
9248void c_test_vector_48_u16(void) {
9249 Vector_48_u16 v = zig_ret_vector_48_u16();
9250 assert_or_panic(v[0] == 433);
9251 assert_or_panic(v[1] == 434);
9252 assert_or_panic(v[2] == 435);
9253 assert_or_panic(v[3] == 436);
9254 assert_or_panic(v[4] == 437);
9255 assert_or_panic(v[5] == 438);
9256 assert_or_panic(v[6] == 439);
9257 assert_or_panic(v[7] == 440);
9258 assert_or_panic(v[8] == 441);
9259 assert_or_panic(v[9] == 442);
9260 assert_or_panic(v[10] == 443);
9261 assert_or_panic(v[11] == 444);
9262 assert_or_panic(v[12] == 445);
9263 assert_or_panic(v[13] == 446);
9264 assert_or_panic(v[14] == 447);
9265 assert_or_panic(v[15] == 448);
9266 assert_or_panic(v[16] == 449);
9267 assert_or_panic(v[17] == 450);
9268 assert_or_panic(v[18] == 451);
9269 assert_or_panic(v[19] == 452);
9270 assert_or_panic(v[20] == 453);
9271 assert_or_panic(v[21] == 454);
9272 assert_or_panic(v[22] == 455);
9273 assert_or_panic(v[23] == 456);
9274 assert_or_panic(v[24] == 457);
9275 assert_or_panic(v[25] == 458);
9276 assert_or_panic(v[26] == 459);
9277 assert_or_panic(v[27] == 460);
9278 assert_or_panic(v[28] == 461);
9279 assert_or_panic(v[29] == 462);
9280 assert_or_panic(v[30] == 463);
9281 assert_or_panic(v[31] == 464);
9282 assert_or_panic(v[32] == 465);
9283 assert_or_panic(v[33] == 466);
9284 assert_or_panic(v[34] == 467);
9285 assert_or_panic(v[35] == 468);
9286 assert_or_panic(v[36] == 469);
9287 assert_or_panic(v[37] == 470);
9288 assert_or_panic(v[38] == 471);
9289 assert_or_panic(v[39] == 472);
9290 assert_or_panic(v[40] == 473);
9291 assert_or_panic(v[41] == 474);
9292 assert_or_panic(v[42] == 475);
9293 assert_or_panic(v[43] == 476);
9294 assert_or_panic(v[44] == 477);
9295 assert_or_panic(v[45] == 478);
9296 assert_or_panic(v[46] == 479);
9297 assert_or_panic(v[47] == 480);
9298 zig_vector_48_u16((Vector_48_u16){
9299 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
9300 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
9301 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
9302 }, 48);
9303}
9304
9305typedef uint16_t Vector_64_u16 __attribute__((vector_size(64 * sizeof(uint16_t))));
9306
9307Vector_64_u16 zig_ret_vector_64_u16(void);
9308void zig_vector_64_u16(Vector_64_u16, size_t);
9309
9310Vector_64_u16 c_ret_vector_64_u16(void) {
9311 return (Vector_64_u16){
9312 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
9313 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
9314 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
9315 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
9316 };
9317}
9318void c_vector_64_u16(Vector_64_u16 v, size_t i) {
9319 assert_or_panic(v[0] == 817);
9320 assert_or_panic(v[1] == 818);
9321 assert_or_panic(v[2] == 819);
9322 assert_or_panic(v[3] == 820);
9323 assert_or_panic(v[4] == 821);
9324 assert_or_panic(v[5] == 822);
9325 assert_or_panic(v[6] == 823);
9326 assert_or_panic(v[7] == 824);
9327 assert_or_panic(v[8] == 825);
9328 assert_or_panic(v[9] == 826);
9329 assert_or_panic(v[10] == 827);
9330 assert_or_panic(v[11] == 828);
9331 assert_or_panic(v[12] == 829);
9332 assert_or_panic(v[13] == 830);
9333 assert_or_panic(v[14] == 831);
9334 assert_or_panic(v[15] == 832);
9335 assert_or_panic(v[16] == 833);
9336 assert_or_panic(v[17] == 834);
9337 assert_or_panic(v[18] == 835);
9338 assert_or_panic(v[19] == 836);
9339 assert_or_panic(v[20] == 837);
9340 assert_or_panic(v[21] == 838);
9341 assert_or_panic(v[22] == 839);
9342 assert_or_panic(v[23] == 840);
9343 assert_or_panic(v[24] == 841);
9344 assert_or_panic(v[25] == 842);
9345 assert_or_panic(v[26] == 843);
9346 assert_or_panic(v[27] == 844);
9347 assert_or_panic(v[28] == 845);
9348 assert_or_panic(v[29] == 846);
9349 assert_or_panic(v[30] == 847);
9350 assert_or_panic(v[31] == 848);
9351 assert_or_panic(v[32] == 849);
9352 assert_or_panic(v[33] == 850);
9353 assert_or_panic(v[34] == 851);
9354 assert_or_panic(v[35] == 852);
9355 assert_or_panic(v[36] == 853);
9356 assert_or_panic(v[37] == 854);
9357 assert_or_panic(v[38] == 855);
9358 assert_or_panic(v[39] == 856);
9359 assert_or_panic(v[40] == 857);
9360 assert_or_panic(v[41] == 858);
9361 assert_or_panic(v[42] == 859);
9362 assert_or_panic(v[43] == 860);
9363 assert_or_panic(v[44] == 861);
9364 assert_or_panic(v[45] == 862);
9365 assert_or_panic(v[46] == 863);
9366 assert_or_panic(v[47] == 864);
9367 assert_or_panic(v[48] == 865);
9368 assert_or_panic(v[49] == 866);
9369 assert_or_panic(v[50] == 867);
9370 assert_or_panic(v[51] == 868);
9371 assert_or_panic(v[52] == 869);
9372 assert_or_panic(v[53] == 870);
9373 assert_or_panic(v[54] == 871);
9374 assert_or_panic(v[55] == 872);
9375 assert_or_panic(v[56] == 873);
9376 assert_or_panic(v[57] == 874);
9377 assert_or_panic(v[58] == 875);
9378 assert_or_panic(v[59] == 876);
9379 assert_or_panic(v[60] == 877);
9380 assert_or_panic(v[61] == 878);
9381 assert_or_panic(v[62] == 879);
9382 assert_or_panic(v[63] == 880);
9383 assert_or_panic(i == 64);
9384}
9385void c_test_vector_64_u16(void) {
9386 Vector_64_u16 v = zig_ret_vector_64_u16();
9387 assert_or_panic(v[0] == 625);
9388 assert_or_panic(v[1] == 626);
9389 assert_or_panic(v[2] == 627);
9390 assert_or_panic(v[3] == 628);
9391 assert_or_panic(v[4] == 629);
9392 assert_or_panic(v[5] == 630);
9393 assert_or_panic(v[6] == 631);
9394 assert_or_panic(v[7] == 632);
9395 assert_or_panic(v[8] == 633);
9396 assert_or_panic(v[9] == 634);
9397 assert_or_panic(v[10] == 635);
9398 assert_or_panic(v[11] == 636);
9399 assert_or_panic(v[12] == 637);
9400 assert_or_panic(v[13] == 638);
9401 assert_or_panic(v[14] == 639);
9402 assert_or_panic(v[15] == 640);
9403 assert_or_panic(v[16] == 641);
9404 assert_or_panic(v[17] == 642);
9405 assert_or_panic(v[18] == 643);
9406 assert_or_panic(v[19] == 644);
9407 assert_or_panic(v[20] == 645);
9408 assert_or_panic(v[21] == 646);
9409 assert_or_panic(v[22] == 647);
9410 assert_or_panic(v[23] == 648);
9411 assert_or_panic(v[24] == 649);
9412 assert_or_panic(v[25] == 650);
9413 assert_or_panic(v[26] == 651);
9414 assert_or_panic(v[27] == 652);
9415 assert_or_panic(v[28] == 653);
9416 assert_or_panic(v[29] == 654);
9417 assert_or_panic(v[30] == 655);
9418 assert_or_panic(v[31] == 656);
9419 assert_or_panic(v[32] == 657);
9420 assert_or_panic(v[33] == 658);
9421 assert_or_panic(v[34] == 659);
9422 assert_or_panic(v[35] == 660);
9423 assert_or_panic(v[36] == 661);
9424 assert_or_panic(v[37] == 662);
9425 assert_or_panic(v[38] == 663);
9426 assert_or_panic(v[39] == 664);
9427 assert_or_panic(v[40] == 665);
9428 assert_or_panic(v[41] == 666);
9429 assert_or_panic(v[42] == 667);
9430 assert_or_panic(v[43] == 668);
9431 assert_or_panic(v[44] == 669);
9432 assert_or_panic(v[45] == 670);
9433 assert_or_panic(v[46] == 671);
9434 assert_or_panic(v[47] == 672);
9435 assert_or_panic(v[48] == 673);
9436 assert_or_panic(v[49] == 674);
9437 assert_or_panic(v[50] == 675);
9438 assert_or_panic(v[51] == 676);
9439 assert_or_panic(v[52] == 677);
9440 assert_or_panic(v[53] == 678);
9441 assert_or_panic(v[54] == 679);
9442 assert_or_panic(v[55] == 680);
9443 assert_or_panic(v[56] == 681);
9444 assert_or_panic(v[57] == 682);
9445 assert_or_panic(v[58] == 683);
9446 assert_or_panic(v[59] == 684);
9447 assert_or_panic(v[60] == 685);
9448 assert_or_panic(v[61] == 686);
9449 assert_or_panic(v[62] == 687);
9450 assert_or_panic(v[63] == 688);
9451 zig_vector_64_u16((Vector_64_u16){
9452 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
9453 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
9454 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
9455 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
9456 }, 64);
9457}
9458
9459typedef uint16_t Vector_96_u16 __attribute__((vector_size(96 * sizeof(uint16_t))));
9460
9461Vector_96_u16 zig_ret_vector_96_u16(void);
9462void zig_vector_96_u16(Vector_96_u16, size_t);
9463
9464Vector_96_u16 c_ret_vector_96_u16(void) {
9465 return (Vector_96_u16){
9466 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
9467 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
9468 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
9469 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
9470 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
9471 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
9472 };
9473}
9474void c_vector_96_u16(Vector_96_u16 v, size_t i) {
9475 assert_or_panic(v[0] == 1178);
9476 assert_or_panic(v[1] == 1179);
9477 assert_or_panic(v[2] == 1180);
9478 assert_or_panic(v[3] == 1181);
9479 assert_or_panic(v[4] == 1182);
9480 assert_or_panic(v[5] == 1183);
9481 assert_or_panic(v[6] == 1184);
9482 assert_or_panic(v[7] == 1185);
9483 assert_or_panic(v[8] == 1186);
9484 assert_or_panic(v[9] == 1187);
9485 assert_or_panic(v[10] == 1188);
9486 assert_or_panic(v[11] == 1189);
9487 assert_or_panic(v[12] == 1190);
9488 assert_or_panic(v[13] == 1191);
9489 assert_or_panic(v[14] == 1192);
9490 assert_or_panic(v[15] == 1193);
9491 assert_or_panic(v[16] == 1194);
9492 assert_or_panic(v[17] == 1195);
9493 assert_or_panic(v[18] == 1196);
9494 assert_or_panic(v[19] == 1197);
9495 assert_or_panic(v[20] == 1198);
9496 assert_or_panic(v[21] == 1199);
9497 assert_or_panic(v[22] == 1200);
9498 assert_or_panic(v[23] == 1201);
9499 assert_or_panic(v[24] == 1202);
9500 assert_or_panic(v[25] == 1203);
9501 assert_or_panic(v[26] == 1204);
9502 assert_or_panic(v[27] == 1205);
9503 assert_or_panic(v[28] == 1206);
9504 assert_or_panic(v[29] == 1207);
9505 assert_or_panic(v[30] == 1208);
9506 assert_or_panic(v[31] == 1209);
9507 assert_or_panic(v[32] == 1210);
9508 assert_or_panic(v[33] == 1211);
9509 assert_or_panic(v[34] == 1212);
9510 assert_or_panic(v[35] == 1213);
9511 assert_or_panic(v[36] == 1214);
9512 assert_or_panic(v[37] == 1215);
9513 assert_or_panic(v[38] == 1216);
9514 assert_or_panic(v[39] == 1217);
9515 assert_or_panic(v[40] == 1218);
9516 assert_or_panic(v[41] == 1219);
9517 assert_or_panic(v[42] == 1220);
9518 assert_or_panic(v[43] == 1221);
9519 assert_or_panic(v[44] == 1222);
9520 assert_or_panic(v[45] == 1223);
9521 assert_or_panic(v[46] == 1224);
9522 assert_or_panic(v[47] == 1225);
9523 assert_or_panic(v[48] == 1226);
9524 assert_or_panic(v[49] == 1227);
9525 assert_or_panic(v[50] == 1228);
9526 assert_or_panic(v[51] == 1229);
9527 assert_or_panic(v[52] == 1230);
9528 assert_or_panic(v[53] == 1231);
9529 assert_or_panic(v[54] == 1232);
9530 assert_or_panic(v[55] == 1233);
9531 assert_or_panic(v[56] == 1234);
9532 assert_or_panic(v[57] == 1235);
9533 assert_or_panic(v[58] == 1236);
9534 assert_or_panic(v[59] == 1237);
9535 assert_or_panic(v[60] == 1238);
9536 assert_or_panic(v[61] == 1239);
9537 assert_or_panic(v[62] == 1240);
9538 assert_or_panic(v[63] == 1241);
9539 assert_or_panic(v[64] == 1242);
9540 assert_or_panic(v[65] == 1243);
9541 assert_or_panic(v[66] == 1244);
9542 assert_or_panic(v[67] == 1245);
9543 assert_or_panic(v[68] == 1246);
9544 assert_or_panic(v[69] == 1247);
9545 assert_or_panic(v[70] == 1248);
9546 assert_or_panic(v[71] == 1249);
9547 assert_or_panic(v[72] == 1250);
9548 assert_or_panic(v[73] == 1251);
9549 assert_or_panic(v[74] == 1252);
9550 assert_or_panic(v[75] == 1253);
9551 assert_or_panic(v[76] == 1254);
9552 assert_or_panic(v[77] == 1255);
9553 assert_or_panic(v[80] == 1258);
9554 assert_or_panic(v[81] == 1259);
9555 assert_or_panic(v[82] == 1260);
9556 assert_or_panic(v[83] == 1261);
9557 assert_or_panic(v[84] == 1262);
9558 assert_or_panic(v[85] == 1263);
9559 assert_or_panic(v[86] == 1264);
9560 assert_or_panic(v[87] == 1265);
9561 assert_or_panic(v[88] == 1266);
9562 assert_or_panic(v[89] == 1267);
9563 assert_or_panic(v[90] == 1268);
9564 assert_or_panic(v[91] == 1269);
9565 assert_or_panic(v[92] == 1270);
9566 assert_or_panic(v[93] == 1271);
9567 assert_or_panic(v[94] == 1272);
9568 assert_or_panic(v[95] == 1273);
9569 assert_or_panic(i == 96);
9570}
9571void c_test_vector_96_u16(void) {
9572 Vector_96_u16 v = zig_ret_vector_96_u16();
9573 assert_or_panic(v[0] == 890);
9574 assert_or_panic(v[1] == 891);
9575 assert_or_panic(v[2] == 892);
9576 assert_or_panic(v[3] == 893);
9577 assert_or_panic(v[4] == 894);
9578 assert_or_panic(v[5] == 895);
9579 assert_or_panic(v[6] == 896);
9580 assert_or_panic(v[7] == 897);
9581 assert_or_panic(v[8] == 898);
9582 assert_or_panic(v[9] == 899);
9583 assert_or_panic(v[10] == 900);
9584 assert_or_panic(v[11] == 901);
9585 assert_or_panic(v[12] == 902);
9586 assert_or_panic(v[13] == 903);
9587 assert_or_panic(v[14] == 904);
9588 assert_or_panic(v[15] == 905);
9589 assert_or_panic(v[16] == 906);
9590 assert_or_panic(v[17] == 907);
9591 assert_or_panic(v[18] == 908);
9592 assert_or_panic(v[19] == 909);
9593 assert_or_panic(v[20] == 910);
9594 assert_or_panic(v[21] == 911);
9595 assert_or_panic(v[22] == 912);
9596 assert_or_panic(v[23] == 913);
9597 assert_or_panic(v[24] == 914);
9598 assert_or_panic(v[25] == 915);
9599 assert_or_panic(v[26] == 916);
9600 assert_or_panic(v[27] == 917);
9601 assert_or_panic(v[28] == 918);
9602 assert_or_panic(v[29] == 919);
9603 assert_or_panic(v[30] == 920);
9604 assert_or_panic(v[31] == 921);
9605 assert_or_panic(v[32] == 922);
9606 assert_or_panic(v[33] == 923);
9607 assert_or_panic(v[34] == 924);
9608 assert_or_panic(v[35] == 925);
9609 assert_or_panic(v[36] == 926);
9610 assert_or_panic(v[37] == 927);
9611 assert_or_panic(v[38] == 928);
9612 assert_or_panic(v[39] == 929);
9613 assert_or_panic(v[40] == 930);
9614 assert_or_panic(v[41] == 931);
9615 assert_or_panic(v[42] == 932);
9616 assert_or_panic(v[43] == 933);
9617 assert_or_panic(v[44] == 934);
9618 assert_or_panic(v[45] == 935);
9619 assert_or_panic(v[46] == 936);
9620 assert_or_panic(v[47] == 937);
9621 assert_or_panic(v[48] == 938);
9622 assert_or_panic(v[49] == 939);
9623 assert_or_panic(v[50] == 940);
9624 assert_or_panic(v[51] == 941);
9625 assert_or_panic(v[52] == 942);
9626 assert_or_panic(v[53] == 943);
9627 assert_or_panic(v[54] == 944);
9628 assert_or_panic(v[55] == 945);
9629 assert_or_panic(v[56] == 946);
9630 assert_or_panic(v[57] == 947);
9631 assert_or_panic(v[58] == 948);
9632 assert_or_panic(v[59] == 949);
9633 assert_or_panic(v[60] == 950);
9634 assert_or_panic(v[61] == 951);
9635 assert_or_panic(v[62] == 952);
9636 assert_or_panic(v[63] == 953);
9637 assert_or_panic(v[64] == 954);
9638 assert_or_panic(v[65] == 955);
9639 assert_or_panic(v[66] == 956);
9640 assert_or_panic(v[67] == 957);
9641 assert_or_panic(v[68] == 958);
9642 assert_or_panic(v[69] == 959);
9643 assert_or_panic(v[70] == 960);
9644 assert_or_panic(v[71] == 961);
9645 assert_or_panic(v[72] == 962);
9646 assert_or_panic(v[73] == 963);
9647 assert_or_panic(v[74] == 964);
9648 assert_or_panic(v[75] == 965);
9649 assert_or_panic(v[76] == 966);
9650 assert_or_panic(v[77] == 967);
9651 assert_or_panic(v[78] == 968);
9652 assert_or_panic(v[79] == 969);
9653 assert_or_panic(v[80] == 970);
9654 assert_or_panic(v[81] == 971);
9655 assert_or_panic(v[82] == 972);
9656 assert_or_panic(v[83] == 973);
9657 assert_or_panic(v[84] == 974);
9658 assert_or_panic(v[85] == 975);
9659 assert_or_panic(v[86] == 976);
9660 assert_or_panic(v[87] == 977);
9661 assert_or_panic(v[88] == 978);
9662 assert_or_panic(v[89] == 979);
9663 assert_or_panic(v[90] == 980);
9664 assert_or_panic(v[91] == 981);
9665 assert_or_panic(v[92] == 982);
9666 assert_or_panic(v[93] == 983);
9667 assert_or_panic(v[94] == 984);
9668 assert_or_panic(v[95] == 985);
9669 zig_vector_96_u16((Vector_96_u16){
9670 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
9671 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
9672 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
9673 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
9674 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
9675 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081,
9676 }, 96);
9677}
9678
9679typedef uint16_t Vector_128_u16 __attribute__((vector_size(128 * sizeof(uint16_t))));
9680
9681Vector_128_u16 zig_ret_vector_128_u16(void);
9682void zig_vector_128_u16(Vector_128_u16, size_t);
9683
9684Vector_128_u16 c_ret_vector_128_u16(void) {
9685 return (Vector_128_u16){
9686 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545,
9687 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
9688 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577,
9689 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
9690 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609,
9691 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
9692 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641,
9693 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657,
9694 };
9695}
9696void c_vector_128_u16(Vector_128_u16 v, size_t i) {
9697 assert_or_panic(v[0] == 1658);
9698 assert_or_panic(v[1] == 1659);
9699 assert_or_panic(v[2] == 1660);
9700 assert_or_panic(v[3] == 1661);
9701 assert_or_panic(v[4] == 1662);
9702 assert_or_panic(v[5] == 1663);
9703 assert_or_panic(v[6] == 1664);
9704 assert_or_panic(v[7] == 1665);
9705 assert_or_panic(v[8] == 1666);
9706 assert_or_panic(v[9] == 1667);
9707 assert_or_panic(v[10] == 1668);
9708 assert_or_panic(v[11] == 1669);
9709 assert_or_panic(v[12] == 1670);
9710 assert_or_panic(v[13] == 1671);
9711 assert_or_panic(v[14] == 1672);
9712 assert_or_panic(v[15] == 1673);
9713 assert_or_panic(v[16] == 1674);
9714 assert_or_panic(v[17] == 1675);
9715 assert_or_panic(v[18] == 1676);
9716 assert_or_panic(v[19] == 1677);
9717 assert_or_panic(v[20] == 1678);
9718 assert_or_panic(v[21] == 1679);
9719 assert_or_panic(v[22] == 1680);
9720 assert_or_panic(v[23] == 1681);
9721 assert_or_panic(v[24] == 1682);
9722 assert_or_panic(v[25] == 1683);
9723 assert_or_panic(v[26] == 1684);
9724 assert_or_panic(v[27] == 1685);
9725 assert_or_panic(v[28] == 1686);
9726 assert_or_panic(v[29] == 1687);
9727 assert_or_panic(v[30] == 1688);
9728 assert_or_panic(v[31] == 1689);
9729 assert_or_panic(v[32] == 1690);
9730 assert_or_panic(v[33] == 1691);
9731 assert_or_panic(v[34] == 1692);
9732 assert_or_panic(v[35] == 1693);
9733 assert_or_panic(v[36] == 1694);
9734 assert_or_panic(v[37] == 1695);
9735 assert_or_panic(v[38] == 1696);
9736 assert_or_panic(v[39] == 1697);
9737 assert_or_panic(v[40] == 1698);
9738 assert_or_panic(v[41] == 1699);
9739 assert_or_panic(v[42] == 1700);
9740 assert_or_panic(v[43] == 1701);
9741 assert_or_panic(v[44] == 1702);
9742 assert_or_panic(v[45] == 1703);
9743 assert_or_panic(v[46] == 1704);
9744 assert_or_panic(v[47] == 1705);
9745 assert_or_panic(v[48] == 1706);
9746 assert_or_panic(v[49] == 1707);
9747 assert_or_panic(v[50] == 1708);
9748 assert_or_panic(v[51] == 1709);
9749 assert_or_panic(v[52] == 1710);
9750 assert_or_panic(v[53] == 1711);
9751 assert_or_panic(v[54] == 1712);
9752 assert_or_panic(v[55] == 1713);
9753 assert_or_panic(v[56] == 1714);
9754 assert_or_panic(v[57] == 1715);
9755 assert_or_panic(v[58] == 1716);
9756 assert_or_panic(v[59] == 1717);
9757 assert_or_panic(v[60] == 1718);
9758 assert_or_panic(v[61] == 1719);
9759 assert_or_panic(v[62] == 1720);
9760 assert_or_panic(v[63] == 1721);
9761 assert_or_panic(v[64] == 1722);
9762 assert_or_panic(v[65] == 1723);
9763 assert_or_panic(v[66] == 1724);
9764 assert_or_panic(v[67] == 1725);
9765 assert_or_panic(v[68] == 1726);
9766 assert_or_panic(v[69] == 1727);
9767 assert_or_panic(v[70] == 1728);
9768 assert_or_panic(v[71] == 1729);
9769 assert_or_panic(v[72] == 1730);
9770 assert_or_panic(v[73] == 1731);
9771 assert_or_panic(v[74] == 1732);
9772 assert_or_panic(v[75] == 1733);
9773 assert_or_panic(v[76] == 1734);
9774 assert_or_panic(v[77] == 1735);
9775 assert_or_panic(v[78] == 1736);
9776 assert_or_panic(v[79] == 1737);
9777 assert_or_panic(v[80] == 1738);
9778 assert_or_panic(v[81] == 1739);
9779 assert_or_panic(v[82] == 1740);
9780 assert_or_panic(v[83] == 1741);
9781 assert_or_panic(v[84] == 1742);
9782 assert_or_panic(v[85] == 1743);
9783 assert_or_panic(v[86] == 1744);
9784 assert_or_panic(v[87] == 1745);
9785 assert_or_panic(v[88] == 1746);
9786 assert_or_panic(v[89] == 1747);
9787 assert_or_panic(v[90] == 1748);
9788 assert_or_panic(v[91] == 1749);
9789 assert_or_panic(v[92] == 1750);
9790 assert_or_panic(v[93] == 1751);
9791 assert_or_panic(v[94] == 1752);
9792 assert_or_panic(v[95] == 1753);
9793 assert_or_panic(v[96] == 1754);
9794 assert_or_panic(v[97] == 1755);
9795 assert_or_panic(v[98] == 1756);
9796 assert_or_panic(v[99] == 1757);
9797 assert_or_panic(v[100] == 1758);
9798 assert_or_panic(v[101] == 1759);
9799 assert_or_panic(v[102] == 1760);
9800 assert_or_panic(v[103] == 1761);
9801 assert_or_panic(v[104] == 1762);
9802 assert_or_panic(v[105] == 1763);
9803 assert_or_panic(v[106] == 1764);
9804 assert_or_panic(v[107] == 1765);
9805 assert_or_panic(v[108] == 1766);
9806 assert_or_panic(v[109] == 1767);
9807 assert_or_panic(v[110] == 1768);
9808 assert_or_panic(v[111] == 1769);
9809 assert_or_panic(v[112] == 1770);
9810 assert_or_panic(v[113] == 1771);
9811 assert_or_panic(v[114] == 1772);
9812 assert_or_panic(v[115] == 1773);
9813 assert_or_panic(v[116] == 1774);
9814 assert_or_panic(v[117] == 1775);
9815 assert_or_panic(v[118] == 1776);
9816 assert_or_panic(v[119] == 1777);
9817 assert_or_panic(v[120] == 1778);
9818 assert_or_panic(v[121] == 1779);
9819 assert_or_panic(v[122] == 1780);
9820 assert_or_panic(v[123] == 1781);
9821 assert_or_panic(v[124] == 1782);
9822 assert_or_panic(v[125] == 1783);
9823 assert_or_panic(v[126] == 1784);
9824 assert_or_panic(v[127] == 1785);
9825 assert_or_panic(i == 128);
9826}
9827void c_test_vector_128_u16(void) {
9828 Vector_128_u16 v = zig_ret_vector_128_u16();
9829 assert_or_panic(v[0] == 1274);
9830 assert_or_panic(v[1] == 1275);
9831 assert_or_panic(v[2] == 1276);
9832 assert_or_panic(v[3] == 1277);
9833 assert_or_panic(v[4] == 1278);
9834 assert_or_panic(v[5] == 1279);
9835 assert_or_panic(v[6] == 1280);
9836 assert_or_panic(v[7] == 1281);
9837 assert_or_panic(v[8] == 1282);
9838 assert_or_panic(v[9] == 1283);
9839 assert_or_panic(v[10] == 1284);
9840 assert_or_panic(v[11] == 1285);
9841 assert_or_panic(v[12] == 1286);
9842 assert_or_panic(v[13] == 1287);
9843 assert_or_panic(v[14] == 1288);
9844 assert_or_panic(v[15] == 1289);
9845 assert_or_panic(v[16] == 1290);
9846 assert_or_panic(v[17] == 1291);
9847 assert_or_panic(v[18] == 1292);
9848 assert_or_panic(v[19] == 1293);
9849 assert_or_panic(v[20] == 1294);
9850 assert_or_panic(v[21] == 1295);
9851 assert_or_panic(v[22] == 1296);
9852 assert_or_panic(v[23] == 1297);
9853 assert_or_panic(v[24] == 1298);
9854 assert_or_panic(v[25] == 1299);
9855 assert_or_panic(v[26] == 1300);
9856 assert_or_panic(v[27] == 1301);
9857 assert_or_panic(v[28] == 1302);
9858 assert_or_panic(v[29] == 1303);
9859 assert_or_panic(v[30] == 1304);
9860 assert_or_panic(v[31] == 1305);
9861 assert_or_panic(v[32] == 1306);
9862 assert_or_panic(v[33] == 1307);
9863 assert_or_panic(v[34] == 1308);
9864 assert_or_panic(v[35] == 1309);
9865 assert_or_panic(v[36] == 1310);
9866 assert_or_panic(v[37] == 1311);
9867 assert_or_panic(v[38] == 1312);
9868 assert_or_panic(v[39] == 1313);
9869 assert_or_panic(v[40] == 1314);
9870 assert_or_panic(v[41] == 1315);
9871 assert_or_panic(v[42] == 1316);
9872 assert_or_panic(v[43] == 1317);
9873 assert_or_panic(v[44] == 1318);
9874 assert_or_panic(v[45] == 1319);
9875 assert_or_panic(v[46] == 1320);
9876 assert_or_panic(v[47] == 1321);
9877 assert_or_panic(v[48] == 1322);
9878 assert_or_panic(v[49] == 1323);
9879 assert_or_panic(v[50] == 1324);
9880 assert_or_panic(v[51] == 1325);
9881 assert_or_panic(v[52] == 1326);
9882 assert_or_panic(v[53] == 1327);
9883 assert_or_panic(v[54] == 1328);
9884 assert_or_panic(v[55] == 1329);
9885 assert_or_panic(v[56] == 1330);
9886 assert_or_panic(v[57] == 1331);
9887 assert_or_panic(v[58] == 1332);
9888 assert_or_panic(v[59] == 1333);
9889 assert_or_panic(v[60] == 1334);
9890 assert_or_panic(v[61] == 1335);
9891 assert_or_panic(v[62] == 1336);
9892 assert_or_panic(v[63] == 1337);
9893 assert_or_panic(v[64] == 1338);
9894 assert_or_panic(v[65] == 1339);
9895 assert_or_panic(v[66] == 1340);
9896 assert_or_panic(v[67] == 1341);
9897 assert_or_panic(v[68] == 1342);
9898 assert_or_panic(v[69] == 1343);
9899 assert_or_panic(v[70] == 1344);
9900 assert_or_panic(v[71] == 1345);
9901 assert_or_panic(v[72] == 1346);
9902 assert_or_panic(v[73] == 1347);
9903 assert_or_panic(v[74] == 1348);
9904 assert_or_panic(v[75] == 1349);
9905 assert_or_panic(v[76] == 1350);
9906 assert_or_panic(v[77] == 1351);
9907 assert_or_panic(v[78] == 1352);
9908 assert_or_panic(v[79] == 1353);
9909 assert_or_panic(v[80] == 1354);
9910 assert_or_panic(v[81] == 1355);
9911 assert_or_panic(v[82] == 1356);
9912 assert_or_panic(v[83] == 1357);
9913 assert_or_panic(v[84] == 1358);
9914 assert_or_panic(v[85] == 1359);
9915 assert_or_panic(v[86] == 1360);
9916 assert_or_panic(v[87] == 1361);
9917 assert_or_panic(v[88] == 1362);
9918 assert_or_panic(v[89] == 1363);
9919 assert_or_panic(v[90] == 1364);
9920 assert_or_panic(v[91] == 1365);
9921 assert_or_panic(v[92] == 1366);
9922 assert_or_panic(v[93] == 1367);
9923 assert_or_panic(v[94] == 1368);
9924 assert_or_panic(v[95] == 1369);
9925 assert_or_panic(v[96] == 1370);
9926 assert_or_panic(v[97] == 1371);
9927 assert_or_panic(v[98] == 1372);
9928 assert_or_panic(v[99] == 1373);
9929 assert_or_panic(v[100] == 1374);
9930 assert_or_panic(v[101] == 1375);
9931 assert_or_panic(v[102] == 1376);
9932 assert_or_panic(v[103] == 1377);
9933 assert_or_panic(v[104] == 1378);
9934 assert_or_panic(v[105] == 1379);
9935 assert_or_panic(v[106] == 1380);
9936 assert_or_panic(v[107] == 1381);
9937 assert_or_panic(v[108] == 1382);
9938 assert_or_panic(v[109] == 1383);
9939 assert_or_panic(v[110] == 1384);
9940 assert_or_panic(v[111] == 1385);
9941 assert_or_panic(v[112] == 1386);
9942 assert_or_panic(v[113] == 1387);
9943 assert_or_panic(v[114] == 1388);
9944 assert_or_panic(v[115] == 1389);
9945 assert_or_panic(v[116] == 1390);
9946 assert_or_panic(v[117] == 1391);
9947 assert_or_panic(v[118] == 1392);
9948 assert_or_panic(v[119] == 1393);
9949 assert_or_panic(v[120] == 1394);
9950 assert_or_panic(v[121] == 1395);
9951 assert_or_panic(v[122] == 1396);
9952 assert_or_panic(v[123] == 1397);
9953 assert_or_panic(v[124] == 1398);
9954 assert_or_panic(v[125] == 1399);
9955 assert_or_panic(v[126] == 1400);
9956 assert_or_panic(v[127] == 1401);
9957 zig_vector_128_u16((Vector_128_u16){
9958 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
9959 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433,
9960 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
9961 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465,
9962 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
9963 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
9964 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513,
9965 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
9966 }, 128);
9967}
9968
9969typedef uint16_t Vector_192_u16 __attribute__((vector_size(192 * sizeof(uint16_t))));
9970
9971Vector_192_u16 zig_ret_vector_192_u16(void);
9972void zig_vector_192_u16(Vector_192_u16, size_t);
9973
9974Vector_192_u16 c_ret_vector_192_u16(void) {
9975 return (Vector_192_u16){
9976 2170, 2171, 2172, 2173, 2174, 2175, 2176, 2177, 2178, 2179, 2180, 2181, 2182, 2183, 2184, 2185,
9977 2186, 2187, 2188, 2189, 2190, 2191, 2192, 2193, 2194, 2195, 2196, 2197, 2198, 2199, 2200, 2201,
9978 2202, 2203, 2204, 2205, 2206, 2207, 2208, 2209, 2210, 2211, 2212, 2213, 2214, 2215, 2216, 2217,
9979 2218, 2219, 2220, 2221, 2222, 2223, 2224, 2225, 2226, 2227, 2228, 2229, 2230, 2231, 2232, 2233,
9980 2234, 2235, 2236, 2237, 2238, 2239, 2240, 2241, 2242, 2243, 2244, 2245, 2246, 2247, 2248, 2249,
9981 2250, 2251, 2252, 2253, 2254, 2255, 2256, 2257, 2258, 2259, 2260, 2261, 2262, 2263, 2264, 2265,
9982 2266, 2267, 2268, 2269, 2270, 2271, 2272, 2273, 2274, 2275, 2276, 2277, 2278, 2279, 2280, 2281,
9983 2282, 2283, 2284, 2285, 2286, 2287, 2288, 2289, 2290, 2291, 2292, 2293, 2294, 2295, 2296, 2297,
9984 2298, 2299, 2300, 2301, 2302, 2303, 2304, 2305, 2306, 2307, 2308, 2309, 2310, 2311, 2312, 2313,
9985 2314, 2315, 2316, 2317, 2318, 2319, 2320, 2321, 2322, 2323, 2324, 2325, 2326, 2327, 2328, 2329,
9986 2330, 2331, 2332, 2333, 2334, 2335, 2336, 2337, 2338, 2339, 2340, 2341, 2342, 2343, 2344, 2345,
9987 2346, 2347, 2348, 2349, 2350, 2351, 2352, 2353, 2354, 2355, 2356, 2357, 2358, 2359, 2360, 2361,
9988 };
9989}
9990void c_vector_192_u16(Vector_192_u16 v, size_t i) {
9991 assert_or_panic(v[0] == 2362);
9992 assert_or_panic(v[1] == 2363);
9993 assert_or_panic(v[2] == 2364);
9994 assert_or_panic(v[3] == 2365);
9995 assert_or_panic(v[4] == 2366);
9996 assert_or_panic(v[5] == 2367);
9997 assert_or_panic(v[6] == 2368);
9998 assert_or_panic(v[7] == 2369);
9999 assert_or_panic(v[8] == 2370);
10000 assert_or_panic(v[9] == 2371);
10001 assert_or_panic(v[10] == 2372);
10002 assert_or_panic(v[11] == 2373);
10003 assert_or_panic(v[12] == 2374);
10004 assert_or_panic(v[13] == 2375);
10005 assert_or_panic(v[14] == 2376);
10006 assert_or_panic(v[15] == 2377);
10007 assert_or_panic(v[16] == 2378);
10008 assert_or_panic(v[17] == 2379);
10009 assert_or_panic(v[18] == 2380);
10010 assert_or_panic(v[19] == 2381);
10011 assert_or_panic(v[20] == 2382);
10012 assert_or_panic(v[21] == 2383);
10013 assert_or_panic(v[22] == 2384);
10014 assert_or_panic(v[23] == 2385);
10015 assert_or_panic(v[24] == 2386);
10016 assert_or_panic(v[25] == 2387);
10017 assert_or_panic(v[26] == 2388);
10018 assert_or_panic(v[27] == 2389);
10019 assert_or_panic(v[28] == 2390);
10020 assert_or_panic(v[29] == 2391);
10021 assert_or_panic(v[30] == 2392);
10022 assert_or_panic(v[31] == 2393);
10023 assert_or_panic(v[32] == 2394);
10024 assert_or_panic(v[33] == 2395);
10025 assert_or_panic(v[34] == 2396);
10026 assert_or_panic(v[35] == 2397);
10027 assert_or_panic(v[36] == 2398);
10028 assert_or_panic(v[37] == 2399);
10029 assert_or_panic(v[38] == 2400);
10030 assert_or_panic(v[39] == 2401);
10031 assert_or_panic(v[40] == 2402);
10032 assert_or_panic(v[41] == 2403);
10033 assert_or_panic(v[42] == 2404);
10034 assert_or_panic(v[43] == 2405);
10035 assert_or_panic(v[44] == 2406);
10036 assert_or_panic(v[45] == 2407);
10037 assert_or_panic(v[46] == 2408);
10038 assert_or_panic(v[47] == 2409);
10039 assert_or_panic(v[48] == 2410);
10040 assert_or_panic(v[49] == 2411);
10041 assert_or_panic(v[50] == 2412);
10042 assert_or_panic(v[51] == 2413);
10043 assert_or_panic(v[52] == 2414);
10044 assert_or_panic(v[53] == 2415);
10045 assert_or_panic(v[54] == 2416);
10046 assert_or_panic(v[55] == 2417);
10047 assert_or_panic(v[56] == 2418);
10048 assert_or_panic(v[57] == 2419);
10049 assert_or_panic(v[58] == 2420);
10050 assert_or_panic(v[59] == 2421);
10051 assert_or_panic(v[60] == 2422);
10052 assert_or_panic(v[61] == 2423);
10053 assert_or_panic(v[62] == 2424);
10054 assert_or_panic(v[63] == 2425);
10055 assert_or_panic(v[64] == 2426);
10056 assert_or_panic(v[65] == 2427);
10057 assert_or_panic(v[66] == 2428);
10058 assert_or_panic(v[67] == 2429);
10059 assert_or_panic(v[68] == 2430);
10060 assert_or_panic(v[69] == 2431);
10061 assert_or_panic(v[70] == 2432);
10062 assert_or_panic(v[71] == 2433);
10063 assert_or_panic(v[72] == 2434);
10064 assert_or_panic(v[73] == 2435);
10065 assert_or_panic(v[74] == 2436);
10066 assert_or_panic(v[75] == 2437);
10067 assert_or_panic(v[76] == 2438);
10068 assert_or_panic(v[77] == 2439);
10069 assert_or_panic(v[78] == 2440);
10070 assert_or_panic(v[79] == 2441);
10071 assert_or_panic(v[80] == 2442);
10072 assert_or_panic(v[81] == 2443);
10073 assert_or_panic(v[82] == 2444);
10074 assert_or_panic(v[83] == 2445);
10075 assert_or_panic(v[84] == 2446);
10076 assert_or_panic(v[85] == 2447);
10077 assert_or_panic(v[86] == 2448);
10078 assert_or_panic(v[87] == 2449);
10079 assert_or_panic(v[88] == 2450);
10080 assert_or_panic(v[89] == 2451);
10081 assert_or_panic(v[90] == 2452);
10082 assert_or_panic(v[91] == 2453);
10083 assert_or_panic(v[92] == 2454);
10084 assert_or_panic(v[93] == 2455);
10085 assert_or_panic(v[94] == 2456);
10086 assert_or_panic(v[95] == 2457);
10087 assert_or_panic(v[96] == 2458);
10088 assert_or_panic(v[97] == 2459);
10089 assert_or_panic(v[98] == 2460);
10090 assert_or_panic(v[99] == 2461);
10091 assert_or_panic(v[100] == 2462);
10092 assert_or_panic(v[101] == 2463);
10093 assert_or_panic(v[102] == 2464);
10094 assert_or_panic(v[103] == 2465);
10095 assert_or_panic(v[104] == 2466);
10096 assert_or_panic(v[105] == 2467);
10097 assert_or_panic(v[106] == 2468);
10098 assert_or_panic(v[107] == 2469);
10099 assert_or_panic(v[108] == 2470);
10100 assert_or_panic(v[109] == 2471);
10101 assert_or_panic(v[110] == 2472);
10102 assert_or_panic(v[111] == 2473);
10103 assert_or_panic(v[112] == 2474);
10104 assert_or_panic(v[113] == 2475);
10105 assert_or_panic(v[114] == 2476);
10106 assert_or_panic(v[115] == 2477);
10107 assert_or_panic(v[116] == 2478);
10108 assert_or_panic(v[117] == 2479);
10109 assert_or_panic(v[118] == 2480);
10110 assert_or_panic(v[119] == 2481);
10111 assert_or_panic(v[120] == 2482);
10112 assert_or_panic(v[121] == 2483);
10113 assert_or_panic(v[122] == 2484);
10114 assert_or_panic(v[123] == 2485);
10115 assert_or_panic(v[124] == 2486);
10116 assert_or_panic(v[125] == 2487);
10117 assert_or_panic(v[126] == 2488);
10118 assert_or_panic(v[127] == 2489);
10119 assert_or_panic(v[128] == 2490);
10120 assert_or_panic(v[129] == 2491);
10121 assert_or_panic(v[130] == 2492);
10122 assert_or_panic(v[131] == 2493);
10123 assert_or_panic(v[132] == 2494);
10124 assert_or_panic(v[133] == 2495);
10125 assert_or_panic(v[134] == 2496);
10126 assert_or_panic(v[135] == 2497);
10127 assert_or_panic(v[136] == 2498);
10128 assert_or_panic(v[137] == 2499);
10129 assert_or_panic(v[138] == 2500);
10130 assert_or_panic(v[139] == 2501);
10131 assert_or_panic(v[140] == 2502);
10132 assert_or_panic(v[141] == 2503);
10133 assert_or_panic(v[142] == 2504);
10134 assert_or_panic(v[143] == 2505);
10135 assert_or_panic(v[144] == 2506);
10136 assert_or_panic(v[145] == 2507);
10137 assert_or_panic(v[146] == 2508);
10138 assert_or_panic(v[147] == 2509);
10139 assert_or_panic(v[148] == 2510);
10140 assert_or_panic(v[149] == 2511);
10141 assert_or_panic(v[150] == 2512);
10142 assert_or_panic(v[151] == 2513);
10143 assert_or_panic(v[152] == 2514);
10144 assert_or_panic(v[153] == 2515);
10145 assert_or_panic(v[154] == 2516);
10146 assert_or_panic(v[155] == 2517);
10147 assert_or_panic(v[156] == 2518);
10148 assert_or_panic(v[157] == 2519);
10149 assert_or_panic(v[158] == 2520);
10150 assert_or_panic(v[159] == 2521);
10151 assert_or_panic(v[160] == 2522);
10152 assert_or_panic(v[161] == 2523);
10153 assert_or_panic(v[162] == 2524);
10154 assert_or_panic(v[163] == 2525);
10155 assert_or_panic(v[164] == 2526);
10156 assert_or_panic(v[165] == 2527);
10157 assert_or_panic(v[166] == 2528);
10158 assert_or_panic(v[167] == 2529);
10159 assert_or_panic(v[168] == 2530);
10160 assert_or_panic(v[169] == 2531);
10161 assert_or_panic(v[170] == 2532);
10162 assert_or_panic(v[171] == 2533);
10163 assert_or_panic(v[172] == 2534);
10164 assert_or_panic(v[173] == 2535);
10165 assert_or_panic(v[174] == 2536);
10166 assert_or_panic(v[175] == 2537);
10167 assert_or_panic(v[176] == 2538);
10168 assert_or_panic(v[177] == 2539);
10169 assert_or_panic(v[178] == 2540);
10170 assert_or_panic(v[179] == 2541);
10171 assert_or_panic(v[180] == 2542);
10172 assert_or_panic(v[181] == 2543);
10173 assert_or_panic(v[182] == 2544);
10174 assert_or_panic(v[183] == 2545);
10175 assert_or_panic(v[184] == 2546);
10176 assert_or_panic(v[185] == 2547);
10177 assert_or_panic(v[186] == 2548);
10178 assert_or_panic(v[187] == 2549);
10179 assert_or_panic(v[188] == 2550);
10180 assert_or_panic(v[189] == 2551);
10181 assert_or_panic(v[190] == 2552);
10182 assert_or_panic(v[191] == 2553);
10183 assert_or_panic(i == 192);
10184}
10185void c_test_vector_192_u16(void) {
10186 Vector_192_u16 v = zig_ret_vector_192_u16();
10187 assert_or_panic(v[0] == 1786);
10188 assert_or_panic(v[1] == 1787);
10189 assert_or_panic(v[2] == 1788);
10190 assert_or_panic(v[3] == 1789);
10191 assert_or_panic(v[4] == 1790);
10192 assert_or_panic(v[5] == 1791);
10193 assert_or_panic(v[6] == 1792);
10194 assert_or_panic(v[7] == 1793);
10195 assert_or_panic(v[8] == 1794);
10196 assert_or_panic(v[9] == 1795);
10197 assert_or_panic(v[10] == 1796);
10198 assert_or_panic(v[11] == 1797);
10199 assert_or_panic(v[12] == 1798);
10200 assert_or_panic(v[13] == 1799);
10201 assert_or_panic(v[14] == 1800);
10202 assert_or_panic(v[15] == 1801);
10203 assert_or_panic(v[16] == 1802);
10204 assert_or_panic(v[17] == 1803);
10205 assert_or_panic(v[18] == 1804);
10206 assert_or_panic(v[19] == 1805);
10207 assert_or_panic(v[20] == 1806);
10208 assert_or_panic(v[21] == 1807);
10209 assert_or_panic(v[22] == 1808);
10210 assert_or_panic(v[23] == 1809);
10211 assert_or_panic(v[24] == 1810);
10212 assert_or_panic(v[25] == 1811);
10213 assert_or_panic(v[26] == 1812);
10214 assert_or_panic(v[27] == 1813);
10215 assert_or_panic(v[28] == 1814);
10216 assert_or_panic(v[29] == 1815);
10217 assert_or_panic(v[30] == 1816);
10218 assert_or_panic(v[31] == 1817);
10219 assert_or_panic(v[32] == 1818);
10220 assert_or_panic(v[33] == 1819);
10221 assert_or_panic(v[34] == 1820);
10222 assert_or_panic(v[35] == 1821);
10223 assert_or_panic(v[36] == 1822);
10224 assert_or_panic(v[37] == 1823);
10225 assert_or_panic(v[38] == 1824);
10226 assert_or_panic(v[39] == 1825);
10227 assert_or_panic(v[40] == 1826);
10228 assert_or_panic(v[41] == 1827);
10229 assert_or_panic(v[42] == 1828);
10230 assert_or_panic(v[43] == 1829);
10231 assert_or_panic(v[44] == 1830);
10232 assert_or_panic(v[45] == 1831);
10233 assert_or_panic(v[46] == 1832);
10234 assert_or_panic(v[47] == 1833);
10235 assert_or_panic(v[48] == 1834);
10236 assert_or_panic(v[49] == 1835);
10237 assert_or_panic(v[50] == 1836);
10238 assert_or_panic(v[51] == 1837);
10239 assert_or_panic(v[52] == 1838);
10240 assert_or_panic(v[53] == 1839);
10241 assert_or_panic(v[54] == 1840);
10242 assert_or_panic(v[55] == 1841);
10243 assert_or_panic(v[56] == 1842);
10244 assert_or_panic(v[57] == 1843);
10245 assert_or_panic(v[58] == 1844);
10246 assert_or_panic(v[59] == 1845);
10247 assert_or_panic(v[60] == 1846);
10248 assert_or_panic(v[61] == 1847);
10249 assert_or_panic(v[62] == 1848);
10250 assert_or_panic(v[63] == 1849);
10251 assert_or_panic(v[64] == 1850);
10252 assert_or_panic(v[65] == 1851);
10253 assert_or_panic(v[66] == 1852);
10254 assert_or_panic(v[67] == 1853);
10255 assert_or_panic(v[68] == 1854);
10256 assert_or_panic(v[69] == 1855);
10257 assert_or_panic(v[70] == 1856);
10258 assert_or_panic(v[71] == 1857);
10259 assert_or_panic(v[72] == 1858);
10260 assert_or_panic(v[73] == 1859);
10261 assert_or_panic(v[74] == 1860);
10262 assert_or_panic(v[75] == 1861);
10263 assert_or_panic(v[76] == 1862);
10264 assert_or_panic(v[77] == 1863);
10265 assert_or_panic(v[78] == 1864);
10266 assert_or_panic(v[79] == 1865);
10267 assert_or_panic(v[80] == 1866);
10268 assert_or_panic(v[81] == 1867);
10269 assert_or_panic(v[82] == 1868);
10270 assert_or_panic(v[83] == 1869);
10271 assert_or_panic(v[84] == 1870);
10272 assert_or_panic(v[85] == 1871);
10273 assert_or_panic(v[86] == 1872);
10274 assert_or_panic(v[87] == 1873);
10275 assert_or_panic(v[88] == 1874);
10276 assert_or_panic(v[89] == 1875);
10277 assert_or_panic(v[90] == 1876);
10278 assert_or_panic(v[91] == 1877);
10279 assert_or_panic(v[92] == 1878);
10280 assert_or_panic(v[93] == 1879);
10281 assert_or_panic(v[94] == 1880);
10282 assert_or_panic(v[95] == 1881);
10283 assert_or_panic(v[96] == 1882);
10284 assert_or_panic(v[97] == 1883);
10285 assert_or_panic(v[98] == 1884);
10286 assert_or_panic(v[99] == 1885);
10287 assert_or_panic(v[100] == 1886);
10288 assert_or_panic(v[101] == 1887);
10289 assert_or_panic(v[102] == 1888);
10290 assert_or_panic(v[103] == 1889);
10291 assert_or_panic(v[104] == 1890);
10292 assert_or_panic(v[105] == 1891);
10293 assert_or_panic(v[106] == 1892);
10294 assert_or_panic(v[107] == 1893);
10295 assert_or_panic(v[108] == 1894);
10296 assert_or_panic(v[109] == 1895);
10297 assert_or_panic(v[110] == 1896);
10298 assert_or_panic(v[111] == 1897);
10299 assert_or_panic(v[112] == 1898);
10300 assert_or_panic(v[113] == 1899);
10301 assert_or_panic(v[114] == 1900);
10302 assert_or_panic(v[115] == 1901);
10303 assert_or_panic(v[116] == 1902);
10304 assert_or_panic(v[117] == 1903);
10305 assert_or_panic(v[118] == 1904);
10306 assert_or_panic(v[119] == 1905);
10307 assert_or_panic(v[120] == 1906);
10308 assert_or_panic(v[121] == 1907);
10309 assert_or_panic(v[122] == 1908);
10310 assert_or_panic(v[123] == 1909);
10311 assert_or_panic(v[124] == 1910);
10312 assert_or_panic(v[125] == 1911);
10313 assert_or_panic(v[126] == 1912);
10314 assert_or_panic(v[127] == 1913);
10315 assert_or_panic(v[128] == 1914);
10316 assert_or_panic(v[129] == 1915);
10317 assert_or_panic(v[130] == 1916);
10318 assert_or_panic(v[131] == 1917);
10319 assert_or_panic(v[132] == 1918);
10320 assert_or_panic(v[133] == 1919);
10321 assert_or_panic(v[134] == 1920);
10322 assert_or_panic(v[135] == 1921);
10323 assert_or_panic(v[136] == 1922);
10324 assert_or_panic(v[137] == 1923);
10325 assert_or_panic(v[138] == 1924);
10326 assert_or_panic(v[139] == 1925);
10327 assert_or_panic(v[140] == 1926);
10328 assert_or_panic(v[141] == 1927);
10329 assert_or_panic(v[142] == 1928);
10330 assert_or_panic(v[143] == 1929);
10331 assert_or_panic(v[144] == 1930);
10332 assert_or_panic(v[145] == 1931);
10333 assert_or_panic(v[146] == 1932);
10334 assert_or_panic(v[147] == 1933);
10335 assert_or_panic(v[148] == 1934);
10336 assert_or_panic(v[149] == 1935);
10337 assert_or_panic(v[150] == 1936);
10338 assert_or_panic(v[151] == 1937);
10339 assert_or_panic(v[152] == 1938);
10340 assert_or_panic(v[153] == 1939);
10341 assert_or_panic(v[154] == 1940);
10342 assert_or_panic(v[155] == 1941);
10343 assert_or_panic(v[156] == 1942);
10344 assert_or_panic(v[157] == 1943);
10345 assert_or_panic(v[158] == 1944);
10346 assert_or_panic(v[159] == 1945);
10347 assert_or_panic(v[160] == 1946);
10348 assert_or_panic(v[161] == 1947);
10349 assert_or_panic(v[162] == 1948);
10350 assert_or_panic(v[163] == 1949);
10351 assert_or_panic(v[164] == 1950);
10352 assert_or_panic(v[165] == 1951);
10353 assert_or_panic(v[166] == 1952);
10354 assert_or_panic(v[167] == 1953);
10355 assert_or_panic(v[168] == 1954);
10356 assert_or_panic(v[169] == 1955);
10357 assert_or_panic(v[170] == 1956);
10358 assert_or_panic(v[171] == 1957);
10359 assert_or_panic(v[172] == 1958);
10360 assert_or_panic(v[173] == 1959);
10361 assert_or_panic(v[174] == 1960);
10362 assert_or_panic(v[175] == 1961);
10363 assert_or_panic(v[176] == 1962);
10364 assert_or_panic(v[177] == 1963);
10365 assert_or_panic(v[178] == 1964);
10366 assert_or_panic(v[179] == 1965);
10367 assert_or_panic(v[180] == 1966);
10368 assert_or_panic(v[181] == 1967);
10369 assert_or_panic(v[182] == 1968);
10370 assert_or_panic(v[183] == 1969);
10371 assert_or_panic(v[184] == 1970);
10372 assert_or_panic(v[185] == 1971);
10373 assert_or_panic(v[186] == 1972);
10374 assert_or_panic(v[187] == 1973);
10375 assert_or_panic(v[188] == 1974);
10376 assert_or_panic(v[189] == 1975);
10377 assert_or_panic(v[190] == 1976);
10378 assert_or_panic(v[191] == 1977);
10379 zig_vector_192_u16((Vector_192_u16){
10380 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993,
10381 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
10382 2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021, 2022, 2023, 2024, 2025,
10383 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041,
10384 2042, 2043, 2044, 2045, 2046, 2047, 2048, 2049, 2050, 2051, 2052, 2053, 2054, 2055, 2056, 2057,
10385 2058, 2059, 2060, 2061, 2062, 2063, 2064, 2065, 2066, 2067, 2068, 2069, 2070, 2071, 2072, 2073,
10386 2074, 2075, 2076, 2077, 2078, 2079, 2080, 2081, 2082, 2083, 2084, 2085, 2086, 2087, 2088, 2089,
10387 2090, 2091, 2092, 2093, 2094, 2095, 2096, 2097, 2098, 2099, 2100, 2101, 2102, 2103, 2104, 2105,
10388 2106, 2107, 2108, 2109, 2110, 2111, 2112, 2113, 2114, 2115, 2116, 2117, 2118, 2119, 2120, 2121,
10389 2122, 2123, 2124, 2125, 2126, 2127, 2128, 2129, 2130, 2131, 2132, 2133, 2134, 2135, 2136, 2137,
10390 2138, 2139, 2140, 2141, 2142, 2143, 2144, 2145, 2146, 2147, 2148, 2149, 2150, 2151, 2152, 2153,
10391 2154, 2155, 2156, 2157, 2158, 2159, 2160, 2161, 2162, 2163, 2164, 2165, 2166, 2167, 2168, 2169,
10392 }, 192);
10393}
10394
10395typedef uint16_t Vector_256_u16 __attribute__((vector_size(256 * sizeof(uint16_t))));
10396
10397Vector_256_u16 zig_ret_vector_256_u16(void);
10398void zig_vector_256_u16(Vector_256_u16, size_t);
10399
10400Vector_256_u16 c_ret_vector_256_u16(void) {
10401 return (Vector_256_u16){
10402 3066, 3067, 3068, 3069, 3070, 3071, 3072, 3073, 3074, 3075, 3076, 3077, 3078, 3079, 3080, 3081,
10403 3082, 3083, 3084, 3085, 3086, 3087, 3088, 3089, 3090, 3091, 3092, 3093, 3094, 3095, 3096, 3097,
10404 3098, 3099, 3100, 3101, 3102, 3103, 3104, 3105, 3106, 3107, 3108, 3109, 3110, 3111, 3112, 3113,
10405 3114, 3115, 3116, 3117, 3118, 3119, 3120, 3121, 3122, 3123, 3124, 3125, 3126, 3127, 3128, 3129,
10406 3130, 3131, 3132, 3133, 3134, 3135, 3136, 3137, 3138, 3139, 3140, 3141, 3142, 3143, 3144, 3145,
10407 3146, 3147, 3148, 3149, 3150, 3151, 3152, 3153, 3154, 3155, 3156, 3157, 3158, 3159, 3160, 3161,
10408 3162, 3163, 3164, 3165, 3166, 3167, 3168, 3169, 3170, 3171, 3172, 3173, 3174, 3175, 3176, 3177,
10409 3178, 3179, 3180, 3181, 3182, 3183, 3184, 3185, 3186, 3187, 3188, 3189, 3190, 3191, 3192, 3193,
10410 3194, 3195, 3196, 3197, 3198, 3199, 3200, 3201, 3202, 3203, 3204, 3205, 3206, 3207, 3208, 3209,
10411 3210, 3211, 3212, 3213, 3214, 3215, 3216, 3217, 3218, 3219, 3220, 3221, 3222, 3223, 3224, 3225,
10412 3226, 3227, 3228, 3229, 3230, 3231, 3232, 3233, 3234, 3235, 3236, 3237, 3238, 3239, 3240, 3241,
10413 3242, 3243, 3244, 3245, 3246, 3247, 3248, 3249, 3250, 3251, 3252, 3253, 3254, 3255, 3256, 3257,
10414 3258, 3259, 3260, 3261, 3262, 3263, 3264, 3265, 3266, 3267, 3268, 3269, 3270, 3271, 3272, 3273,
10415 3274, 3275, 3276, 3277, 3278, 3279, 3280, 3281, 3282, 3283, 3284, 3285, 3286, 3287, 3288, 3289,
10416 3290, 3291, 3292, 3293, 3294, 3295, 3296, 3297, 3298, 3299, 3300, 3301, 3302, 3303, 3304, 3305,
10417 3306, 3307, 3308, 3309, 3310, 3311, 3312, 3313, 3314, 3315, 3316, 3317, 3318, 3319, 3320, 3321,
10418 };
10419}
10420void c_vector_256_u16(Vector_256_u16 v, size_t i) {
10421 assert_or_panic(v[0] == 3322);
10422 assert_or_panic(v[1] == 3323);
10423 assert_or_panic(v[2] == 3324);
10424 assert_or_panic(v[3] == 3325);
10425 assert_or_panic(v[4] == 3326);
10426 assert_or_panic(v[5] == 3327);
10427 assert_or_panic(v[6] == 3328);
10428 assert_or_panic(v[7] == 3329);
10429 assert_or_panic(v[8] == 3330);
10430 assert_or_panic(v[9] == 3331);
10431 assert_or_panic(v[10] == 3332);
10432 assert_or_panic(v[11] == 3333);
10433 assert_or_panic(v[12] == 3334);
10434 assert_or_panic(v[13] == 3335);
10435 assert_or_panic(v[14] == 3336);
10436 assert_or_panic(v[15] == 3337);
10437 assert_or_panic(v[16] == 3338);
10438 assert_or_panic(v[17] == 3339);
10439 assert_or_panic(v[18] == 3340);
10440 assert_or_panic(v[19] == 3341);
10441 assert_or_panic(v[20] == 3342);
10442 assert_or_panic(v[21] == 3343);
10443 assert_or_panic(v[22] == 3344);
10444 assert_or_panic(v[23] == 3345);
10445 assert_or_panic(v[24] == 3346);
10446 assert_or_panic(v[25] == 3347);
10447 assert_or_panic(v[26] == 3348);
10448 assert_or_panic(v[27] == 3349);
10449 assert_or_panic(v[28] == 3350);
10450 assert_or_panic(v[29] == 3351);
10451 assert_or_panic(v[30] == 3352);
10452 assert_or_panic(v[31] == 3353);
10453 assert_or_panic(v[32] == 3354);
10454 assert_or_panic(v[33] == 3355);
10455 assert_or_panic(v[34] == 3356);
10456 assert_or_panic(v[35] == 3357);
10457 assert_or_panic(v[36] == 3358);
10458 assert_or_panic(v[37] == 3359);
10459 assert_or_panic(v[38] == 3360);
10460 assert_or_panic(v[39] == 3361);
10461 assert_or_panic(v[40] == 3362);
10462 assert_or_panic(v[41] == 3363);
10463 assert_or_panic(v[42] == 3364);
10464 assert_or_panic(v[43] == 3365);
10465 assert_or_panic(v[44] == 3366);
10466 assert_or_panic(v[45] == 3367);
10467 assert_or_panic(v[46] == 3368);
10468 assert_or_panic(v[47] == 3369);
10469 assert_or_panic(v[48] == 3370);
10470 assert_or_panic(v[49] == 3371);
10471 assert_or_panic(v[50] == 3372);
10472 assert_or_panic(v[51] == 3373);
10473 assert_or_panic(v[52] == 3374);
10474 assert_or_panic(v[53] == 3375);
10475 assert_or_panic(v[54] == 3376);
10476 assert_or_panic(v[55] == 3377);
10477 assert_or_panic(v[56] == 3378);
10478 assert_or_panic(v[57] == 3379);
10479 assert_or_panic(v[58] == 3380);
10480 assert_or_panic(v[59] == 3381);
10481 assert_or_panic(v[60] == 3382);
10482 assert_or_panic(v[61] == 3383);
10483 assert_or_panic(v[62] == 3384);
10484 assert_or_panic(v[63] == 3385);
10485 assert_or_panic(v[64] == 3386);
10486 assert_or_panic(v[65] == 3387);
10487 assert_or_panic(v[66] == 3388);
10488 assert_or_panic(v[67] == 3389);
10489 assert_or_panic(v[68] == 3390);
10490 assert_or_panic(v[69] == 3391);
10491 assert_or_panic(v[70] == 3392);
10492 assert_or_panic(v[71] == 3393);
10493 assert_or_panic(v[72] == 3394);
10494 assert_or_panic(v[73] == 3395);
10495 assert_or_panic(v[74] == 3396);
10496 assert_or_panic(v[75] == 3397);
10497 assert_or_panic(v[76] == 3398);
10498 assert_or_panic(v[77] == 3399);
10499 assert_or_panic(v[78] == 3400);
10500 assert_or_panic(v[79] == 3401);
10501 assert_or_panic(v[80] == 3402);
10502 assert_or_panic(v[81] == 3403);
10503 assert_or_panic(v[82] == 3404);
10504 assert_or_panic(v[83] == 3405);
10505 assert_or_panic(v[84] == 3406);
10506 assert_or_panic(v[85] == 3407);
10507 assert_or_panic(v[86] == 3408);
10508 assert_or_panic(v[87] == 3409);
10509 assert_or_panic(v[88] == 3410);
10510 assert_or_panic(v[89] == 3411);
10511 assert_or_panic(v[90] == 3412);
10512 assert_or_panic(v[91] == 3413);
10513 assert_or_panic(v[92] == 3414);
10514 assert_or_panic(v[93] == 3415);
10515 assert_or_panic(v[94] == 3416);
10516 assert_or_panic(v[95] == 3417);
10517 assert_or_panic(v[96] == 3418);
10518 assert_or_panic(v[97] == 3419);
10519 assert_or_panic(v[98] == 3420);
10520 assert_or_panic(v[99] == 3421);
10521 assert_or_panic(v[100] == 3422);
10522 assert_or_panic(v[101] == 3423);
10523 assert_or_panic(v[102] == 3424);
10524 assert_or_panic(v[103] == 3425);
10525 assert_or_panic(v[104] == 3426);
10526 assert_or_panic(v[105] == 3427);
10527 assert_or_panic(v[106] == 3428);
10528 assert_or_panic(v[107] == 3429);
10529 assert_or_panic(v[108] == 3430);
10530 assert_or_panic(v[109] == 3431);
10531 assert_or_panic(v[110] == 3432);
10532 assert_or_panic(v[111] == 3433);
10533 assert_or_panic(v[112] == 3434);
10534 assert_or_panic(v[113] == 3435);
10535 assert_or_panic(v[114] == 3436);
10536 assert_or_panic(v[115] == 3437);
10537 assert_or_panic(v[116] == 3438);
10538 assert_or_panic(v[117] == 3439);
10539 assert_or_panic(v[118] == 3440);
10540 assert_or_panic(v[119] == 3441);
10541 assert_or_panic(v[120] == 3442);
10542 assert_or_panic(v[121] == 3443);
10543 assert_or_panic(v[122] == 3444);
10544 assert_or_panic(v[123] == 3445);
10545 assert_or_panic(v[124] == 3446);
10546 assert_or_panic(v[125] == 3447);
10547 assert_or_panic(v[126] == 3448);
10548 assert_or_panic(v[127] == 3449);
10549 assert_or_panic(v[128] == 3450);
10550 assert_or_panic(v[129] == 3451);
10551 assert_or_panic(v[130] == 3452);
10552 assert_or_panic(v[131] == 3453);
10553 assert_or_panic(v[132] == 3454);
10554 assert_or_panic(v[133] == 3455);
10555 assert_or_panic(v[134] == 3456);
10556 assert_or_panic(v[135] == 3457);
10557 assert_or_panic(v[136] == 3458);
10558 assert_or_panic(v[137] == 3459);
10559 assert_or_panic(v[138] == 3460);
10560 assert_or_panic(v[139] == 3461);
10561 assert_or_panic(v[140] == 3462);
10562 assert_or_panic(v[141] == 3463);
10563 assert_or_panic(v[142] == 3464);
10564 assert_or_panic(v[143] == 3465);
10565 assert_or_panic(v[144] == 3466);
10566 assert_or_panic(v[145] == 3467);
10567 assert_or_panic(v[146] == 3468);
10568 assert_or_panic(v[147] == 3469);
10569 assert_or_panic(v[148] == 3470);
10570 assert_or_panic(v[149] == 3471);
10571 assert_or_panic(v[150] == 3472);
10572 assert_or_panic(v[151] == 3473);
10573 assert_or_panic(v[152] == 3474);
10574 assert_or_panic(v[153] == 3475);
10575 assert_or_panic(v[154] == 3476);
10576 assert_or_panic(v[155] == 3477);
10577 assert_or_panic(v[156] == 3478);
10578 assert_or_panic(v[157] == 3479);
10579 assert_or_panic(v[158] == 3480);
10580 assert_or_panic(v[159] == 3481);
10581 assert_or_panic(v[160] == 3482);
10582 assert_or_panic(v[161] == 3483);
10583 assert_or_panic(v[162] == 3484);
10584 assert_or_panic(v[163] == 3485);
10585 assert_or_panic(v[164] == 3486);
10586 assert_or_panic(v[165] == 3487);
10587 assert_or_panic(v[166] == 3488);
10588 assert_or_panic(v[167] == 3489);
10589 assert_or_panic(v[168] == 3490);
10590 assert_or_panic(v[169] == 3491);
10591 assert_or_panic(v[170] == 3492);
10592 assert_or_panic(v[171] == 3493);
10593 assert_or_panic(v[172] == 3494);
10594 assert_or_panic(v[173] == 3495);
10595 assert_or_panic(v[174] == 3496);
10596 assert_or_panic(v[175] == 3497);
10597 assert_or_panic(v[176] == 3498);
10598 assert_or_panic(v[177] == 3499);
10599 assert_or_panic(v[178] == 3500);
10600 assert_or_panic(v[179] == 3501);
10601 assert_or_panic(v[180] == 3502);
10602 assert_or_panic(v[181] == 3503);
10603 assert_or_panic(v[182] == 3504);
10604 assert_or_panic(v[183] == 3505);
10605 assert_or_panic(v[184] == 3506);
10606 assert_or_panic(v[185] == 3507);
10607 assert_or_panic(v[186] == 3508);
10608 assert_or_panic(v[187] == 3509);
10609 assert_or_panic(v[188] == 3510);
10610 assert_or_panic(v[189] == 3511);
10611 assert_or_panic(v[190] == 3512);
10612 assert_or_panic(v[191] == 3513);
10613 assert_or_panic(v[192] == 3514);
10614 assert_or_panic(v[193] == 3515);
10615 assert_or_panic(v[194] == 3516);
10616 assert_or_panic(v[195] == 3517);
10617 assert_or_panic(v[196] == 3518);
10618 assert_or_panic(v[197] == 3519);
10619 assert_or_panic(v[198] == 3520);
10620 assert_or_panic(v[199] == 3521);
10621 assert_or_panic(v[200] == 3522);
10622 assert_or_panic(v[201] == 3523);
10623 assert_or_panic(v[202] == 3524);
10624 assert_or_panic(v[203] == 3525);
10625 assert_or_panic(v[204] == 3526);
10626 assert_or_panic(v[205] == 3527);
10627 assert_or_panic(v[206] == 3528);
10628 assert_or_panic(v[207] == 3529);
10629 assert_or_panic(v[208] == 3530);
10630 assert_or_panic(v[209] == 3531);
10631 assert_or_panic(v[210] == 3532);
10632 assert_or_panic(v[211] == 3533);
10633 assert_or_panic(v[212] == 3534);
10634 assert_or_panic(v[213] == 3535);
10635 assert_or_panic(v[214] == 3536);
10636 assert_or_panic(v[215] == 3537);
10637 assert_or_panic(v[216] == 3538);
10638 assert_or_panic(v[217] == 3539);
10639 assert_or_panic(v[218] == 3540);
10640 assert_or_panic(v[219] == 3541);
10641 assert_or_panic(v[220] == 3542);
10642 assert_or_panic(v[221] == 3543);
10643 assert_or_panic(v[222] == 3544);
10644 assert_or_panic(v[223] == 3545);
10645 assert_or_panic(v[224] == 3546);
10646 assert_or_panic(v[225] == 3547);
10647 assert_or_panic(v[226] == 3548);
10648 assert_or_panic(v[227] == 3549);
10649 assert_or_panic(v[228] == 3550);
10650 assert_or_panic(v[229] == 3551);
10651 assert_or_panic(v[230] == 3552);
10652 assert_or_panic(v[231] == 3553);
10653 assert_or_panic(v[232] == 3554);
10654 assert_or_panic(v[233] == 3555);
10655 assert_or_panic(v[234] == 3556);
10656 assert_or_panic(v[235] == 3557);
10657 assert_or_panic(v[236] == 3558);
10658 assert_or_panic(v[237] == 3559);
10659 assert_or_panic(v[238] == 3560);
10660 assert_or_panic(v[239] == 3561);
10661 assert_or_panic(v[240] == 3562);
10662 assert_or_panic(v[241] == 3563);
10663 assert_or_panic(v[242] == 3564);
10664 assert_or_panic(v[243] == 3565);
10665 assert_or_panic(v[244] == 3566);
10666 assert_or_panic(v[245] == 3567);
10667 assert_or_panic(v[246] == 3568);
10668 assert_or_panic(v[247] == 3569);
10669 assert_or_panic(v[248] == 3570);
10670 assert_or_panic(v[249] == 3571);
10671 assert_or_panic(v[250] == 3572);
10672 assert_or_panic(v[251] == 3573);
10673 assert_or_panic(v[252] == 3574);
10674 assert_or_panic(v[253] == 3575);
10675 assert_or_panic(v[254] == 3576);
10676 assert_or_panic(v[255] == 3577);
10677 assert_or_panic(i == 256);
10678}
10679void c_test_vector_256_u16(void) {
10680 Vector_256_u16 v = zig_ret_vector_256_u16();
10681 assert_or_panic(v[0] == 2554);
10682 assert_or_panic(v[1] == 2555);
10683 assert_or_panic(v[2] == 2556);
10684 assert_or_panic(v[3] == 2557);
10685 assert_or_panic(v[4] == 2558);
10686 assert_or_panic(v[5] == 2559);
10687 assert_or_panic(v[6] == 2560);
10688 assert_or_panic(v[7] == 2561);
10689 assert_or_panic(v[8] == 2562);
10690 assert_or_panic(v[9] == 2563);
10691 assert_or_panic(v[10] == 2564);
10692 assert_or_panic(v[11] == 2565);
10693 assert_or_panic(v[12] == 2566);
10694 assert_or_panic(v[13] == 2567);
10695 assert_or_panic(v[14] == 2568);
10696 assert_or_panic(v[15] == 2569);
10697 assert_or_panic(v[16] == 2570);
10698 assert_or_panic(v[17] == 2571);
10699 assert_or_panic(v[18] == 2572);
10700 assert_or_panic(v[19] == 2573);
10701 assert_or_panic(v[20] == 2574);
10702 assert_or_panic(v[21] == 2575);
10703 assert_or_panic(v[22] == 2576);
10704 assert_or_panic(v[23] == 2577);
10705 assert_or_panic(v[24] == 2578);
10706 assert_or_panic(v[25] == 2579);
10707 assert_or_panic(v[26] == 2580);
10708 assert_or_panic(v[27] == 2581);
10709 assert_or_panic(v[28] == 2582);
10710 assert_or_panic(v[29] == 2583);
10711 assert_or_panic(v[30] == 2584);
10712 assert_or_panic(v[31] == 2585);
10713 assert_or_panic(v[32] == 2586);
10714 assert_or_panic(v[33] == 2587);
10715 assert_or_panic(v[34] == 2588);
10716 assert_or_panic(v[35] == 2589);
10717 assert_or_panic(v[36] == 2590);
10718 assert_or_panic(v[37] == 2591);
10719 assert_or_panic(v[38] == 2592);
10720 assert_or_panic(v[39] == 2593);
10721 assert_or_panic(v[40] == 2594);
10722 assert_or_panic(v[41] == 2595);
10723 assert_or_panic(v[42] == 2596);
10724 assert_or_panic(v[43] == 2597);
10725 assert_or_panic(v[44] == 2598);
10726 assert_or_panic(v[45] == 2599);
10727 assert_or_panic(v[46] == 2600);
10728 assert_or_panic(v[47] == 2601);
10729 assert_or_panic(v[48] == 2602);
10730 assert_or_panic(v[49] == 2603);
10731 assert_or_panic(v[50] == 2604);
10732 assert_or_panic(v[51] == 2605);
10733 assert_or_panic(v[52] == 2606);
10734 assert_or_panic(v[53] == 2607);
10735 assert_or_panic(v[54] == 2608);
10736 assert_or_panic(v[55] == 2609);
10737 assert_or_panic(v[56] == 2610);
10738 assert_or_panic(v[57] == 2611);
10739 assert_or_panic(v[58] == 2612);
10740 assert_or_panic(v[59] == 2613);
10741 assert_or_panic(v[60] == 2614);
10742 assert_or_panic(v[61] == 2615);
10743 assert_or_panic(v[62] == 2616);
10744 assert_or_panic(v[63] == 2617);
10745 assert_or_panic(v[64] == 2618);
10746 assert_or_panic(v[65] == 2619);
10747 assert_or_panic(v[66] == 2620);
10748 assert_or_panic(v[67] == 2621);
10749 assert_or_panic(v[68] == 2622);
10750 assert_or_panic(v[69] == 2623);
10751 assert_or_panic(v[70] == 2624);
10752 assert_or_panic(v[71] == 2625);
10753 assert_or_panic(v[72] == 2626);
10754 assert_or_panic(v[73] == 2627);
10755 assert_or_panic(v[74] == 2628);
10756 assert_or_panic(v[75] == 2629);
10757 assert_or_panic(v[76] == 2630);
10758 assert_or_panic(v[77] == 2631);
10759 assert_or_panic(v[78] == 2632);
10760 assert_or_panic(v[79] == 2633);
10761 assert_or_panic(v[80] == 2634);
10762 assert_or_panic(v[81] == 2635);
10763 assert_or_panic(v[82] == 2636);
10764 assert_or_panic(v[83] == 2637);
10765 assert_or_panic(v[84] == 2638);
10766 assert_or_panic(v[85] == 2639);
10767 assert_or_panic(v[86] == 2640);
10768 assert_or_panic(v[87] == 2641);
10769 assert_or_panic(v[88] == 2642);
10770 assert_or_panic(v[89] == 2643);
10771 assert_or_panic(v[90] == 2644);
10772 assert_or_panic(v[91] == 2645);
10773 assert_or_panic(v[92] == 2646);
10774 assert_or_panic(v[93] == 2647);
10775 assert_or_panic(v[94] == 2648);
10776 assert_or_panic(v[95] == 2649);
10777 assert_or_panic(v[96] == 2650);
10778 assert_or_panic(v[97] == 2651);
10779 assert_or_panic(v[98] == 2652);
10780 assert_or_panic(v[99] == 2653);
10781 assert_or_panic(v[100] == 2654);
10782 assert_or_panic(v[101] == 2655);
10783 assert_or_panic(v[102] == 2656);
10784 assert_or_panic(v[103] == 2657);
10785 assert_or_panic(v[104] == 2658);
10786 assert_or_panic(v[105] == 2659);
10787 assert_or_panic(v[106] == 2660);
10788 assert_or_panic(v[107] == 2661);
10789 assert_or_panic(v[108] == 2662);
10790 assert_or_panic(v[109] == 2663);
10791 assert_or_panic(v[110] == 2664);
10792 assert_or_panic(v[111] == 2665);
10793 assert_or_panic(v[112] == 2666);
10794 assert_or_panic(v[113] == 2667);
10795 assert_or_panic(v[114] == 2668);
10796 assert_or_panic(v[115] == 2669);
10797 assert_or_panic(v[116] == 2670);
10798 assert_or_panic(v[117] == 2671);
10799 assert_or_panic(v[118] == 2672);
10800 assert_or_panic(v[119] == 2673);
10801 assert_or_panic(v[120] == 2674);
10802 assert_or_panic(v[121] == 2675);
10803 assert_or_panic(v[122] == 2676);
10804 assert_or_panic(v[123] == 2677);
10805 assert_or_panic(v[124] == 2678);
10806 assert_or_panic(v[125] == 2679);
10807 assert_or_panic(v[126] == 2680);
10808 assert_or_panic(v[127] == 2681);
10809 assert_or_panic(v[128] == 2682);
10810 assert_or_panic(v[129] == 2683);
10811 assert_or_panic(v[130] == 2684);
10812 assert_or_panic(v[131] == 2685);
10813 assert_or_panic(v[132] == 2686);
10814 assert_or_panic(v[133] == 2687);
10815 assert_or_panic(v[134] == 2688);
10816 assert_or_panic(v[135] == 2689);
10817 assert_or_panic(v[136] == 2690);
10818 assert_or_panic(v[137] == 2691);
10819 assert_or_panic(v[138] == 2692);
10820 assert_or_panic(v[139] == 2693);
10821 assert_or_panic(v[140] == 2694);
10822 assert_or_panic(v[141] == 2695);
10823 assert_or_panic(v[142] == 2696);
10824 assert_or_panic(v[143] == 2697);
10825 assert_or_panic(v[144] == 2698);
10826 assert_or_panic(v[145] == 2699);
10827 assert_or_panic(v[146] == 2700);
10828 assert_or_panic(v[147] == 2701);
10829 assert_or_panic(v[148] == 2702);
10830 assert_or_panic(v[149] == 2703);
10831 assert_or_panic(v[150] == 2704);
10832 assert_or_panic(v[151] == 2705);
10833 assert_or_panic(v[152] == 2706);
10834 assert_or_panic(v[153] == 2707);
10835 assert_or_panic(v[154] == 2708);
10836 assert_or_panic(v[155] == 2709);
10837 assert_or_panic(v[156] == 2710);
10838 assert_or_panic(v[157] == 2711);
10839 assert_or_panic(v[158] == 2712);
10840 assert_or_panic(v[159] == 2713);
10841 assert_or_panic(v[160] == 2714);
10842 assert_or_panic(v[161] == 2715);
10843 assert_or_panic(v[162] == 2716);
10844 assert_or_panic(v[163] == 2717);
10845 assert_or_panic(v[164] == 2718);
10846 assert_or_panic(v[165] == 2719);
10847 assert_or_panic(v[166] == 2720);
10848 assert_or_panic(v[167] == 2721);
10849 assert_or_panic(v[168] == 2722);
10850 assert_or_panic(v[169] == 2723);
10851 assert_or_panic(v[170] == 2724);
10852 assert_or_panic(v[171] == 2725);
10853 assert_or_panic(v[172] == 2726);
10854 assert_or_panic(v[173] == 2727);
10855 assert_or_panic(v[174] == 2728);
10856 assert_or_panic(v[175] == 2729);
10857 assert_or_panic(v[176] == 2730);
10858 assert_or_panic(v[177] == 2731);
10859 assert_or_panic(v[178] == 2732);
10860 assert_or_panic(v[179] == 2733);
10861 assert_or_panic(v[180] == 2734);
10862 assert_or_panic(v[181] == 2735);
10863 assert_or_panic(v[182] == 2736);
10864 assert_or_panic(v[183] == 2737);
10865 assert_or_panic(v[184] == 2738);
10866 assert_or_panic(v[185] == 2739);
10867 assert_or_panic(v[186] == 2740);
10868 assert_or_panic(v[187] == 2741);
10869 assert_or_panic(v[188] == 2742);
10870 assert_or_panic(v[189] == 2743);
10871 assert_or_panic(v[190] == 2744);
10872 assert_or_panic(v[191] == 2745);
10873 assert_or_panic(v[192] == 2746);
10874 assert_or_panic(v[193] == 2747);
10875 assert_or_panic(v[194] == 2748);
10876 assert_or_panic(v[195] == 2749);
10877 assert_or_panic(v[196] == 2750);
10878 assert_or_panic(v[197] == 2751);
10879 assert_or_panic(v[198] == 2752);
10880 assert_or_panic(v[199] == 2753);
10881 assert_or_panic(v[200] == 2754);
10882 assert_or_panic(v[201] == 2755);
10883 assert_or_panic(v[202] == 2756);
10884 assert_or_panic(v[203] == 2757);
10885 assert_or_panic(v[204] == 2758);
10886 assert_or_panic(v[205] == 2759);
10887 assert_or_panic(v[206] == 2760);
10888 assert_or_panic(v[207] == 2761);
10889 assert_or_panic(v[208] == 2762);
10890 assert_or_panic(v[209] == 2763);
10891 assert_or_panic(v[210] == 2764);
10892 assert_or_panic(v[211] == 2765);
10893 assert_or_panic(v[212] == 2766);
10894 assert_or_panic(v[213] == 2767);
10895 assert_or_panic(v[214] == 2768);
10896 assert_or_panic(v[215] == 2769);
10897 assert_or_panic(v[216] == 2770);
10898 assert_or_panic(v[217] == 2771);
10899 assert_or_panic(v[218] == 2772);
10900 assert_or_panic(v[219] == 2773);
10901 assert_or_panic(v[220] == 2774);
10902 assert_or_panic(v[221] == 2775);
10903 assert_or_panic(v[222] == 2776);
10904 assert_or_panic(v[223] == 2777);
10905 assert_or_panic(v[224] == 2778);
10906 assert_or_panic(v[225] == 2779);
10907 assert_or_panic(v[226] == 2780);
10908 assert_or_panic(v[227] == 2781);
10909 assert_or_panic(v[228] == 2782);
10910 assert_or_panic(v[229] == 2783);
10911 assert_or_panic(v[230] == 2784);
10912 assert_or_panic(v[231] == 2785);
10913 assert_or_panic(v[232] == 2786);
10914 assert_or_panic(v[233] == 2787);
10915 assert_or_panic(v[234] == 2788);
10916 assert_or_panic(v[235] == 2789);
10917 assert_or_panic(v[236] == 2790);
10918 assert_or_panic(v[237] == 2791);
10919 assert_or_panic(v[238] == 2792);
10920 assert_or_panic(v[239] == 2793);
10921 assert_or_panic(v[240] == 2794);
10922 assert_or_panic(v[241] == 2795);
10923 assert_or_panic(v[242] == 2796);
10924 assert_or_panic(v[243] == 2797);
10925 assert_or_panic(v[244] == 2798);
10926 assert_or_panic(v[245] == 2799);
10927 assert_or_panic(v[246] == 2800);
10928 assert_or_panic(v[247] == 2801);
10929 assert_or_panic(v[248] == 2802);
10930 assert_or_panic(v[249] == 2803);
10931 assert_or_panic(v[250] == 2804);
10932 assert_or_panic(v[251] == 2805);
10933 assert_or_panic(v[252] == 2806);
10934 assert_or_panic(v[253] == 2807);
10935 assert_or_panic(v[254] == 2808);
10936 assert_or_panic(v[255] == 2809);
10937 zig_vector_256_u16((Vector_256_u16){
10938 2810, 2811, 2812, 2813, 2814, 2815, 2816, 2817, 2818, 2819, 2820, 2821, 2822, 2823, 2824, 2825,
10939 2826, 2827, 2828, 2829, 2830, 2831, 2832, 2833, 2834, 2835, 2836, 2837, 2838, 2839, 2840, 2841,
10940 2842, 2843, 2844, 2845, 2846, 2847, 2848, 2849, 2850, 2851, 2852, 2853, 2854, 2855, 2856, 2857,
10941 2858, 2859, 2860, 2861, 2862, 2863, 2864, 2865, 2866, 2867, 2868, 2869, 2870, 2871, 2872, 2873,
10942 2874, 2875, 2876, 2877, 2878, 2879, 2880, 2881, 2882, 2883, 2884, 2885, 2886, 2887, 2888, 2889,
10943 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899, 2900, 2901, 2902, 2903, 2904, 2905,
10944 2906, 2907, 2908, 2909, 2910, 2911, 2912, 2913, 2914, 2915, 2916, 2917, 2918, 2919, 2920, 2921,
10945 2922, 2923, 2924, 2925, 2926, 2927, 2928, 2929, 2930, 2931, 2932, 2933, 2934, 2935, 2936, 2937,
10946 2938, 2939, 2940, 2941, 2942, 2943, 2944, 2945, 2946, 2947, 2948, 2949, 2950, 2951, 2952, 2953,
10947 2954, 2955, 2956, 2957, 2958, 2959, 2960, 2961, 2962, 2963, 2964, 2965, 2966, 2967, 2968, 2969,
10948 2970, 2971, 2972, 2973, 2974, 2975, 2976, 2977, 2978, 2979, 2980, 2981, 2982, 2983, 2984, 2985,
10949 2986, 2987, 2988, 2989, 2990, 2991, 2992, 2993, 2994, 2995, 2996, 2997, 2998, 2999, 3000, 3001,
10950 3002, 3003, 3004, 3005, 3006, 3007, 3008, 3009, 3010, 3011, 3012, 3013, 3014, 3015, 3016, 3017,
10951 3018, 3019, 3020, 3021, 3022, 3023, 3024, 3025, 3026, 3027, 3028, 3029, 3030, 3031, 3032, 3033,
10952 3034, 3035, 3036, 3037, 3038, 3039, 3040, 3041, 3042, 3043, 3044, 3045, 3046, 3047, 3048, 3049,
10953 3050, 3051, 3052, 3053, 3054, 3055, 3056, 3057, 3058, 3059, 3060, 3061, 3062, 3063, 3064, 3065,
10954 }, 256);
10955}
10956
10957typedef uint32_t Vector_1_u32 __attribute__((vector_size(1 * sizeof(uint32_t))));
10958
10959Vector_1_u32 zig_ret_vector_1_u32(void);
10960void zig_vector_1_u32(Vector_1_u32, size_t);
10961
10962Vector_1_u32 c_ret_vector_1_u32(void) {
10963 return (Vector_1_u32){ 3 };
10964}
10965void c_vector_1_u32(Vector_1_u32 v, size_t i) {
10966 assert_or_panic(v[0] == 4);
10967 assert_or_panic(i == 1);
10968}
10969void c_test_vector_1_u32(void) {
10970 Vector_1_u32 v = zig_ret_vector_1_u32();
10971 assert_or_panic(v[0] == 1);
10972 zig_vector_1_u32((Vector_1_u32){ 2 }, 1);
10973}
10974
10975typedef uint32_t Vector_2_u32 __attribute__((vector_size(2 * sizeof(uint32_t))));
10976
10977Vector_2_u32 zig_ret_vector_2_u32(void);
10978void zig_vector_2_u32(Vector_2_u32, size_t);
10979
10980Vector_2_u32 c_ret_vector_2_u32(void) {
10981 return (Vector_2_u32){ 9, 10 };
10982}
10983void c_vector_2_u32(Vector_2_u32 v, size_t i) {
10984 assert_or_panic(v[0] == 11);
10985 assert_or_panic(v[1] == 12);
10986 assert_or_panic(i == 2);
10987}
10988void c_test_vector_2_u32(void) {
10989 Vector_2_u32 v = zig_ret_vector_2_u32();
10990 assert_or_panic(v[0] == 5);
10991 assert_or_panic(v[1] == 6);
10992 zig_vector_2_u32((Vector_2_u32){ 7, 8 }, 2);
10993}
10994
10995typedef uint32_t Vector_3_u32 __attribute__((vector_size(3 * sizeof(uint32_t))));
10996
10997Vector_3_u32 zig_ret_vector_3_u32(void);
10998void zig_vector_3_u32(Vector_3_u32, size_t);
10999
11000Vector_3_u32 c_ret_vector_3_u32(void) {
11001 return (Vector_3_u32){ 19, 20, 21 };
11002}
11003void c_vector_3_u32(Vector_3_u32 v, size_t i) {
11004 assert_or_panic(v[0] == 22);
11005 assert_or_panic(v[1] == 23);
11006 assert_or_panic(v[2] == 24);
11007 assert_or_panic(i == 3);
11008}
11009void c_test_vector_3_u32(void) {
11010 Vector_3_u32 v = zig_ret_vector_3_u32();
11011 assert_or_panic(v[0] == 13);
11012 assert_or_panic(v[1] == 14);
11013 assert_or_panic(v[2] == 15);
11014 zig_vector_3_u32((Vector_3_u32){ 16, 17, 18 }, 3);
11015}
11016
11017typedef uint32_t Vector_4_u32 __attribute__((vector_size(4 * sizeof(uint32_t))));
11018
11019Vector_4_u32 zig_ret_vector_4_u32(void);
11020
11021void zig_vector_4_u32(Vector_4_u32, size_t);
11022void zig_vector_4_u32_vector_4_u32(Vector_4_u32, Vector_4_u32, size_t);
11023
11024Vector_4_u32 c_ret_vector_4_u32(void) {
11025 return (Vector_4_u32){ 41, 42, 43, 44 };
11026}
11027void c_vector_4_u32(Vector_4_u32 v, size_t i) {
11028 assert_or_panic(v[0] == 45);
11029 assert_or_panic(v[1] == 46);
11030 assert_or_panic(v[2] == 47);
11031 assert_or_panic(v[3] == 48);
11032 assert_or_panic(i == 4);
11033}
11034void c_vector_4_u32_vector_4_u32(Vector_4_u32 v0, Vector_4_u32 v1, size_t i) {
11035 assert_or_panic(v0[0] == 49);
11036 assert_or_panic(v0[1] == 50);
11037 assert_or_panic(v0[2] == 51);
11038 assert_or_panic(v0[3] == 52);
11039 assert_or_panic(v1[0] == 53);
11040 assert_or_panic(v1[1] == 54);
11041 assert_or_panic(v1[2] == 55);
11042 assert_or_panic(v1[3] == 56);
11043 assert_or_panic(i == 8);
11044}
11045void c_test_vector_4_u32(void) {
11046 Vector_4_u32 v = zig_ret_vector_4_u32();
11047 assert_or_panic(v[0] == 25);
11048 assert_or_panic(v[1] == 26);
11049 assert_or_panic(v[2] == 27);
11050 assert_or_panic(v[3] == 28);
11051 zig_vector_4_u32((Vector_4_u32){ 29, 30, 31, 32 }, 4);
11052 zig_vector_4_u32_vector_4_u32((Vector_4_u32){ 33, 34, 35, 36 }, (Vector_4_u32){ 37, 38, 39, 40 }, 8);
11053}
11054
11055typedef uint32_t Vector_6_u32 __attribute__((vector_size(6 * sizeof(uint32_t))));
11056
11057Vector_6_u32 zig_ret_vector_6_u32(void);
11058void zig_vector_6_u32(Vector_6_u32, size_t);
11059
11060Vector_6_u32 c_ret_vector_6_u32(void) {
11061 return (Vector_6_u32){ 53, 54, 55, 56, 57, 58 };
11062}
11063void c_vector_6_u32(Vector_6_u32 v, size_t i) {
11064 assert_or_panic(v[0] == 59);
11065 assert_or_panic(v[1] == 60);
11066 assert_or_panic(v[2] == 61);
11067 assert_or_panic(v[3] == 62);
11068 assert_or_panic(v[4] == 63);
11069 assert_or_panic(v[5] == 64);
11070 assert_or_panic(i == 6);
11071}
11072void c_test_vector_6_u32(void) {
11073 Vector_6_u32 v = zig_ret_vector_6_u32();
11074 assert_or_panic(v[0] == 41);
11075 assert_or_panic(v[1] == 42);
11076 assert_or_panic(v[2] == 43);
11077 assert_or_panic(v[3] == 44);
11078 assert_or_panic(v[4] == 45);
11079 assert_or_panic(v[5] == 46);
11080 zig_vector_6_u32((Vector_6_u32){ 47, 48, 49, 50, 51, 52 }, 6);
11081}
11082
11083typedef uint32_t Vector_8_u32 __attribute__((vector_size(8 * sizeof(uint32_t))));
11084
11085Vector_8_u32 zig_ret_vector_8_u32(void);
11086void zig_vector_8_u32(Vector_8_u32, size_t);
11087
11088Vector_8_u32 c_ret_vector_8_u32(void) {
11089 return (Vector_8_u32){ 81, 82, 83, 84, 85, 86, 87, 88 };
11090}
11091void c_vector_8_u32(Vector_8_u32 v, size_t i) {
11092 assert_or_panic(v[0] == 89);
11093 assert_or_panic(v[1] == 90);
11094 assert_or_panic(v[2] == 91);
11095 assert_or_panic(v[3] == 92);
11096 assert_or_panic(v[4] == 93);
11097 assert_or_panic(v[5] == 94);
11098 assert_or_panic(v[6] == 95);
11099 assert_or_panic(v[7] == 96);
11100 assert_or_panic(i == 8);
11101}
11102void c_test_vector_8_u32(void) {
11103 Vector_8_u32 v = zig_ret_vector_8_u32();
11104 assert_or_panic(v[0] == 65);
11105 assert_or_panic(v[1] == 66);
11106 assert_or_panic(v[2] == 67);
11107 assert_or_panic(v[3] == 68);
11108 assert_or_panic(v[4] == 69);
11109 assert_or_panic(v[5] == 70);
11110 assert_or_panic(v[6] == 71);
11111 assert_or_panic(v[7] == 72);
11112 zig_vector_8_u32((Vector_8_u32){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
11113}
11114
11115typedef uint32_t Vector_12_u32 __attribute__((vector_size(12 * sizeof(uint32_t))));
11116
11117Vector_12_u32 zig_ret_vector_12_u32(void);
11118void zig_vector_12_u32(Vector_12_u32, size_t);
11119
11120Vector_12_u32 c_ret_vector_12_u32(void) {
11121 return (Vector_12_u32){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
11122}
11123void c_vector_12_u32(Vector_12_u32 v, size_t i) {
11124 assert_or_panic(v[0] == 133);
11125 assert_or_panic(v[1] == 134);
11126 assert_or_panic(v[2] == 135);
11127 assert_or_panic(v[3] == 136);
11128 assert_or_panic(v[4] == 137);
11129 assert_or_panic(v[5] == 138);
11130 assert_or_panic(v[6] == 139);
11131 assert_or_panic(v[7] == 140);
11132 assert_or_panic(v[8] == 141);
11133 assert_or_panic(v[9] == 142);
11134 assert_or_panic(v[10] == 143);
11135 assert_or_panic(v[11] == 144);
11136 assert_or_panic(i == 12);
11137}
11138void c_test_vector_12_u32(void) {
11139 Vector_12_u32 v = zig_ret_vector_12_u32();
11140 assert_or_panic(v[0] == 97);
11141 assert_or_panic(v[1] == 98);
11142 assert_or_panic(v[2] == 99);
11143 assert_or_panic(v[3] == 100);
11144 assert_or_panic(v[4] == 101);
11145 assert_or_panic(v[5] == 102);
11146 assert_or_panic(v[6] == 103);
11147 assert_or_panic(v[7] == 104);
11148 assert_or_panic(v[8] == 105);
11149 assert_or_panic(v[9] == 106);
11150 assert_or_panic(v[10] == 107);
11151 assert_or_panic(v[11] == 108);
11152 zig_vector_12_u32((Vector_12_u32){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
11153}
11154
11155typedef uint32_t Vector_16_u32 __attribute__((vector_size(16 * sizeof(uint32_t))));
11156
11157Vector_16_u32 zig_ret_vector_16_u32(void);
11158void zig_vector_16_u32(Vector_16_u32, size_t);
11159
11160Vector_16_u32 c_ret_vector_16_u32(void) {
11161 return (Vector_16_u32){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
11162}
11163void c_vector_16_u32(Vector_16_u32 v, size_t i) {
11164 assert_or_panic(v[0] == 193);
11165 assert_or_panic(v[1] == 194);
11166 assert_or_panic(v[2] == 195);
11167 assert_or_panic(v[3] == 196);
11168 assert_or_panic(v[4] == 197);
11169 assert_or_panic(v[5] == 198);
11170 assert_or_panic(v[6] == 199);
11171 assert_or_panic(v[7] == 200);
11172 assert_or_panic(v[8] == 201);
11173 assert_or_panic(v[9] == 202);
11174 assert_or_panic(v[10] == 203);
11175 assert_or_panic(v[11] == 204);
11176 assert_or_panic(v[12] == 205);
11177 assert_or_panic(v[13] == 206);
11178 assert_or_panic(v[14] == 207);
11179 assert_or_panic(v[15] == 208);
11180 assert_or_panic(i == 16);
11181}
11182void c_test_vector_16_u32(void) {
11183 Vector_16_u32 v = zig_ret_vector_16_u32();
11184 assert_or_panic(v[0] == 145);
11185 assert_or_panic(v[1] == 146);
11186 assert_or_panic(v[2] == 147);
11187 assert_or_panic(v[3] == 148);
11188 assert_or_panic(v[4] == 149);
11189 assert_or_panic(v[5] == 150);
11190 assert_or_panic(v[6] == 151);
11191 assert_or_panic(v[7] == 152);
11192 assert_or_panic(v[8] == 153);
11193 assert_or_panic(v[9] == 154);
11194 assert_or_panic(v[10] == 155);
11195 assert_or_panic(v[11] == 156);
11196 assert_or_panic(v[12] == 157);
11197 assert_or_panic(v[13] == 158);
11198 assert_or_panic(v[14] == 159);
11199 assert_or_panic(v[15] == 160);
11200 zig_vector_16_u32((Vector_16_u32){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
11201}
11202
11203typedef uint32_t Vector_24_u32 __attribute__((vector_size(24 * sizeof(uint32_t))));
11204
11205Vector_24_u32 zig_ret_vector_24_u32(void);
11206void zig_vector_24_u32(Vector_24_u32, size_t);
11207
11208Vector_24_u32 c_ret_vector_24_u32(void) {
11209 return (Vector_24_u32){
11210 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
11211 273, 274, 275, 276, 277, 278, 279, 280,
11212 };
11213}
11214void c_vector_24_u32(Vector_24_u32 v, size_t i) {
11215 assert_or_panic(v[0] == 281);
11216 assert_or_panic(v[1] == 282);
11217 assert_or_panic(v[2] == 283);
11218 assert_or_panic(v[3] == 284);
11219 assert_or_panic(v[4] == 285);
11220 assert_or_panic(v[5] == 286);
11221 assert_or_panic(v[6] == 287);
11222 assert_or_panic(v[7] == 288);
11223 assert_or_panic(v[8] == 289);
11224 assert_or_panic(v[9] == 290);
11225 assert_or_panic(v[10] == 291);
11226 assert_or_panic(v[11] == 292);
11227 assert_or_panic(v[12] == 293);
11228 assert_or_panic(v[13] == 294);
11229 assert_or_panic(v[14] == 295);
11230 assert_or_panic(v[15] == 296);
11231 assert_or_panic(v[16] == 297);
11232 assert_or_panic(v[17] == 298);
11233 assert_or_panic(v[18] == 299);
11234 assert_or_panic(v[19] == 300);
11235 assert_or_panic(v[20] == 301);
11236 assert_or_panic(v[21] == 302);
11237 assert_or_panic(v[22] == 303);
11238 assert_or_panic(v[23] == 304);
11239 assert_or_panic(i == 24);
11240}
11241void c_test_vector_24_u32(void) {
11242 Vector_24_u32 v = zig_ret_vector_24_u32();
11243 assert_or_panic(v[0] == 209);
11244 assert_or_panic(v[1] == 210);
11245 assert_or_panic(v[2] == 211);
11246 assert_or_panic(v[3] == 212);
11247 assert_or_panic(v[4] == 213);
11248 assert_or_panic(v[5] == 214);
11249 assert_or_panic(v[6] == 215);
11250 assert_or_panic(v[7] == 216);
11251 assert_or_panic(v[8] == 217);
11252 assert_or_panic(v[9] == 218);
11253 assert_or_panic(v[10] == 219);
11254 assert_or_panic(v[11] == 220);
11255 assert_or_panic(v[12] == 221);
11256 assert_or_panic(v[13] == 222);
11257 assert_or_panic(v[14] == 223);
11258 assert_or_panic(v[15] == 224);
11259 assert_or_panic(v[16] == 225);
11260 assert_or_panic(v[17] == 226);
11261 assert_or_panic(v[18] == 227);
11262 assert_or_panic(v[19] == 228);
11263 assert_or_panic(v[20] == 229);
11264 assert_or_panic(v[21] == 230);
11265 assert_or_panic(v[22] == 231);
11266 assert_or_panic(v[23] == 232);
11267 zig_vector_24_u32((Vector_24_u32){
11268 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
11269 249, 250, 251, 252, 253, 254, 255, 256,
11270 }, 24);
11271}
11272
11273typedef uint32_t Vector_32_u32 __attribute__((vector_size(32 * sizeof(uint32_t))));
11274
11275Vector_32_u32 zig_ret_vector_32_u32(void);
11276void zig_vector_32_u32(Vector_32_u32, size_t);
11277
11278Vector_32_u32 c_ret_vector_32_u32(void) {
11279 return (Vector_32_u32){
11280 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
11281 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
11282 };
11283}
11284void c_vector_32_u32(Vector_32_u32 v, size_t i) {
11285 assert_or_panic(v[0] == 401);
11286 assert_or_panic(v[1] == 402);
11287 assert_or_panic(v[2] == 403);
11288 assert_or_panic(v[3] == 404);
11289 assert_or_panic(v[4] == 405);
11290 assert_or_panic(v[5] == 406);
11291 assert_or_panic(v[6] == 407);
11292 assert_or_panic(v[7] == 408);
11293 assert_or_panic(v[8] == 409);
11294 assert_or_panic(v[9] == 410);
11295 assert_or_panic(v[10] == 411);
11296 assert_or_panic(v[11] == 412);
11297 assert_or_panic(v[12] == 413);
11298 assert_or_panic(v[13] == 414);
11299 assert_or_panic(v[14] == 415);
11300 assert_or_panic(v[15] == 416);
11301 assert_or_panic(v[16] == 417);
11302 assert_or_panic(v[17] == 418);
11303 assert_or_panic(v[18] == 419);
11304 assert_or_panic(v[19] == 420);
11305 assert_or_panic(v[20] == 421);
11306 assert_or_panic(v[21] == 422);
11307 assert_or_panic(v[22] == 423);
11308 assert_or_panic(v[23] == 424);
11309 assert_or_panic(v[24] == 425);
11310 assert_or_panic(v[25] == 426);
11311 assert_or_panic(v[26] == 427);
11312 assert_or_panic(v[27] == 428);
11313 assert_or_panic(v[28] == 429);
11314 assert_or_panic(v[29] == 430);
11315 assert_or_panic(v[30] == 431);
11316 assert_or_panic(v[31] == 432);
11317 assert_or_panic(i == 32);
11318}
11319void c_test_vector_32_u32(void) {
11320 Vector_32_u32 v = zig_ret_vector_32_u32();
11321 assert_or_panic(v[0] == 305);
11322 assert_or_panic(v[1] == 306);
11323 assert_or_panic(v[2] == 307);
11324 assert_or_panic(v[3] == 308);
11325 assert_or_panic(v[4] == 309);
11326 assert_or_panic(v[5] == 310);
11327 assert_or_panic(v[6] == 311);
11328 assert_or_panic(v[7] == 312);
11329 assert_or_panic(v[8] == 313);
11330 assert_or_panic(v[9] == 314);
11331 assert_or_panic(v[10] == 315);
11332 assert_or_panic(v[11] == 316);
11333 assert_or_panic(v[12] == 317);
11334 assert_or_panic(v[13] == 318);
11335 assert_or_panic(v[14] == 319);
11336 assert_or_panic(v[15] == 320);
11337 assert_or_panic(v[16] == 321);
11338 assert_or_panic(v[17] == 322);
11339 assert_or_panic(v[18] == 323);
11340 assert_or_panic(v[19] == 324);
11341 assert_or_panic(v[20] == 325);
11342 assert_or_panic(v[21] == 326);
11343 assert_or_panic(v[22] == 327);
11344 assert_or_panic(v[23] == 328);
11345 assert_or_panic(v[24] == 329);
11346 assert_or_panic(v[25] == 330);
11347 assert_or_panic(v[26] == 331);
11348 assert_or_panic(v[27] == 332);
11349 assert_or_panic(v[28] == 333);
11350 assert_or_panic(v[29] == 334);
11351 assert_or_panic(v[30] == 335);
11352 assert_or_panic(v[31] == 336);
11353 zig_vector_32_u32((Vector_32_u32){
11354 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
11355 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
11356 }, 32);
11357}
11358
11359typedef uint32_t Vector_48_u32 __attribute__((vector_size(48 * sizeof(uint32_t))));
11360
11361Vector_48_u32 zig_ret_vector_48_u32(void);
11362void zig_vector_48_u32(Vector_48_u32, size_t);
11363
11364Vector_48_u32 c_ret_vector_48_u32(void) {
11365 return (Vector_48_u32){
11366 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
11367 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
11368 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
11369 };
11370}
11371void c_vector_48_u32(Vector_48_u32 v, size_t i) {
11372 assert_or_panic(v[0] == 577);
11373 assert_or_panic(v[1] == 578);
11374 assert_or_panic(v[2] == 579);
11375 assert_or_panic(v[3] == 580);
11376 assert_or_panic(v[4] == 581);
11377 assert_or_panic(v[5] == 582);
11378 assert_or_panic(v[6] == 583);
11379 assert_or_panic(v[7] == 584);
11380 assert_or_panic(v[8] == 585);
11381 assert_or_panic(v[9] == 586);
11382 assert_or_panic(v[10] == 587);
11383 assert_or_panic(v[11] == 588);
11384 assert_or_panic(v[12] == 589);
11385 assert_or_panic(v[13] == 590);
11386 assert_or_panic(v[14] == 591);
11387 assert_or_panic(v[15] == 592);
11388 assert_or_panic(v[16] == 593);
11389 assert_or_panic(v[17] == 594);
11390 assert_or_panic(v[18] == 595);
11391 assert_or_panic(v[19] == 596);
11392 assert_or_panic(v[20] == 597);
11393 assert_or_panic(v[21] == 598);
11394 assert_or_panic(v[22] == 599);
11395 assert_or_panic(v[23] == 600);
11396 assert_or_panic(v[24] == 601);
11397 assert_or_panic(v[25] == 602);
11398 assert_or_panic(v[26] == 603);
11399 assert_or_panic(v[27] == 604);
11400 assert_or_panic(v[28] == 605);
11401 assert_or_panic(v[29] == 606);
11402 assert_or_panic(v[30] == 607);
11403 assert_or_panic(v[31] == 608);
11404 assert_or_panic(v[32] == 609);
11405 assert_or_panic(v[33] == 610);
11406 assert_or_panic(v[34] == 611);
11407 assert_or_panic(v[35] == 612);
11408 assert_or_panic(v[36] == 613);
11409 assert_or_panic(v[37] == 614);
11410 assert_or_panic(v[38] == 615);
11411 assert_or_panic(v[39] == 616);
11412 assert_or_panic(v[40] == 617);
11413 assert_or_panic(v[41] == 618);
11414 assert_or_panic(v[42] == 619);
11415 assert_or_panic(v[43] == 620);
11416 assert_or_panic(v[44] == 621);
11417 assert_or_panic(v[45] == 622);
11418 assert_or_panic(v[46] == 623);
11419 assert_or_panic(v[47] == 624);
11420 assert_or_panic(i == 48);
11421}
11422void c_test_vector_48_u32(void) {
11423 Vector_48_u32 v = zig_ret_vector_48_u32();
11424 assert_or_panic(v[0] == 433);
11425 assert_or_panic(v[1] == 434);
11426 assert_or_panic(v[2] == 435);
11427 assert_or_panic(v[3] == 436);
11428 assert_or_panic(v[4] == 437);
11429 assert_or_panic(v[5] == 438);
11430 assert_or_panic(v[6] == 439);
11431 assert_or_panic(v[7] == 440);
11432 assert_or_panic(v[8] == 441);
11433 assert_or_panic(v[9] == 442);
11434 assert_or_panic(v[10] == 443);
11435 assert_or_panic(v[11] == 444);
11436 assert_or_panic(v[12] == 445);
11437 assert_or_panic(v[13] == 446);
11438 assert_or_panic(v[14] == 447);
11439 assert_or_panic(v[15] == 448);
11440 assert_or_panic(v[16] == 449);
11441 assert_or_panic(v[17] == 450);
11442 assert_or_panic(v[18] == 451);
11443 assert_or_panic(v[19] == 452);
11444 assert_or_panic(v[20] == 453);
11445 assert_or_panic(v[21] == 454);
11446 assert_or_panic(v[22] == 455);
11447 assert_or_panic(v[23] == 456);
11448 assert_or_panic(v[24] == 457);
11449 assert_or_panic(v[25] == 458);
11450 assert_or_panic(v[26] == 459);
11451 assert_or_panic(v[27] == 460);
11452 assert_or_panic(v[28] == 461);
11453 assert_or_panic(v[29] == 462);
11454 assert_or_panic(v[30] == 463);
11455 assert_or_panic(v[31] == 464);
11456 assert_or_panic(v[32] == 465);
11457 assert_or_panic(v[33] == 466);
11458 assert_or_panic(v[34] == 467);
11459 assert_or_panic(v[35] == 468);
11460 assert_or_panic(v[36] == 469);
11461 assert_or_panic(v[37] == 470);
11462 assert_or_panic(v[38] == 471);
11463 assert_or_panic(v[39] == 472);
11464 assert_or_panic(v[40] == 473);
11465 assert_or_panic(v[41] == 474);
11466 assert_or_panic(v[42] == 475);
11467 assert_or_panic(v[43] == 476);
11468 assert_or_panic(v[44] == 477);
11469 assert_or_panic(v[45] == 478);
11470 assert_or_panic(v[46] == 479);
11471 assert_or_panic(v[47] == 480);
11472 zig_vector_48_u32((Vector_48_u32){
11473 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
11474 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
11475 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
11476 }, 48);
11477}
11478
11479typedef uint32_t Vector_64_u32 __attribute__((vector_size(64 * sizeof(uint32_t))));
11480
11481Vector_64_u32 zig_ret_vector_64_u32(void);
11482void zig_vector_64_u32(Vector_64_u32, size_t);
11483
11484Vector_64_u32 c_ret_vector_64_u32(void) {
11485 return (Vector_64_u32){
11486 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
11487 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
11488 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
11489 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
11490 };
11491}
11492void c_vector_64_u32(Vector_64_u32 v, size_t i) {
11493 assert_or_panic(v[0] == 817);
11494 assert_or_panic(v[1] == 818);
11495 assert_or_panic(v[2] == 819);
11496 assert_or_panic(v[3] == 820);
11497 assert_or_panic(v[4] == 821);
11498 assert_or_panic(v[5] == 822);
11499 assert_or_panic(v[6] == 823);
11500 assert_or_panic(v[7] == 824);
11501 assert_or_panic(v[8] == 825);
11502 assert_or_panic(v[9] == 826);
11503 assert_or_panic(v[10] == 827);
11504 assert_or_panic(v[11] == 828);
11505 assert_or_panic(v[12] == 829);
11506 assert_or_panic(v[13] == 830);
11507 assert_or_panic(v[14] == 831);
11508 assert_or_panic(v[15] == 832);
11509 assert_or_panic(v[16] == 833);
11510 assert_or_panic(v[17] == 834);
11511 assert_or_panic(v[18] == 835);
11512 assert_or_panic(v[19] == 836);
11513 assert_or_panic(v[20] == 837);
11514 assert_or_panic(v[21] == 838);
11515 assert_or_panic(v[22] == 839);
11516 assert_or_panic(v[23] == 840);
11517 assert_or_panic(v[24] == 841);
11518 assert_or_panic(v[25] == 842);
11519 assert_or_panic(v[26] == 843);
11520 assert_or_panic(v[27] == 844);
11521 assert_or_panic(v[28] == 845);
11522 assert_or_panic(v[29] == 846);
11523 assert_or_panic(v[30] == 847);
11524 assert_or_panic(v[31] == 848);
11525 assert_or_panic(v[32] == 849);
11526 assert_or_panic(v[33] == 850);
11527 assert_or_panic(v[34] == 851);
11528 assert_or_panic(v[35] == 852);
11529 assert_or_panic(v[36] == 853);
11530 assert_or_panic(v[37] == 854);
11531 assert_or_panic(v[38] == 855);
11532 assert_or_panic(v[39] == 856);
11533 assert_or_panic(v[40] == 857);
11534 assert_or_panic(v[41] == 858);
11535 assert_or_panic(v[42] == 859);
11536 assert_or_panic(v[43] == 860);
11537 assert_or_panic(v[44] == 861);
11538 assert_or_panic(v[45] == 862);
11539 assert_or_panic(v[46] == 863);
11540 assert_or_panic(v[47] == 864);
11541 assert_or_panic(v[48] == 865);
11542 assert_or_panic(v[49] == 866);
11543 assert_or_panic(v[50] == 867);
11544 assert_or_panic(v[51] == 868);
11545 assert_or_panic(v[52] == 869);
11546 assert_or_panic(v[53] == 870);
11547 assert_or_panic(v[54] == 871);
11548 assert_or_panic(v[55] == 872);
11549 assert_or_panic(v[56] == 873);
11550 assert_or_panic(v[57] == 874);
11551 assert_or_panic(v[58] == 875);
11552 assert_or_panic(v[59] == 876);
11553 assert_or_panic(v[60] == 877);
11554 assert_or_panic(v[61] == 878);
11555 assert_or_panic(v[62] == 879);
11556 assert_or_panic(v[63] == 880);
11557 assert_or_panic(i == 64);
11558}
11559void c_test_vector_64_u32(void) {
11560 Vector_64_u32 v = zig_ret_vector_64_u32();
11561 assert_or_panic(v[0] == 625);
11562 assert_or_panic(v[1] == 626);
11563 assert_or_panic(v[2] == 627);
11564 assert_or_panic(v[3] == 628);
11565 assert_or_panic(v[4] == 629);
11566 assert_or_panic(v[5] == 630);
11567 assert_or_panic(v[6] == 631);
11568 assert_or_panic(v[7] == 632);
11569 assert_or_panic(v[8] == 633);
11570 assert_or_panic(v[9] == 634);
11571 assert_or_panic(v[10] == 635);
11572 assert_or_panic(v[11] == 636);
11573 assert_or_panic(v[12] == 637);
11574 assert_or_panic(v[13] == 638);
11575 assert_or_panic(v[14] == 639);
11576 assert_or_panic(v[15] == 640);
11577 assert_or_panic(v[16] == 641);
11578 assert_or_panic(v[17] == 642);
11579 assert_or_panic(v[18] == 643);
11580 assert_or_panic(v[19] == 644);
11581 assert_or_panic(v[20] == 645);
11582 assert_or_panic(v[21] == 646);
11583 assert_or_panic(v[22] == 647);
11584 assert_or_panic(v[23] == 648);
11585 assert_or_panic(v[24] == 649);
11586 assert_or_panic(v[25] == 650);
11587 assert_or_panic(v[26] == 651);
11588 assert_or_panic(v[27] == 652);
11589 assert_or_panic(v[28] == 653);
11590 assert_or_panic(v[29] == 654);
11591 assert_or_panic(v[30] == 655);
11592 assert_or_panic(v[31] == 656);
11593 assert_or_panic(v[32] == 657);
11594 assert_or_panic(v[33] == 658);
11595 assert_or_panic(v[34] == 659);
11596 assert_or_panic(v[35] == 660);
11597 assert_or_panic(v[36] == 661);
11598 assert_or_panic(v[37] == 662);
11599 assert_or_panic(v[38] == 663);
11600 assert_or_panic(v[39] == 664);
11601 assert_or_panic(v[40] == 665);
11602 assert_or_panic(v[41] == 666);
11603 assert_or_panic(v[42] == 667);
11604 assert_or_panic(v[43] == 668);
11605 assert_or_panic(v[44] == 669);
11606 assert_or_panic(v[45] == 670);
11607 assert_or_panic(v[46] == 671);
11608 assert_or_panic(v[47] == 672);
11609 assert_or_panic(v[48] == 673);
11610 assert_or_panic(v[49] == 674);
11611 assert_or_panic(v[50] == 675);
11612 assert_or_panic(v[51] == 676);
11613 assert_or_panic(v[52] == 677);
11614 assert_or_panic(v[53] == 678);
11615 assert_or_panic(v[54] == 679);
11616 assert_or_panic(v[55] == 680);
11617 assert_or_panic(v[56] == 681);
11618 assert_or_panic(v[57] == 682);
11619 assert_or_panic(v[58] == 683);
11620 assert_or_panic(v[59] == 684);
11621 assert_or_panic(v[60] == 685);
11622 assert_or_panic(v[61] == 686);
11623 assert_or_panic(v[62] == 687);
11624 assert_or_panic(v[63] == 688);
11625 zig_vector_64_u32((Vector_64_u32){
11626 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
11627 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
11628 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
11629 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
11630 }, 64);
11631}
11632
11633typedef uint32_t Vector_96_u32 __attribute__((vector_size(96 * sizeof(uint32_t))));
11634
11635Vector_96_u32 zig_ret_vector_96_u32(void);
11636void zig_vector_96_u32(Vector_96_u32, size_t);
11637
11638Vector_96_u32 c_ret_vector_96_u32(void) {
11639 return (Vector_96_u32){
11640 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
11641 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
11642 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
11643 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
11644 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
11645 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
11646 };
11647}
11648void c_vector_96_u32(Vector_96_u32 v, size_t i) {
11649 assert_or_panic(v[0] == 1178);
11650 assert_or_panic(v[1] == 1179);
11651 assert_or_panic(v[2] == 1180);
11652 assert_or_panic(v[3] == 1181);
11653 assert_or_panic(v[4] == 1182);
11654 assert_or_panic(v[5] == 1183);
11655 assert_or_panic(v[6] == 1184);
11656 assert_or_panic(v[7] == 1185);
11657 assert_or_panic(v[8] == 1186);
11658 assert_or_panic(v[9] == 1187);
11659 assert_or_panic(v[10] == 1188);
11660 assert_or_panic(v[11] == 1189);
11661 assert_or_panic(v[12] == 1190);
11662 assert_or_panic(v[13] == 1191);
11663 assert_or_panic(v[14] == 1192);
11664 assert_or_panic(v[15] == 1193);
11665 assert_or_panic(v[16] == 1194);
11666 assert_or_panic(v[17] == 1195);
11667 assert_or_panic(v[18] == 1196);
11668 assert_or_panic(v[19] == 1197);
11669 assert_or_panic(v[20] == 1198);
11670 assert_or_panic(v[21] == 1199);
11671 assert_or_panic(v[22] == 1200);
11672 assert_or_panic(v[23] == 1201);
11673 assert_or_panic(v[24] == 1202);
11674 assert_or_panic(v[25] == 1203);
11675 assert_or_panic(v[26] == 1204);
11676 assert_or_panic(v[27] == 1205);
11677 assert_or_panic(v[28] == 1206);
11678 assert_or_panic(v[29] == 1207);
11679 assert_or_panic(v[30] == 1208);
11680 assert_or_panic(v[31] == 1209);
11681 assert_or_panic(v[32] == 1210);
11682 assert_or_panic(v[33] == 1211);
11683 assert_or_panic(v[34] == 1212);
11684 assert_or_panic(v[35] == 1213);
11685 assert_or_panic(v[36] == 1214);
11686 assert_or_panic(v[37] == 1215);
11687 assert_or_panic(v[38] == 1216);
11688 assert_or_panic(v[39] == 1217);
11689 assert_or_panic(v[40] == 1218);
11690 assert_or_panic(v[41] == 1219);
11691 assert_or_panic(v[42] == 1220);
11692 assert_or_panic(v[43] == 1221);
11693 assert_or_panic(v[44] == 1222);
11694 assert_or_panic(v[45] == 1223);
11695 assert_or_panic(v[46] == 1224);
11696 assert_or_panic(v[47] == 1225);
11697 assert_or_panic(v[48] == 1226);
11698 assert_or_panic(v[49] == 1227);
11699 assert_or_panic(v[50] == 1228);
11700 assert_or_panic(v[51] == 1229);
11701 assert_or_panic(v[52] == 1230);
11702 assert_or_panic(v[53] == 1231);
11703 assert_or_panic(v[54] == 1232);
11704 assert_or_panic(v[55] == 1233);
11705 assert_or_panic(v[56] == 1234);
11706 assert_or_panic(v[57] == 1235);
11707 assert_or_panic(v[58] == 1236);
11708 assert_or_panic(v[59] == 1237);
11709 assert_or_panic(v[60] == 1238);
11710 assert_or_panic(v[61] == 1239);
11711 assert_or_panic(v[62] == 1240);
11712 assert_or_panic(v[63] == 1241);
11713 assert_or_panic(v[64] == 1242);
11714 assert_or_panic(v[65] == 1243);
11715 assert_or_panic(v[66] == 1244);
11716 assert_or_panic(v[67] == 1245);
11717 assert_or_panic(v[68] == 1246);
11718 assert_or_panic(v[69] == 1247);
11719 assert_or_panic(v[70] == 1248);
11720 assert_or_panic(v[71] == 1249);
11721 assert_or_panic(v[72] == 1250);
11722 assert_or_panic(v[73] == 1251);
11723 assert_or_panic(v[74] == 1252);
11724 assert_or_panic(v[75] == 1253);
11725 assert_or_panic(v[76] == 1254);
11726 assert_or_panic(v[77] == 1255);
11727 assert_or_panic(v[80] == 1258);
11728 assert_or_panic(v[81] == 1259);
11729 assert_or_panic(v[82] == 1260);
11730 assert_or_panic(v[83] == 1261);
11731 assert_or_panic(v[84] == 1262);
11732 assert_or_panic(v[85] == 1263);
11733 assert_or_panic(v[86] == 1264);
11734 assert_or_panic(v[87] == 1265);
11735 assert_or_panic(v[88] == 1266);
11736 assert_or_panic(v[89] == 1267);
11737 assert_or_panic(v[90] == 1268);
11738 assert_or_panic(v[91] == 1269);
11739 assert_or_panic(v[92] == 1270);
11740 assert_or_panic(v[93] == 1271);
11741 assert_or_panic(v[94] == 1272);
11742 assert_or_panic(v[95] == 1273);
11743 assert_or_panic(i == 96);
11744}
11745void c_test_vector_96_u32(void) {
11746 Vector_96_u32 v = zig_ret_vector_96_u32();
11747 assert_or_panic(v[0] == 890);
11748 assert_or_panic(v[1] == 891);
11749 assert_or_panic(v[2] == 892);
11750 assert_or_panic(v[3] == 893);
11751 assert_or_panic(v[4] == 894);
11752 assert_or_panic(v[5] == 895);
11753 assert_or_panic(v[6] == 896);
11754 assert_or_panic(v[7] == 897);
11755 assert_or_panic(v[8] == 898);
11756 assert_or_panic(v[9] == 899);
11757 assert_or_panic(v[10] == 900);
11758 assert_or_panic(v[11] == 901);
11759 assert_or_panic(v[12] == 902);
11760 assert_or_panic(v[13] == 903);
11761 assert_or_panic(v[14] == 904);
11762 assert_or_panic(v[15] == 905);
11763 assert_or_panic(v[16] == 906);
11764 assert_or_panic(v[17] == 907);
11765 assert_or_panic(v[18] == 908);
11766 assert_or_panic(v[19] == 909);
11767 assert_or_panic(v[20] == 910);
11768 assert_or_panic(v[21] == 911);
11769 assert_or_panic(v[22] == 912);
11770 assert_or_panic(v[23] == 913);
11771 assert_or_panic(v[24] == 914);
11772 assert_or_panic(v[25] == 915);
11773 assert_or_panic(v[26] == 916);
11774 assert_or_panic(v[27] == 917);
11775 assert_or_panic(v[28] == 918);
11776 assert_or_panic(v[29] == 919);
11777 assert_or_panic(v[30] == 920);
11778 assert_or_panic(v[31] == 921);
11779 assert_or_panic(v[32] == 922);
11780 assert_or_panic(v[33] == 923);
11781 assert_or_panic(v[34] == 924);
11782 assert_or_panic(v[35] == 925);
11783 assert_or_panic(v[36] == 926);
11784 assert_or_panic(v[37] == 927);
11785 assert_or_panic(v[38] == 928);
11786 assert_or_panic(v[39] == 929);
11787 assert_or_panic(v[40] == 930);
11788 assert_or_panic(v[41] == 931);
11789 assert_or_panic(v[42] == 932);
11790 assert_or_panic(v[43] == 933);
11791 assert_or_panic(v[44] == 934);
11792 assert_or_panic(v[45] == 935);
11793 assert_or_panic(v[46] == 936);
11794 assert_or_panic(v[47] == 937);
11795 assert_or_panic(v[48] == 938);
11796 assert_or_panic(v[49] == 939);
11797 assert_or_panic(v[50] == 940);
11798 assert_or_panic(v[51] == 941);
11799 assert_or_panic(v[52] == 942);
11800 assert_or_panic(v[53] == 943);
11801 assert_or_panic(v[54] == 944);
11802 assert_or_panic(v[55] == 945);
11803 assert_or_panic(v[56] == 946);
11804 assert_or_panic(v[57] == 947);
11805 assert_or_panic(v[58] == 948);
11806 assert_or_panic(v[59] == 949);
11807 assert_or_panic(v[60] == 950);
11808 assert_or_panic(v[61] == 951);
11809 assert_or_panic(v[62] == 952);
11810 assert_or_panic(v[63] == 953);
11811 assert_or_panic(v[64] == 954);
11812 assert_or_panic(v[65] == 955);
11813 assert_or_panic(v[66] == 956);
11814 assert_or_panic(v[67] == 957);
11815 assert_or_panic(v[68] == 958);
11816 assert_or_panic(v[69] == 959);
11817 assert_or_panic(v[70] == 960);
11818 assert_or_panic(v[71] == 961);
11819 assert_or_panic(v[72] == 962);
11820 assert_or_panic(v[73] == 963);
11821 assert_or_panic(v[74] == 964);
11822 assert_or_panic(v[75] == 965);
11823 assert_or_panic(v[76] == 966);
11824 assert_or_panic(v[77] == 967);
11825 assert_or_panic(v[78] == 968);
11826 assert_or_panic(v[79] == 969);
11827 assert_or_panic(v[80] == 970);
11828 assert_or_panic(v[81] == 971);
11829 assert_or_panic(v[82] == 972);
11830 assert_or_panic(v[83] == 973);
11831 assert_or_panic(v[84] == 974);
11832 assert_or_panic(v[85] == 975);
11833 assert_or_panic(v[86] == 976);
11834 assert_or_panic(v[87] == 977);
11835 assert_or_panic(v[88] == 978);
11836 assert_or_panic(v[89] == 979);
11837 assert_or_panic(v[90] == 980);
11838 assert_or_panic(v[91] == 981);
11839 assert_or_panic(v[92] == 982);
11840 assert_or_panic(v[93] == 983);
11841 assert_or_panic(v[94] == 984);
11842 assert_or_panic(v[95] == 985);
11843 zig_vector_96_u32((Vector_96_u32){
11844 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
11845 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
11846 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
11847 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
11848 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
11849 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081,
11850 }, 96);
11851}
11852
11853typedef uint32_t Vector_128_u32 __attribute__((vector_size(128 * sizeof(uint32_t))));
11854
11855Vector_128_u32 zig_ret_vector_128_u32(void);
11856void zig_vector_128_u32(Vector_128_u32, size_t);
11857
11858Vector_128_u32 c_ret_vector_128_u32(void) {
11859 return (Vector_128_u32){
11860 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545,
11861 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
11862 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577,
11863 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
11864 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609,
11865 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
11866 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641,
11867 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657,
11868 };
11869}
11870void c_vector_128_u32(Vector_128_u32 v, size_t i) {
11871 assert_or_panic(v[0] == 1658);
11872 assert_or_panic(v[1] == 1659);
11873 assert_or_panic(v[2] == 1660);
11874 assert_or_panic(v[3] == 1661);
11875 assert_or_panic(v[4] == 1662);
11876 assert_or_panic(v[5] == 1663);
11877 assert_or_panic(v[6] == 1664);
11878 assert_or_panic(v[7] == 1665);
11879 assert_or_panic(v[8] == 1666);
11880 assert_or_panic(v[9] == 1667);
11881 assert_or_panic(v[10] == 1668);
11882 assert_or_panic(v[11] == 1669);
11883 assert_or_panic(v[12] == 1670);
11884 assert_or_panic(v[13] == 1671);
11885 assert_or_panic(v[14] == 1672);
11886 assert_or_panic(v[15] == 1673);
11887 assert_or_panic(v[16] == 1674);
11888 assert_or_panic(v[17] == 1675);
11889 assert_or_panic(v[18] == 1676);
11890 assert_or_panic(v[19] == 1677);
11891 assert_or_panic(v[20] == 1678);
11892 assert_or_panic(v[21] == 1679);
11893 assert_or_panic(v[22] == 1680);
11894 assert_or_panic(v[23] == 1681);
11895 assert_or_panic(v[24] == 1682);
11896 assert_or_panic(v[25] == 1683);
11897 assert_or_panic(v[26] == 1684);
11898 assert_or_panic(v[27] == 1685);
11899 assert_or_panic(v[28] == 1686);
11900 assert_or_panic(v[29] == 1687);
11901 assert_or_panic(v[30] == 1688);
11902 assert_or_panic(v[31] == 1689);
11903 assert_or_panic(v[32] == 1690);
11904 assert_or_panic(v[33] == 1691);
11905 assert_or_panic(v[34] == 1692);
11906 assert_or_panic(v[35] == 1693);
11907 assert_or_panic(v[36] == 1694);
11908 assert_or_panic(v[37] == 1695);
11909 assert_or_panic(v[38] == 1696);
11910 assert_or_panic(v[39] == 1697);
11911 assert_or_panic(v[40] == 1698);
11912 assert_or_panic(v[41] == 1699);
11913 assert_or_panic(v[42] == 1700);
11914 assert_or_panic(v[43] == 1701);
11915 assert_or_panic(v[44] == 1702);
11916 assert_or_panic(v[45] == 1703);
11917 assert_or_panic(v[46] == 1704);
11918 assert_or_panic(v[47] == 1705);
11919 assert_or_panic(v[48] == 1706);
11920 assert_or_panic(v[49] == 1707);
11921 assert_or_panic(v[50] == 1708);
11922 assert_or_panic(v[51] == 1709);
11923 assert_or_panic(v[52] == 1710);
11924 assert_or_panic(v[53] == 1711);
11925 assert_or_panic(v[54] == 1712);
11926 assert_or_panic(v[55] == 1713);
11927 assert_or_panic(v[56] == 1714);
11928 assert_or_panic(v[57] == 1715);
11929 assert_or_panic(v[58] == 1716);
11930 assert_or_panic(v[59] == 1717);
11931 assert_or_panic(v[60] == 1718);
11932 assert_or_panic(v[61] == 1719);
11933 assert_or_panic(v[62] == 1720);
11934 assert_or_panic(v[63] == 1721);
11935 assert_or_panic(v[64] == 1722);
11936 assert_or_panic(v[65] == 1723);
11937 assert_or_panic(v[66] == 1724);
11938 assert_or_panic(v[67] == 1725);
11939 assert_or_panic(v[68] == 1726);
11940 assert_or_panic(v[69] == 1727);
11941 assert_or_panic(v[70] == 1728);
11942 assert_or_panic(v[71] == 1729);
11943 assert_or_panic(v[72] == 1730);
11944 assert_or_panic(v[73] == 1731);
11945 assert_or_panic(v[74] == 1732);
11946 assert_or_panic(v[75] == 1733);
11947 assert_or_panic(v[76] == 1734);
11948 assert_or_panic(v[77] == 1735);
11949 assert_or_panic(v[78] == 1736);
11950 assert_or_panic(v[79] == 1737);
11951 assert_or_panic(v[80] == 1738);
11952 assert_or_panic(v[81] == 1739);
11953 assert_or_panic(v[82] == 1740);
11954 assert_or_panic(v[83] == 1741);
11955 assert_or_panic(v[84] == 1742);
11956 assert_or_panic(v[85] == 1743);
11957 assert_or_panic(v[86] == 1744);
11958 assert_or_panic(v[87] == 1745);
11959 assert_or_panic(v[88] == 1746);
11960 assert_or_panic(v[89] == 1747);
11961 assert_or_panic(v[90] == 1748);
11962 assert_or_panic(v[91] == 1749);
11963 assert_or_panic(v[92] == 1750);
11964 assert_or_panic(v[93] == 1751);
11965 assert_or_panic(v[94] == 1752);
11966 assert_or_panic(v[95] == 1753);
11967 assert_or_panic(v[96] == 1754);
11968 assert_or_panic(v[97] == 1755);
11969 assert_or_panic(v[98] == 1756);
11970 assert_or_panic(v[99] == 1757);
11971 assert_or_panic(v[100] == 1758);
11972 assert_or_panic(v[101] == 1759);
11973 assert_or_panic(v[102] == 1760);
11974 assert_or_panic(v[103] == 1761);
11975 assert_or_panic(v[104] == 1762);
11976 assert_or_panic(v[105] == 1763);
11977 assert_or_panic(v[106] == 1764);
11978 assert_or_panic(v[107] == 1765);
11979 assert_or_panic(v[108] == 1766);
11980 assert_or_panic(v[109] == 1767);
11981 assert_or_panic(v[110] == 1768);
11982 assert_or_panic(v[111] == 1769);
11983 assert_or_panic(v[112] == 1770);
11984 assert_or_panic(v[113] == 1771);
11985 assert_or_panic(v[114] == 1772);
11986 assert_or_panic(v[115] == 1773);
11987 assert_or_panic(v[116] == 1774);
11988 assert_or_panic(v[117] == 1775);
11989 assert_or_panic(v[118] == 1776);
11990 assert_or_panic(v[119] == 1777);
11991 assert_or_panic(v[120] == 1778);
11992 assert_or_panic(v[121] == 1779);
11993 assert_or_panic(v[122] == 1780);
11994 assert_or_panic(v[123] == 1781);
11995 assert_or_panic(v[124] == 1782);
11996 assert_or_panic(v[125] == 1783);
11997 assert_or_panic(v[126] == 1784);
11998 assert_or_panic(v[127] == 1785);
11999 assert_or_panic(i == 128);
12000}
12001void c_test_vector_128_u32(void) {
12002 Vector_128_u32 v = zig_ret_vector_128_u32();
12003 assert_or_panic(v[0] == 1274);
12004 assert_or_panic(v[1] == 1275);
12005 assert_or_panic(v[2] == 1276);
12006 assert_or_panic(v[3] == 1277);
12007 assert_or_panic(v[4] == 1278);
12008 assert_or_panic(v[5] == 1279);
12009 assert_or_panic(v[6] == 1280);
12010 assert_or_panic(v[7] == 1281);
12011 assert_or_panic(v[8] == 1282);
12012 assert_or_panic(v[9] == 1283);
12013 assert_or_panic(v[10] == 1284);
12014 assert_or_panic(v[11] == 1285);
12015 assert_or_panic(v[12] == 1286);
12016 assert_or_panic(v[13] == 1287);
12017 assert_or_panic(v[14] == 1288);
12018 assert_or_panic(v[15] == 1289);
12019 assert_or_panic(v[16] == 1290);
12020 assert_or_panic(v[17] == 1291);
12021 assert_or_panic(v[18] == 1292);
12022 assert_or_panic(v[19] == 1293);
12023 assert_or_panic(v[20] == 1294);
12024 assert_or_panic(v[21] == 1295);
12025 assert_or_panic(v[22] == 1296);
12026 assert_or_panic(v[23] == 1297);
12027 assert_or_panic(v[24] == 1298);
12028 assert_or_panic(v[25] == 1299);
12029 assert_or_panic(v[26] == 1300);
12030 assert_or_panic(v[27] == 1301);
12031 assert_or_panic(v[28] == 1302);
12032 assert_or_panic(v[29] == 1303);
12033 assert_or_panic(v[30] == 1304);
12034 assert_or_panic(v[31] == 1305);
12035 assert_or_panic(v[32] == 1306);
12036 assert_or_panic(v[33] == 1307);
12037 assert_or_panic(v[34] == 1308);
12038 assert_or_panic(v[35] == 1309);
12039 assert_or_panic(v[36] == 1310);
12040 assert_or_panic(v[37] == 1311);
12041 assert_or_panic(v[38] == 1312);
12042 assert_or_panic(v[39] == 1313);
12043 assert_or_panic(v[40] == 1314);
12044 assert_or_panic(v[41] == 1315);
12045 assert_or_panic(v[42] == 1316);
12046 assert_or_panic(v[43] == 1317);
12047 assert_or_panic(v[44] == 1318);
12048 assert_or_panic(v[45] == 1319);
12049 assert_or_panic(v[46] == 1320);
12050 assert_or_panic(v[47] == 1321);
12051 assert_or_panic(v[48] == 1322);
12052 assert_or_panic(v[49] == 1323);
12053 assert_or_panic(v[50] == 1324);
12054 assert_or_panic(v[51] == 1325);
12055 assert_or_panic(v[52] == 1326);
12056 assert_or_panic(v[53] == 1327);
12057 assert_or_panic(v[54] == 1328);
12058 assert_or_panic(v[55] == 1329);
12059 assert_or_panic(v[56] == 1330);
12060 assert_or_panic(v[57] == 1331);
12061 assert_or_panic(v[58] == 1332);
12062 assert_or_panic(v[59] == 1333);
12063 assert_or_panic(v[60] == 1334);
12064 assert_or_panic(v[61] == 1335);
12065 assert_or_panic(v[62] == 1336);
12066 assert_or_panic(v[63] == 1337);
12067 assert_or_panic(v[64] == 1338);
12068 assert_or_panic(v[65] == 1339);
12069 assert_or_panic(v[66] == 1340);
12070 assert_or_panic(v[67] == 1341);
12071 assert_or_panic(v[68] == 1342);
12072 assert_or_panic(v[69] == 1343);
12073 assert_or_panic(v[70] == 1344);
12074 assert_or_panic(v[71] == 1345);
12075 assert_or_panic(v[72] == 1346);
12076 assert_or_panic(v[73] == 1347);
12077 assert_or_panic(v[74] == 1348);
12078 assert_or_panic(v[75] == 1349);
12079 assert_or_panic(v[76] == 1350);
12080 assert_or_panic(v[77] == 1351);
12081 assert_or_panic(v[78] == 1352);
12082 assert_or_panic(v[79] == 1353);
12083 assert_or_panic(v[80] == 1354);
12084 assert_or_panic(v[81] == 1355);
12085 assert_or_panic(v[82] == 1356);
12086 assert_or_panic(v[83] == 1357);
12087 assert_or_panic(v[84] == 1358);
12088 assert_or_panic(v[85] == 1359);
12089 assert_or_panic(v[86] == 1360);
12090 assert_or_panic(v[87] == 1361);
12091 assert_or_panic(v[88] == 1362);
12092 assert_or_panic(v[89] == 1363);
12093 assert_or_panic(v[90] == 1364);
12094 assert_or_panic(v[91] == 1365);
12095 assert_or_panic(v[92] == 1366);
12096 assert_or_panic(v[93] == 1367);
12097 assert_or_panic(v[94] == 1368);
12098 assert_or_panic(v[95] == 1369);
12099 assert_or_panic(v[96] == 1370);
12100 assert_or_panic(v[97] == 1371);
12101 assert_or_panic(v[98] == 1372);
12102 assert_or_panic(v[99] == 1373);
12103 assert_or_panic(v[100] == 1374);
12104 assert_or_panic(v[101] == 1375);
12105 assert_or_panic(v[102] == 1376);
12106 assert_or_panic(v[103] == 1377);
12107 assert_or_panic(v[104] == 1378);
12108 assert_or_panic(v[105] == 1379);
12109 assert_or_panic(v[106] == 1380);
12110 assert_or_panic(v[107] == 1381);
12111 assert_or_panic(v[108] == 1382);
12112 assert_or_panic(v[109] == 1383);
12113 assert_or_panic(v[110] == 1384);
12114 assert_or_panic(v[111] == 1385);
12115 assert_or_panic(v[112] == 1386);
12116 assert_or_panic(v[113] == 1387);
12117 assert_or_panic(v[114] == 1388);
12118 assert_or_panic(v[115] == 1389);
12119 assert_or_panic(v[116] == 1390);
12120 assert_or_panic(v[117] == 1391);
12121 assert_or_panic(v[118] == 1392);
12122 assert_or_panic(v[119] == 1393);
12123 assert_or_panic(v[120] == 1394);
12124 assert_or_panic(v[121] == 1395);
12125 assert_or_panic(v[122] == 1396);
12126 assert_or_panic(v[123] == 1397);
12127 assert_or_panic(v[124] == 1398);
12128 assert_or_panic(v[125] == 1399);
12129 assert_or_panic(v[126] == 1400);
12130 assert_or_panic(v[127] == 1401);
12131 zig_vector_128_u32((Vector_128_u32){
12132 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
12133 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433,
12134 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
12135 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465,
12136 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
12137 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
12138 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513,
12139 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
12140 }, 128);
12141}
12142
12143typedef uint64_t Vector_1_u64 __attribute__((vector_size(1 * sizeof(uint64_t))));
12144
12145Vector_1_u64 zig_ret_vector_1_u64(void);
12146void zig_vector_1_u64(Vector_1_u64, size_t);
12147
12148Vector_1_u64 c_ret_vector_1_u64(void) {
12149 return (Vector_1_u64){ 3 };
12150}
12151void c_vector_1_u64(Vector_1_u64 v, size_t i) {
12152 assert_or_panic(v[0] == 4);
12153 assert_or_panic(i == 1);
12154}
12155void c_test_vector_1_u64(void) {
12156 Vector_1_u64 v = zig_ret_vector_1_u64();
12157 assert_or_panic(v[0] == 1);
12158 zig_vector_1_u64((Vector_1_u64){ 2 }, 1);
12159}
12160
12161typedef uint64_t Vector_2_u64 __attribute__((vector_size(2 * sizeof(uint64_t))));
12162
12163Vector_2_u64 zig_ret_vector_2_u64(void);
12164void zig_vector_2_u64(Vector_2_u64, size_t);
12165
12166Vector_2_u64 c_ret_vector_2_u64(void) {
12167 return (Vector_2_u64){ 9, 10 };
12168}
12169void c_vector_2_u64(Vector_2_u64 v, size_t i) {
12170 assert_or_panic(v[0] == 11);
12171 assert_or_panic(v[1] == 12);
12172 assert_or_panic(i == 2);
12173}
12174void c_test_vector_2_u64(void) {
12175 Vector_2_u64 v = zig_ret_vector_2_u64();
12176 assert_or_panic(v[0] == 5);
12177 assert_or_panic(v[1] == 6);
12178 zig_vector_2_u64((Vector_2_u64){ 7, 8 }, 2);
12179}
12180
12181typedef uint64_t Vector_3_u64 __attribute__((vector_size(3 * sizeof(uint64_t))));
12182
12183Vector_3_u64 zig_ret_vector_3_u64(void);
12184void zig_vector_3_u64(Vector_3_u64, size_t);
12185
12186Vector_3_u64 c_ret_vector_3_u64(void) {
12187 return (Vector_3_u64){ 19, 20, 21 };
12188}
12189void c_vector_3_u64(Vector_3_u64 v, size_t i) {
12190 assert_or_panic(v[0] == 22);
12191 assert_or_panic(v[1] == 23);
12192 assert_or_panic(v[2] == 24);
12193 assert_or_panic(i == 3);
12194}
12195void c_test_vector_3_u64(void) {
12196 Vector_3_u64 v = zig_ret_vector_3_u64();
12197 assert_or_panic(v[0] == 13);
12198 assert_or_panic(v[1] == 14);
12199 assert_or_panic(v[2] == 15);
12200 zig_vector_3_u64((Vector_3_u64){ 16, 17, 18 }, 3);
12201}
12202
12203typedef uint64_t Vector_4_u64 __attribute__((vector_size(4 * sizeof(uint64_t))));
12204
12205Vector_4_u64 zig_ret_vector_4_u64(void);
12206void zig_vector_4_u64(Vector_4_u64, size_t);
12207
12208Vector_4_u64 c_ret_vector_4_u64(void) {
12209 return (Vector_4_u64){ 33, 34, 35, 36 };
12210}
12211void c_vector_4_u64(Vector_4_u64 v, size_t i) {
12212 assert_or_panic(v[0] == 37);
12213 assert_or_panic(v[1] == 38);
12214 assert_or_panic(v[2] == 39);
12215 assert_or_panic(v[3] == 40);
12216 assert_or_panic(i == 4);
12217}
12218void c_test_vector_4_u64(void) {
12219 Vector_4_u64 v = zig_ret_vector_4_u64();
12220 assert_or_panic(v[0] == 25);
12221 assert_or_panic(v[1] == 26);
12222 assert_or_panic(v[2] == 27);
12223 assert_or_panic(v[3] == 28);
12224 zig_vector_4_u64((Vector_4_u64){ 29, 30, 31, 32 }, 4);
12225}
12226
12227typedef uint64_t Vector_6_u64 __attribute__((vector_size(6 * sizeof(uint64_t))));
12228
12229Vector_6_u64 zig_ret_vector_6_u64(void);
12230void zig_vector_6_u64(Vector_6_u64, size_t);
12231
12232Vector_6_u64 c_ret_vector_6_u64(void) {
12233 return (Vector_6_u64){ 53, 54, 55, 56, 57, 58 };
12234}
12235void c_vector_6_u64(Vector_6_u64 v, size_t i) {
12236 assert_or_panic(v[0] == 59);
12237 assert_or_panic(v[1] == 60);
12238 assert_or_panic(v[2] == 61);
12239 assert_or_panic(v[3] == 62);
12240 assert_or_panic(v[4] == 63);
12241 assert_or_panic(v[5] == 64);
12242 assert_or_panic(i == 6);
12243}
12244void c_test_vector_6_u64(void) {
12245 Vector_6_u64 v = zig_ret_vector_6_u64();
12246 assert_or_panic(v[0] == 41);
12247 assert_or_panic(v[1] == 42);
12248 assert_or_panic(v[2] == 43);
12249 assert_or_panic(v[3] == 44);
12250 assert_or_panic(v[4] == 45);
12251 assert_or_panic(v[5] == 46);
12252 zig_vector_6_u64((Vector_6_u64){ 47, 48, 49, 50, 51, 52 }, 6);
12253}
12254
12255typedef uint64_t Vector_8_u64 __attribute__((vector_size(8 * sizeof(uint64_t))));
12256
12257Vector_8_u64 zig_ret_vector_8_u64(void);
12258void zig_vector_8_u64(Vector_8_u64, size_t);
12259
12260Vector_8_u64 c_ret_vector_8_u64(void) {
12261 return (Vector_8_u64){ 81, 82, 83, 84, 85, 86, 87, 88 };
12262}
12263void c_vector_8_u64(Vector_8_u64 v, size_t i) {
12264 assert_or_panic(v[0] == 89);
12265 assert_or_panic(v[1] == 90);
12266 assert_or_panic(v[2] == 91);
12267 assert_or_panic(v[3] == 92);
12268 assert_or_panic(v[4] == 93);
12269 assert_or_panic(v[5] == 94);
12270 assert_or_panic(v[6] == 95);
12271 assert_or_panic(v[7] == 96);
12272 assert_or_panic(i == 8);
12273}
12274void c_test_vector_8_u64(void) {
12275 Vector_8_u64 v = zig_ret_vector_8_u64();
12276 assert_or_panic(v[0] == 65);
12277 assert_or_panic(v[1] == 66);
12278 assert_or_panic(v[2] == 67);
12279 assert_or_panic(v[3] == 68);
12280 assert_or_panic(v[4] == 69);
12281 assert_or_panic(v[5] == 70);
12282 assert_or_panic(v[6] == 71);
12283 assert_or_panic(v[7] == 72);
12284 zig_vector_8_u64((Vector_8_u64){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
12285}
12286
12287typedef uint64_t Vector_12_u64 __attribute__((vector_size(12 * sizeof(uint64_t))));
12288
12289Vector_12_u64 zig_ret_vector_12_u64(void);
12290void zig_vector_12_u64(Vector_12_u64, size_t);
12291
12292Vector_12_u64 c_ret_vector_12_u64(void) {
12293 return (Vector_12_u64){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
12294}
12295void c_vector_12_u64(Vector_12_u64 v, size_t i) {
12296 assert_or_panic(v[0] == 133);
12297 assert_or_panic(v[1] == 134);
12298 assert_or_panic(v[2] == 135);
12299 assert_or_panic(v[3] == 136);
12300 assert_or_panic(v[4] == 137);
12301 assert_or_panic(v[5] == 138);
12302 assert_or_panic(v[6] == 139);
12303 assert_or_panic(v[7] == 140);
12304 assert_or_panic(v[8] == 141);
12305 assert_or_panic(v[9] == 142);
12306 assert_or_panic(v[10] == 143);
12307 assert_or_panic(v[11] == 144);
12308 assert_or_panic(i == 12);
12309}
12310void c_test_vector_12_u64(void) {
12311 Vector_12_u64 v = zig_ret_vector_12_u64();
12312 assert_or_panic(v[0] == 97);
12313 assert_or_panic(v[1] == 98);
12314 assert_or_panic(v[2] == 99);
12315 assert_or_panic(v[3] == 100);
12316 assert_or_panic(v[4] == 101);
12317 assert_or_panic(v[5] == 102);
12318 assert_or_panic(v[6] == 103);
12319 assert_or_panic(v[7] == 104);
12320 assert_or_panic(v[8] == 105);
12321 assert_or_panic(v[9] == 106);
12322 assert_or_panic(v[10] == 107);
12323 assert_or_panic(v[11] == 108);
12324 zig_vector_12_u64((Vector_12_u64){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
12325}
12326
12327typedef uint64_t Vector_16_u64 __attribute__((vector_size(16 * sizeof(uint64_t))));
12328
12329Vector_16_u64 zig_ret_vector_16_u64(void);
12330void zig_vector_16_u64(Vector_16_u64, size_t);
12331
12332Vector_16_u64 c_ret_vector_16_u64(void) {
12333 return (Vector_16_u64){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
12334}
12335void c_vector_16_u64(Vector_16_u64 v, size_t i) {
12336 assert_or_panic(v[0] == 193);
12337 assert_or_panic(v[1] == 194);
12338 assert_or_panic(v[2] == 195);
12339 assert_or_panic(v[3] == 196);
12340 assert_or_panic(v[4] == 197);
12341 assert_or_panic(v[5] == 198);
12342 assert_or_panic(v[6] == 199);
12343 assert_or_panic(v[7] == 200);
12344 assert_or_panic(v[8] == 201);
12345 assert_or_panic(v[9] == 202);
12346 assert_or_panic(v[10] == 203);
12347 assert_or_panic(v[11] == 204);
12348 assert_or_panic(v[12] == 205);
12349 assert_or_panic(v[13] == 206);
12350 assert_or_panic(v[14] == 207);
12351 assert_or_panic(v[15] == 208);
12352 assert_or_panic(i == 16);
12353}
12354void c_test_vector_16_u64(void) {
12355 Vector_16_u64 v = zig_ret_vector_16_u64();
12356 assert_or_panic(v[0] == 145);
12357 assert_or_panic(v[1] == 146);
12358 assert_or_panic(v[2] == 147);
12359 assert_or_panic(v[3] == 148);
12360 assert_or_panic(v[4] == 149);
12361 assert_or_panic(v[5] == 150);
12362 assert_or_panic(v[6] == 151);
12363 assert_or_panic(v[7] == 152);
12364 assert_or_panic(v[8] == 153);
12365 assert_or_panic(v[9] == 154);
12366 assert_or_panic(v[10] == 155);
12367 assert_or_panic(v[11] == 156);
12368 assert_or_panic(v[12] == 157);
12369 assert_or_panic(v[13] == 158);
12370 assert_or_panic(v[14] == 159);
12371 assert_or_panic(v[15] == 160);
12372 zig_vector_16_u64((Vector_16_u64){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
12373}
12374
12375typedef uint64_t Vector_24_u64 __attribute__((vector_size(24 * sizeof(uint64_t))));
12376
12377Vector_24_u64 zig_ret_vector_24_u64(void);
12378void zig_vector_24_u64(Vector_24_u64, size_t);
12379
12380Vector_24_u64 c_ret_vector_24_u64(void) {
12381 return (Vector_24_u64){
12382 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
12383 273, 274, 275, 276, 277, 278, 279, 280,
12384 };
12385}
12386void c_vector_24_u64(Vector_24_u64 v, size_t i) {
12387 assert_or_panic(v[0] == 281);
12388 assert_or_panic(v[1] == 282);
12389 assert_or_panic(v[2] == 283);
12390 assert_or_panic(v[3] == 284);
12391 assert_or_panic(v[4] == 285);
12392 assert_or_panic(v[5] == 286);
12393 assert_or_panic(v[6] == 287);
12394 assert_or_panic(v[7] == 288);
12395 assert_or_panic(v[8] == 289);
12396 assert_or_panic(v[9] == 290);
12397 assert_or_panic(v[10] == 291);
12398 assert_or_panic(v[11] == 292);
12399 assert_or_panic(v[12] == 293);
12400 assert_or_panic(v[13] == 294);
12401 assert_or_panic(v[14] == 295);
12402 assert_or_panic(v[15] == 296);
12403 assert_or_panic(v[16] == 297);
12404 assert_or_panic(v[17] == 298);
12405 assert_or_panic(v[18] == 299);
12406 assert_or_panic(v[19] == 300);
12407 assert_or_panic(v[20] == 301);
12408 assert_or_panic(v[21] == 302);
12409 assert_or_panic(v[22] == 303);
12410 assert_or_panic(v[23] == 304);
12411 assert_or_panic(i == 24);
12412}
12413void c_test_vector_24_u64(void) {
12414 Vector_24_u64 v = zig_ret_vector_24_u64();
12415 assert_or_panic(v[0] == 209);
12416 assert_or_panic(v[1] == 210);
12417 assert_or_panic(v[2] == 211);
12418 assert_or_panic(v[3] == 212);
12419 assert_or_panic(v[4] == 213);
12420 assert_or_panic(v[5] == 214);
12421 assert_or_panic(v[6] == 215);
12422 assert_or_panic(v[7] == 216);
12423 assert_or_panic(v[8] == 217);
12424 assert_or_panic(v[9] == 218);
12425 assert_or_panic(v[10] == 219);
12426 assert_or_panic(v[11] == 220);
12427 assert_or_panic(v[12] == 221);
12428 assert_or_panic(v[13] == 222);
12429 assert_or_panic(v[14] == 223);
12430 assert_or_panic(v[15] == 224);
12431 assert_or_panic(v[16] == 225);
12432 assert_or_panic(v[17] == 226);
12433 assert_or_panic(v[18] == 227);
12434 assert_or_panic(v[19] == 228);
12435 assert_or_panic(v[20] == 229);
12436 assert_or_panic(v[21] == 230);
12437 assert_or_panic(v[22] == 231);
12438 assert_or_panic(v[23] == 232);
12439 zig_vector_24_u64((Vector_24_u64){
12440 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
12441 249, 250, 251, 252, 253, 254, 255, 256,
12442 }, 24);
12443}
12444
12445typedef uint64_t Vector_32_u64 __attribute__((vector_size(32 * sizeof(uint64_t))));
12446
12447Vector_32_u64 zig_ret_vector_32_u64(void);
12448void zig_vector_32_u64(Vector_32_u64, size_t);
12449
12450Vector_32_u64 c_ret_vector_32_u64(void) {
12451 return (Vector_32_u64){
12452 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
12453 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
12454 };
12455}
12456void c_vector_32_u64(Vector_32_u64 v, size_t i) {
12457 assert_or_panic(v[0] == 401);
12458 assert_or_panic(v[1] == 402);
12459 assert_or_panic(v[2] == 403);
12460 assert_or_panic(v[3] == 404);
12461 assert_or_panic(v[4] == 405);
12462 assert_or_panic(v[5] == 406);
12463 assert_or_panic(v[6] == 407);
12464 assert_or_panic(v[7] == 408);
12465 assert_or_panic(v[8] == 409);
12466 assert_or_panic(v[9] == 410);
12467 assert_or_panic(v[10] == 411);
12468 assert_or_panic(v[11] == 412);
12469 assert_or_panic(v[12] == 413);
12470 assert_or_panic(v[13] == 414);
12471 assert_or_panic(v[14] == 415);
12472 assert_or_panic(v[15] == 416);
12473 assert_or_panic(v[16] == 417);
12474 assert_or_panic(v[17] == 418);
12475 assert_or_panic(v[18] == 419);
12476 assert_or_panic(v[19] == 420);
12477 assert_or_panic(v[20] == 421);
12478 assert_or_panic(v[21] == 422);
12479 assert_or_panic(v[22] == 423);
12480 assert_or_panic(v[23] == 424);
12481 assert_or_panic(v[24] == 425);
12482 assert_or_panic(v[25] == 426);
12483 assert_or_panic(v[26] == 427);
12484 assert_or_panic(v[27] == 428);
12485 assert_or_panic(v[28] == 429);
12486 assert_or_panic(v[29] == 430);
12487 assert_or_panic(v[30] == 431);
12488 assert_or_panic(v[31] == 432);
12489 assert_or_panic(i == 32);
12490}
12491void c_test_vector_32_u64(void) {
12492 Vector_32_u64 v = zig_ret_vector_32_u64();
12493 assert_or_panic(v[0] == 305);
12494 assert_or_panic(v[1] == 306);
12495 assert_or_panic(v[2] == 307);
12496 assert_or_panic(v[3] == 308);
12497 assert_or_panic(v[4] == 309);
12498 assert_or_panic(v[5] == 310);
12499 assert_or_panic(v[6] == 311);
12500 assert_or_panic(v[7] == 312);
12501 assert_or_panic(v[8] == 313);
12502 assert_or_panic(v[9] == 314);
12503 assert_or_panic(v[10] == 315);
12504 assert_or_panic(v[11] == 316);
12505 assert_or_panic(v[12] == 317);
12506 assert_or_panic(v[13] == 318);
12507 assert_or_panic(v[14] == 319);
12508 assert_or_panic(v[15] == 320);
12509 assert_or_panic(v[16] == 321);
12510 assert_or_panic(v[17] == 322);
12511 assert_or_panic(v[18] == 323);
12512 assert_or_panic(v[19] == 324);
12513 assert_or_panic(v[20] == 325);
12514 assert_or_panic(v[21] == 326);
12515 assert_or_panic(v[22] == 327);
12516 assert_or_panic(v[23] == 328);
12517 assert_or_panic(v[24] == 329);
12518 assert_or_panic(v[25] == 330);
12519 assert_or_panic(v[26] == 331);
12520 assert_or_panic(v[27] == 332);
12521 assert_or_panic(v[28] == 333);
12522 assert_or_panic(v[29] == 334);
12523 assert_or_panic(v[30] == 335);
12524 assert_or_panic(v[31] == 336);
12525 zig_vector_32_u64((Vector_32_u64){
12526 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
12527 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
12528 }, 32);
12529}
12530
12531typedef uint64_t Vector_48_u64 __attribute__((vector_size(48 * sizeof(uint64_t))));
12532
12533Vector_48_u64 zig_ret_vector_48_u64(void);
12534void zig_vector_48_u64(Vector_48_u64, size_t);
12535
12536Vector_48_u64 c_ret_vector_48_u64(void) {
12537 return (Vector_48_u64){
12538 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
12539 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
12540 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
12541 };
12542}
12543void c_vector_48_u64(Vector_48_u64 v, size_t i) {
12544 assert_or_panic(v[0] == 577);
12545 assert_or_panic(v[1] == 578);
12546 assert_or_panic(v[2] == 579);
12547 assert_or_panic(v[3] == 580);
12548 assert_or_panic(v[4] == 581);
12549 assert_or_panic(v[5] == 582);
12550 assert_or_panic(v[6] == 583);
12551 assert_or_panic(v[7] == 584);
12552 assert_or_panic(v[8] == 585);
12553 assert_or_panic(v[9] == 586);
12554 assert_or_panic(v[10] == 587);
12555 assert_or_panic(v[11] == 588);
12556 assert_or_panic(v[12] == 589);
12557 assert_or_panic(v[13] == 590);
12558 assert_or_panic(v[14] == 591);
12559 assert_or_panic(v[15] == 592);
12560 assert_or_panic(v[16] == 593);
12561 assert_or_panic(v[17] == 594);
12562 assert_or_panic(v[18] == 595);
12563 assert_or_panic(v[19] == 596);
12564 assert_or_panic(v[20] == 597);
12565 assert_or_panic(v[21] == 598);
12566 assert_or_panic(v[22] == 599);
12567 assert_or_panic(v[23] == 600);
12568 assert_or_panic(v[24] == 601);
12569 assert_or_panic(v[25] == 602);
12570 assert_or_panic(v[26] == 603);
12571 assert_or_panic(v[27] == 604);
12572 assert_or_panic(v[28] == 605);
12573 assert_or_panic(v[29] == 606);
12574 assert_or_panic(v[30] == 607);
12575 assert_or_panic(v[31] == 608);
12576 assert_or_panic(v[32] == 609);
12577 assert_or_panic(v[33] == 610);
12578 assert_or_panic(v[34] == 611);
12579 assert_or_panic(v[35] == 612);
12580 assert_or_panic(v[36] == 613);
12581 assert_or_panic(v[37] == 614);
12582 assert_or_panic(v[38] == 615);
12583 assert_or_panic(v[39] == 616);
12584 assert_or_panic(v[40] == 617);
12585 assert_or_panic(v[41] == 618);
12586 assert_or_panic(v[42] == 619);
12587 assert_or_panic(v[43] == 620);
12588 assert_or_panic(v[44] == 621);
12589 assert_or_panic(v[45] == 622);
12590 assert_or_panic(v[46] == 623);
12591 assert_or_panic(v[47] == 624);
12592 assert_or_panic(i == 48);
12593}
12594void c_test_vector_48_u64(void) {
12595 Vector_48_u64 v = zig_ret_vector_48_u64();
12596 assert_or_panic(v[0] == 433);
12597 assert_or_panic(v[1] == 434);
12598 assert_or_panic(v[2] == 435);
12599 assert_or_panic(v[3] == 436);
12600 assert_or_panic(v[4] == 437);
12601 assert_or_panic(v[5] == 438);
12602 assert_or_panic(v[6] == 439);
12603 assert_or_panic(v[7] == 440);
12604 assert_or_panic(v[8] == 441);
12605 assert_or_panic(v[9] == 442);
12606 assert_or_panic(v[10] == 443);
12607 assert_or_panic(v[11] == 444);
12608 assert_or_panic(v[12] == 445);
12609 assert_or_panic(v[13] == 446);
12610 assert_or_panic(v[14] == 447);
12611 assert_or_panic(v[15] == 448);
12612 assert_or_panic(v[16] == 449);
12613 assert_or_panic(v[17] == 450);
12614 assert_or_panic(v[18] == 451);
12615 assert_or_panic(v[19] == 452);
12616 assert_or_panic(v[20] == 453);
12617 assert_or_panic(v[21] == 454);
12618 assert_or_panic(v[22] == 455);
12619 assert_or_panic(v[23] == 456);
12620 assert_or_panic(v[24] == 457);
12621 assert_or_panic(v[25] == 458);
12622 assert_or_panic(v[26] == 459);
12623 assert_or_panic(v[27] == 460);
12624 assert_or_panic(v[28] == 461);
12625 assert_or_panic(v[29] == 462);
12626 assert_or_panic(v[30] == 463);
12627 assert_or_panic(v[31] == 464);
12628 assert_or_panic(v[32] == 465);
12629 assert_or_panic(v[33] == 466);
12630 assert_or_panic(v[34] == 467);
12631 assert_or_panic(v[35] == 468);
12632 assert_or_panic(v[36] == 469);
12633 assert_or_panic(v[37] == 470);
12634 assert_or_panic(v[38] == 471);
12635 assert_or_panic(v[39] == 472);
12636 assert_or_panic(v[40] == 473);
12637 assert_or_panic(v[41] == 474);
12638 assert_or_panic(v[42] == 475);
12639 assert_or_panic(v[43] == 476);
12640 assert_or_panic(v[44] == 477);
12641 assert_or_panic(v[45] == 478);
12642 assert_or_panic(v[46] == 479);
12643 assert_or_panic(v[47] == 480);
12644 zig_vector_48_u64((Vector_48_u64){
12645 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
12646 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
12647 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
12648 }, 48);
12649}
12650
12651typedef uint64_t Vector_64_u64 __attribute__((vector_size(64 * sizeof(uint64_t))));
12652
12653Vector_64_u64 zig_ret_vector_64_u64(void);
12654void zig_vector_64_u64(Vector_64_u64, size_t);
12655
12656Vector_64_u64 c_ret_vector_64_u64(void) {
12657 return (Vector_64_u64){
12658 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
12659 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
12660 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
12661 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
12662 };
12663}
12664void c_vector_64_u64(Vector_64_u64 v, size_t i) {
12665 assert_or_panic(v[0] == 817);
12666 assert_or_panic(v[1] == 818);
12667 assert_or_panic(v[2] == 819);
12668 assert_or_panic(v[3] == 820);
12669 assert_or_panic(v[4] == 821);
12670 assert_or_panic(v[5] == 822);
12671 assert_or_panic(v[6] == 823);
12672 assert_or_panic(v[7] == 824);
12673 assert_or_panic(v[8] == 825);
12674 assert_or_panic(v[9] == 826);
12675 assert_or_panic(v[10] == 827);
12676 assert_or_panic(v[11] == 828);
12677 assert_or_panic(v[12] == 829);
12678 assert_or_panic(v[13] == 830);
12679 assert_or_panic(v[14] == 831);
12680 assert_or_panic(v[15] == 832);
12681 assert_or_panic(v[16] == 833);
12682 assert_or_panic(v[17] == 834);
12683 assert_or_panic(v[18] == 835);
12684 assert_or_panic(v[19] == 836);
12685 assert_or_panic(v[20] == 837);
12686 assert_or_panic(v[21] == 838);
12687 assert_or_panic(v[22] == 839);
12688 assert_or_panic(v[23] == 840);
12689 assert_or_panic(v[24] == 841);
12690 assert_or_panic(v[25] == 842);
12691 assert_or_panic(v[26] == 843);
12692 assert_or_panic(v[27] == 844);
12693 assert_or_panic(v[28] == 845);
12694 assert_or_panic(v[29] == 846);
12695 assert_or_panic(v[30] == 847);
12696 assert_or_panic(v[31] == 848);
12697 assert_or_panic(v[32] == 849);
12698 assert_or_panic(v[33] == 850);
12699 assert_or_panic(v[34] == 851);
12700 assert_or_panic(v[35] == 852);
12701 assert_or_panic(v[36] == 853);
12702 assert_or_panic(v[37] == 854);
12703 assert_or_panic(v[38] == 855);
12704 assert_or_panic(v[39] == 856);
12705 assert_or_panic(v[40] == 857);
12706 assert_or_panic(v[41] == 858);
12707 assert_or_panic(v[42] == 859);
12708 assert_or_panic(v[43] == 860);
12709 assert_or_panic(v[44] == 861);
12710 assert_or_panic(v[45] == 862);
12711 assert_or_panic(v[46] == 863);
12712 assert_or_panic(v[47] == 864);
12713 assert_or_panic(v[48] == 865);
12714 assert_or_panic(v[49] == 866);
12715 assert_or_panic(v[50] == 867);
12716 assert_or_panic(v[51] == 868);
12717 assert_or_panic(v[52] == 869);
12718 assert_or_panic(v[53] == 870);
12719 assert_or_panic(v[54] == 871);
12720 assert_or_panic(v[55] == 872);
12721 assert_or_panic(v[56] == 873);
12722 assert_or_panic(v[57] == 874);
12723 assert_or_panic(v[58] == 875);
12724 assert_or_panic(v[59] == 876);
12725 assert_or_panic(v[60] == 877);
12726 assert_or_panic(v[61] == 878);
12727 assert_or_panic(v[62] == 879);
12728 assert_or_panic(v[63] == 880);
12729 assert_or_panic(i == 64);
12730}
12731void c_test_vector_64_u64(void) {
12732 Vector_64_u64 v = zig_ret_vector_64_u64();
12733 assert_or_panic(v[0] == 625);
12734 assert_or_panic(v[1] == 626);
12735 assert_or_panic(v[2] == 627);
12736 assert_or_panic(v[3] == 628);
12737 assert_or_panic(v[4] == 629);
12738 assert_or_panic(v[5] == 630);
12739 assert_or_panic(v[6] == 631);
12740 assert_or_panic(v[7] == 632);
12741 assert_or_panic(v[8] == 633);
12742 assert_or_panic(v[9] == 634);
12743 assert_or_panic(v[10] == 635);
12744 assert_or_panic(v[11] == 636);
12745 assert_or_panic(v[12] == 637);
12746 assert_or_panic(v[13] == 638);
12747 assert_or_panic(v[14] == 639);
12748 assert_or_panic(v[15] == 640);
12749 assert_or_panic(v[16] == 641);
12750 assert_or_panic(v[17] == 642);
12751 assert_or_panic(v[18] == 643);
12752 assert_or_panic(v[19] == 644);
12753 assert_or_panic(v[20] == 645);
12754 assert_or_panic(v[21] == 646);
12755 assert_or_panic(v[22] == 647);
12756 assert_or_panic(v[23] == 648);
12757 assert_or_panic(v[24] == 649);
12758 assert_or_panic(v[25] == 650);
12759 assert_or_panic(v[26] == 651);
12760 assert_or_panic(v[27] == 652);
12761 assert_or_panic(v[28] == 653);
12762 assert_or_panic(v[29] == 654);
12763 assert_or_panic(v[30] == 655);
12764 assert_or_panic(v[31] == 656);
12765 assert_or_panic(v[32] == 657);
12766 assert_or_panic(v[33] == 658);
12767 assert_or_panic(v[34] == 659);
12768 assert_or_panic(v[35] == 660);
12769 assert_or_panic(v[36] == 661);
12770 assert_or_panic(v[37] == 662);
12771 assert_or_panic(v[38] == 663);
12772 assert_or_panic(v[39] == 664);
12773 assert_or_panic(v[40] == 665);
12774 assert_or_panic(v[41] == 666);
12775 assert_or_panic(v[42] == 667);
12776 assert_or_panic(v[43] == 668);
12777 assert_or_panic(v[44] == 669);
12778 assert_or_panic(v[45] == 670);
12779 assert_or_panic(v[46] == 671);
12780 assert_or_panic(v[47] == 672);
12781 assert_or_panic(v[48] == 673);
12782 assert_or_panic(v[49] == 674);
12783 assert_or_panic(v[50] == 675);
12784 assert_or_panic(v[51] == 676);
12785 assert_or_panic(v[52] == 677);
12786 assert_or_panic(v[53] == 678);
12787 assert_or_panic(v[54] == 679);
12788 assert_or_panic(v[55] == 680);
12789 assert_or_panic(v[56] == 681);
12790 assert_or_panic(v[57] == 682);
12791 assert_or_panic(v[58] == 683);
12792 assert_or_panic(v[59] == 684);
12793 assert_or_panic(v[60] == 685);
12794 assert_or_panic(v[61] == 686);
12795 assert_or_panic(v[62] == 687);
12796 assert_or_panic(v[63] == 688);
12797 zig_vector_64_u64((Vector_64_u64){
12798 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
12799 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
12800 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
12801 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
12802 }, 64);
12803}
12804
12805typedef float Vector_1_f32 __attribute__((vector_size(1 * sizeof(float))));
12806
12807Vector_1_f32 zig_ret_vector_1_f32(void);
12808void zig_vector_1_f32(Vector_1_f32, size_t);
12809
12810Vector_1_f32 c_ret_vector_1_f32(void) {
12811 return (Vector_1_f32){ 3 };
12812}
12813void c_vector_1_f32(Vector_1_f32 v, size_t i) {
12814 assert_or_panic(v[0] == 4);
12815 assert_or_panic(i == 1);
12816}
12817void c_test_vector_1_f32(void) {
12818 Vector_1_f32 v = zig_ret_vector_1_f32();
12819 assert_or_panic(v[0] == 1);
12820 zig_vector_1_f32((Vector_1_f32){ 2 }, 1);
12821}
12822
12823typedef float Vector_2_f32 __attribute__((vector_size(2 * sizeof(float))));
12824
12825Vector_2_f32 zig_ret_vector_2_f32(void);
12826void zig_vector_2_f32(Vector_2_f32, size_t);
12827
12828Vector_2_f32 c_ret_vector_2_f32(void) {
12829 return (Vector_2_f32){ 9, 10 };
12830}
12831void c_vector_2_f32(Vector_2_f32 v, size_t i) {
12832 assert_or_panic(v[0] == 11);
12833 assert_or_panic(v[1] == 12);
12834 assert_or_panic(i == 2);
12835}
12836void c_test_vector_2_f32(void) {
12837 Vector_2_f32 v = zig_ret_vector_2_f32();
12838 assert_or_panic(v[0] == 5);
12839 assert_or_panic(v[1] == 6);
12840 zig_vector_2_f32((Vector_2_f32){ 7, 8 }, 2);
12841}
12842
12843typedef float Vector_3_f32 __attribute__((vector_size(3 * sizeof(float))));
12844
12845Vector_3_f32 zig_ret_vector_3_f32(void);
12846void zig_vector_3_f32(Vector_3_f32, size_t);
12847
12848Vector_3_f32 c_ret_vector_3_f32(void) {
12849 return (Vector_3_f32){ 19, 20, 21 };
12850}
12851void c_vector_3_f32(Vector_3_f32 v, size_t i) {
12852 assert_or_panic(v[0] == 22);
12853 assert_or_panic(v[1] == 23);
12854 assert_or_panic(v[2] == 24);
12855 assert_or_panic(i == 32);
12856}
12857void c_test_vector_3_f32(void) {
12858 Vector_3_f32 v = zig_ret_vector_3_f32();
12859 assert_or_panic(v[0] == 13);
12860 assert_or_panic(v[1] == 14);
12861 assert_or_panic(v[2] == 15);
12862 zig_vector_3_f32((Vector_3_f32){ 16, 17, 18 }, 3);
12863}
12864
12865typedef float Vector_4_f32 __attribute__((vector_size(4 * sizeof(float))));
12866
12867Vector_4_f32 zig_ret_vector_4_f32(void);
12868void zig_vector_4_f32(Vector_4_f32, size_t);
12869void zig_vector_4_f32_vector_4_f32(Vector_4_f32, Vector_4_f32, size_t);
12870
12871Vector_4_f32 c_ret_vector_4_f32(void) {
12872 return (Vector_4_f32){ 41, 42, 43, 44 };
12873}
12874void c_vector_4_f32(Vector_4_f32 v, size_t i) {
12875 assert_or_panic(v[0] == 45);
12876 assert_or_panic(v[1] == 46);
12877 assert_or_panic(v[2] == 47);
12878 assert_or_panic(v[3] == 48);
12879 assert_or_panic(i == 4);
12880}
12881void c_vector_4_f32_vector_4_f32(Vector_4_f32 v0, Vector_4_f32 v1, size_t i) {
12882 assert_or_panic(v0[0] == 49);
12883 assert_or_panic(v0[1] == 50);
12884 assert_or_panic(v0[2] == 51);
12885 assert_or_panic(v0[3] == 52);
12886 assert_or_panic(v1[0] == 53);
12887 assert_or_panic(v1[1] == 54);
12888 assert_or_panic(v1[2] == 55);
12889 assert_or_panic(v1[3] == 56);
12890 assert_or_panic(i == 8);
12891}
12892void c_test_vector_4_f32(void) {
12893 Vector_4_f32 v = zig_ret_vector_4_f32();
12894 assert_or_panic(v[0] == 25);
12895 assert_or_panic(v[1] == 26);
12896 assert_or_panic(v[2] == 27);
12897 assert_or_panic(v[3] == 28);
12898 zig_vector_4_f32((Vector_4_f32){ 29, 30, 31, 32 }, 4);
12899 zig_vector_4_f32_vector_4_f32((Vector_4_f32){ 33, 34, 35, 36 }, (Vector_4_f32){ 37, 38, 39, 40 }, 8);
12900}
12901
12902typedef float Vector_6_f32 __attribute__((vector_size(6 * sizeof(float))));
12903
12904Vector_6_f32 zig_ret_vector_6_f32(void);
12905void zig_vector_6_f32(Vector_6_f32, size_t);
12906
12907Vector_6_f32 c_ret_vector_6_f32(void) {
12908 return (Vector_6_f32){ 53, 54, 55, 56, 57, 58 };
12909}
12910void c_vector_6_f32(Vector_6_f32 v, size_t i) {
12911 assert_or_panic(v[0] == 59);
12912 assert_or_panic(v[1] == 60);
12913 assert_or_panic(v[2] == 61);
12914 assert_or_panic(v[3] == 62);
12915 assert_or_panic(v[4] == 63);
12916 assert_or_panic(v[5] == 64);
12917 assert_or_panic(i == 6);
12918}
12919void c_test_vector_6_f32(void) {
12920 Vector_6_f32 v = zig_ret_vector_6_f32();
12921 assert_or_panic(v[0] == 41);
12922 assert_or_panic(v[1] == 42);
12923 assert_or_panic(v[2] == 43);
12924 assert_or_panic(v[3] == 44);
12925 assert_or_panic(v[4] == 45);
12926 assert_or_panic(v[5] == 46);
12927 zig_vector_6_f32((Vector_6_f32){ 47, 48, 49, 50, 51, 52 }, 6);
12928}
12929
12930typedef float Vector_8_f32 __attribute__((vector_size(8 * sizeof(float))));
12931
12932Vector_8_f32 zig_ret_vector_8_f32(void);
12933void zig_vector_8_f32(Vector_8_f32, size_t);
12934
12935Vector_8_f32 c_ret_vector_8_f32(void) {
12936 return (Vector_8_f32){ 81, 82, 83, 84, 85, 86, 87, 88 };
12937}
12938void c_vector_8_f32(Vector_8_f32 v, size_t i) {
12939 assert_or_panic(v[0] == 89);
12940 assert_or_panic(v[1] == 90);
12941 assert_or_panic(v[2] == 91);
12942 assert_or_panic(v[3] == 92);
12943 assert_or_panic(v[4] == 93);
12944 assert_or_panic(v[5] == 94);
12945 assert_or_panic(v[6] == 95);
12946 assert_or_panic(v[7] == 96);
12947 assert_or_panic(i == 8);
12948}
12949void c_test_vector_8_f32(void) {
12950 Vector_8_f32 v = zig_ret_vector_8_f32();
12951 assert_or_panic(v[0] == 65);
12952 assert_or_panic(v[1] == 66);
12953 assert_or_panic(v[2] == 67);
12954 assert_or_panic(v[3] == 68);
12955 assert_or_panic(v[4] == 69);
12956 assert_or_panic(v[5] == 70);
12957 assert_or_panic(v[6] == 71);
12958 assert_or_panic(v[7] == 72);
12959 zig_vector_8_f32((Vector_8_f32){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
12960}
12961
12962typedef float Vector_12_f32 __attribute__((vector_size(12 * sizeof(float))));
12963
12964Vector_12_f32 zig_ret_vector_12_f32(void);
12965void zig_vector_12_f32(Vector_12_f32, size_t);
12966
12967Vector_12_f32 c_ret_vector_12_f32(void) {
12968 return (Vector_12_f32){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
12969}
12970void c_vector_12_f32(Vector_12_f32 v, size_t i) {
12971 assert_or_panic(v[0] == 133);
12972 assert_or_panic(v[1] == 134);
12973 assert_or_panic(v[2] == 135);
12974 assert_or_panic(v[3] == 136);
12975 assert_or_panic(v[4] == 137);
12976 assert_or_panic(v[5] == 138);
12977 assert_or_panic(v[6] == 139);
12978 assert_or_panic(v[7] == 140);
12979 assert_or_panic(v[8] == 141);
12980 assert_or_panic(v[9] == 142);
12981 assert_or_panic(v[10] == 143);
12982 assert_or_panic(v[11] == 144);
12983 assert_or_panic(i == 12);
12984}
12985void c_test_vector_12_f32(void) {
12986 Vector_12_f32 v = zig_ret_vector_12_f32();
12987 assert_or_panic(v[0] == 97);
12988 assert_or_panic(v[1] == 98);
12989 assert_or_panic(v[2] == 99);
12990 assert_or_panic(v[3] == 100);
12991 assert_or_panic(v[4] == 101);
12992 assert_or_panic(v[5] == 102);
12993 assert_or_panic(v[6] == 103);
12994 assert_or_panic(v[7] == 104);
12995 assert_or_panic(v[8] == 105);
12996 assert_or_panic(v[9] == 106);
12997 assert_or_panic(v[10] == 107);
12998 assert_or_panic(v[11] == 108);
12999 zig_vector_12_f32((Vector_12_f32){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
13000}
13001
13002typedef float Vector_16_f32 __attribute__((vector_size(16 * sizeof(float))));
13003
13004Vector_16_f32 zig_ret_vector_16_f32(void);
13005void zig_vector_16_f32(Vector_16_f32, size_t);
13006
13007Vector_16_f32 c_ret_vector_16_f32(void) {
13008 return (Vector_16_f32){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
13009}
13010void c_vector_16_f32(Vector_16_f32 v, size_t i) {
13011 assert_or_panic(v[0] == 193);
13012 assert_or_panic(v[1] == 194);
13013 assert_or_panic(v[2] == 195);
13014 assert_or_panic(v[3] == 196);
13015 assert_or_panic(v[4] == 197);
13016 assert_or_panic(v[5] == 198);
13017 assert_or_panic(v[6] == 199);
13018 assert_or_panic(v[7] == 200);
13019 assert_or_panic(v[8] == 201);
13020 assert_or_panic(v[9] == 202);
13021 assert_or_panic(v[10] == 203);
13022 assert_or_panic(v[11] == 204);
13023 assert_or_panic(v[12] == 205);
13024 assert_or_panic(v[13] == 206);
13025 assert_or_panic(v[14] == 207);
13026 assert_or_panic(v[15] == 208);
13027 assert_or_panic(i == 16);
13028}
13029void c_test_vector_16_f32(void) {
13030 Vector_16_f32 v = zig_ret_vector_16_f32();
13031 assert_or_panic(v[0] == 145);
13032 assert_or_panic(v[1] == 146);
13033 assert_or_panic(v[2] == 147);
13034 assert_or_panic(v[3] == 148);
13035 assert_or_panic(v[4] == 149);
13036 assert_or_panic(v[5] == 150);
13037 assert_or_panic(v[6] == 151);
13038 assert_or_panic(v[7] == 152);
13039 assert_or_panic(v[8] == 153);
13040 assert_or_panic(v[9] == 154);
13041 assert_or_panic(v[10] == 155);
13042 assert_or_panic(v[11] == 156);
13043 assert_or_panic(v[12] == 157);
13044 assert_or_panic(v[13] == 158);
13045 assert_or_panic(v[14] == 159);
13046 assert_or_panic(v[15] == 160);
13047 zig_vector_16_f32((Vector_16_f32){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
13048}
13049
13050typedef float Vector_24_f32 __attribute__((vector_size(24 * sizeof(float))));
13051
13052Vector_24_f32 zig_ret_vector_24_f32(void);
13053void zig_vector_24_f32(Vector_24_f32, size_t);
13054
13055Vector_24_f32 c_ret_vector_24_f32(void) {
13056 return (Vector_24_f32){
13057 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
13058 273, 274, 275, 276, 277, 278, 279, 280,
13059 };
13060}
13061void c_vector_24_f32(Vector_24_f32 v, size_t i) {
13062 assert_or_panic(v[0] == 281);
13063 assert_or_panic(v[1] == 282);
13064 assert_or_panic(v[2] == 283);
13065 assert_or_panic(v[3] == 284);
13066 assert_or_panic(v[4] == 285);
13067 assert_or_panic(v[5] == 286);
13068 assert_or_panic(v[6] == 287);
13069 assert_or_panic(v[7] == 288);
13070 assert_or_panic(v[8] == 289);
13071 assert_or_panic(v[9] == 290);
13072 assert_or_panic(v[10] == 291);
13073 assert_or_panic(v[11] == 292);
13074 assert_or_panic(v[12] == 293);
13075 assert_or_panic(v[13] == 294);
13076 assert_or_panic(v[14] == 295);
13077 assert_or_panic(v[15] == 296);
13078 assert_or_panic(v[16] == 297);
13079 assert_or_panic(v[17] == 298);
13080 assert_or_panic(v[18] == 299);
13081 assert_or_panic(v[19] == 300);
13082 assert_or_panic(v[20] == 301);
13083 assert_or_panic(v[21] == 302);
13084 assert_or_panic(v[22] == 303);
13085 assert_or_panic(v[23] == 304);
13086 assert_or_panic(i == 24);
13087}
13088void c_test_vector_24_f32(void) {
13089 Vector_24_f32 v = zig_ret_vector_24_f32();
13090 assert_or_panic(v[0] == 209);
13091 assert_or_panic(v[1] == 210);
13092 assert_or_panic(v[2] == 211);
13093 assert_or_panic(v[3] == 212);
13094 assert_or_panic(v[4] == 213);
13095 assert_or_panic(v[5] == 214);
13096 assert_or_panic(v[6] == 215);
13097 assert_or_panic(v[7] == 216);
13098 assert_or_panic(v[8] == 217);
13099 assert_or_panic(v[9] == 218);
13100 assert_or_panic(v[10] == 219);
13101 assert_or_panic(v[11] == 220);
13102 assert_or_panic(v[12] == 221);
13103 assert_or_panic(v[13] == 222);
13104 assert_or_panic(v[14] == 223);
13105 assert_or_panic(v[15] == 224);
13106 assert_or_panic(v[16] == 225);
13107 assert_or_panic(v[17] == 226);
13108 assert_or_panic(v[18] == 227);
13109 assert_or_panic(v[19] == 228);
13110 assert_or_panic(v[20] == 229);
13111 assert_or_panic(v[21] == 230);
13112 assert_or_panic(v[22] == 231);
13113 assert_or_panic(v[23] == 232);
13114 zig_vector_24_f32((Vector_24_f32){
13115 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
13116 249, 250, 251, 252, 253, 254, 255, 256,
13117 }, 24);
13118}
13119
13120typedef float Vector_32_f32 __attribute__((vector_size(32 * sizeof(float))));
13121
13122Vector_32_f32 zig_ret_vector_32_f32(void);
13123void zig_vector_32_f32(Vector_32_f32, size_t);
13124
13125Vector_32_f32 c_ret_vector_32_f32(void) {
13126 return (Vector_32_f32){
13127 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
13128 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
13129 };
13130}
13131void c_vector_32_f32(Vector_32_f32 v, size_t i) {
13132 assert_or_panic(v[0] == 401);
13133 assert_or_panic(v[1] == 402);
13134 assert_or_panic(v[2] == 403);
13135 assert_or_panic(v[3] == 404);
13136 assert_or_panic(v[4] == 405);
13137 assert_or_panic(v[5] == 406);
13138 assert_or_panic(v[6] == 407);
13139 assert_or_panic(v[7] == 408);
13140 assert_or_panic(v[8] == 409);
13141 assert_or_panic(v[9] == 410);
13142 assert_or_panic(v[10] == 411);
13143 assert_or_panic(v[11] == 412);
13144 assert_or_panic(v[12] == 413);
13145 assert_or_panic(v[13] == 414);
13146 assert_or_panic(v[14] == 415);
13147 assert_or_panic(v[15] == 416);
13148 assert_or_panic(v[16] == 417);
13149 assert_or_panic(v[17] == 418);
13150 assert_or_panic(v[18] == 419);
13151 assert_or_panic(v[19] == 420);
13152 assert_or_panic(v[20] == 421);
13153 assert_or_panic(v[21] == 422);
13154 assert_or_panic(v[22] == 423);
13155 assert_or_panic(v[23] == 424);
13156 assert_or_panic(v[24] == 425);
13157 assert_or_panic(v[25] == 426);
13158 assert_or_panic(v[26] == 427);
13159 assert_or_panic(v[27] == 428);
13160 assert_or_panic(v[28] == 429);
13161 assert_or_panic(v[29] == 430);
13162 assert_or_panic(v[30] == 431);
13163 assert_or_panic(v[31] == 432);
13164 assert_or_panic(i == 32);
13165}
13166void c_test_vector_32_f32(void) {
13167 Vector_32_f32 v = zig_ret_vector_32_f32();
13168 assert_or_panic(v[0] == 305);
13169 assert_or_panic(v[1] == 306);
13170 assert_or_panic(v[2] == 307);
13171 assert_or_panic(v[3] == 308);
13172 assert_or_panic(v[4] == 309);
13173 assert_or_panic(v[5] == 310);
13174 assert_or_panic(v[6] == 311);
13175 assert_or_panic(v[7] == 312);
13176 assert_or_panic(v[8] == 313);
13177 assert_or_panic(v[9] == 314);
13178 assert_or_panic(v[10] == 315);
13179 assert_or_panic(v[11] == 316);
13180 assert_or_panic(v[12] == 317);
13181 assert_or_panic(v[13] == 318);
13182 assert_or_panic(v[14] == 319);
13183 assert_or_panic(v[15] == 320);
13184 assert_or_panic(v[16] == 321);
13185 assert_or_panic(v[17] == 322);
13186 assert_or_panic(v[18] == 323);
13187 assert_or_panic(v[19] == 324);
13188 assert_or_panic(v[20] == 325);
13189 assert_or_panic(v[21] == 326);
13190 assert_or_panic(v[22] == 327);
13191 assert_or_panic(v[23] == 328);
13192 assert_or_panic(v[24] == 329);
13193 assert_or_panic(v[25] == 330);
13194 assert_or_panic(v[26] == 331);
13195 assert_or_panic(v[27] == 332);
13196 assert_or_panic(v[28] == 333);
13197 assert_or_panic(v[29] == 334);
13198 assert_or_panic(v[30] == 335);
13199 assert_or_panic(v[31] == 336);
13200 zig_vector_32_f32((Vector_32_f32){
13201 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
13202 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
13203 }, 32);
13204}
13205
13206typedef float Vector_48_f32 __attribute__((vector_size(48 * sizeof(float))));
13207
13208Vector_48_f32 zig_ret_vector_48_f32(void);
13209void zig_vector_48_f32(Vector_48_f32, size_t);
13210
13211Vector_48_f32 c_ret_vector_48_f32(void) {
13212 return (Vector_48_f32){
13213 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
13214 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
13215 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
13216 };
13217}
13218void c_vector_48_f32(Vector_48_f32 v, size_t i) {
13219 assert_or_panic(v[0] == 577);
13220 assert_or_panic(v[1] == 578);
13221 assert_or_panic(v[2] == 579);
13222 assert_or_panic(v[3] == 580);
13223 assert_or_panic(v[4] == 581);
13224 assert_or_panic(v[5] == 582);
13225 assert_or_panic(v[6] == 583);
13226 assert_or_panic(v[7] == 584);
13227 assert_or_panic(v[8] == 585);
13228 assert_or_panic(v[9] == 586);
13229 assert_or_panic(v[10] == 587);
13230 assert_or_panic(v[11] == 588);
13231 assert_or_panic(v[12] == 589);
13232 assert_or_panic(v[13] == 590);
13233 assert_or_panic(v[14] == 591);
13234 assert_or_panic(v[15] == 592);
13235 assert_or_panic(v[16] == 593);
13236 assert_or_panic(v[17] == 594);
13237 assert_or_panic(v[18] == 595);
13238 assert_or_panic(v[19] == 596);
13239 assert_or_panic(v[20] == 597);
13240 assert_or_panic(v[21] == 598);
13241 assert_or_panic(v[22] == 599);
13242 assert_or_panic(v[23] == 600);
13243 assert_or_panic(v[24] == 601);
13244 assert_or_panic(v[25] == 602);
13245 assert_or_panic(v[26] == 603);
13246 assert_or_panic(v[27] == 604);
13247 assert_or_panic(v[28] == 605);
13248 assert_or_panic(v[29] == 606);
13249 assert_or_panic(v[30] == 607);
13250 assert_or_panic(v[31] == 608);
13251 assert_or_panic(v[32] == 609);
13252 assert_or_panic(v[33] == 610);
13253 assert_or_panic(v[34] == 611);
13254 assert_or_panic(v[35] == 612);
13255 assert_or_panic(v[36] == 613);
13256 assert_or_panic(v[37] == 614);
13257 assert_or_panic(v[38] == 615);
13258 assert_or_panic(v[39] == 616);
13259 assert_or_panic(v[40] == 617);
13260 assert_or_panic(v[41] == 618);
13261 assert_or_panic(v[42] == 619);
13262 assert_or_panic(v[43] == 620);
13263 assert_or_panic(v[44] == 621);
13264 assert_or_panic(v[45] == 622);
13265 assert_or_panic(v[46] == 623);
13266 assert_or_panic(v[47] == 624);
13267 assert_or_panic(i == 48);
13268}
13269void c_test_vector_48_f32(void) {
13270 Vector_48_f32 v = zig_ret_vector_48_f32();
13271 assert_or_panic(v[0] == 433);
13272 assert_or_panic(v[1] == 434);
13273 assert_or_panic(v[2] == 435);
13274 assert_or_panic(v[3] == 436);
13275 assert_or_panic(v[4] == 437);
13276 assert_or_panic(v[5] == 438);
13277 assert_or_panic(v[6] == 439);
13278 assert_or_panic(v[7] == 440);
13279 assert_or_panic(v[8] == 441);
13280 assert_or_panic(v[9] == 442);
13281 assert_or_panic(v[10] == 443);
13282 assert_or_panic(v[11] == 444);
13283 assert_or_panic(v[12] == 445);
13284 assert_or_panic(v[13] == 446);
13285 assert_or_panic(v[14] == 447);
13286 assert_or_panic(v[15] == 448);
13287 assert_or_panic(v[16] == 449);
13288 assert_or_panic(v[17] == 450);
13289 assert_or_panic(v[18] == 451);
13290 assert_or_panic(v[19] == 452);
13291 assert_or_panic(v[20] == 453);
13292 assert_or_panic(v[21] == 454);
13293 assert_or_panic(v[22] == 455);
13294 assert_or_panic(v[23] == 456);
13295 assert_or_panic(v[24] == 457);
13296 assert_or_panic(v[25] == 458);
13297 assert_or_panic(v[26] == 459);
13298 assert_or_panic(v[27] == 460);
13299 assert_or_panic(v[28] == 461);
13300 assert_or_panic(v[29] == 462);
13301 assert_or_panic(v[30] == 463);
13302 assert_or_panic(v[31] == 464);
13303 assert_or_panic(v[32] == 465);
13304 assert_or_panic(v[33] == 466);
13305 assert_or_panic(v[34] == 467);
13306 assert_or_panic(v[35] == 468);
13307 assert_or_panic(v[36] == 469);
13308 assert_or_panic(v[37] == 470);
13309 assert_or_panic(v[38] == 471);
13310 assert_or_panic(v[39] == 472);
13311 assert_or_panic(v[40] == 473);
13312 assert_or_panic(v[41] == 474);
13313 assert_or_panic(v[42] == 475);
13314 assert_or_panic(v[43] == 476);
13315 assert_or_panic(v[44] == 477);
13316 assert_or_panic(v[45] == 478);
13317 assert_or_panic(v[46] == 479);
13318 assert_or_panic(v[47] == 480);
13319 zig_vector_48_f32((Vector_48_f32){
13320 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
13321 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
13322 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
13323 }, 48);
13324}
13325
13326typedef float Vector_64_f32 __attribute__((vector_size(64 * sizeof(float))));
13327
13328Vector_64_f32 zig_ret_vector_64_f32(void);
13329void zig_vector_64_f32(Vector_64_f32, size_t);
13330
13331Vector_64_f32 c_ret_vector_64_f32(void) {
13332 return (Vector_64_f32){
13333 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
13334 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
13335 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
13336 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
13337 };
13338}
13339void c_vector_64_f32(Vector_64_f32 v, size_t i) {
13340 assert_or_panic(v[0] == 817);
13341 assert_or_panic(v[1] == 818);
13342 assert_or_panic(v[2] == 819);
13343 assert_or_panic(v[3] == 820);
13344 assert_or_panic(v[4] == 821);
13345 assert_or_panic(v[5] == 822);
13346 assert_or_panic(v[6] == 823);
13347 assert_or_panic(v[7] == 824);
13348 assert_or_panic(v[8] == 825);
13349 assert_or_panic(v[9] == 826);
13350 assert_or_panic(v[10] == 827);
13351 assert_or_panic(v[11] == 828);
13352 assert_or_panic(v[12] == 829);
13353 assert_or_panic(v[13] == 830);
13354 assert_or_panic(v[14] == 831);
13355 assert_or_panic(v[15] == 832);
13356 assert_or_panic(v[16] == 833);
13357 assert_or_panic(v[17] == 834);
13358 assert_or_panic(v[18] == 835);
13359 assert_or_panic(v[19] == 836);
13360 assert_or_panic(v[20] == 837);
13361 assert_or_panic(v[21] == 838);
13362 assert_or_panic(v[22] == 839);
13363 assert_or_panic(v[23] == 840);
13364 assert_or_panic(v[24] == 841);
13365 assert_or_panic(v[25] == 842);
13366 assert_or_panic(v[26] == 843);
13367 assert_or_panic(v[27] == 844);
13368 assert_or_panic(v[28] == 845);
13369 assert_or_panic(v[29] == 846);
13370 assert_or_panic(v[30] == 847);
13371 assert_or_panic(v[31] == 848);
13372 assert_or_panic(v[32] == 849);
13373 assert_or_panic(v[33] == 850);
13374 assert_or_panic(v[34] == 851);
13375 assert_or_panic(v[35] == 852);
13376 assert_or_panic(v[36] == 853);
13377 assert_or_panic(v[37] == 854);
13378 assert_or_panic(v[38] == 855);
13379 assert_or_panic(v[39] == 856);
13380 assert_or_panic(v[40] == 857);
13381 assert_or_panic(v[41] == 858);
13382 assert_or_panic(v[42] == 859);
13383 assert_or_panic(v[43] == 860);
13384 assert_or_panic(v[44] == 861);
13385 assert_or_panic(v[45] == 862);
13386 assert_or_panic(v[46] == 863);
13387 assert_or_panic(v[47] == 864);
13388 assert_or_panic(v[48] == 865);
13389 assert_or_panic(v[49] == 866);
13390 assert_or_panic(v[50] == 867);
13391 assert_or_panic(v[51] == 868);
13392 assert_or_panic(v[52] == 869);
13393 assert_or_panic(v[53] == 870);
13394 assert_or_panic(v[54] == 871);
13395 assert_or_panic(v[55] == 872);
13396 assert_or_panic(v[56] == 873);
13397 assert_or_panic(v[57] == 874);
13398 assert_or_panic(v[58] == 875);
13399 assert_or_panic(v[59] == 876);
13400 assert_or_panic(v[60] == 877);
13401 assert_or_panic(v[61] == 878);
13402 assert_or_panic(v[62] == 879);
13403 assert_or_panic(v[63] == 880);
13404 assert_or_panic(i == 64);
13405}
13406void c_test_vector_64_f32(void) {
13407 Vector_64_f32 v = zig_ret_vector_64_f32();
13408 assert_or_panic(v[0] == 625);
13409 assert_or_panic(v[1] == 626);
13410 assert_or_panic(v[2] == 627);
13411 assert_or_panic(v[3] == 628);
13412 assert_or_panic(v[4] == 629);
13413 assert_or_panic(v[5] == 630);
13414 assert_or_panic(v[6] == 631);
13415 assert_or_panic(v[7] == 632);
13416 assert_or_panic(v[8] == 633);
13417 assert_or_panic(v[9] == 634);
13418 assert_or_panic(v[10] == 635);
13419 assert_or_panic(v[11] == 636);
13420 assert_or_panic(v[12] == 637);
13421 assert_or_panic(v[13] == 638);
13422 assert_or_panic(v[14] == 639);
13423 assert_or_panic(v[15] == 640);
13424 assert_or_panic(v[16] == 641);
13425 assert_or_panic(v[17] == 642);
13426 assert_or_panic(v[18] == 643);
13427 assert_or_panic(v[19] == 644);
13428 assert_or_panic(v[20] == 645);
13429 assert_or_panic(v[21] == 646);
13430 assert_or_panic(v[22] == 647);
13431 assert_or_panic(v[23] == 648);
13432 assert_or_panic(v[24] == 649);
13433 assert_or_panic(v[25] == 650);
13434 assert_or_panic(v[26] == 651);
13435 assert_or_panic(v[27] == 652);
13436 assert_or_panic(v[28] == 653);
13437 assert_or_panic(v[29] == 654);
13438 assert_or_panic(v[30] == 655);
13439 assert_or_panic(v[31] == 656);
13440 assert_or_panic(v[32] == 657);
13441 assert_or_panic(v[33] == 658);
13442 assert_or_panic(v[34] == 659);
13443 assert_or_panic(v[35] == 660);
13444 assert_or_panic(v[36] == 661);
13445 assert_or_panic(v[37] == 662);
13446 assert_or_panic(v[38] == 663);
13447 assert_or_panic(v[39] == 664);
13448 assert_or_panic(v[40] == 665);
13449 assert_or_panic(v[41] == 666);
13450 assert_or_panic(v[42] == 667);
13451 assert_or_panic(v[43] == 668);
13452 assert_or_panic(v[44] == 669);
13453 assert_or_panic(v[45] == 670);
13454 assert_or_panic(v[46] == 671);
13455 assert_or_panic(v[47] == 672);
13456 assert_or_panic(v[48] == 673);
13457 assert_or_panic(v[49] == 674);
13458 assert_or_panic(v[50] == 675);
13459 assert_or_panic(v[51] == 676);
13460 assert_or_panic(v[52] == 677);
13461 assert_or_panic(v[53] == 678);
13462 assert_or_panic(v[54] == 679);
13463 assert_or_panic(v[55] == 680);
13464 assert_or_panic(v[56] == 681);
13465 assert_or_panic(v[57] == 682);
13466 assert_or_panic(v[58] == 683);
13467 assert_or_panic(v[59] == 684);
13468 assert_or_panic(v[60] == 685);
13469 assert_or_panic(v[61] == 686);
13470 assert_or_panic(v[62] == 687);
13471 assert_or_panic(v[63] == 688);
13472 zig_vector_64_f32((Vector_64_f32){
13473 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
13474 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
13475 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
13476 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
13477 }, 64);
13478}
13479
13480typedef float Vector_96_f32 __attribute__((vector_size(96 * sizeof(float))));
13481
13482Vector_96_f32 zig_ret_vector_96_f32(void);
13483void zig_vector_96_f32(Vector_96_f32, size_t);
13484
13485Vector_96_f32 c_ret_vector_96_f32(void) {
13486 return (Vector_96_f32){
13487 1082, 1083, 1084, 1085, 1086, 1087, 1088, 1089, 1090, 1091, 1092, 1093, 1094, 1095, 1096, 1097,
13488 1098, 1099, 1100, 1101, 1102, 1103, 1104, 1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 1113,
13489 1114, 1115, 1116, 1117, 1118, 1119, 1120, 1121, 1122, 1123, 1124, 1125, 1126, 1127, 1128, 1129,
13490 1130, 1131, 1132, 1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 1143, 1144, 1145,
13491 1146, 1147, 1148, 1149, 1150, 1151, 1152, 1153, 1154, 1155, 1156, 1157, 1158, 1159, 1160, 1161,
13492 1162, 1163, 1164, 1165, 1166, 1167, 1168, 1169, 1170, 1171, 1172, 1173, 1174, 1175, 1176, 1177,
13493 };
13494}
13495void c_vector_96_f32(Vector_96_f32 v, size_t i) {
13496 assert_or_panic(v[0] == 1178);
13497 assert_or_panic(v[1] == 1179);
13498 assert_or_panic(v[2] == 1180);
13499 assert_or_panic(v[3] == 1181);
13500 assert_or_panic(v[4] == 1182);
13501 assert_or_panic(v[5] == 1183);
13502 assert_or_panic(v[6] == 1184);
13503 assert_or_panic(v[7] == 1185);
13504 assert_or_panic(v[8] == 1186);
13505 assert_or_panic(v[9] == 1187);
13506 assert_or_panic(v[10] == 1188);
13507 assert_or_panic(v[11] == 1189);
13508 assert_or_panic(v[12] == 1190);
13509 assert_or_panic(v[13] == 1191);
13510 assert_or_panic(v[14] == 1192);
13511 assert_or_panic(v[15] == 1193);
13512 assert_or_panic(v[16] == 1194);
13513 assert_or_panic(v[17] == 1195);
13514 assert_or_panic(v[18] == 1196);
13515 assert_or_panic(v[19] == 1197);
13516 assert_or_panic(v[20] == 1198);
13517 assert_or_panic(v[21] == 1199);
13518 assert_or_panic(v[22] == 1200);
13519 assert_or_panic(v[23] == 1201);
13520 assert_or_panic(v[24] == 1202);
13521 assert_or_panic(v[25] == 1203);
13522 assert_or_panic(v[26] == 1204);
13523 assert_or_panic(v[27] == 1205);
13524 assert_or_panic(v[28] == 1206);
13525 assert_or_panic(v[29] == 1207);
13526 assert_or_panic(v[30] == 1208);
13527 assert_or_panic(v[31] == 1209);
13528 assert_or_panic(v[32] == 1210);
13529 assert_or_panic(v[33] == 1211);
13530 assert_or_panic(v[34] == 1212);
13531 assert_or_panic(v[35] == 1213);
13532 assert_or_panic(v[36] == 1214);
13533 assert_or_panic(v[37] == 1215);
13534 assert_or_panic(v[38] == 1216);
13535 assert_or_panic(v[39] == 1217);
13536 assert_or_panic(v[40] == 1218);
13537 assert_or_panic(v[41] == 1219);
13538 assert_or_panic(v[42] == 1220);
13539 assert_or_panic(v[43] == 1221);
13540 assert_or_panic(v[44] == 1222);
13541 assert_or_panic(v[45] == 1223);
13542 assert_or_panic(v[46] == 1224);
13543 assert_or_panic(v[47] == 1225);
13544 assert_or_panic(v[48] == 1226);
13545 assert_or_panic(v[49] == 1227);
13546 assert_or_panic(v[50] == 1228);
13547 assert_or_panic(v[51] == 1229);
13548 assert_or_panic(v[52] == 1230);
13549 assert_or_panic(v[53] == 1231);
13550 assert_or_panic(v[54] == 1232);
13551 assert_or_panic(v[55] == 1233);
13552 assert_or_panic(v[56] == 1234);
13553 assert_or_panic(v[57] == 1235);
13554 assert_or_panic(v[58] == 1236);
13555 assert_or_panic(v[59] == 1237);
13556 assert_or_panic(v[60] == 1238);
13557 assert_or_panic(v[61] == 1239);
13558 assert_or_panic(v[62] == 1240);
13559 assert_or_panic(v[63] == 1241);
13560 assert_or_panic(v[64] == 1242);
13561 assert_or_panic(v[65] == 1243);
13562 assert_or_panic(v[66] == 1244);
13563 assert_or_panic(v[67] == 1245);
13564 assert_or_panic(v[68] == 1246);
13565 assert_or_panic(v[69] == 1247);
13566 assert_or_panic(v[70] == 1248);
13567 assert_or_panic(v[71] == 1249);
13568 assert_or_panic(v[72] == 1250);
13569 assert_or_panic(v[73] == 1251);
13570 assert_or_panic(v[74] == 1252);
13571 assert_or_panic(v[75] == 1253);
13572 assert_or_panic(v[76] == 1254);
13573 assert_or_panic(v[77] == 1255);
13574 assert_or_panic(v[80] == 1258);
13575 assert_or_panic(v[81] == 1259);
13576 assert_or_panic(v[82] == 1260);
13577 assert_or_panic(v[83] == 1261);
13578 assert_or_panic(v[84] == 1262);
13579 assert_or_panic(v[85] == 1263);
13580 assert_or_panic(v[86] == 1264);
13581 assert_or_panic(v[87] == 1265);
13582 assert_or_panic(v[88] == 1266);
13583 assert_or_panic(v[89] == 1267);
13584 assert_or_panic(v[90] == 1268);
13585 assert_or_panic(v[91] == 1269);
13586 assert_or_panic(v[92] == 1270);
13587 assert_or_panic(v[93] == 1271);
13588 assert_or_panic(v[94] == 1272);
13589 assert_or_panic(v[95] == 1273);
13590 assert_or_panic(i == 96);
13591}
13592void c_test_vector_96_f32(void) {
13593 Vector_96_f32 v = zig_ret_vector_96_f32();
13594 assert_or_panic(v[0] == 890);
13595 assert_or_panic(v[1] == 891);
13596 assert_or_panic(v[2] == 892);
13597 assert_or_panic(v[3] == 893);
13598 assert_or_panic(v[4] == 894);
13599 assert_or_panic(v[5] == 895);
13600 assert_or_panic(v[6] == 896);
13601 assert_or_panic(v[7] == 897);
13602 assert_or_panic(v[8] == 898);
13603 assert_or_panic(v[9] == 899);
13604 assert_or_panic(v[10] == 900);
13605 assert_or_panic(v[11] == 901);
13606 assert_or_panic(v[12] == 902);
13607 assert_or_panic(v[13] == 903);
13608 assert_or_panic(v[14] == 904);
13609 assert_or_panic(v[15] == 905);
13610 assert_or_panic(v[16] == 906);
13611 assert_or_panic(v[17] == 907);
13612 assert_or_panic(v[18] == 908);
13613 assert_or_panic(v[19] == 909);
13614 assert_or_panic(v[20] == 910);
13615 assert_or_panic(v[21] == 911);
13616 assert_or_panic(v[22] == 912);
13617 assert_or_panic(v[23] == 913);
13618 assert_or_panic(v[24] == 914);
13619 assert_or_panic(v[25] == 915);
13620 assert_or_panic(v[26] == 916);
13621 assert_or_panic(v[27] == 917);
13622 assert_or_panic(v[28] == 918);
13623 assert_or_panic(v[29] == 919);
13624 assert_or_panic(v[30] == 920);
13625 assert_or_panic(v[31] == 921);
13626 assert_or_panic(v[32] == 922);
13627 assert_or_panic(v[33] == 923);
13628 assert_or_panic(v[34] == 924);
13629 assert_or_panic(v[35] == 925);
13630 assert_or_panic(v[36] == 926);
13631 assert_or_panic(v[37] == 927);
13632 assert_or_panic(v[38] == 928);
13633 assert_or_panic(v[39] == 929);
13634 assert_or_panic(v[40] == 930);
13635 assert_or_panic(v[41] == 931);
13636 assert_or_panic(v[42] == 932);
13637 assert_or_panic(v[43] == 933);
13638 assert_or_panic(v[44] == 934);
13639 assert_or_panic(v[45] == 935);
13640 assert_or_panic(v[46] == 936);
13641 assert_or_panic(v[47] == 937);
13642 assert_or_panic(v[48] == 938);
13643 assert_or_panic(v[49] == 939);
13644 assert_or_panic(v[50] == 940);
13645 assert_or_panic(v[51] == 941);
13646 assert_or_panic(v[52] == 942);
13647 assert_or_panic(v[53] == 943);
13648 assert_or_panic(v[54] == 944);
13649 assert_or_panic(v[55] == 945);
13650 assert_or_panic(v[56] == 946);
13651 assert_or_panic(v[57] == 947);
13652 assert_or_panic(v[58] == 948);
13653 assert_or_panic(v[59] == 949);
13654 assert_or_panic(v[60] == 950);
13655 assert_or_panic(v[61] == 951);
13656 assert_or_panic(v[62] == 952);
13657 assert_or_panic(v[63] == 953);
13658 assert_or_panic(v[64] == 954);
13659 assert_or_panic(v[65] == 955);
13660 assert_or_panic(v[66] == 956);
13661 assert_or_panic(v[67] == 957);
13662 assert_or_panic(v[68] == 958);
13663 assert_or_panic(v[69] == 959);
13664 assert_or_panic(v[70] == 960);
13665 assert_or_panic(v[71] == 961);
13666 assert_or_panic(v[72] == 962);
13667 assert_or_panic(v[73] == 963);
13668 assert_or_panic(v[74] == 964);
13669 assert_or_panic(v[75] == 965);
13670 assert_or_panic(v[76] == 966);
13671 assert_or_panic(v[77] == 967);
13672 assert_or_panic(v[78] == 968);
13673 assert_or_panic(v[79] == 969);
13674 assert_or_panic(v[80] == 970);
13675 assert_or_panic(v[81] == 971);
13676 assert_or_panic(v[82] == 972);
13677 assert_or_panic(v[83] == 973);
13678 assert_or_panic(v[84] == 974);
13679 assert_or_panic(v[85] == 975);
13680 assert_or_panic(v[86] == 976);
13681 assert_or_panic(v[87] == 977);
13682 assert_or_panic(v[88] == 978);
13683 assert_or_panic(v[89] == 979);
13684 assert_or_panic(v[90] == 980);
13685 assert_or_panic(v[91] == 981);
13686 assert_or_panic(v[92] == 982);
13687 assert_or_panic(v[93] == 983);
13688 assert_or_panic(v[94] == 984);
13689 assert_or_panic(v[95] == 985);
13690 zig_vector_96_f32((Vector_96_f32){
13691 986, 987, 988, 989, 990, 991, 992, 993, 994, 995, 996, 997, 998, 999, 1000, 1001,
13692 1002, 1003, 1004, 1005, 1006, 1007, 1008, 1009, 1010, 1011, 1012, 1013, 1014, 1015, 1016, 1017,
13693 1018, 1019, 1020, 1021, 1022, 1023, 1024, 1025, 1026, 1027, 1028, 1029, 1030, 1031, 1032, 1033,
13694 1034, 1035, 1036, 1037, 1038, 1039, 1040, 1041, 1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049,
13695 1050, 1051, 1052, 1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 1061, 1062, 1063, 1064, 1065,
13696 1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081,
13697 }, 96);
13698}
13699
13700typedef float Vector_128_f32 __attribute__((vector_size(128 * sizeof(float))));
13701
13702Vector_128_f32 zig_ret_vector_128_f32(void);
13703void zig_vector_128_f32(Vector_128_f32, size_t);
13704
13705Vector_128_f32 c_ret_vector_128_f32(void) {
13706 return (Vector_128_f32){
13707 1530, 1531, 1532, 1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 1541, 1542, 1543, 1544, 1545,
13708 1546, 1547, 1548, 1549, 1550, 1551, 1552, 1553, 1554, 1555, 1556, 1557, 1558, 1559, 1560, 1561,
13709 1562, 1563, 1564, 1565, 1566, 1567, 1568, 1569, 1570, 1571, 1572, 1573, 1574, 1575, 1576, 1577,
13710 1578, 1579, 1580, 1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 1589, 1590, 1591, 1592, 1593,
13711 1594, 1595, 1596, 1597, 1598, 1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 1607, 1608, 1609,
13712 1610, 1611, 1612, 1613, 1614, 1615, 1616, 1617, 1618, 1619, 1620, 1621, 1622, 1623, 1624, 1625,
13713 1626, 1627, 1628, 1629, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 1639, 1640, 1641,
13714 1642, 1643, 1644, 1645, 1646, 1647, 1648, 1649, 1650, 1651, 1652, 1653, 1654, 1655, 1656, 1657,
13715 };
13716}
13717void c_vector_128_f32(Vector_128_f32 v, size_t i) {
13718 assert_or_panic(v[0] == 1658);
13719 assert_or_panic(v[1] == 1659);
13720 assert_or_panic(v[2] == 1660);
13721 assert_or_panic(v[3] == 1661);
13722 assert_or_panic(v[4] == 1662);
13723 assert_or_panic(v[5] == 1663);
13724 assert_or_panic(v[6] == 1664);
13725 assert_or_panic(v[7] == 1665);
13726 assert_or_panic(v[8] == 1666);
13727 assert_or_panic(v[9] == 1667);
13728 assert_or_panic(v[10] == 1668);
13729 assert_or_panic(v[11] == 1669);
13730 assert_or_panic(v[12] == 1670);
13731 assert_or_panic(v[13] == 1671);
13732 assert_or_panic(v[14] == 1672);
13733 assert_or_panic(v[15] == 1673);
13734 assert_or_panic(v[16] == 1674);
13735 assert_or_panic(v[17] == 1675);
13736 assert_or_panic(v[18] == 1676);
13737 assert_or_panic(v[19] == 1677);
13738 assert_or_panic(v[20] == 1678);
13739 assert_or_panic(v[21] == 1679);
13740 assert_or_panic(v[22] == 1680);
13741 assert_or_panic(v[23] == 1681);
13742 assert_or_panic(v[24] == 1682);
13743 assert_or_panic(v[25] == 1683);
13744 assert_or_panic(v[26] == 1684);
13745 assert_or_panic(v[27] == 1685);
13746 assert_or_panic(v[28] == 1686);
13747 assert_or_panic(v[29] == 1687);
13748 assert_or_panic(v[30] == 1688);
13749 assert_or_panic(v[31] == 1689);
13750 assert_or_panic(v[32] == 1690);
13751 assert_or_panic(v[33] == 1691);
13752 assert_or_panic(v[34] == 1692);
13753 assert_or_panic(v[35] == 1693);
13754 assert_or_panic(v[36] == 1694);
13755 assert_or_panic(v[37] == 1695);
13756 assert_or_panic(v[38] == 1696);
13757 assert_or_panic(v[39] == 1697);
13758 assert_or_panic(v[40] == 1698);
13759 assert_or_panic(v[41] == 1699);
13760 assert_or_panic(v[42] == 1700);
13761 assert_or_panic(v[43] == 1701);
13762 assert_or_panic(v[44] == 1702);
13763 assert_or_panic(v[45] == 1703);
13764 assert_or_panic(v[46] == 1704);
13765 assert_or_panic(v[47] == 1705);
13766 assert_or_panic(v[48] == 1706);
13767 assert_or_panic(v[49] == 1707);
13768 assert_or_panic(v[50] == 1708);
13769 assert_or_panic(v[51] == 1709);
13770 assert_or_panic(v[52] == 1710);
13771 assert_or_panic(v[53] == 1711);
13772 assert_or_panic(v[54] == 1712);
13773 assert_or_panic(v[55] == 1713);
13774 assert_or_panic(v[56] == 1714);
13775 assert_or_panic(v[57] == 1715);
13776 assert_or_panic(v[58] == 1716);
13777 assert_or_panic(v[59] == 1717);
13778 assert_or_panic(v[60] == 1718);
13779 assert_or_panic(v[61] == 1719);
13780 assert_or_panic(v[62] == 1720);
13781 assert_or_panic(v[63] == 1721);
13782 assert_or_panic(v[64] == 1722);
13783 assert_or_panic(v[65] == 1723);
13784 assert_or_panic(v[66] == 1724);
13785 assert_or_panic(v[67] == 1725);
13786 assert_or_panic(v[68] == 1726);
13787 assert_or_panic(v[69] == 1727);
13788 assert_or_panic(v[70] == 1728);
13789 assert_or_panic(v[71] == 1729);
13790 assert_or_panic(v[72] == 1730);
13791 assert_or_panic(v[73] == 1731);
13792 assert_or_panic(v[74] == 1732);
13793 assert_or_panic(v[75] == 1733);
13794 assert_or_panic(v[76] == 1734);
13795 assert_or_panic(v[77] == 1735);
13796 assert_or_panic(v[78] == 1736);
13797 assert_or_panic(v[79] == 1737);
13798 assert_or_panic(v[80] == 1738);
13799 assert_or_panic(v[81] == 1739);
13800 assert_or_panic(v[82] == 1740);
13801 assert_or_panic(v[83] == 1741);
13802 assert_or_panic(v[84] == 1742);
13803 assert_or_panic(v[85] == 1743);
13804 assert_or_panic(v[86] == 1744);
13805 assert_or_panic(v[87] == 1745);
13806 assert_or_panic(v[88] == 1746);
13807 assert_or_panic(v[89] == 1747);
13808 assert_or_panic(v[90] == 1748);
13809 assert_or_panic(v[91] == 1749);
13810 assert_or_panic(v[92] == 1750);
13811 assert_or_panic(v[93] == 1751);
13812 assert_or_panic(v[94] == 1752);
13813 assert_or_panic(v[95] == 1753);
13814 assert_or_panic(v[96] == 1754);
13815 assert_or_panic(v[97] == 1755);
13816 assert_or_panic(v[98] == 1756);
13817 assert_or_panic(v[99] == 1757);
13818 assert_or_panic(v[100] == 1758);
13819 assert_or_panic(v[101] == 1759);
13820 assert_or_panic(v[102] == 1760);
13821 assert_or_panic(v[103] == 1761);
13822 assert_or_panic(v[104] == 1762);
13823 assert_or_panic(v[105] == 1763);
13824 assert_or_panic(v[106] == 1764);
13825 assert_or_panic(v[107] == 1765);
13826 assert_or_panic(v[108] == 1766);
13827 assert_or_panic(v[109] == 1767);
13828 assert_or_panic(v[110] == 1768);
13829 assert_or_panic(v[111] == 1769);
13830 assert_or_panic(v[112] == 1770);
13831 assert_or_panic(v[113] == 1771);
13832 assert_or_panic(v[114] == 1772);
13833 assert_or_panic(v[115] == 1773);
13834 assert_or_panic(v[116] == 1774);
13835 assert_or_panic(v[117] == 1775);
13836 assert_or_panic(v[118] == 1776);
13837 assert_or_panic(v[119] == 1777);
13838 assert_or_panic(v[120] == 1778);
13839 assert_or_panic(v[121] == 1779);
13840 assert_or_panic(v[122] == 1780);
13841 assert_or_panic(v[123] == 1781);
13842 assert_or_panic(v[124] == 1782);
13843 assert_or_panic(v[125] == 1783);
13844 assert_or_panic(v[126] == 1784);
13845 assert_or_panic(v[127] == 1785);
13846 assert_or_panic(i == 128);
13847}
13848void c_test_vector_128_f32(void) {
13849 Vector_128_f32 v = zig_ret_vector_128_f32();
13850 assert_or_panic(v[0] == 1274);
13851 assert_or_panic(v[1] == 1275);
13852 assert_or_panic(v[2] == 1276);
13853 assert_or_panic(v[3] == 1277);
13854 assert_or_panic(v[4] == 1278);
13855 assert_or_panic(v[5] == 1279);
13856 assert_or_panic(v[6] == 1280);
13857 assert_or_panic(v[7] == 1281);
13858 assert_or_panic(v[8] == 1282);
13859 assert_or_panic(v[9] == 1283);
13860 assert_or_panic(v[10] == 1284);
13861 assert_or_panic(v[11] == 1285);
13862 assert_or_panic(v[12] == 1286);
13863 assert_or_panic(v[13] == 1287);
13864 assert_or_panic(v[14] == 1288);
13865 assert_or_panic(v[15] == 1289);
13866 assert_or_panic(v[16] == 1290);
13867 assert_or_panic(v[17] == 1291);
13868 assert_or_panic(v[18] == 1292);
13869 assert_or_panic(v[19] == 1293);
13870 assert_or_panic(v[20] == 1294);
13871 assert_or_panic(v[21] == 1295);
13872 assert_or_panic(v[22] == 1296);
13873 assert_or_panic(v[23] == 1297);
13874 assert_or_panic(v[24] == 1298);
13875 assert_or_panic(v[25] == 1299);
13876 assert_or_panic(v[26] == 1300);
13877 assert_or_panic(v[27] == 1301);
13878 assert_or_panic(v[28] == 1302);
13879 assert_or_panic(v[29] == 1303);
13880 assert_or_panic(v[30] == 1304);
13881 assert_or_panic(v[31] == 1305);
13882 assert_or_panic(v[32] == 1306);
13883 assert_or_panic(v[33] == 1307);
13884 assert_or_panic(v[34] == 1308);
13885 assert_or_panic(v[35] == 1309);
13886 assert_or_panic(v[36] == 1310);
13887 assert_or_panic(v[37] == 1311);
13888 assert_or_panic(v[38] == 1312);
13889 assert_or_panic(v[39] == 1313);
13890 assert_or_panic(v[40] == 1314);
13891 assert_or_panic(v[41] == 1315);
13892 assert_or_panic(v[42] == 1316);
13893 assert_or_panic(v[43] == 1317);
13894 assert_or_panic(v[44] == 1318);
13895 assert_or_panic(v[45] == 1319);
13896 assert_or_panic(v[46] == 1320);
13897 assert_or_panic(v[47] == 1321);
13898 assert_or_panic(v[48] == 1322);
13899 assert_or_panic(v[49] == 1323);
13900 assert_or_panic(v[50] == 1324);
13901 assert_or_panic(v[51] == 1325);
13902 assert_or_panic(v[52] == 1326);
13903 assert_or_panic(v[53] == 1327);
13904 assert_or_panic(v[54] == 1328);
13905 assert_or_panic(v[55] == 1329);
13906 assert_or_panic(v[56] == 1330);
13907 assert_or_panic(v[57] == 1331);
13908 assert_or_panic(v[58] == 1332);
13909 assert_or_panic(v[59] == 1333);
13910 assert_or_panic(v[60] == 1334);
13911 assert_or_panic(v[61] == 1335);
13912 assert_or_panic(v[62] == 1336);
13913 assert_or_panic(v[63] == 1337);
13914 assert_or_panic(v[64] == 1338);
13915 assert_or_panic(v[65] == 1339);
13916 assert_or_panic(v[66] == 1340);
13917 assert_or_panic(v[67] == 1341);
13918 assert_or_panic(v[68] == 1342);
13919 assert_or_panic(v[69] == 1343);
13920 assert_or_panic(v[70] == 1344);
13921 assert_or_panic(v[71] == 1345);
13922 assert_or_panic(v[72] == 1346);
13923 assert_or_panic(v[73] == 1347);
13924 assert_or_panic(v[74] == 1348);
13925 assert_or_panic(v[75] == 1349);
13926 assert_or_panic(v[76] == 1350);
13927 assert_or_panic(v[77] == 1351);
13928 assert_or_panic(v[78] == 1352);
13929 assert_or_panic(v[79] == 1353);
13930 assert_or_panic(v[80] == 1354);
13931 assert_or_panic(v[81] == 1355);
13932 assert_or_panic(v[82] == 1356);
13933 assert_or_panic(v[83] == 1357);
13934 assert_or_panic(v[84] == 1358);
13935 assert_or_panic(v[85] == 1359);
13936 assert_or_panic(v[86] == 1360);
13937 assert_or_panic(v[87] == 1361);
13938 assert_or_panic(v[88] == 1362);
13939 assert_or_panic(v[89] == 1363);
13940 assert_or_panic(v[90] == 1364);
13941 assert_or_panic(v[91] == 1365);
13942 assert_or_panic(v[92] == 1366);
13943 assert_or_panic(v[93] == 1367);
13944 assert_or_panic(v[94] == 1368);
13945 assert_or_panic(v[95] == 1369);
13946 assert_or_panic(v[96] == 1370);
13947 assert_or_panic(v[97] == 1371);
13948 assert_or_panic(v[98] == 1372);
13949 assert_or_panic(v[99] == 1373);
13950 assert_or_panic(v[100] == 1374);
13951 assert_or_panic(v[101] == 1375);
13952 assert_or_panic(v[102] == 1376);
13953 assert_or_panic(v[103] == 1377);
13954 assert_or_panic(v[104] == 1378);
13955 assert_or_panic(v[105] == 1379);
13956 assert_or_panic(v[106] == 1380);
13957 assert_or_panic(v[107] == 1381);
13958 assert_or_panic(v[108] == 1382);
13959 assert_or_panic(v[109] == 1383);
13960 assert_or_panic(v[110] == 1384);
13961 assert_or_panic(v[111] == 1385);
13962 assert_or_panic(v[112] == 1386);
13963 assert_or_panic(v[113] == 1387);
13964 assert_or_panic(v[114] == 1388);
13965 assert_or_panic(v[115] == 1389);
13966 assert_or_panic(v[116] == 1390);
13967 assert_or_panic(v[117] == 1391);
13968 assert_or_panic(v[118] == 1392);
13969 assert_or_panic(v[119] == 1393);
13970 assert_or_panic(v[120] == 1394);
13971 assert_or_panic(v[121] == 1395);
13972 assert_or_panic(v[122] == 1396);
13973 assert_or_panic(v[123] == 1397);
13974 assert_or_panic(v[124] == 1398);
13975 assert_or_panic(v[125] == 1399);
13976 assert_or_panic(v[126] == 1400);
13977 assert_or_panic(v[127] == 1401);
13978 zig_vector_128_f32((Vector_128_f32){
13979 1402, 1403, 1404, 1405, 1406, 1407, 1408, 1409, 1410, 1411, 1412, 1413, 1414, 1415, 1416, 1417,
13980 1418, 1419, 1420, 1421, 1422, 1423, 1424, 1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 1433,
13981 1434, 1435, 1436, 1437, 1438, 1439, 1440, 1441, 1442, 1443, 1444, 1445, 1446, 1447, 1448, 1449,
13982 1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 1462, 1463, 1464, 1465,
13983 1466, 1467, 1468, 1469, 1470, 1471, 1472, 1473, 1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481,
13984 1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 1490, 1491, 1492, 1493, 1494, 1495, 1496, 1497,
13985 1498, 1499, 1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 1513,
13986 1514, 1515, 1516, 1517, 1518, 1519, 1520, 1521, 1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529,
13987 }, 128);
13988}
13989
13990typedef double Vector_1_f64 __attribute__((vector_size(1 * sizeof(double))));
13991
13992Vector_1_f64 zig_ret_vector_1_f64(void);
13993void zig_vector_1_f64(Vector_1_f64, size_t);
13994
13995Vector_1_f64 c_ret_vector_1_f64(void) {
13996 return (Vector_1_f64){ 3 };
13997}
13998void c_vector_1_f64(Vector_1_f64 v, size_t i) {
13999 assert_or_panic(v[0] == 4);
14000 assert_or_panic(i == 1);
14001}
14002void c_test_vector_1_f64(void) {
14003 Vector_1_f64 v = zig_ret_vector_1_f64();
14004 assert_or_panic(v[0] == 1);
14005 zig_vector_1_f64((Vector_1_f64){ 2 }, 1);
14006}
14007
14008typedef double Vector_2_f64 __attribute__((vector_size(2 * sizeof(double))));
14009
14010Vector_2_f64 zig_ret_vector_2_f64(void);
14011void zig_vector_2_f64(Vector_2_f64, size_t);
14012
14013Vector_2_f64 c_ret_vector_2_f64(void) {
14014 return (Vector_2_f64){ 9, 10 };
14015}
14016void c_vector_2_f64(Vector_2_f64 v, size_t i) {
14017 assert_or_panic(v[0] == 11);
14018 assert_or_panic(v[1] == 12);
14019 assert_or_panic(i == 2);
14020}
14021void c_test_vector_2_f64(void) {
14022 Vector_2_f64 v = zig_ret_vector_2_f64();
14023 assert_or_panic(v[0] == 5);
14024 assert_or_panic(v[1] == 6);
14025 zig_vector_2_f64((Vector_2_f64){ 7, 8 }, 2);
14026}
14027
14028typedef double Vector_3_f64 __attribute__((vector_size(3 * sizeof(double))));
14029
14030Vector_3_f64 zig_ret_vector_3_f64(void);
14031void zig_vector_3_f64(Vector_3_f64, size_t);
14032
14033Vector_3_f64 c_ret_vector_3_f64(void) {
14034 return (Vector_3_f64){ 19, 20, 21 };
14035}
14036void c_vector_3_f64(Vector_3_f64 v, size_t i) {
14037 assert_or_panic(v[0] == 22);
14038 assert_or_panic(v[1] == 23);
14039 assert_or_panic(v[2] == 24);
14040 assert_or_panic(i == 3);
14041}
14042void c_test_vector_3_f64(void) {
14043 Vector_3_f64 v = zig_ret_vector_3_f64();
14044 assert_or_panic(v[0] == 13);
14045 assert_or_panic(v[1] == 14);
14046 assert_or_panic(v[2] == 15);
14047 zig_vector_3_f64((Vector_3_f64){ 16, 17, 18 }, 3);
14048}
14049
14050typedef double Vector_4_f64 __attribute__((vector_size(4 * sizeof(double))));
14051
14052Vector_4_f64 zig_ret_vector_4_f64(void);
14053void zig_vector_4_f64(Vector_4_f64, size_t);
14054
14055Vector_4_f64 c_ret_vector_4_f64(void) {
14056 return (Vector_4_f64){ 33, 34, 35, 36 };
14057}
14058void c_vector_4_f64(Vector_4_f64 v, size_t i) {
14059 assert_or_panic(v[0] == 37);
14060 assert_or_panic(v[1] == 38);
14061 assert_or_panic(v[2] == 39);
14062 assert_or_panic(v[3] == 40);
14063 assert_or_panic(i == 4);
14064}
14065void c_test_vector_4_f64(void) {
14066 Vector_4_f64 v = zig_ret_vector_4_f64();
14067 assert_or_panic(v[0] == 25);
14068 assert_or_panic(v[1] == 26);
14069 assert_or_panic(v[2] == 27);
14070 assert_or_panic(v[3] == 28);
14071 zig_vector_4_f64((Vector_4_f64){ 29, 30, 31, 32 }, 4);
14072}
14073
14074typedef double Vector_6_f64 __attribute__((vector_size(6 * sizeof(double))));
14075
14076Vector_6_f64 zig_ret_vector_6_f64(void);
14077void zig_vector_6_f64(Vector_6_f64, size_t);
14078
14079Vector_6_f64 c_ret_vector_6_f64(void) {
14080 return (Vector_6_f64){ 53, 54, 55, 56, 57, 58 };
14081}
14082void c_vector_6_f64(Vector_6_f64 v, size_t i) {
14083 assert_or_panic(v[0] == 59);
14084 assert_or_panic(v[1] == 60);
14085 assert_or_panic(v[2] == 61);
14086 assert_or_panic(v[3] == 62);
14087 assert_or_panic(v[4] == 63);
14088 assert_or_panic(v[5] == 64);
14089 assert_or_panic(i == 6);
14090}
14091void c_test_vector_6_f64(void) {
14092 Vector_6_f64 v = zig_ret_vector_6_f64();
14093 assert_or_panic(v[0] == 41);
14094 assert_or_panic(v[1] == 42);
14095 assert_or_panic(v[2] == 43);
14096 assert_or_panic(v[3] == 44);
14097 assert_or_panic(v[4] == 45);
14098 assert_or_panic(v[5] == 46);
14099 zig_vector_6_f64((Vector_6_f64){ 47, 48, 49, 50, 51, 52 }, 6);
14100}
14101
14102typedef double Vector_8_f64 __attribute__((vector_size(8 * sizeof(double))));
14103
14104Vector_8_f64 zig_ret_vector_8_f64(void);
14105void zig_vector_8_f64(Vector_8_f64, size_t);
14106
14107Vector_8_f64 c_ret_vector_8_f64(void) {
14108 return (Vector_8_f64){ 81, 82, 83, 84, 85, 86, 87, 88 };
14109}
14110void c_vector_8_f64(Vector_8_f64 v, size_t i) {
14111 assert_or_panic(v[0] == 89);
14112 assert_or_panic(v[1] == 90);
14113 assert_or_panic(v[2] == 91);
14114 assert_or_panic(v[3] == 92);
14115 assert_or_panic(v[4] == 93);
14116 assert_or_panic(v[5] == 94);
14117 assert_or_panic(v[6] == 95);
14118 assert_or_panic(v[7] == 96);
14119 assert_or_panic(i == 8);
14120}
14121void c_test_vector_8_f64(void) {
14122 Vector_8_f64 v = zig_ret_vector_8_f64();
14123 assert_or_panic(v[0] == 65);
14124 assert_or_panic(v[1] == 66);
14125 assert_or_panic(v[2] == 67);
14126 assert_or_panic(v[3] == 68);
14127 assert_or_panic(v[4] == 69);
14128 assert_or_panic(v[5] == 70);
14129 assert_or_panic(v[6] == 71);
14130 assert_or_panic(v[7] == 72);
14131 zig_vector_8_f64((Vector_8_f64){ 73, 74, 75, 76, 77, 78, 79, 80 }, 8);
14132}
14133
14134typedef double Vector_12_f64 __attribute__((vector_size(12 * sizeof(double))));
14135
14136Vector_12_f64 zig_ret_vector_12_f64(void);
14137void zig_vector_12_f64(Vector_12_f64, size_t);
14138
14139Vector_12_f64 c_ret_vector_12_f64(void) {
14140 return (Vector_12_f64){ 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132 };
14141}
14142void c_vector_12_f64(Vector_12_f64 v, size_t i) {
14143 assert_or_panic(v[0] == 133);
14144 assert_or_panic(v[1] == 134);
14145 assert_or_panic(v[2] == 135);
14146 assert_or_panic(v[3] == 136);
14147 assert_or_panic(v[4] == 137);
14148 assert_or_panic(v[5] == 138);
14149 assert_or_panic(v[6] == 139);
14150 assert_or_panic(v[7] == 140);
14151 assert_or_panic(v[8] == 141);
14152 assert_or_panic(v[9] == 142);
14153 assert_or_panic(v[10] == 143);
14154 assert_or_panic(v[11] == 144);
14155 assert_or_panic(i == 12);
14156}
14157void c_test_vector_12_f64(void) {
14158 Vector_12_f64 v = zig_ret_vector_12_f64();
14159 assert_or_panic(v[0] == 97);
14160 assert_or_panic(v[1] == 98);
14161 assert_or_panic(v[2] == 99);
14162 assert_or_panic(v[3] == 100);
14163 assert_or_panic(v[4] == 101);
14164 assert_or_panic(v[5] == 102);
14165 assert_or_panic(v[6] == 103);
14166 assert_or_panic(v[7] == 104);
14167 assert_or_panic(v[8] == 105);
14168 assert_or_panic(v[9] == 106);
14169 assert_or_panic(v[10] == 107);
14170 assert_or_panic(v[11] == 108);
14171 zig_vector_12_f64((Vector_12_f64){ 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120 }, 12);
14172}
14173
14174typedef double Vector_16_f64 __attribute__((vector_size(16 * sizeof(double))));
14175
14176Vector_16_f64 zig_ret_vector_16_f64(void);
14177void zig_vector_16_f64(Vector_16_f64, size_t);
14178
14179Vector_16_f64 c_ret_vector_16_f64(void) {
14180 return (Vector_16_f64){ 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192 };
14181}
14182void c_vector_16_f64(Vector_16_f64 v, size_t i) {
14183 assert_or_panic(v[0] == 193);
14184 assert_or_panic(v[1] == 194);
14185 assert_or_panic(v[2] == 195);
14186 assert_or_panic(v[3] == 196);
14187 assert_or_panic(v[4] == 197);
14188 assert_or_panic(v[5] == 198);
14189 assert_or_panic(v[6] == 199);
14190 assert_or_panic(v[7] == 200);
14191 assert_or_panic(v[8] == 201);
14192 assert_or_panic(v[9] == 202);
14193 assert_or_panic(v[10] == 203);
14194 assert_or_panic(v[11] == 204);
14195 assert_or_panic(v[12] == 205);
14196 assert_or_panic(v[13] == 206);
14197 assert_or_panic(v[14] == 207);
14198 assert_or_panic(v[15] == 208);
14199 assert_or_panic(i == 16);
14200}
14201void c_test_vector_16_f64(void) {
14202 Vector_16_f64 v = zig_ret_vector_16_f64();
14203 assert_or_panic(v[0] == 145);
14204 assert_or_panic(v[1] == 146);
14205 assert_or_panic(v[2] == 147);
14206 assert_or_panic(v[3] == 148);
14207 assert_or_panic(v[4] == 149);
14208 assert_or_panic(v[5] == 150);
14209 assert_or_panic(v[6] == 151);
14210 assert_or_panic(v[7] == 152);
14211 assert_or_panic(v[8] == 153);
14212 assert_or_panic(v[9] == 154);
14213 assert_or_panic(v[10] == 155);
14214 assert_or_panic(v[11] == 156);
14215 assert_or_panic(v[12] == 157);
14216 assert_or_panic(v[13] == 158);
14217 assert_or_panic(v[14] == 159);
14218 assert_or_panic(v[15] == 160);
14219 zig_vector_16_f64((Vector_16_f64){ 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176 }, 16);
14220}
14221
14222typedef double Vector_24_f64 __attribute__((vector_size(24 * sizeof(double))));
14223
14224Vector_24_f64 zig_ret_vector_24_f64(void);
14225void zig_vector_24_f64(Vector_24_f64, size_t);
14226
14227Vector_24_f64 c_ret_vector_24_f64(void) {
14228 return (Vector_24_f64){
14229 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272,
14230 273, 274, 275, 276, 277, 278, 279, 280,
14231 };
14232}
14233void c_vector_24_f64(Vector_24_f64 v, size_t i) {
14234 assert_or_panic(v[0] == 281);
14235 assert_or_panic(v[1] == 282);
14236 assert_or_panic(v[2] == 283);
14237 assert_or_panic(v[3] == 284);
14238 assert_or_panic(v[4] == 285);
14239 assert_or_panic(v[5] == 286);
14240 assert_or_panic(v[6] == 287);
14241 assert_or_panic(v[7] == 288);
14242 assert_or_panic(v[8] == 289);
14243 assert_or_panic(v[9] == 290);
14244 assert_or_panic(v[10] == 291);
14245 assert_or_panic(v[11] == 292);
14246 assert_or_panic(v[12] == 293);
14247 assert_or_panic(v[13] == 294);
14248 assert_or_panic(v[14] == 295);
14249 assert_or_panic(v[15] == 296);
14250 assert_or_panic(v[16] == 297);
14251 assert_or_panic(v[17] == 298);
14252 assert_or_panic(v[18] == 299);
14253 assert_or_panic(v[19] == 300);
14254 assert_or_panic(v[20] == 301);
14255 assert_or_panic(v[21] == 302);
14256 assert_or_panic(v[22] == 303);
14257 assert_or_panic(v[23] == 304);
14258 assert_or_panic(i == 24);
14259}
14260void c_test_vector_24_f64(void) {
14261 Vector_24_f64 v = zig_ret_vector_24_f64();
14262 assert_or_panic(v[0] == 209);
14263 assert_or_panic(v[1] == 210);
14264 assert_or_panic(v[2] == 211);
14265 assert_or_panic(v[3] == 212);
14266 assert_or_panic(v[4] == 213);
14267 assert_or_panic(v[5] == 214);
14268 assert_or_panic(v[6] == 215);
14269 assert_or_panic(v[7] == 216);
14270 assert_or_panic(v[8] == 217);
14271 assert_or_panic(v[9] == 218);
14272 assert_or_panic(v[10] == 219);
14273 assert_or_panic(v[11] == 220);
14274 assert_or_panic(v[12] == 221);
14275 assert_or_panic(v[13] == 222);
14276 assert_or_panic(v[14] == 223);
14277 assert_or_panic(v[15] == 224);
14278 assert_or_panic(v[16] == 225);
14279 assert_or_panic(v[17] == 226);
14280 assert_or_panic(v[18] == 227);
14281 assert_or_panic(v[19] == 228);
14282 assert_or_panic(v[20] == 229);
14283 assert_or_panic(v[21] == 230);
14284 assert_or_panic(v[22] == 231);
14285 assert_or_panic(v[23] == 232);
14286 zig_vector_24_f64((Vector_24_f64){
14287 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248,
14288 249, 250, 251, 252, 253, 254, 255, 256,
14289 }, 24);
14290}
14291
14292typedef double Vector_32_f64 __attribute__((vector_size(32 * sizeof(double))));
14293
14294Vector_32_f64 zig_ret_vector_32_f64(void);
14295void zig_vector_32_f64(Vector_32_f64, size_t);
14296
14297Vector_32_f64 c_ret_vector_32_f64(void) {
14298 return (Vector_32_f64){
14299 369, 370, 371, 372, 373, 374, 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
14300 385, 386, 387, 388, 389, 390, 391, 392, 393, 394, 395, 396, 397, 398, 399, 400,
14301 };
14302}
14303void c_vector_32_f64(Vector_32_f64 v, size_t i) {
14304 assert_or_panic(v[0] == 401);
14305 assert_or_panic(v[1] == 402);
14306 assert_or_panic(v[2] == 403);
14307 assert_or_panic(v[3] == 404);
14308 assert_or_panic(v[4] == 405);
14309 assert_or_panic(v[5] == 406);
14310 assert_or_panic(v[6] == 407);
14311 assert_or_panic(v[7] == 408);
14312 assert_or_panic(v[8] == 409);
14313 assert_or_panic(v[9] == 410);
14314 assert_or_panic(v[10] == 411);
14315 assert_or_panic(v[11] == 412);
14316 assert_or_panic(v[12] == 413);
14317 assert_or_panic(v[13] == 414);
14318 assert_or_panic(v[14] == 415);
14319 assert_or_panic(v[15] == 416);
14320 assert_or_panic(v[16] == 417);
14321 assert_or_panic(v[17] == 418);
14322 assert_or_panic(v[18] == 419);
14323 assert_or_panic(v[19] == 420);
14324 assert_or_panic(v[20] == 421);
14325 assert_or_panic(v[21] == 422);
14326 assert_or_panic(v[22] == 423);
14327 assert_or_panic(v[23] == 424);
14328 assert_or_panic(v[24] == 425);
14329 assert_or_panic(v[25] == 426);
14330 assert_or_panic(v[26] == 427);
14331 assert_or_panic(v[27] == 428);
14332 assert_or_panic(v[28] == 429);
14333 assert_or_panic(v[29] == 430);
14334 assert_or_panic(v[30] == 431);
14335 assert_or_panic(v[31] == 432);
14336 assert_or_panic(i == 32);
14337}
14338void c_test_vector_32_f64(void) {
14339 Vector_32_f64 v = zig_ret_vector_32_f64();
14340 assert_or_panic(v[0] == 305);
14341 assert_or_panic(v[1] == 306);
14342 assert_or_panic(v[2] == 307);
14343 assert_or_panic(v[3] == 308);
14344 assert_or_panic(v[4] == 309);
14345 assert_or_panic(v[5] == 310);
14346 assert_or_panic(v[6] == 311);
14347 assert_or_panic(v[7] == 312);
14348 assert_or_panic(v[8] == 313);
14349 assert_or_panic(v[9] == 314);
14350 assert_or_panic(v[10] == 315);
14351 assert_or_panic(v[11] == 316);
14352 assert_or_panic(v[12] == 317);
14353 assert_or_panic(v[13] == 318);
14354 assert_or_panic(v[14] == 319);
14355 assert_or_panic(v[15] == 320);
14356 assert_or_panic(v[16] == 321);
14357 assert_or_panic(v[17] == 322);
14358 assert_or_panic(v[18] == 323);
14359 assert_or_panic(v[19] == 324);
14360 assert_or_panic(v[20] == 325);
14361 assert_or_panic(v[21] == 326);
14362 assert_or_panic(v[22] == 327);
14363 assert_or_panic(v[23] == 328);
14364 assert_or_panic(v[24] == 329);
14365 assert_or_panic(v[25] == 330);
14366 assert_or_panic(v[26] == 331);
14367 assert_or_panic(v[27] == 332);
14368 assert_or_panic(v[28] == 333);
14369 assert_or_panic(v[29] == 334);
14370 assert_or_panic(v[30] == 335);
14371 assert_or_panic(v[31] == 336);
14372 zig_vector_32_f64((Vector_32_f64){
14373 337, 338, 339, 340, 341, 342, 343, 344, 345, 346, 347, 348, 349, 350, 351, 352,
14374 353, 354, 355, 356, 357, 358, 359, 360, 361, 362, 363, 364, 365, 366, 367, 368,
14375 }, 32);
14376}
14377
14378typedef double Vector_48_f64 __attribute__((vector_size(48 * sizeof(double))));
14379
14380Vector_48_f64 zig_ret_vector_48_f64(void);
14381void zig_vector_48_f64(Vector_48_f64, size_t);
14382
14383Vector_48_f64 c_ret_vector_48_f64(void) {
14384 return (Vector_48_f64){
14385 529, 530, 531, 532, 533, 534, 535, 536, 537, 538, 539, 540, 541, 542, 543, 544,
14386 545, 546, 547, 548, 549, 550, 551, 552, 553, 554, 555, 556, 557, 558, 559, 560,
14387 561, 562, 563, 564, 565, 566, 567, 568, 569, 570, 571, 572, 573, 574, 575, 576,
14388 };
14389}
14390void c_vector_48_f64(Vector_48_f64 v, size_t i) {
14391 assert_or_panic(v[0] == 577);
14392 assert_or_panic(v[1] == 578);
14393 assert_or_panic(v[2] == 579);
14394 assert_or_panic(v[3] == 580);
14395 assert_or_panic(v[4] == 581);
14396 assert_or_panic(v[5] == 582);
14397 assert_or_panic(v[6] == 583);
14398 assert_or_panic(v[7] == 584);
14399 assert_or_panic(v[8] == 585);
14400 assert_or_panic(v[9] == 586);
14401 assert_or_panic(v[10] == 587);
14402 assert_or_panic(v[11] == 588);
14403 assert_or_panic(v[12] == 589);
14404 assert_or_panic(v[13] == 590);
14405 assert_or_panic(v[14] == 591);
14406 assert_or_panic(v[15] == 592);
14407 assert_or_panic(v[16] == 593);
14408 assert_or_panic(v[17] == 594);
14409 assert_or_panic(v[18] == 595);
14410 assert_or_panic(v[19] == 596);
14411 assert_or_panic(v[20] == 597);
14412 assert_or_panic(v[21] == 598);
14413 assert_or_panic(v[22] == 599);
14414 assert_or_panic(v[23] == 600);
14415 assert_or_panic(v[24] == 601);
14416 assert_or_panic(v[25] == 602);
14417 assert_or_panic(v[26] == 603);
14418 assert_or_panic(v[27] == 604);
14419 assert_or_panic(v[28] == 605);
14420 assert_or_panic(v[29] == 606);
14421 assert_or_panic(v[30] == 607);
14422 assert_or_panic(v[31] == 608);
14423 assert_or_panic(v[32] == 609);
14424 assert_or_panic(v[33] == 610);
14425 assert_or_panic(v[34] == 611);
14426 assert_or_panic(v[35] == 612);
14427 assert_or_panic(v[36] == 613);
14428 assert_or_panic(v[37] == 614);
14429 assert_or_panic(v[38] == 615);
14430 assert_or_panic(v[39] == 616);
14431 assert_or_panic(v[40] == 617);
14432 assert_or_panic(v[41] == 618);
14433 assert_or_panic(v[42] == 619);
14434 assert_or_panic(v[43] == 620);
14435 assert_or_panic(v[44] == 621);
14436 assert_or_panic(v[45] == 622);
14437 assert_or_panic(v[46] == 623);
14438 assert_or_panic(v[47] == 624);
14439 assert_or_panic(i == 48);
14440}
14441void c_test_vector_48_f64(void) {
14442 Vector_48_f64 v = zig_ret_vector_48_f64();
14443 assert_or_panic(v[0] == 433);
14444 assert_or_panic(v[1] == 434);
14445 assert_or_panic(v[2] == 435);
14446 assert_or_panic(v[3] == 436);
14447 assert_or_panic(v[4] == 437);
14448 assert_or_panic(v[5] == 438);
14449 assert_or_panic(v[6] == 439);
14450 assert_or_panic(v[7] == 440);
14451 assert_or_panic(v[8] == 441);
14452 assert_or_panic(v[9] == 442);
14453 assert_or_panic(v[10] == 443);
14454 assert_or_panic(v[11] == 444);
14455 assert_or_panic(v[12] == 445);
14456 assert_or_panic(v[13] == 446);
14457 assert_or_panic(v[14] == 447);
14458 assert_or_panic(v[15] == 448);
14459 assert_or_panic(v[16] == 449);
14460 assert_or_panic(v[17] == 450);
14461 assert_or_panic(v[18] == 451);
14462 assert_or_panic(v[19] == 452);
14463 assert_or_panic(v[20] == 453);
14464 assert_or_panic(v[21] == 454);
14465 assert_or_panic(v[22] == 455);
14466 assert_or_panic(v[23] == 456);
14467 assert_or_panic(v[24] == 457);
14468 assert_or_panic(v[25] == 458);
14469 assert_or_panic(v[26] == 459);
14470 assert_or_panic(v[27] == 460);
14471 assert_or_panic(v[28] == 461);
14472 assert_or_panic(v[29] == 462);
14473 assert_or_panic(v[30] == 463);
14474 assert_or_panic(v[31] == 464);
14475 assert_or_panic(v[32] == 465);
14476 assert_or_panic(v[33] == 466);
14477 assert_or_panic(v[34] == 467);
14478 assert_or_panic(v[35] == 468);
14479 assert_or_panic(v[36] == 469);
14480 assert_or_panic(v[37] == 470);
14481 assert_or_panic(v[38] == 471);
14482 assert_or_panic(v[39] == 472);
14483 assert_or_panic(v[40] == 473);
14484 assert_or_panic(v[41] == 474);
14485 assert_or_panic(v[42] == 475);
14486 assert_or_panic(v[43] == 476);
14487 assert_or_panic(v[44] == 477);
14488 assert_or_panic(v[45] == 478);
14489 assert_or_panic(v[46] == 479);
14490 assert_or_panic(v[47] == 480);
14491 zig_vector_48_f64((Vector_48_f64){
14492 481, 482, 483, 484, 485, 486, 487, 488, 489, 490, 491, 492, 493, 494, 495, 496,
14493 497, 498, 499, 500, 501, 502, 503, 504, 505, 506, 507, 508, 509, 510, 511, 512,
14494 513, 514, 515, 516, 517, 518, 519, 520, 521, 522, 523, 524, 525, 526, 527, 528,
14495 }, 48);
14496}
14497
14498typedef double Vector_64_f64 __attribute__((vector_size(64 * sizeof(double))));
14499
14500Vector_64_f64 zig_ret_vector_64_f64(void);
14501void zig_vector_64_f64(Vector_64_f64, size_t);
14502
14503Vector_64_f64 c_ret_vector_64_f64(void) {
14504 return (Vector_64_f64){
14505 753, 754, 755, 756, 757, 758, 759, 760, 761, 762, 763, 764, 765, 766, 767, 768,
14506 769, 770, 771, 772, 773, 774, 775, 776, 777, 778, 779, 780, 781, 782, 783, 784,
14507 785, 786, 787, 788, 789, 790, 791, 792, 793, 794, 795, 796, 797, 798, 799, 800,
14508 801, 802, 803, 804, 805, 806, 807, 808, 809, 810, 811, 812, 813, 814, 815, 816,
14509 };
14510}
14511void c_vector_64_f64(Vector_64_f64 v, size_t i) {
14512 assert_or_panic(v[0] == 817);
14513 assert_or_panic(v[1] == 818);
14514 assert_or_panic(v[2] == 819);
14515 assert_or_panic(v[3] == 820);
14516 assert_or_panic(v[4] == 821);
14517 assert_or_panic(v[5] == 822);
14518 assert_or_panic(v[6] == 823);
14519 assert_or_panic(v[7] == 824);
14520 assert_or_panic(v[8] == 825);
14521 assert_or_panic(v[9] == 826);
14522 assert_or_panic(v[10] == 827);
14523 assert_or_panic(v[11] == 828);
14524 assert_or_panic(v[12] == 829);
14525 assert_or_panic(v[13] == 830);
14526 assert_or_panic(v[14] == 831);
14527 assert_or_panic(v[15] == 832);
14528 assert_or_panic(v[16] == 833);
14529 assert_or_panic(v[17] == 834);
14530 assert_or_panic(v[18] == 835);
14531 assert_or_panic(v[19] == 836);
14532 assert_or_panic(v[20] == 837);
14533 assert_or_panic(v[21] == 838);
14534 assert_or_panic(v[22] == 839);
14535 assert_or_panic(v[23] == 840);
14536 assert_or_panic(v[24] == 841);
14537 assert_or_panic(v[25] == 842);
14538 assert_or_panic(v[26] == 843);
14539 assert_or_panic(v[27] == 844);
14540 assert_or_panic(v[28] == 845);
14541 assert_or_panic(v[29] == 846);
14542 assert_or_panic(v[30] == 847);
14543 assert_or_panic(v[31] == 848);
14544 assert_or_panic(v[32] == 849);
14545 assert_or_panic(v[33] == 850);
14546 assert_or_panic(v[34] == 851);
14547 assert_or_panic(v[35] == 852);
14548 assert_or_panic(v[36] == 853);
14549 assert_or_panic(v[37] == 854);
14550 assert_or_panic(v[38] == 855);
14551 assert_or_panic(v[39] == 856);
14552 assert_or_panic(v[40] == 857);
14553 assert_or_panic(v[41] == 858);
14554 assert_or_panic(v[42] == 859);
14555 assert_or_panic(v[43] == 860);
14556 assert_or_panic(v[44] == 861);
14557 assert_or_panic(v[45] == 862);
14558 assert_or_panic(v[46] == 863);
14559 assert_or_panic(v[47] == 864);
14560 assert_or_panic(v[48] == 865);
14561 assert_or_panic(v[49] == 866);
14562 assert_or_panic(v[50] == 867);
14563 assert_or_panic(v[51] == 868);
14564 assert_or_panic(v[52] == 869);
14565 assert_or_panic(v[53] == 870);
14566 assert_or_panic(v[54] == 871);
14567 assert_or_panic(v[55] == 872);
14568 assert_or_panic(v[56] == 873);
14569 assert_or_panic(v[57] == 874);
14570 assert_or_panic(v[58] == 875);
14571 assert_or_panic(v[59] == 876);
14572 assert_or_panic(v[60] == 877);
14573 assert_or_panic(v[61] == 878);
14574 assert_or_panic(v[62] == 879);
14575 assert_or_panic(v[63] == 880);
14576 assert_or_panic(i == 64);
14577}
14578void c_test_vector_64_f64(void) {
14579 Vector_64_f64 v = zig_ret_vector_64_f64();
14580 assert_or_panic(v[0] == 625);
14581 assert_or_panic(v[1] == 626);
14582 assert_or_panic(v[2] == 627);
14583 assert_or_panic(v[3] == 628);
14584 assert_or_panic(v[4] == 629);
14585 assert_or_panic(v[5] == 630);
14586 assert_or_panic(v[6] == 631);
14587 assert_or_panic(v[7] == 632);
14588 assert_or_panic(v[8] == 633);
14589 assert_or_panic(v[9] == 634);
14590 assert_or_panic(v[10] == 635);
14591 assert_or_panic(v[11] == 636);
14592 assert_or_panic(v[12] == 637);
14593 assert_or_panic(v[13] == 638);
14594 assert_or_panic(v[14] == 639);
14595 assert_or_panic(v[15] == 640);
14596 assert_or_panic(v[16] == 641);
14597 assert_or_panic(v[17] == 642);
14598 assert_or_panic(v[18] == 643);
14599 assert_or_panic(v[19] == 644);
14600 assert_or_panic(v[20] == 645);
14601 assert_or_panic(v[21] == 646);
14602 assert_or_panic(v[22] == 647);
14603 assert_or_panic(v[23] == 648);
14604 assert_or_panic(v[24] == 649);
14605 assert_or_panic(v[25] == 650);
14606 assert_or_panic(v[26] == 651);
14607 assert_or_panic(v[27] == 652);
14608 assert_or_panic(v[28] == 653);
14609 assert_or_panic(v[29] == 654);
14610 assert_or_panic(v[30] == 655);
14611 assert_or_panic(v[31] == 656);
14612 assert_or_panic(v[32] == 657);
14613 assert_or_panic(v[33] == 658);
14614 assert_or_panic(v[34] == 659);
14615 assert_or_panic(v[35] == 660);
14616 assert_or_panic(v[36] == 661);
14617 assert_or_panic(v[37] == 662);
14618 assert_or_panic(v[38] == 663);
14619 assert_or_panic(v[39] == 664);
14620 assert_or_panic(v[40] == 665);
14621 assert_or_panic(v[41] == 666);
14622 assert_or_panic(v[42] == 667);
14623 assert_or_panic(v[43] == 668);
14624 assert_or_panic(v[44] == 669);
14625 assert_or_panic(v[45] == 670);
14626 assert_or_panic(v[46] == 671);
14627 assert_or_panic(v[47] == 672);
14628 assert_or_panic(v[48] == 673);
14629 assert_or_panic(v[49] == 674);
14630 assert_or_panic(v[50] == 675);
14631 assert_or_panic(v[51] == 676);
14632 assert_or_panic(v[52] == 677);
14633 assert_or_panic(v[53] == 678);
14634 assert_or_panic(v[54] == 679);
14635 assert_or_panic(v[55] == 680);
14636 assert_or_panic(v[56] == 681);
14637 assert_or_panic(v[57] == 682);
14638 assert_or_panic(v[58] == 683);
14639 assert_or_panic(v[59] == 684);
14640 assert_or_panic(v[60] == 685);
14641 assert_or_panic(v[61] == 686);
14642 assert_or_panic(v[62] == 687);
14643 assert_or_panic(v[63] == 688);
14644 zig_vector_64_f64((Vector_64_f64){
14645 689, 690, 691, 692, 693, 694, 695, 696, 697, 698, 699, 700, 701, 702, 703, 704,
14646 705, 706, 707, 708, 709, 710, 711, 712, 713, 714, 715, 716, 717, 718, 719, 720,
14647 721, 722, 723, 724, 725, 726, 727, 728, 729, 730, 731, 732, 733, 734, 735, 736,
14648 737, 738, 739, 740, 741, 742, 743, 744, 745, 746, 747, 748, 749, 750, 751, 752,
14649 }, 64);
14650}
14651
14652struct Struct_u8 {
14653 uint8_t a;
14654};
14655
14656struct Struct_u8 zig_ret_struct_u8(void);
14657void zig_struct_u8(struct Struct_u8, size_t);
14658
14659struct Struct_u8 c_ret_struct_u8(void) {
14660 return (struct Struct_u8){ .a = 4 };
14661}
14662void c_struct_u8(struct Struct_u8 s, size_t i) {
14663 assert_or_panic(s.a == 5);
14664 assert_or_panic(i == 6);
14665}
14666void c_test_struct_u8(void) {
14667 struct Struct_u8 s = zig_ret_struct_u8();
14668 assert_or_panic(s.a == 1);
14669 zig_struct_u8((struct Struct_u8){ .a = 2 }, 3);
14670}
14671
14672struct Struct_u8_u8 {
14673 uint8_t a, b;
14674};
14675
14676struct Struct_u8_u8 zig_ret_struct_u8_u8(void);
14677void zig_struct_u8_u8(struct Struct_u8_u8, size_t);
14678
14679struct Struct_u8_u8 c_ret_struct_u8_u8(void) {
14680 return (struct Struct_u8_u8){ .a = 6, .b = 7 };
14681}
14682void c_struct_u8_u8(struct Struct_u8_u8 s, size_t i) {
14683 assert_or_panic(s.a == 8);
14684 assert_or_panic(s.b == 9);
14685 assert_or_panic(i == 10);
14686}
14687void c_test_struct_u8_u8(void) {
14688 struct Struct_u8_u8 s = zig_ret_struct_u8_u8();
14689 assert_or_panic(s.a == 1);
14690 assert_or_panic(s.b == 2);
14691 zig_struct_u8_u8((struct Struct_u8_u8){ .a = 3, .b = 4 }, 5);
14692}
14693
14694struct Struct_u8_u8_u8 {
14695 uint8_t a, b, c;
14696};
14697
14698struct Struct_u8_u8_u8 zig_ret_struct_u8_u8_u8(void);
14699void zig_struct_u8_u8_u8(struct Struct_u8_u8_u8, size_t);
14700
14701struct Struct_u8_u8_u8 c_ret_struct_u8_u8_u8(void) {
14702 return (struct Struct_u8_u8_u8){ .a = 8, .b = 9, .c = 10 };
14703}
14704void c_struct_u8_u8_u8(struct Struct_u8_u8_u8 s, size_t i) {
14705 assert_or_panic(s.a == 11);
14706 assert_or_panic(s.b == 12);
14707 assert_or_panic(s.c == 13);
14708 assert_or_panic(i == 14);
14709}
14710void c_test_struct_u8_u8_u8(void) {
14711 struct Struct_u8_u8_u8 s = zig_ret_struct_u8_u8_u8();
14712 assert_or_panic(s.a == 1);
14713 assert_or_panic(s.b == 2);
14714 assert_or_panic(s.c == 3);
14715 zig_struct_u8_u8_u8((struct Struct_u8_u8_u8){ .a = 4, .b = 5, .c = 6 }, 7);
14716}
14717
14718struct Struct_u8_u8_u8_u8 {
14719 uint8_t a, b, c, d;
14720};
14721
14722struct Struct_u8_u8_u8_u8 zig_ret_struct_u8_u8_u8_u8(void);
14723void zig_struct_u8_u8_u8_u8(struct Struct_u8_u8_u8_u8, size_t);
14724
14725struct Struct_u8_u8_u8_u8 c_ret_struct_u8_u8_u8_u8(void) {
14726 return (struct Struct_u8_u8_u8_u8){ .a = 10, .b = 11, .c = 12, .d = 13 };
14727}
14728void c_struct_u8_u8_u8_u8(struct Struct_u8_u8_u8_u8 s, size_t i) {
14729 assert_or_panic(s.a == 14);
14730 assert_or_panic(s.b == 15);
14731 assert_or_panic(s.c == 16);
14732 assert_or_panic(s.d == 17);
14733 assert_or_panic(i == 18);
14734}
14735void c_test_struct_u8_u8_u8_u8(void) {
14736 struct Struct_u8_u8_u8_u8 s = zig_ret_struct_u8_u8_u8_u8();
14737 assert_or_panic(s.a == 1);
14738 assert_or_panic(s.b == 2);
14739 assert_or_panic(s.c == 3);
14740 assert_or_panic(s.d == 4);
14741 zig_struct_u8_u8_u8_u8((struct Struct_u8_u8_u8_u8){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
14742}
14743
14744struct Struct_u16 {
14745 uint16_t a;
14746};
14747
14748struct Struct_u16 zig_ret_struct_u16(void);
14749void zig_struct_u16(struct Struct_u16, size_t);
14750
14751struct Struct_u16 c_ret_struct_u16(void) {
14752 return (struct Struct_u16){ .a = 4 };
14753}
14754void c_struct_u16(struct Struct_u16 s, size_t i) {
14755 assert_or_panic(s.a == 5);
14756 assert_or_panic(i == 6);
14757}
14758void c_test_struct_u16(void) {
14759 struct Struct_u16 s = zig_ret_struct_u16();
14760 assert_or_panic(s.a == 1);
14761 zig_struct_u16((struct Struct_u16){ .a = 2 }, 3);
14762}
14763
14764struct Struct_u16_u16 {
14765 uint16_t a, b;
14766};
14767
14768struct Struct_u16_u16 zig_ret_struct_u16_u16(void);
14769void zig_struct_u16_u16(struct Struct_u16_u16, size_t);
14770
14771struct Struct_u16_u16 c_ret_struct_u16_u16(void) {
14772 return (struct Struct_u16_u16){ .a = 6, .b = 7 };
14773}
14774void c_struct_u16_u16(struct Struct_u16_u16 s, size_t i) {
14775 assert_or_panic(s.a == 8);
14776 assert_or_panic(s.b == 9);
14777 assert_or_panic(i == 10);
14778}
14779void c_test_struct_u16_u16(void) {
14780 struct Struct_u16_u16 s = zig_ret_struct_u16_u16();
14781 assert_or_panic(s.a == 1);
14782 assert_or_panic(s.b == 2);
14783 zig_struct_u16_u16((struct Struct_u16_u16){ .a = 3, .b = 4 }, 5);
14784}
14785
14786struct Struct_u16_u16_u16 {
14787 uint16_t a, b, c;
14788};
14789
14790struct Struct_u16_u16_u16 zig_ret_struct_u16_u16_u16(void);
14791void zig_struct_u16_u16_u16(struct Struct_u16_u16_u16, size_t);
14792
14793struct Struct_u16_u16_u16 c_ret_struct_u16_u16_u16(void) {
14794 return (struct Struct_u16_u16_u16){ .a = 8, .b = 9, .c = 10 };
14795}
14796void c_struct_u16_u16_u16(struct Struct_u16_u16_u16 s, size_t i) {
14797 assert_or_panic(s.a == 11);
14798 assert_or_panic(s.b == 12);
14799 assert_or_panic(s.c == 13);
14800 assert_or_panic(i == 14);
14801}
14802void c_test_struct_u16_u16_u16(void) {
14803 struct Struct_u16_u16_u16 s = zig_ret_struct_u16_u16_u16();
14804 assert_or_panic(s.a == 1);
14805 assert_or_panic(s.b == 2);
14806 assert_or_panic(s.c == 3);
14807 zig_struct_u16_u16_u16((struct Struct_u16_u16_u16){ .a = 4, .b = 5, .c = 6 }, 7);
14808}
14809
14810struct Struct_u16_u16_u16_u16 {
14811 uint16_t a, b, c, d;
14812};
14813
14814struct Struct_u16_u16_u16_u16 zig_ret_struct_u16_u16_u16_u16(void);
14815void zig_struct_u16_u16_u16_u16(struct Struct_u16_u16_u16_u16, size_t);
14816
14817struct Struct_u16_u16_u16_u16 c_ret_struct_u16_u16_u16_u16(void) {
14818 return (struct Struct_u16_u16_u16_u16){ .a = 10, .b = 11, .c = 12, .d = 13 };
14819}
14820void c_struct_u16_u16_u16_u16(struct Struct_u16_u16_u16_u16 s, size_t i) {
14821 assert_or_panic(s.a == 14);
14822 assert_or_panic(s.b == 15);
14823 assert_or_panic(s.c == 16);
14824 assert_or_panic(s.d == 17);
14825 assert_or_panic(i == 18);
14826}
14827void c_test_struct_u16_u16_u16_u16(void) {
14828 struct Struct_u16_u16_u16_u16 s = zig_ret_struct_u16_u16_u16_u16();
14829 assert_or_panic(s.a == 1);
14830 assert_or_panic(s.b == 2);
14831 assert_or_panic(s.c == 3);
14832 assert_or_panic(s.d == 4);
14833 zig_struct_u16_u16_u16_u16((struct Struct_u16_u16_u16_u16){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
14834}
14835
14836struct Struct_u32 {
14837 uint32_t a;
14838};
14839
14840struct Struct_u32 zig_ret_struct_u32(void);
14841void zig_struct_u32(struct Struct_u32, size_t);
14842
14843struct Struct_u32 c_ret_struct_u32(void) {
14844 return (struct Struct_u32){ .a = 4 };
14845}
14846void c_struct_u32(struct Struct_u32 s, size_t i) {
14847 assert_or_panic(s.a == 5);
14848 assert_or_panic(i == 6);
14849}
14850void c_test_struct_u32(void) {
14851 struct Struct_u32 s = zig_ret_struct_u32();
14852 assert_or_panic(s.a == 1);
14853 zig_struct_u32((struct Struct_u32){ .a = 2 }, 3);
14854}
14855
14856struct Struct_u32_u32 {
14857 uint32_t a, b;
14858};
14859
14860struct Struct_u32_u32 zig_ret_struct_u32_u32(void);
14861void zig_struct_u32_u32(struct Struct_u32_u32, size_t);
14862
14863struct Struct_u32_u32 c_ret_struct_u32_u32(void) {
14864 return (struct Struct_u32_u32){ .a = 6, .b = 7 };
14865}
14866void c_struct_u32_u32(struct Struct_u32_u32 s, size_t i) {
14867 assert_or_panic(s.a == 8);
14868 assert_or_panic(s.b == 9);
14869 assert_or_panic(i == 10);
14870}
14871void c_test_struct_u32_u32(void) {
14872 struct Struct_u32_u32 s = zig_ret_struct_u32_u32();
14873 assert_or_panic(s.a == 1);
14874 assert_or_panic(s.b == 2);
14875 zig_struct_u32_u32((struct Struct_u32_u32){ .a = 3, .b = 4 }, 5);
14876}
14877
14878struct Struct_u32_u32_u32 {
14879 uint32_t a, b, c;
14880};
14881
14882struct Struct_u32_u32_u32 zig_ret_struct_u32_u32_u32(void);
14883void zig_struct_u32_u32_u32(struct Struct_u32_u32_u32, size_t);
14884
14885struct Struct_u32_u32_u32 c_ret_struct_u32_u32_u32(void) {
14886 return (struct Struct_u32_u32_u32){ .a = 8, .b = 9, .c = 10 };
14887}
14888void c_struct_u32_u32_u32(struct Struct_u32_u32_u32 s, size_t i) {
14889 assert_or_panic(s.a == 11);
14890 assert_or_panic(s.b == 12);
14891 assert_or_panic(s.c == 13);
14892 assert_or_panic(i == 14);
14893}
14894void c_test_struct_u32_u32_u32(void) {
14895 struct Struct_u32_u32_u32 s = zig_ret_struct_u32_u32_u32();
14896 assert_or_panic(s.a == 1);
14897 assert_or_panic(s.b == 2);
14898 assert_or_panic(s.c == 3);
14899 zig_struct_u32_u32_u32((struct Struct_u32_u32_u32){ .a = 4, .b = 5, .c = 6 }, 7);
14900}
14901
14902struct Struct_u32_u32_u32_u32 {
14903 uint32_t a, b, c, d;
14904};
14905
14906struct Struct_u32_u32_u32_u32 zig_ret_struct_u32_u32_u32_u32(void);
14907void zig_struct_u32_u32_u32_u32(struct Struct_u32_u32_u32_u32, size_t);
14908
14909struct Struct_u32_u32_u32_u32 c_ret_struct_u32_u32_u32_u32(void) {
14910 return (struct Struct_u32_u32_u32_u32){ .a = 10, .b = 11, .c = 12, .d = 13 };
14911}
14912void c_struct_u32_u32_u32_u32(struct Struct_u32_u32_u32_u32 s, size_t i) {
14913 assert_or_panic(s.a == 14);
14914 assert_or_panic(s.b == 15);
14915 assert_or_panic(s.c == 16);
14916 assert_or_panic(s.d == 17);
14917 assert_or_panic(i == 18);
14918}
14919void c_test_struct_u32_u32_u32_u32(void) {
14920 struct Struct_u32_u32_u32_u32 s = zig_ret_struct_u32_u32_u32_u32();
14921 assert_or_panic(s.a == 1);
14922 assert_or_panic(s.b == 2);
14923 assert_or_panic(s.c == 3);
14924 assert_or_panic(s.d == 4);
14925 zig_struct_u32_u32_u32_u32((struct Struct_u32_u32_u32_u32){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
14926}
14927
14928struct Struct_u64 {
14929 uint64_t a;
14930};
14931
14932struct Struct_u64 zig_ret_struct_u64(void);
14933void zig_struct_u64(struct Struct_u64, size_t);
14934
14935struct Struct_u64 c_ret_struct_u64(void) {
14936 return (struct Struct_u64){ .a = 4 };
14937}
14938void c_struct_u64(struct Struct_u64 s, size_t i) {
14939 assert_or_panic(s.a == 5);
14940 assert_or_panic(i == 6);
14941}
14942void c_test_struct_u64(void) {
14943 struct Struct_u64 s = zig_ret_struct_u64();
14944 assert_or_panic(s.a == 1);
14945 zig_struct_u64((struct Struct_u64){ .a = 2 }, 3);
14946}
14947
14948struct Struct_u64_u64 {
14949 uint64_t a;
14950 uint64_t b;
14951};
14952
14953struct Struct_u64_u64 zig_ret_struct_u64_u64(void);
14954void zig_struct_u64_u64(struct Struct_u64_u64, size_t);
14955void zig_1_struct_u64_u64(size_t, struct Struct_u64_u64, size_t);
14956void zig_2_struct_u64_u64(size_t, size_t, struct Struct_u64_u64, size_t);
14957void zig_3_struct_u64_u64(size_t, size_t, size_t, struct Struct_u64_u64, size_t);
14958void zig_4_struct_u64_u64(size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
14959void zig_5_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
14960void zig_6_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
14961void zig_7_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
14962void zig_8_struct_u64_u64(size_t, size_t, size_t, size_t, size_t, size_t, size_t, size_t, struct Struct_u64_u64, size_t);
14963
14964struct Struct_u64_u64 c_ret_struct_u64_u64(void) {
14965 return (struct Struct_u64_u64){ .a = 21, .b = 22 };
14966}
14967void c_struct_u64_u64(struct Struct_u64_u64 s, size_t i) {
14968 assert_or_panic(s.a == 23);
14969 assert_or_panic(s.b == 24);
14970 assert_or_panic(i == 1);
14971}
14972void c_1_struct_u64_u64(size_t a0, struct Struct_u64_u64 s, size_t i) {
14973 assert_or_panic(s.a == 25);
14974 assert_or_panic(s.b == 26);
14975 assert_or_panic(i == 2);
14976}
14977void c_2_struct_u64_u64(size_t a0, size_t a1, struct Struct_u64_u64 s, size_t i) {
14978 assert_or_panic(s.a == 27);
14979 assert_or_panic(s.b == 28);
14980 assert_or_panic(i == 3);
14981}
14982void c_3_struct_u64_u64(size_t a0, size_t a1, size_t a2, struct Struct_u64_u64 s, size_t i) {
14983 assert_or_panic(s.a == 29);
14984 assert_or_panic(s.b == 30);
14985 assert_or_panic(i == 4);
14986}
14987void c_4_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, struct Struct_u64_u64 s, size_t i) {
14988 assert_or_panic(s.a == 31);
14989 assert_or_panic(s.b == 32);
14990 assert_or_panic(i == 5);
14991}
14992void c_5_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, struct Struct_u64_u64 s, size_t i) {
14993 assert_or_panic(s.a == 33);
14994 assert_or_panic(s.b == 34);
14995 assert_or_panic(i == 6);
14996}
14997void c_6_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, struct Struct_u64_u64 s, size_t i) {
14998 assert_or_panic(s.a == 35);
14999 assert_or_panic(s.b == 36);
15000 assert_or_panic(i == 7);
15001}
15002void c_7_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, struct Struct_u64_u64 s, size_t i) {
15003 assert_or_panic(s.a == 37);
15004 assert_or_panic(s.b == 38);
15005 assert_or_panic(i == 8);
15006}
15007void c_8_struct_u64_u64(size_t a0, size_t a1, size_t a2, size_t a3, size_t a4, size_t a5, size_t a6, size_t a7, struct Struct_u64_u64 s, size_t i) {
15008 assert_or_panic(s.a == 39);
15009 assert_or_panic(s.b == 40);
15010 assert_or_panic(i == 9);
15011}
15012void c_test_struct_u64_u64(void) {
15013 struct Struct_u64_u64 s = zig_ret_struct_u64_u64();
15014 assert_or_panic(s.a == 1);
15015 assert_or_panic(s.b == 2);
15016 zig_struct_u64_u64((struct Struct_u64_u64){ .a = 3, .b = 4 }, 1);
15017 zig_1_struct_u64_u64(0, (struct Struct_u64_u64){ .a = 5, .b = 6 }, 2);
15018 zig_2_struct_u64_u64(0, 1, (struct Struct_u64_u64){ .a = 7, .b = 8 }, 3);
15019 zig_3_struct_u64_u64(0, 1, 2, (struct Struct_u64_u64){ .a = 9, .b = 10 }, 4);
15020 zig_4_struct_u64_u64(0, 1, 2, 3, (struct Struct_u64_u64){ .a = 11, .b = 12 }, 5);
15021 zig_5_struct_u64_u64(0, 1, 2, 3, 4, (struct Struct_u64_u64){ .a = 13, .b = 14 }, 6);
15022 zig_6_struct_u64_u64(0, 1, 2, 3, 4, 5, (struct Struct_u64_u64){ .a = 15, .b = 16 }, 7);
15023 zig_7_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, (struct Struct_u64_u64){ .a = 17, .b = 18 }, 8);
15024 zig_8_struct_u64_u64(0, 1, 2, 3, 4, 5, 6, 7, (struct Struct_u64_u64){ .a = 19, .b = 20 }, 9);
15025}
15026
15027struct Struct_u64_u64_u64 {
15028 uint64_t a, b, c;
15029};
15030
15031struct Struct_u64_u64_u64 zig_ret_struct_u64_u64_u64(void);
15032void zig_struct_u64_u64_u64(struct Struct_u64_u64_u64, size_t);
15033
15034struct Struct_u64_u64_u64 c_ret_struct_u64_u64_u64(void) {
15035 return (struct Struct_u64_u64_u64){ .a = 8, .b = 9, .c = 10 };
15036}
15037void c_struct_u64_u64_u64(struct Struct_u64_u64_u64 s, size_t i) {
15038 assert_or_panic(s.a == 11);
15039 assert_or_panic(s.b == 12);
15040 assert_or_panic(s.c == 13);
15041 assert_or_panic(i == 14);
15042}
15043void c_test_struct_u64_u64_u64(void) {
15044 struct Struct_u64_u64_u64 s = zig_ret_struct_u64_u64_u64();
15045 assert_or_panic(s.a == 1);
15046 assert_or_panic(s.b == 2);
15047 assert_or_panic(s.c == 3);
15048 zig_struct_u64_u64_u64((struct Struct_u64_u64_u64){ .a = 4, .b = 5, .c = 6 }, 7);
15049}
15050
15051struct Struct_u64_u64_u64_u64 {
15052 uint64_t a, b, c, d;
15053};
15054
15055struct Struct_u64_u64_u64_u64 zig_ret_struct_u64_u64_u64_u64(void);
15056void zig_struct_u64_u64_u64_u64(struct Struct_u64_u64_u64_u64, size_t);
15057
15058struct Struct_u64_u64_u64_u64 c_ret_struct_u64_u64_u64_u64(void) {
15059 return (struct Struct_u64_u64_u64_u64){ .a = 10, .b = 11, .c = 12, .d = 13 };
15060}
15061void c_struct_u64_u64_u64_u64(struct Struct_u64_u64_u64_u64 s, size_t i) {
15062 assert_or_panic(s.a == 14);
15063 assert_or_panic(s.b == 15);
15064 assert_or_panic(s.c == 16);
15065 assert_or_panic(s.d == 17);
15066 assert_or_panic(i == 18);
15067}
15068void c_test_struct_u64_u64_u64_u64(void) {
15069 struct Struct_u64_u64_u64_u64 s = zig_ret_struct_u64_u64_u64_u64();
15070 assert_or_panic(s.a == 1);
15071 assert_or_panic(s.b == 2);
15072 assert_or_panic(s.c == 3);
15073 assert_or_panic(s.d == 4);
15074 zig_struct_u64_u64_u64_u64((struct Struct_u64_u64_u64_u64){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
15075}
15076
15077struct Struct_f32 {
15078 float a;
15079};
15080
15081struct Struct_f32 zig_ret_struct_f32(void);
15082void zig_struct_f32(struct Struct_f32, size_t);
15083
15084struct Struct_f32 c_ret_struct_f32(void) {
15085 return (struct Struct_f32){ .a = 4 };
15086}
15087void c_struct_f32(struct Struct_f32 s, size_t i) {
15088 assert_or_panic(s.a == 5);
15089 assert_or_panic(i == 6);
15090}
15091void c_test_struct_f32(void) {
15092 struct Struct_f32 s = zig_ret_struct_f32();
15093 assert_or_panic(s.a == 1);
15094 zig_struct_f32((struct Struct_f32){ .a = 2 }, 3);
15095}
15096
15097struct Struct_f32_f32 {
15098 float a, b;
15099};
15100
15101struct Struct_f32_f32 zig_ret_struct_f32_f32(void);
15102void zig_struct_f32_f32(struct Struct_f32_f32, size_t);
15103
15104struct Struct_f32_f32 c_ret_struct_f32_f32(void) {
15105 return (struct Struct_f32_f32){ .a = 6, .b = 7 };
15106}
15107void c_struct_f32_f32(struct Struct_f32_f32 s, size_t i) {
15108 assert_or_panic(s.a == 8);
15109 assert_or_panic(s.b == 9);
15110 assert_or_panic(i == 10);
15111}
15112void c_test_struct_f32_f32(void) {
15113 struct Struct_f32_f32 s = zig_ret_struct_f32_f32();
15114 assert_or_panic(s.a == 1);
15115 assert_or_panic(s.b == 2);
15116 zig_struct_f32_f32((struct Struct_f32_f32){ .a = 3, .b = 4 }, 5);
15117}
15118
15119struct Struct_f32_f32_f32 {
15120 float a, b, c;
15121};
15122
15123struct Struct_f32_f32_f32 zig_ret_struct_f32_f32_f32(void);
15124void zig_struct_f32_f32_f32(struct Struct_f32_f32_f32, size_t);
15125
15126struct Struct_f32_f32_f32 c_ret_struct_f32_f32_f32(void) {
15127 return (struct Struct_f32_f32_f32){ .a = 8, .b = 9, .c = 10 };
15128}
15129void c_struct_f32_f32_f32(struct Struct_f32_f32_f32 s, size_t i) {
15130 assert_or_panic(s.a == 11);
15131 assert_or_panic(s.b == 12);
15132 assert_or_panic(s.c == 13);
15133 assert_or_panic(i == 14);
15134}
15135void c_test_struct_f32_f32_f32(void) {
15136 struct Struct_f32_f32_f32 s = zig_ret_struct_f32_f32_f32();
15137 assert_or_panic(s.a == 1);
15138 assert_or_panic(s.b == 2);
15139 assert_or_panic(s.c == 3);
15140 zig_struct_f32_f32_f32((struct Struct_f32_f32_f32){ .a = 4, .b = 5, .c = 6 }, 7);
15141}
15142
15143struct Struct_f32_f32_f32_f32 {
15144 float a, b, c, d;
15145};
15146
15147struct Struct_f32_f32_f32_f32 zig_ret_struct_f32_f32_f32_f32(void);
15148void zig_struct_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32, size_t);
15149
15150struct Struct_f32_f32_f32_f32 c_ret_struct_f32_f32_f32_f32(void) {
15151 return (struct Struct_f32_f32_f32_f32){ .a = 10, .b = 11, .c = 12, .d = 13 };
15152}
15153void c_struct_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32 s, size_t i) {
15154 assert_or_panic(s.a == 14);
15155 assert_or_panic(s.b == 15);
15156 assert_or_panic(s.c == 16);
15157 assert_or_panic(s.d == 17);
15158 assert_or_panic(i == 18);
15159}
15160void c_test_struct_f32_f32_f32_f32(void) {
15161 struct Struct_f32_f32_f32_f32 s = zig_ret_struct_f32_f32_f32_f32();
15162 assert_or_panic(s.a == 1);
15163 assert_or_panic(s.b == 2);
15164 assert_or_panic(s.c == 3);
15165 assert_or_panic(s.d == 4);
15166 zig_struct_f32_f32_f32_f32((struct Struct_f32_f32_f32_f32){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
15167}
15168
15169struct Struct_f32_f32_f32_f32_f32 {
15170 float a, b, c, d, e;
15171};
15172
15173struct Struct_f32_f32_f32_f32_f32 zig_ret_struct_f32_f32_f32_f32_f32(void);
15174void zig_struct_f32_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32_f32, size_t);
15175
15176struct Struct_f32_f32_f32_f32_f32 c_ret_struct_f32_f32_f32_f32_f32(void) {
15177 return (struct Struct_f32_f32_f32_f32_f32){ .a = 12, .b = 13, .c = 14, .d = 15, .e = 16 };
15178}
15179void c_struct_f32_f32_f32_f32_f32(struct Struct_f32_f32_f32_f32_f32 s, size_t i) {
15180 assert_or_panic(s.a == 17);
15181 assert_or_panic(s.b == 18);
15182 assert_or_panic(s.c == 19);
15183 assert_or_panic(s.d == 20);
15184 assert_or_panic(s.e == 21);
15185 assert_or_panic(i == 22);
15186}
15187void c_test_struct_f32_f32_f32_f32_f32(void) {
15188 struct Struct_f32_f32_f32_f32_f32 s = zig_ret_struct_f32_f32_f32_f32_f32();
15189 assert_or_panic(s.a == 1);
15190 assert_or_panic(s.b == 2);
15191 assert_or_panic(s.c == 3);
15192 assert_or_panic(s.d == 4);
15193 assert_or_panic(s.e == 5);
15194 zig_struct_f32_f32_f32_f32_f32((struct Struct_f32_f32_f32_f32_f32){ .a = 6, .b = 7, .c = 8, .d = 9, .e = 10 }, 11);
15195}
15196
15197struct Struct_f32 zig_ret_struct_void_f32(void);
15198void zig_struct_void_f32(struct Struct_f32, size_t);
15199
15200struct Struct_f32 c_ret_struct_void_f32(void) {
15201 return (struct Struct_f32){ .a = 4 };
15202}
15203void c_struct_void_f32(struct Struct_f32 s, size_t i) {
15204 assert_or_panic(s.a == 5);
15205 assert_or_panic(i == 6);
15206}
15207void c_test_struct_void_f32(void) {
15208 struct Struct_f32 s = zig_ret_struct_void_f32();
15209 assert_or_panic(s.a == 1);
15210 zig_struct_void_f32((struct Struct_f32){ .a = 2 }, 3);
15211}
15212
15213struct Struct_array_1_f32 {
15214 float a[1];
15215};
15216
15217struct Struct_array_1_f32 zig_ret_struct_array_1_f32(void);
15218void zig_struct_array_1_f32(struct Struct_array_1_f32, size_t);
15219
15220struct Struct_array_1_f32 c_ret_struct_array_1_f32(void) {
15221 return (struct Struct_array_1_f32){ .a = { 4 } };
15222}
15223void c_struct_array_1_f32(struct Struct_array_1_f32 s, size_t i) {
15224 assert_or_panic(s.a[0] == 5);
15225 assert_or_panic(i == 6);
15226}
15227void c_test_struct_array_1_f32(void) {
15228 struct Struct_array_1_f32 s = zig_ret_struct_array_1_f32();
15229 assert_or_panic(s.a[0] == 1);
15230 zig_struct_array_1_f32((struct Struct_array_1_f32){ .a = { 2 } }, 3);
15231}
15232
15233struct Struct_array_2_f32 {
15234 float a[2];
15235};
15236
15237struct Struct_array_2_f32 zig_ret_struct_array_2_f32(void);
15238void zig_struct_array_2_f32(struct Struct_array_2_f32, size_t);
15239
15240struct Struct_array_2_f32 c_ret_struct_array_2_f32(void) {
15241 return (struct Struct_array_2_f32){ .a = { 6, 7 } };
15242}
15243void c_struct_array_2_f32(struct Struct_array_2_f32 s, size_t i) {
15244 assert_or_panic(s.a[0] == 8);
15245 assert_or_panic(s.a[1] == 9);
15246 assert_or_panic(i == 10);
15247}
15248void c_test_struct_array_2_f32(void) {
15249 struct Struct_array_2_f32 s = zig_ret_struct_array_2_f32();
15250 assert_or_panic(s.a[0] == 1);
15251 assert_or_panic(s.a[1] == 2);
15252 zig_struct_array_2_f32((struct Struct_array_2_f32){ .a = { 3, 4 } }, 5);
15253}
15254
15255struct Struct_array_3_f32 {
15256 float a[3];
15257};
15258
15259struct Struct_array_3_f32 zig_ret_struct_array_3_f32(void);
15260void zig_struct_array_3_f32(struct Struct_array_3_f32, size_t);
15261
15262struct Struct_array_3_f32 c_ret_struct_array_3_f32(void) {
15263 return (struct Struct_array_3_f32){ .a = { 8, 9, 10 } };
15264}
15265void c_struct_array_3_f32(struct Struct_array_3_f32 s, size_t i) {
15266 assert_or_panic(s.a[0] == 11);
15267 assert_or_panic(s.a[1] == 12);
15268 assert_or_panic(s.a[2] == 13);
15269 assert_or_panic(i == 14);
15270}
15271void c_test_struct_array_3_f32(void) {
15272 struct Struct_array_3_f32 s = zig_ret_struct_array_3_f32();
15273 assert_or_panic(s.a[0] == 1);
15274 assert_or_panic(s.a[1] == 2);
15275 assert_or_panic(s.a[2] == 3);
15276 zig_struct_array_3_f32((struct Struct_array_3_f32){ .a = { 4, 5, 6 } }, 7);
15277}
15278
15279struct Struct_array_4_f32 {
15280 float a[4];
15281};
15282
15283struct Struct_array_4_f32 zig_ret_struct_array_4_f32(void);
15284void zig_struct_array_4_f32(struct Struct_array_4_f32, size_t);
15285
15286struct Struct_array_4_f32 c_ret_struct_array_4_f32(void) {
15287 return (struct Struct_array_4_f32){ .a = { 10, 11, 12, 13 } };
15288}
15289void c_struct_array_4_f32(struct Struct_array_4_f32 s, size_t i) {
15290 assert_or_panic(s.a[0] == 14);
15291 assert_or_panic(s.a[1] == 15);
15292 assert_or_panic(s.a[2] == 16);
15293 assert_or_panic(s.a[3] == 17);
15294 assert_or_panic(i == 18);
15295}
15296void c_test_struct_array_4_f32(void) {
15297 struct Struct_array_4_f32 s = zig_ret_struct_array_4_f32();
15298 assert_or_panic(s.a[0] == 1);
15299 assert_or_panic(s.a[1] == 2);
15300 assert_or_panic(s.a[2] == 3);
15301 assert_or_panic(s.a[3] == 4);
15302 zig_struct_array_4_f32((struct Struct_array_4_f32){ .a = { 5, 6, 7, 8 } }, 9);
15303}
15304
15305struct Struct_array_5_f32 {
15306 float a[5];
15307};
15308
15309struct Struct_array_5_f32 zig_ret_struct_array_5_f32(void);
15310void zig_struct_array_5_f32(struct Struct_array_5_f32, size_t);
15311
15312struct Struct_array_5_f32 c_ret_struct_array_5_f32(void) {
15313 return (struct Struct_array_5_f32){ .a = { 12, 13, 14, 15, 16 } };
15314}
15315void c_struct_array_5_f32(struct Struct_array_5_f32 s, size_t i) {
15316 assert_or_panic(s.a[0] == 17);
15317 assert_or_panic(s.a[1] == 18);
15318 assert_or_panic(s.a[2] == 19);
15319 assert_or_panic(s.a[3] == 20);
15320 assert_or_panic(s.a[4] == 21);
15321 assert_or_panic(i == 22);
15322}
15323void c_test_struct_array_5_f32(void) {
15324 struct Struct_array_5_f32 s = zig_ret_struct_array_5_f32();
15325 assert_or_panic(s.a[0] == 1);
15326 assert_or_panic(s.a[1] == 2);
15327 assert_or_panic(s.a[2] == 3);
15328 assert_or_panic(s.a[3] == 4);
15329 assert_or_panic(s.a[4] == 5);
15330 zig_struct_array_5_f32((struct Struct_array_5_f32){ .a = { 6, 7, 8, 9, 10 } }, 11);
15331}
15332
15333struct Struct_array_1_f32 zig_ret_struct_array_0_sentinel_f32(void);
15334void zig_struct_array_0_sentinel_f32(struct Struct_array_1_f32, size_t);
15335
15336struct Struct_array_1_f32 c_ret_struct_array_0_sentinel_f32(void) {
15337 return (struct Struct_array_1_f32){ .a = { 0x1e1 } };
15338}
15339void c_struct_array_0_sentinel_f32(struct Struct_array_1_f32 s, size_t i) {
15340 assert_or_panic(s.a[0] == 0x1e1);
15341 assert_or_panic(i == 2);
15342}
15343void c_test_struct_array_0_sentinel_f32(void) {
15344 struct Struct_array_1_f32 s = zig_ret_struct_array_0_sentinel_f32();
15345 assert_or_panic(s.a[0] == 0x1e1);
15346 zig_struct_array_0_sentinel_f32((struct Struct_array_1_f32){ .a = { 0x1e1 } }, 1);
15347}
15348
15349struct Struct_array_2_f32 zig_ret_struct_array_1_sentinel_f32(void);
15350void zig_struct_array_1_sentinel_f32(struct Struct_array_2_f32, size_t);
15351
15352struct Struct_array_2_f32 c_ret_struct_array_1_sentinel_f32(void) {
15353 return (struct Struct_array_2_f32){ .a = { 4, 0x1e1 } };
15354}
15355void c_struct_array_1_sentinel_f32(struct Struct_array_2_f32 s, size_t i) {
15356 assert_or_panic(s.a[0] == 5);
15357 assert_or_panic(s.a[1] == 0x1e1);
15358 assert_or_panic(i == 6);
15359}
15360void c_test_struct_array_1_sentinel_f32(void) {
15361 struct Struct_array_2_f32 s = zig_ret_struct_array_1_sentinel_f32();
15362 assert_or_panic(s.a[0] == 1);
15363 assert_or_panic(s.a[1] == 0x1e1);
15364 zig_struct_array_1_sentinel_f32((struct Struct_array_2_f32){ .a = { 2, 0x1e1 } }, 3);
15365}
15366
15367struct Struct_array_3_f32 zig_ret_struct_array_2_sentinel_f32(void);
15368void zig_struct_array_2_sentinel_f32(struct Struct_array_3_f32, size_t);
15369
15370struct Struct_array_3_f32 c_ret_struct_array_2_sentinel_f32(void) {
15371 return (struct Struct_array_3_f32){ .a = { 6, 7, 0x1e1 } };
15372}
15373void c_struct_array_2_sentinel_f32(struct Struct_array_3_f32 s, size_t i) {
15374 assert_or_panic(s.a[0] == 8);
15375 assert_or_panic(s.a[1] == 9);
15376 assert_or_panic(s.a[2] == 0x1e1);
15377 assert_or_panic(i == 10);
15378}
15379void c_test_struct_array_2_sentinel_f32(void) {
15380 struct Struct_array_3_f32 s = zig_ret_struct_array_2_sentinel_f32();
15381 assert_or_panic(s.a[0] == 1);
15382 assert_or_panic(s.a[1] == 2);
15383 assert_or_panic(s.a[2] == 0x1e1);
15384 zig_struct_array_2_sentinel_f32((struct Struct_array_3_f32){ .a = { 3, 4, 0x1e1 } }, 5);
15385}
15386
15387struct Struct_array_4_f32 zig_ret_struct_array_3_sentinel_f32(void);
15388void zig_struct_array_3_sentinel_f32(struct Struct_array_4_f32, size_t);
15389
15390struct Struct_array_4_f32 c_ret_struct_array_3_sentinel_f32(void) {
15391 return (struct Struct_array_4_f32){ .a = { 8, 9, 10, 0x1e1 } };
15392}
15393void c_struct_array_3_sentinel_f32(struct Struct_array_4_f32 s, size_t i) {
15394 assert_or_panic(s.a[0] == 11);
15395 assert_or_panic(s.a[1] == 12);
15396 assert_or_panic(s.a[2] == 13);
15397 assert_or_panic(s.a[3] == 0x1e1);
15398 assert_or_panic(i == 14);
15399}
15400void c_test_struct_array_3_sentinel_f32(void) {
15401 struct Struct_array_4_f32 s = zig_ret_struct_array_3_sentinel_f32();
15402 assert_or_panic(s.a[0] == 1);
15403 assert_or_panic(s.a[1] == 2);
15404 assert_or_panic(s.a[2] == 3);
15405 assert_or_panic(s.a[3] == 0x1e1);
15406 zig_struct_array_3_sentinel_f32((struct Struct_array_4_f32){ .a = { 4, 5, 6, 0x1e1 } }, 7);
15407}
15408
15409struct Struct_array_5_f32 zig_ret_struct_array_4_sentinel_f32(void);
15410void zig_struct_array_4_sentinel_f32(struct Struct_array_5_f32, size_t);
15411
15412struct Struct_array_5_f32 c_ret_struct_array_4_sentinel_f32(void) {
15413 return (struct Struct_array_5_f32){ .a = { 10, 11, 12, 13, 0x1e1 } };
15414}
15415void c_struct_array_4_sentinel_f32(struct Struct_array_5_f32 s, size_t i) {
15416 assert_or_panic(s.a[0] == 14);
15417 assert_or_panic(s.a[1] == 15);
15418 assert_or_panic(s.a[2] == 16);
15419 assert_or_panic(s.a[3] == 17);
15420 assert_or_panic(s.a[4] == 0x1e1);
15421 assert_or_panic(i == 18);
15422}
15423void c_test_struct_array_4_sentinel_f32(void) {
15424 struct Struct_array_5_f32 s = zig_ret_struct_array_4_sentinel_f32();
15425 assert_or_panic(s.a[0] == 1);
15426 assert_or_panic(s.a[1] == 2);
15427 assert_or_panic(s.a[2] == 3);
15428 assert_or_panic(s.a[3] == 4);
15429 assert_or_panic(s.a[4] == 0x1e1);
15430 zig_struct_array_4_sentinel_f32((struct Struct_array_5_f32){ .a = { 5, 6, 7, 8, 0x1e1 } }, 9);
15431}
15432
15433struct Struct_f32a8 {
15434 alignas(8) float a;
15435};
15436
15437struct Struct_f32a8 zig_ret_struct_f32a8(void);
15438void zig_struct_f32a8(struct Struct_f32a8, float);
15439
15440struct Struct_f32a8 c_ret_struct_f32a8(void) {
15441 return (struct Struct_f32a8){ .a = 4.125f };
15442}
15443void c_struct_f32a8(struct Struct_f32a8 s, float f) {
15444 assert_or_panic(s.a == 5.375f);
15445 assert_or_panic(f == 6.5f);
15446}
15447void c_test_struct_f32a8(void) {
15448 struct Struct_f32a8 s = zig_ret_struct_f32a8();
15449 assert_or_panic(s.a == 1.25f);
15450 zig_struct_f32a8((struct Struct_f32a8){ .a = 2.75f }, 3.5f);
15451}
15452
15453struct Struct_f32a8_f32a8 {
15454 alignas(8) float a;
15455 alignas(8) float b;
15456};
15457
15458struct Struct_f32a8_f32a8 zig_ret_struct_f32a8_f32a8(void);
15459void zig_struct_f32a8_f32a8(struct Struct_f32a8_f32a8, float);
15460
15461struct Struct_f32a8_f32a8 c_ret_struct_f32a8_f32a8(void) {
15462 return (struct Struct_f32a8_f32a8){ .a = 6.625f, .b = 7.875f };
15463}
15464void c_struct_f32a8_f32a8(struct Struct_f32a8_f32a8 s, float f) {
15465 assert_or_panic(s.a == 8.0625f);
15466 assert_or_panic(s.b == 9.1875f);
15467 assert_or_panic(f == 10.5f);
15468}
15469void c_test_struct_f32a8_f32a8(void) {
15470 struct Struct_f32a8_f32a8 s = zig_ret_struct_f32a8_f32a8();
15471 assert_or_panic(s.a == 1.25f);
15472 assert_or_panic(s.b == 2.75f);
15473 zig_struct_f32a8_f32a8((struct Struct_f32a8_f32a8){ .a = 3.125f, .b = 4.375f }, 5.5f);
15474}
15475
15476struct Struct_f32f32_f32 {
15477 struct {
15478 float b, c;
15479 } a;
15480 float d;
15481};
15482
15483struct Struct_f32f32_f32 zig_ret_struct_f32f32_f32(void);
15484void zig_struct_f32f32_f32(struct Struct_f32f32_f32);
15485
15486struct Struct_f32f32_f32 c_ret_struct_f32f32_f32(void) {
15487 return (struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f };
15488}
15489void c_struct_f32f32_f32(struct Struct_f32f32_f32 s) {
15490 assert_or_panic(s.a.b == 1.0f);
15491 assert_or_panic(s.a.c == 2.0f);
15492 assert_or_panic(s.d == 3.0f);
15493}
15494void c_test_struct_f32f32_f32(void) {
15495 struct Struct_f32f32_f32 s = zig_ret_struct_f32f32_f32();
15496 assert_or_panic(s.a.b == 1.0f);
15497 assert_or_panic(s.a.c == 2.0f);
15498 assert_or_panic(s.d == 3.0f);
15499 zig_struct_f32f32_f32((struct Struct_f32f32_f32){ .a = { .b = 1.0f, .c = 2.0f }, .d = 3.0f });
15500}
15501
15502struct Struct_f32_f32f32 {
15503 float a;
15504 struct {
15505 float c, d;
15506 } b;
15507};
15508
15509struct Struct_f32_f32f32 zig_ret_struct_f32_f32f32(void);
15510void zig_struct_f32_f32f32(struct Struct_f32_f32f32);
15511
15512struct Struct_f32_f32f32 c_ret_struct_f32_f32f32(void) {
15513 return (struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } };
15514}
15515void c_struct_f32_f32f32(struct Struct_f32_f32f32 s) {
15516 assert_or_panic(s.a == 1.0f);
15517 assert_or_panic(s.b.c == 2.0f);
15518 assert_or_panic(s.b.d == 3.0f);
15519}
15520void c_test_struct_f32_f32f32(void) {
15521 struct Struct_f32_f32f32 s = zig_ret_struct_f32_f32f32();
15522 assert_or_panic(s.a == 1.0f);
15523 assert_or_panic(s.b.c == 2.0f);
15524 assert_or_panic(s.b.d == 3.0f);
15525 zig_struct_f32_f32f32((struct Struct_f32_f32f32){ .a = 1.0f, .b = { .c = 2.0f, .d = 3.0f } });
15526}
15527
15528struct Struct_f64 {
15529 double a;
15530};
15531
15532struct Struct_f64 zig_ret_struct_f64(void);
15533void zig_struct_f64(struct Struct_f64, size_t);
15534
15535struct Struct_f64 c_ret_struct_f64(void) {
15536 return (struct Struct_f64){ .a = 4 };
15537}
15538void c_struct_f64(struct Struct_f64 s, size_t i) {
15539 assert_or_panic(s.a == 5);
15540 assert_or_panic(i == 6);
15541}
15542void c_test_struct_f64(void) {
15543 struct Struct_f64 s = zig_ret_struct_f64();
15544 assert_or_panic(s.a == 1);
15545 zig_struct_f64((struct Struct_f64){ .a = 2 }, 3);
15546}
15547
15548struct Struct_f64_f64 {
15549 double a, b;
15550};
15551
15552struct Struct_f64_f64 zig_ret_struct_f64_f64(void);
15553void zig_struct_f64_f64(struct Struct_f64_f64, size_t);
15554
15555struct Struct_f64_f64 c_ret_struct_f64_f64(void) {
15556 return (struct Struct_f64_f64){ .a = 6, .b = 7 };
15557}
15558void c_struct_f64_f64(struct Struct_f64_f64 s, size_t i) {
15559 assert_or_panic(s.a == 8);
15560 assert_or_panic(s.b == 9);
15561 assert_or_panic(i == 10);
15562}
15563void c_test_struct_f64_f64(void) {
15564 struct Struct_f64_f64 s = zig_ret_struct_f64_f64();
15565 assert_or_panic(s.a == 1);
15566 assert_or_panic(s.b == 2);
15567 zig_struct_f64_f64((struct Struct_f64_f64){ .a = 3, .b = 4 }, 5);
15568}
15569
15570struct Struct_f64_f64_f64 {
15571 double a, b, c;
15572};
15573
15574struct Struct_f64_f64_f64 zig_ret_struct_f64_f64_f64(void);
15575void zig_struct_f64_f64_f64(struct Struct_f64_f64_f64, size_t);
15576
15577struct Struct_f64_f64_f64 c_ret_struct_f64_f64_f64(void) {
15578 return (struct Struct_f64_f64_f64){ .a = 8, .b = 9, .c = 10 };
15579}
15580void c_struct_f64_f64_f64(struct Struct_f64_f64_f64 s, size_t i) {
15581 assert_or_panic(s.a == 11);
15582 assert_or_panic(s.b == 12);
15583 assert_or_panic(s.c == 13);
15584 assert_or_panic(i == 14);
15585}
15586void c_test_struct_f64_f64_f64(void) {
15587 struct Struct_f64_f64_f64 s = zig_ret_struct_f64_f64_f64();
15588 assert_or_panic(s.a == 1);
15589 assert_or_panic(s.b == 2);
15590 assert_or_panic(s.c == 3);
15591 zig_struct_f64_f64_f64((struct Struct_f64_f64_f64){ .a = 4, .b = 5, .c = 6 }, 7);
15592}
15593
15594struct Struct_f64_f64_f64_f64 {
15595 double a, b, c, d;
15596};
15597
15598struct Struct_f64_f64_f64_f64 zig_ret_struct_f64_f64_f64_f64(void);
15599void zig_struct_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64, size_t);
15600
15601struct Struct_f64_f64_f64_f64 c_ret_struct_f64_f64_f64_f64(void) {
15602 return (struct Struct_f64_f64_f64_f64){ .a = 10, .b = 11, .c = 12, .d = 13 };
15603}
15604void c_struct_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64 s, size_t i) {
15605 assert_or_panic(s.a == 14);
15606 assert_or_panic(s.b == 15);
15607 assert_or_panic(s.c == 16);
15608 assert_or_panic(s.d == 17);
15609 assert_or_panic(i == 18);
15610}
15611void c_test_struct_f64_f64_f64_f64(void) {
15612 struct Struct_f64_f64_f64_f64 s = zig_ret_struct_f64_f64_f64_f64();
15613 assert_or_panic(s.a == 1);
15614 assert_or_panic(s.b == 2);
15615 assert_or_panic(s.c == 3);
15616 assert_or_panic(s.d == 4);
15617 zig_struct_f64_f64_f64_f64((struct Struct_f64_f64_f64_f64){ .a = 5, .b = 6, .c = 7, .d = 8 }, 9);
15618}
15619
15620struct Struct_f64_f64_f64_f64_f64 {
15621 double a, b, c, d, e;
15622};
15623
15624struct Struct_f64_f64_f64_f64_f64 zig_ret_struct_f64_f64_f64_f64_f64(void);
15625void zig_struct_f64_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64_f64, size_t);
15626
15627struct Struct_f64_f64_f64_f64_f64 c_ret_struct_f64_f64_f64_f64_f64(void) {
15628 return (struct Struct_f64_f64_f64_f64_f64){ .a = 12, .b = 13, .c = 14, .d = 15, .e = 16 };
15629}
15630void c_struct_f64_f64_f64_f64_f64(struct Struct_f64_f64_f64_f64_f64 s, size_t i) {
15631 assert_or_panic(s.a == 17);
15632 assert_or_panic(s.b == 18);
15633 assert_or_panic(s.c == 19);
15634 assert_or_panic(s.d == 20);
15635 assert_or_panic(s.e == 21);
15636 assert_or_panic(i == 22);
15637}
15638void c_test_struct_f64_f64_f64_f64_f64(void) {
15639 struct Struct_f64_f64_f64_f64_f64 s = zig_ret_struct_f64_f64_f64_f64_f64();
15640 assert_or_panic(s.a == 1);
15641 assert_or_panic(s.b == 2);
15642 assert_or_panic(s.c == 3);
15643 assert_or_panic(s.d == 4);
15644 assert_or_panic(s.e == 5);
15645 zig_struct_f64_f64_f64_f64_f64((struct Struct_f64_f64_f64_f64_f64){ .a = 6, .b = 7, .c = 8, .d = 9, .e = 10 }, 11);
15646}
15647
15648struct Struct_array_1_f64 {
15649 double a[1];
15650};
15651
15652struct Struct_array_1_f64 zig_ret_struct_array_1_f64(void);
15653void zig_struct_array_1_f64(struct Struct_array_1_f64, size_t);
15654
15655struct Struct_array_1_f64 c_ret_struct_array_1_f64(void) {
15656 return (struct Struct_array_1_f64){ .a = { 4 } };
15657}
15658void c_struct_array_1_f64(struct Struct_array_1_f64 s, size_t i) {
15659 assert_or_panic(s.a[0] == 5);
15660 assert_or_panic(i == 6);
15661}
15662void c_test_struct_array_1_f64(void) {
15663 struct Struct_array_1_f64 s = zig_ret_struct_array_1_f64();
15664 assert_or_panic(s.a[0] == 1);
15665 zig_struct_array_1_f64((struct Struct_array_1_f64){ .a = { 2 } }, 3);
15666}
15667
15668struct Struct_array_2_f64 {
15669 double a[2];
15670};
15671
15672struct Struct_array_2_f64 zig_ret_struct_array_2_f64(void);
15673void zig_struct_array_2_f64(struct Struct_array_2_f64, size_t);
15674
15675struct Struct_array_2_f64 c_ret_struct_array_2_f64(void) {
15676 return (struct Struct_array_2_f64){ .a = { 6, 7 } };
15677}
15678void c_struct_array_2_f64(struct Struct_array_2_f64 s, size_t i) {
15679 assert_or_panic(s.a[0] == 8);
15680 assert_or_panic(s.a[1] == 9);
15681 assert_or_panic(i == 10);
15682}
15683void c_test_struct_array_2_f64(void) {
15684 struct Struct_array_2_f64 s = zig_ret_struct_array_2_f64();
15685 assert_or_panic(s.a[0] == 1);
15686 assert_or_panic(s.a[1] == 2);
15687 zig_struct_array_2_f64((struct Struct_array_2_f64){ .a = { 3, 4 } }, 5);
15688}
15689
15690struct Struct_array_3_f64 {
15691 double a[3];
15692};
15693
15694struct Struct_array_3_f64 zig_ret_struct_array_3_f64(void);
15695void zig_struct_array_3_f64(struct Struct_array_3_f64, size_t);
15696
15697struct Struct_array_3_f64 c_ret_struct_array_3_f64(void) {
15698 return (struct Struct_array_3_f64){ .a = { 8, 9, 10 } };
15699}
15700void c_struct_array_3_f64(struct Struct_array_3_f64 s, size_t i) {
15701 assert_or_panic(s.a[0] == 11);
15702 assert_or_panic(s.a[1] == 12);
15703 assert_or_panic(s.a[2] == 13);
15704 assert_or_panic(i == 14);
15705}
15706void c_test_struct_array_3_f64(void) {
15707 struct Struct_array_3_f64 s = zig_ret_struct_array_3_f64();
15708 assert_or_panic(s.a[0] == 1);
15709 assert_or_panic(s.a[1] == 2);
15710 assert_or_panic(s.a[2] == 3);
15711 zig_struct_array_3_f64((struct Struct_array_3_f64){ .a = { 4, 5, 6 } }, 7);
15712}
15713
15714struct Struct_array_4_f64 {
15715 double a[4];
15716};
15717
15718struct Struct_array_4_f64 zig_ret_struct_array_4_f64(void);
15719void zig_struct_array_4_f64(struct Struct_array_4_f64, size_t);
15720
15721struct Struct_array_4_f64 c_ret_struct_array_4_f64(void) {
15722 return (struct Struct_array_4_f64){ .a = { 10, 11, 12, 13 } };
15723}
15724void c_struct_array_4_f64(struct Struct_array_4_f64 s, size_t i) {
15725 assert_or_panic(s.a[0] == 14);
15726 assert_or_panic(s.a[1] == 15);
15727 assert_or_panic(s.a[2] == 16);
15728 assert_or_panic(s.a[3] == 17);
15729 assert_or_panic(i == 18);
15730}
15731void c_test_struct_array_4_f64(void) {
15732 struct Struct_array_4_f64 s = zig_ret_struct_array_4_f64();
15733 assert_or_panic(s.a[0] == 1);
15734 assert_or_panic(s.a[1] == 2);
15735 assert_or_panic(s.a[2] == 3);
15736 assert_or_panic(s.a[3] == 4);
15737 zig_struct_array_4_f64((struct Struct_array_4_f64){ .a = { 5, 6, 7, 8 } }, 9);
15738}
15739
15740struct Struct_array_5_f64 {
15741 double a[5];
15742};
15743
15744struct Struct_array_5_f64 zig_ret_struct_array_5_f64(void);
15745void zig_struct_array_5_f64(struct Struct_array_5_f64, size_t);
15746
15747struct Struct_array_5_f64 c_ret_struct_array_5_f64(void) {
15748 return (struct Struct_array_5_f64){ .a = { 12, 13, 14, 15, 16 } };
15749}
15750void c_struct_array_5_f64(struct Struct_array_5_f64 s, size_t i) {
15751 assert_or_panic(s.a[0] == 17);
15752 assert_or_panic(s.a[1] == 18);
15753 assert_or_panic(s.a[2] == 19);
15754 assert_or_panic(s.a[3] == 20);
15755 assert_or_panic(s.a[4] == 21);
15756 assert_or_panic(i == 22);
15757}
15758void c_test_struct_array_5_f64(void) {
15759 struct Struct_array_5_f64 s = zig_ret_struct_array_5_f64();
15760 assert_or_panic(s.a[0] == 1);
15761 assert_or_panic(s.a[1] == 2);
15762 assert_or_panic(s.a[2] == 3);
15763 assert_or_panic(s.a[3] == 4);
15764 assert_or_panic(s.a[4] == 5);
15765 zig_struct_array_5_f64((struct Struct_array_5_f64){ .a = { 6, 7, 8, 9, 10 } }, 11);
15766}
15767
15768union Union_f64 {
15769 double a;
15770};
15771
15772union Union_f64 zig_ret_union_f64(void);
15773void zig_union_f64(union Union_f64, size_t);
15774
15775union Union_f64 c_ret_union_f64(void) {
15776 return (union Union_f64){ .a = 4 };
15777}
15778void c_union_f64(union Union_f64 s, size_t i) {
15779 assert_or_panic(s.a == 5);
15780 assert_or_panic(i == 6);
15781}
15782void c_test_union_f64(void) {
15783 union Union_f64 s = zig_ret_union_f64();
15784 assert_or_panic(s.a == 1);
15785 zig_union_f64((union Union_f64){ .a = 2 }, 3);
15786}
15787
15788struct Struct_u32_Union_u32_u32u32 {
15789 uint32_t a;
15790 union {
15791 struct {
15792 uint32_t d, e;
15793 } c;
15794 } b;
15795};
15796
15797struct Struct_u32_Union_u32_u32u32 zig_ret_struct_u32_union_u32_u32u32(void);
15798void zig_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32);
15799
15800struct Struct_u32_Union_u32_u32u32 c_ret_struct_u32_union_u32_u32u32(void) {
15801 struct Struct_u32_Union_u32_u32u32 s;
15802 s.a = 1;
15803 s.b.c.d = 2;
15804 s.b.c.e = 3;
15805 return s;
15806}
15807void c_struct_u32_union_u32_u32u32(struct Struct_u32_Union_u32_u32u32 s) {
15808 assert_or_panic(s.a == 1);
15809 assert_or_panic(s.b.c.d == 2);
15810 assert_or_panic(s.b.c.e == 3);
15811}
15812void c_test_struct_u32_union_u32_u32u32(void) {
15813 struct Struct_u32_Union_u32_u32u32 s = zig_ret_struct_u32_union_u32_u32u32();
15814 assert_or_panic(s.a == 1);
15815 assert_or_panic(s.b.c.d == 2);
15816 assert_or_panic(s.b.c.e == 3);
15817 zig_struct_u32_union_u32_u32u32(s);
15818}
15819
15820struct Struct_i32_i32 {
15821 int32_t a;
15822 int32_t b;
15823};
15824
15825void zig_struct_i32_i32(struct Struct_i32_i32);
15826
15827struct BigStruct {
15828 uint64_t a;
15829 uint64_t b;
15830 uint64_t c;
15831 uint64_t d;
15832 uint8_t e;
15833};
15834
15835void zig_big_struct(struct BigStruct);
15836
15837union BigUnion {
15838 struct BigStruct a;
15839};
15840
15841void zig_big_union(union BigUnion);
15842
15843struct MedStructMixed {
15844 uint32_t a;
15845 float b;
15846 float c;
15847 uint32_t d;
15848};
15849
15850void zig_med_struct_mixed(struct MedStructMixed);
15851struct MedStructMixed zig_ret_med_struct_mixed();
15852
15853void zig_small_packed_struct(uint8_t);
15854#ifndef ZIG_NO_I128
15855void zig_big_packed_struct(__int128);
15856#endif
15857
15858struct SplitStructInts {
15859 uint64_t a;
15860 uint8_t b;
15861 uint32_t c;
15862};
15863void zig_split_struct_ints(struct SplitStructInts);
15864
15865struct SplitStructMixed {
15866 uint64_t a;
15867 uint8_t b;
15868 float c;
15869};
15870void zig_split_struct_mixed(struct SplitStructMixed);
15871struct SplitStructMixed zig_ret_split_struct_mixed();
15872
15873struct BigStruct zig_big_struct_both(struct BigStruct);
15874
15875void run_c_tests(void) {
15876 zig_u8(0xff);
15877 zig_u16(0xfffe);
15878 zig_u32(0xfffffffd);
15879 zig_u64(0xfffffffffffffffc);
15880
15881#ifndef ZIG_NO_I128
15882 {
15883 struct u128 s = {0xfffffffffffffffc};
15884 zig_struct_u128(s);
15885 }
15886#endif
15887
15888 zig_i8(-1);
15889 zig_i16(-2);
15890 zig_i32(-3);
15891 zig_i64(-4);
15892
15893#ifndef ZIG_NO_I128
15894 {
15895 struct i128 s = {-6};
15896 zig_struct_i128(s);
15897 }
15898#endif
15899
15900 zig_five_integers(12, 34, 56, 78, 90);
15901
15902 zig_five_floats(1.0f, 2.0f, 3.0f, 4.0f, 5.0f);
15903
15904 zig_ptr((void *)0xdeadbeefL);
15905
15906 zig_bool(true);
15907
15908#ifndef ZIG_NO_COMPLEX
15909 // TODO: Resolve https://github.com/ziglang/zig/issues/8465
15910 //{
15911 // float complex a = 1.25f + I * 2.6f;
15912 // float complex b = 11.3f - I * 1.5f;
15913 // float complex z = zig_cmultf(a, b);
15914 // assert_or_panic(creal(z) == 1.5f);
15915 // assert_or_panic(cimag(z) == 13.5f);
15916 //}
15917
15918 {
15919 double complex a = 1.25 + I * 2.6;
15920 double complex b = 11.3 - I * 1.5;
15921 double complex z = zig_cmultd(a, b);
15922 assert_or_panic(creal(z) == 1.5);
15923 assert_or_panic(cimag(z) == 13.5);
15924 }
15925
15926 {
15927 float a_r = 1.25f;
15928 float a_i = 2.6f;
15929 float b_r = 11.3f;
15930 float b_i = -1.5f;
15931 float complex z = zig_cmultf_comp(a_r, a_i, b_r, b_i);
15932 assert_or_panic(creal(z) == 1.5f);
15933 assert_or_panic(cimag(z) == 13.5f);
15934 }
15935
15936 {
15937 double a_r = 1.25;
15938 double a_i = 2.6;
15939 double b_r = 11.3;
15940 double b_i = -1.5;
15941 double complex z = zig_cmultd_comp(a_r, a_i, b_r, b_i);
15942 assert_or_panic(creal(z) == 1.5);
15943 assert_or_panic(cimag(z) == 13.5);
15944 }
15945#endif
15946
15947#if !(defined(__i386__) && defined(_WIN32))
15948#ifndef __loongarch__
15949#ifndef ZIG_MIPS64
15950#ifndef ZIG_PPC32
15951 {
15952 struct Struct_i32_i32 s = {1, 2};
15953 zig_struct_i32_i32(s);
15954 }
15955#endif
15956#endif
15957#endif
15958#endif
15959
15960#ifndef __hexagon__
15961#ifndef __loongarch__
15962#ifndef ZIG_MIPS64
15963#ifndef ZIG_PPC32
15964 {
15965 struct BigStruct s = {1, 2, 3, 4, 5};
15966 zig_big_struct(s);
15967 }
15968#endif
15969#endif
15970#endif
15971#endif
15972
15973#ifndef ZIG_NO_I128
15974 {
15975 __int128 s = 0;
15976 s |= 1 << 0;
15977 s |= (__int128)2 << 64;
15978 zig_big_packed_struct(s);
15979 }
15980#endif
15981
15982 {
15983 uint8_t s = 0;
15984 s |= 0 << 0;
15985 s |= 1 << 2;
15986 s |= 2 << 4;
15987 s |= 3 << 6;
15988 zig_small_packed_struct(s);
15989 }
15990
15991#ifndef __hexagon__
15992#ifndef __i386__
15993#ifndef __loongarch__
15994#ifndef ZIG_MIPS64
15995#ifndef ZIG_PPC32
15996 {
15997 struct SplitStructInts s = {1234, 100, 1337};
15998 zig_split_struct_ints(s);
15999 }
16000#endif
16001#endif
16002#endif
16003#endif
16004#endif
16005
16006#ifndef __hexagon__
16007#ifndef __loongarch__
16008#ifndef ZIG_MIPS64
16009#ifndef ZIG_PPC32
16010 {
16011 struct MedStructMixed s = {1234, 100.0f, 1337.0f};
16012 zig_med_struct_mixed(s);
16013 }
16014#endif
16015#endif
16016#endif
16017#endif
16018
16019#ifndef __hexagon__
16020#ifndef __i386__
16021#ifndef __loongarch__
16022#ifndef ZIG_MIPS64
16023#ifndef ZIG_PPC32
16024 {
16025 struct SplitStructMixed s = {1234, 100, 1337.0f};
16026 zig_split_struct_mixed(s);
16027 }
16028#endif
16029#endif
16030#endif
16031#endif
16032#endif
16033
16034#ifndef __hexagon__
16035#ifndef __loongarch__
16036#ifndef ZIG_MIPS64
16037#ifndef ZIG_PPC32
16038 {
16039 struct BigStruct s = {30, 31, 32, 33, 34};
16040 struct BigStruct res = zig_big_struct_both(s);
16041 assert_or_panic(res.a == 20);
16042 assert_or_panic(res.b == 21);
16043 assert_or_panic(res.c == 22);
16044 assert_or_panic(res.d == 23);
16045 assert_or_panic(res.e == 24);
16046 }
16047#endif
16048#endif
16049#endif
16050#endif
16051
16052 {
16053 assert_or_panic(zig_ret_bool() == 1);
16054
16055 assert_or_panic(zig_ret_u8() == 0xff);
16056 assert_or_panic(zig_ret_u16() == 0xffff);
16057 assert_or_panic(zig_ret_u32() == 0xffffffff);
16058 assert_or_panic(zig_ret_u64() == 0xffffffffffffffff);
16059
16060 assert_or_panic(zig_ret_i8() == -1);
16061 assert_or_panic(zig_ret_i16() == -1);
16062 assert_or_panic(zig_ret_i32() == -1);
16063 assert_or_panic(zig_ret_i64() == -1);
16064 }
16065}
16066
16067void c_u8(uint8_t x) {
16068 assert_or_panic(x == 0xff);
16069}
16070
16071void c_u16(uint16_t x) {
16072 assert_or_panic(x == 0xfffe);
16073}
16074
16075void c_u32(uint32_t x) {
16076 assert_or_panic(x == 0xfffffffd);
16077}
16078
16079void c_u64(uint64_t x) {
16080 assert_or_panic(x == 0xfffffffffffffffcULL);
16081}
16082
16083#ifndef ZIG_NO_I128
16084void c_struct_u128(struct u128 x) {
16085 assert_or_panic(x.value == 0xfffffffffffffffcULL);
16086}
16087#endif
16088
16089void c_i8(int8_t x) {
16090 assert_or_panic(x == -1);
16091}
16092
16093void c_i16(int16_t x) {
16094 assert_or_panic(x == -2);
16095}
16096
16097void c_i32(int32_t x) {
16098 assert_or_panic(x == -3);
16099}
16100
16101void c_i64(int64_t x) {
16102 assert_or_panic(x == -4);
16103}
16104
16105#ifndef ZIG_NO_I128
16106void c_struct_i128(struct i128 x) {
16107 assert_or_panic(x.value == -6);
16108}
16109#endif
16110
16111void c_ptr(void *x) {
16112 assert_or_panic(x == (void *)0xdeadbeefL);
16113}
16114
16115void c_bool(bool x) {
16116 assert_or_panic(x);
16117}
16118
16119void c_five_integers(int32_t a, int32_t b, int32_t c, int32_t d, int32_t e) {
16120 assert_or_panic(a == 12);
16121 assert_or_panic(b == 34);
16122 assert_or_panic(c == 56);
16123 assert_or_panic(d == 78);
16124 assert_or_panic(e == 90);
16125}
16126
16127void c_five_floats(float a, float b, float c, float d, float e) {
16128 assert_or_panic(a == 1.0);
16129 assert_or_panic(b == 2.0);
16130 assert_or_panic(c == 3.0);
16131 assert_or_panic(d == 4.0);
16132 assert_or_panic(e == 5.0);
16133}
16134
16135#ifndef ZIG_NO_COMPLEX
16136float complex c_cmultf_comp(float a_r, float a_i, float b_r, float b_i) {
16137 assert_or_panic(a_r == 1.25f);
16138 assert_or_panic(a_i == 2.6f);
16139 assert_or_panic(b_r == 11.3f);
16140 assert_or_panic(b_i == -1.5f);
16141
16142 return 1.5f + I * 13.5f;
16143}
16144
16145double complex c_cmultd_comp(double a_r, double a_i, double b_r, double b_i) {
16146 assert_or_panic(a_r == 1.25);
16147 assert_or_panic(a_i == 2.6);
16148 assert_or_panic(b_r == 11.3);
16149 assert_or_panic(b_i == -1.5);
16150
16151 return 1.5 + I * 13.5;
16152}
16153
16154float complex c_cmultf(float complex a, float complex b) {
16155 assert_or_panic(creal(a) == 1.25f);
16156 assert_or_panic(cimag(a) == 2.6f);
16157 assert_or_panic(creal(b) == 11.3f);
16158 assert_or_panic(cimag(b) == -1.5f);
16159
16160 return 1.5f + I * 13.5f;
16161}
16162
16163double complex c_cmultd(double complex a, double complex b) {
16164 assert_or_panic(creal(a) == 1.25);
16165 assert_or_panic(cimag(a) == 2.6);
16166 assert_or_panic(creal(b) == 11.3);
16167 assert_or_panic(cimag(b) == -1.5);
16168
16169 return 1.5 + I * 13.5;
16170}
16171#endif
16172
16173struct Struct_i32_i32 c_mut_struct_i32_i32(struct Struct_i32_i32 s) {
16174 assert_or_panic(s.a == 1);
16175 assert_or_panic(s.b == 2);
16176 s.a += 100;
16177 s.b += 250;
16178 assert_or_panic(s.a == 101);
16179 assert_or_panic(s.b == 252);
16180 return s;
16181}
16182
16183void c_struct_i32_i32(struct Struct_i32_i32 s) {
16184 assert_or_panic(s.a == 1);
16185 assert_or_panic(s.b == 2);
16186}
16187
16188void c_big_struct(struct BigStruct x) {
16189 assert_or_panic(x.a == 1);
16190 assert_or_panic(x.b == 2);
16191 assert_or_panic(x.c == 3);
16192 assert_or_panic(x.d == 4);
16193 assert_or_panic(x.e == 5);
16194}
16195
16196void c_big_union(union BigUnion x) {
16197 assert_or_panic(x.a.a == 1);
16198 assert_or_panic(x.a.b == 2);
16199 assert_or_panic(x.a.c == 3);
16200 assert_or_panic(x.a.d == 4);
16201}
16202
16203void c_med_struct_mixed(struct MedStructMixed x) {
16204 assert_or_panic(x.a == 1234);
16205 assert_or_panic(x.b == 100.0f);
16206 assert_or_panic(x.c == 1337.0f);
16207
16208 struct MedStructMixed y = zig_ret_med_struct_mixed();
16209
16210 assert_or_panic(y.a == 1234);
16211 assert_or_panic(y.b == 100.0f);
16212 assert_or_panic(y.c == 1337.0f);
16213}
16214
16215struct MedStructMixed c_ret_med_struct_mixed(void) {
16216 struct MedStructMixed s = {
16217 .a = 1234,
16218 .b = 100.0,
16219 .c = 1337.0,
16220 };
16221 return s;
16222}
16223
16224void c_split_struct_ints(struct SplitStructInts x) {
16225 assert_or_panic(x.a == 1234);
16226 assert_or_panic(x.b == 100);
16227 assert_or_panic(x.c == 1337);
16228}
16229
16230void c_split_struct_mixed(struct SplitStructMixed x) {
16231 assert_or_panic(x.a == 1234);
16232 assert_or_panic(x.b == 100);
16233 assert_or_panic(x.c == 1337.0f);
16234 struct SplitStructMixed y = zig_ret_split_struct_mixed();
16235
16236 assert_or_panic(y.a == 1234);
16237 assert_or_panic(y.b == 100);
16238 assert_or_panic(y.c == 1337.0f);
16239}
16240
16241uint8_t c_ret_small_packed_struct(void) {
16242 uint8_t s = 0;
16243 s |= 0 << 0;
16244 s |= 1 << 2;
16245 s |= 2 << 4;
16246 s |= 3 << 6;
16247 return s;
16248}
16249
16250void c_small_packed_struct(uint8_t x) {
16251 assert_or_panic(((x >> 0) & 0x3) == 0);
16252 assert_or_panic(((x >> 2) & 0x3) == 1);
16253 assert_or_panic(((x >> 4) & 0x3) == 2);
16254 assert_or_panic(((x >> 6) & 0x3) == 3);
16255}
16256
16257#ifndef ZIG_NO_I128
16258__int128 c_ret_big_packed_struct(void) {
16259 __int128 s = 0;
16260 s |= 1 << 0;
16261 s |= (__int128)2 << 64;
16262 return s;
16263}
16264
16265void c_big_packed_struct(__int128 x) {
16266 assert_or_panic(((x >> 0) & 0xFFFFFFFFFFFFFFFF) == 1);
16267 assert_or_panic(((x >> 64) & 0xFFFFFFFFFFFFFFFF) == 2);
16268}
16269#endif
16270
16271struct SplitStructMixed c_ret_split_struct_mixed(void) {
16272 struct SplitStructMixed s = {
16273 .a = 1234,
16274 .b = 100,
16275 .c = 1337.0f,
16276 };
16277 return s;
16278}
16279
16280struct BigStruct c_big_struct_both(struct BigStruct x) {
16281 assert_or_panic(x.a == 1);
16282 assert_or_panic(x.b == 2);
16283 assert_or_panic(x.c == 3);
16284 assert_or_panic(x.d == 4);
16285 assert_or_panic(x.e == 5);
16286 struct BigStruct y = {10, 11, 12, 13, 14};
16287 return y;
16288}
16289
16290bool c_ret_bool(void) {
16291 return 1;
16292}
16293uint8_t c_ret_u8(void) {
16294 return 0xff;
16295}
16296uint16_t c_ret_u16(void) {
16297 return 0xffff;
16298}
16299uint32_t c_ret_u32(void) {
16300 return 0xffffffff;
16301}
16302uint64_t c_ret_u64(void) {
16303 return 0xffffffffffffffff;
16304}
16305int8_t c_ret_i8(void) {
16306 return -1;
16307}
16308int16_t c_ret_i16(void) {
16309 return -1;
16310}
16311int32_t c_ret_i32(void) {
16312 return -1;
16313}
16314int64_t c_ret_i64(void) {
16315 return -1;
16316}
16317
16318typedef struct {
16319 uint32_t a;
16320 uint8_t padding[4];
16321 uint64_t b;
16322} StructWithArray;
16323
16324void c_struct_with_array(StructWithArray x) {
16325 assert_or_panic(x.a == 1);
16326 assert_or_panic(x.b == 2);
16327}
16328
16329StructWithArray c_ret_struct_with_array(void) {
16330 return (StructWithArray){4, {}, 155};
16331}
16332
16333typedef struct {
16334 struct Point {
16335 double x;
16336 double y;
16337 } origin;
16338 struct Size {
16339 double width;
16340 double height;
16341 } size;
16342} FloatArrayStruct;
16343
16344void c_float_array_struct(FloatArrayStruct x) {
16345 assert_or_panic(x.origin.x == 5);
16346 assert_or_panic(x.origin.y == 6);
16347 assert_or_panic(x.size.width == 7);
16348 assert_or_panic(x.size.height == 8);
16349}
16350
16351FloatArrayStruct c_ret_float_array_struct(void) {
16352 FloatArrayStruct x;
16353 x.origin.x = 1;
16354 x.origin.y = 2;
16355 x.size.width = 3;
16356 x.size.height = 4;
16357 return x;
16358}
16359
16360typedef uint32_t SmallVec __attribute__((vector_size(2 * sizeof(uint32_t))));
16361
16362void c_small_vec(SmallVec vec) {
16363 assert_or_panic(vec[0] == 1);
16364 assert_or_panic(vec[1] == 2);
16365}
16366
16367SmallVec c_ret_small_vec(void) {
16368 return (SmallVec){3, 4};
16369}
16370
16371typedef size_t MediumVec __attribute__((vector_size(4 * sizeof(size_t))));
16372
16373void c_medium_vec(MediumVec vec) {
16374 assert_or_panic(vec[0] == 1);
16375 assert_or_panic(vec[1] == 2);
16376 assert_or_panic(vec[2] == 3);
16377 assert_or_panic(vec[3] == 4);
16378}
16379
16380MediumVec c_ret_medium_vec(void) {
16381 return (MediumVec){5, 6, 7, 8};
16382}
16383
16384typedef size_t BigVec __attribute__((vector_size(8 * sizeof(size_t))));
16385
16386void c_big_vec(BigVec vec) {
16387 assert_or_panic(vec[0] == 1);
16388 assert_or_panic(vec[1] == 2);
16389 assert_or_panic(vec[2] == 3);
16390 assert_or_panic(vec[3] == 4);
16391 assert_or_panic(vec[4] == 5);
16392 assert_or_panic(vec[5] == 6);
16393 assert_or_panic(vec[6] == 7);
16394 assert_or_panic(vec[7] == 8);
16395}
16396
16397BigVec c_ret_big_vec(void) {
16398 return (BigVec){9, 10, 11, 12, 13, 14, 15, 16};
16399}
16400
16401typedef struct {
16402 float x, y;
16403} Vector2;
16404
16405void c_ptr_size_float_struct(Vector2 vec) {
16406 assert_or_panic(vec.x == 1);
16407 assert_or_panic(vec.y == 2);
16408}
16409Vector2 c_ret_ptr_size_float_struct(void) {
16410 return (Vector2){3, 4};
16411}
16412
16413/// Tests for Double + Char struct
16414struct DC { double v1; char v2; };
16415
16416int c_assert_DC(struct DC lv){
16417 if (lv.v1 != -0.25) return 1;
16418 if (lv.v2 != 15) return 2;
16419 return 0;
16420}
16421struct DC c_ret_DC(){
16422 struct DC lv = { .v1 = -0.25, .v2 = 15 };
16423 return lv;
16424}
16425int zig_assert_DC(struct DC);
16426int c_send_DC(){
16427 return zig_assert_DC(c_ret_DC());
16428}
16429struct DC zig_ret_DC();
16430int c_assert_ret_DC(){
16431 return c_assert_DC(zig_ret_DC());
16432}
16433
16434/// Tests for Char + Float + Float struct
16435struct CFF { char v1; float v2; float v3; };
16436
16437int c_assert_CFF(struct CFF lv){
16438 if (lv.v1 != 39) return 1;
16439 if (lv.v2 != 0.875) return 2;
16440 if (lv.v3 != 1.0) return 3;
16441 return 0;
16442}
16443struct CFF c_ret_CFF(){
16444 struct CFF lv = { .v1 = 39, .v2 = 0.875, .v3 = 1.0 };
16445 return lv;
16446}
16447int zig_assert_CFF(struct CFF);
16448int c_send_CFF(){
16449 return zig_assert_CFF(c_ret_CFF());
16450}
16451struct CFF zig_ret_CFF();
16452int c_assert_ret_CFF(){
16453 return c_assert_CFF(zig_ret_CFF());
16454}
16455
16456struct PD { void* v1; double v2; };
16457
16458int c_assert_PD(struct PD lv){
16459 if (lv.v1 != 0) return 1;
16460 if (lv.v2 != 0.5) return 2;
16461 return 0;
16462}
16463struct PD c_ret_PD(){
16464 struct PD lv = { .v1 = 0, .v2 = 0.5 };
16465 return lv;
16466}
16467int zig_assert_PD(struct PD);
16468int c_send_PD(){
16469 return zig_assert_PD(c_ret_PD());
16470}
16471struct PD zig_ret_PD();
16472int c_assert_ret_PD(){
16473 return c_assert_PD(zig_ret_PD());
16474}
16475
16476struct ByRef {
16477 int val;
16478 int arr[15];
16479};
16480struct ByRef c_modify_by_ref_param(struct ByRef in) {
16481 in.val = 42;
16482 return in;
16483}
16484
16485struct ByVal {
16486 struct {
16487 unsigned long x;
16488 unsigned long y;
16489 unsigned long z;
16490 } origin;
16491 struct {
16492 unsigned long width;
16493 unsigned long height;
16494 unsigned long depth;
16495 } size;
16496};
16497
16498void c_func_ptr_byval(void *a, void *b, struct ByVal in, unsigned long c, void *d, unsigned long e) {
16499 assert_or_panic((intptr_t)a == 1);
16500 assert_or_panic((intptr_t)b == 2);
16501
16502 assert_or_panic(in.origin.x == 9);
16503 assert_or_panic(in.origin.y == 10);
16504 assert_or_panic(in.origin.z == 11);
16505 assert_or_panic(in.size.width == 12);
16506 assert_or_panic(in.size.height == 13);
16507 assert_or_panic(in.size.depth == 14);
16508
16509 assert_or_panic(c == 3);
16510 assert_or_panic((intptr_t)d == 4);
16511 assert_or_panic(e == 5);
16512}
16513
16514#ifndef ZIG_NO_RAW_F16
16515__fp16 c_f16(__fp16 a) {
16516 assert_or_panic(a == 12);
16517 return 34;
16518}
16519#endif
16520
16521typedef struct {
16522 __fp16 a;
16523} f16_struct;
16524f16_struct c_f16_struct(f16_struct a) {
16525 assert_or_panic(a.a == 12);
16526 return (f16_struct){34};
16527}
16528
16529#if (defined __x86_64__ || defined __i386__) && !defined _MSC_VER
16530typedef long double f80;
16531f80 c_f80(f80 a) {
16532 assert_or_panic((double)a == 12.34);
16533 return 56.78;
16534}
16535typedef struct {
16536 f80 a;
16537} f80_struct;
16538f80_struct c_f80_struct(f80_struct a) {
16539 assert_or_panic((double)a.a == 12.34);
16540 return (f80_struct){56.78};
16541}
16542typedef struct {
16543 f80 a;
16544 int b;
16545} f80_extra_struct;
16546f80_extra_struct c_f80_extra_struct(f80_extra_struct a) {
16547 assert_or_panic((double)a.a == 12.34);
16548 assert_or_panic(a.b == 42);
16549 return (f80_extra_struct){56.78, 24};
16550}
16551#endif
16552
16553#ifndef ZIG_NO_F128
16554__float128 zig_f128(__float128 a);
16555__float128 c_f128(__float128 a) {
16556 assert_or_panic((double)a == 12.34);
16557 assert_or_panic(zig_f128(12) == 34);
16558 return 56.78;
16559}
16560typedef struct {
16561 __float128 a;
16562} f128_struct;
16563f128_struct zig_f128_struct(f128_struct a);
16564f128_struct c_f128_struct(f128_struct a) {
16565 assert_or_panic((double)a.a == 12.34);
16566 f128_struct b = zig_f128_struct((f128_struct){12345});
16567 assert_or_panic(b.a == 98765);
16568 return (f128_struct){56.78};
16569}
16570
16571typedef struct {
16572 __float128 a, b;
16573} f128_f128_struct;
16574f128_f128_struct zig_f128_f128_struct(f128_f128_struct a);
16575f128_f128_struct c_f128_f128_struct(f128_f128_struct a) {
16576 assert_or_panic((double)a.a == 12.34);
16577 assert_or_panic((double)a.b == 87.65);
16578 f128_f128_struct b = zig_f128_f128_struct((f128_f128_struct){13, 57});
16579 assert_or_panic((double)b.a == 24);
16580 assert_or_panic((double)b.b == 68);
16581 return (f128_f128_struct){56.78, 43.21};
16582}
16583#endif
16584
16585void __attribute__((stdcall)) stdcall_scalars(char a, short b, int c, float d, double e) {
16586 assert_or_panic(a == 1);
16587 assert_or_panic(b == 2);
16588 assert_or_panic(c == 3);
16589 assert_or_panic(d == 4.0);
16590 assert_or_panic(e == 5.0);
16591}
16592
16593typedef struct {
16594 short x;
16595 short y;
16596} Coord2;
16597
16598Coord2 __attribute__((stdcall)) stdcall_coord2(Coord2 a, Coord2 b, Coord2 c) {
16599 assert_or_panic(a.x == 0x1111);
16600 assert_or_panic(a.y == 0x2222);
16601 assert_or_panic(b.x == 0x3333);
16602 assert_or_panic(b.y == 0x4444);
16603 assert_or_panic(c.x == 0x5555);
16604 assert_or_panic(c.y == 0x6666);
16605 return (Coord2){123, 456};
16606}
16607
16608void __attribute__((stdcall)) stdcall_big_union(union BigUnion x) {
16609 assert_or_panic(x.a.a == 1);
16610 assert_or_panic(x.a.b == 2);
16611 assert_or_panic(x.a.c == 3);
16612 assert_or_panic(x.a.d == 4);
16613}
16614
16615#ifdef __x86_64__
16616struct ByRef __attribute__((ms_abi)) c_explict_win64(struct ByRef in) {
16617 in.val = 42;
16618 return in;
16619}
16620
16621struct ByRef __attribute__((sysv_abi)) c_explict_sys_v(struct ByRef in) {
16622 in.val = 42;
16623 return in;
16624}
16625#endif
16626
16627#if defined __x86_64__ || defined __aarch64__
16628int __attribute__((preserve_none)) c_preserve_none(int x) {
16629 return x + 1;
16630}
16631int __attribute__((preserve_none)) zig_preserve_none(int);
16632void c_preserve_none_check(void) {
16633 assert_or_panic(zig_preserve_none(41) == 42);
16634}
16635#endif
16636
16637struct byval_tail_callsite_attr_Point {
16638 double x;
16639 double y;
16640} Point;
16641struct byval_tail_callsite_attr_Size {
16642 double width;
16643 double height;
16644} Size;
16645struct byval_tail_callsite_attr_Rect {
16646 struct byval_tail_callsite_attr_Point origin;
16647 struct byval_tail_callsite_attr_Size size;
16648};
16649double c_byval_tail_callsite_attr(struct byval_tail_callsite_attr_Rect in) {
16650 return in.size.width;
16651}
16652
16653#if defined(__i386__) && defined(_WIN32) && !defined(_WIN64) && defined(_MSC_VER)
16654void __attribute__((fastcall)) zig_fastcall_check(int a, float b, void *c, double d, int e);
16655void __attribute__((fastcall)) c_fastcall_check(int a, float b, void *c, double d, int e) {
16656 assert_or_panic(a == 1);
16657 assert_or_panic(b == 2.0);
16658 assert_or_panic((uintptr_t)c == 3);
16659 assert_or_panic(d == 4.0);
16660 assert_or_panic(e == 5);
16661}
16662
16663typedef struct {
16664 int a;
16665 int b;
16666 int c;
16667} FastcallSRet;
16668FastcallSRet __attribute__((fastcall)) zig_fastcall_sret(void);
16669FastcallSRet __attribute__((fastcall)) c_fastcall_sret(void) {
16670 return (FastcallSRet){
16671 .a = 1,
16672 .b = 2,
16673 .c = 3
16674 };
16675}
16676
16677typedef struct {
16678 char a;
16679 short b;
16680} FastcallNoSRet;
16681FastcallNoSRet __attribute__((fastcall)) zig_fastcall_no_sret(void);
16682FastcallNoSRet __attribute__((fastcall)) c_fastcall_no_sret(void) {
16683 return (FastcallNoSRet){
16684 .a = 1,
16685 .b = 2
16686 };
16687}
16688
16689typedef struct {
16690 float a;
16691 float b;
16692} FastcallNoSRetF32F32;
16693FastcallNoSRetF32F32 __attribute__((fastcall)) zig_fastcall_no_sret_f32_f32(void);
16694FastcallNoSRetF32F32 __attribute__((fastcall)) c_fastcall_no_sret_f32_f32(void) {
16695 return (FastcallNoSRetF32F32){
16696 .a = 1,
16697 .b = 2
16698 };
16699}
16700
16701typedef struct {
16702 double a;
16703} FastcallNoSRetF64;
16704FastcallNoSRetF64 __attribute__((fastcall)) zig_fastcall_no_sret_f64(void);
16705FastcallNoSRetF64 __attribute__((fastcall)) c_fastcall_no_sret_f64(void) {
16706 return (FastcallNoSRetF64){
16707 .a = 1
16708 };
16709}
16710
16711float __attribute__((fastcall)) zig_fastcall_ret_f32(void);
16712float __attribute__((fastcall)) c_fastcall_ret_f32(void) {
16713 return 1;
16714}
16715
16716double __attribute__((fastcall)) zig_fastcall_ret_f64(void);
16717double __attribute__((fastcall)) c_fastcall_ret_f64(void) {
16718 return 1;
16719}
16720
16721void run_c_fastcall_tests(void) {
16722 {
16723 zig_fastcall_check(1, 2, (void*)3, 4, 5);
16724 }
16725 {
16726 const FastcallSRet s = zig_fastcall_sret();
16727 assert_or_panic(s.a == 1);
16728 assert_or_panic(s.b == 2);
16729 assert_or_panic(s.c == 3);
16730 }
16731 {
16732 const FastcallNoSRet s = zig_fastcall_no_sret();
16733 assert_or_panic(s.a == 1);
16734 assert_or_panic(s.b == 2);
16735 }
16736 {
16737 const FastcallNoSRetF32F32 s = zig_fastcall_no_sret_f32_f32();
16738 assert_or_panic(s.a == 1);
16739 assert_or_panic(s.b == 2);
16740 }
16741 {
16742 const FastcallNoSRetF64 s = zig_fastcall_no_sret_f64();
16743 assert_or_panic(s.a == 1);
16744 }
16745 {
16746 const float s = zig_fastcall_ret_f32();
16747 assert_or_panic(s == 1);
16748 }
16749 {
16750 const double s = zig_fastcall_ret_f64();
16751 assert_or_panic(s == 1);
16752 }
16753}
16754
16755void __attribute__((vectorcall)) zig_vectorcall_check(int a, float b, double c, void *d, float e, double f, double g, float h, float i, int j);
16756void __attribute__((vectorcall)) c_vectorcall_check(int a, float b, double c, void *d, float e, double f, double g, float h, float i, int j) {
16757 assert_or_panic(a == 1);
16758 assert_or_panic(b == 2.0);
16759 assert_or_panic(c == 3.0);
16760 assert_or_panic((uintptr_t)d == 4);
16761 assert_or_panic(e == 5.0);
16762 assert_or_panic(f == 6.0);
16763 assert_or_panic(g == 7.0);
16764 assert_or_panic(h == 8.0);
16765 assert_or_panic(i == 9.0);
16766 assert_or_panic(j == 10);
16767 zig_vectorcall_check(a, b, c, d, e, f, g, h, i, j);
16768}
16769#endif
16770
16771void c_x86_64_sysv_uint_int_uint_int(unsigned a, int b, unsigned c, int d) {
16772 assert_or_panic(a == 1);
16773 assert_or_panic(b == -2);
16774 assert_or_panic(c == 3);
16775 assert_or_panic(d == -4);
16776}
16777
16778void c_win64_varargs_u64_f64_u64_f64(uint64_t a, double b, uint64_t c, double d) {
16779 assert_or_panic(a == UINT64_C(0x3ff0000000000000));
16780 assert_or_panic(b == 2.0);
16781 assert_or_panic(c == UINT64_C(0x4008000000000000));
16782 assert_or_panic(d == 4.0);
16783}
16784void c_win64_varargs_f64_u64_f64_u64(double a, uint64_t b, double c, uint64_t d) {
16785 assert_or_panic(a == 5.0);
16786 assert_or_panic(b == UINT64_C(0x4018000000000000));
16787 assert_or_panic(c == 7.0);
16788 assert_or_panic(d == UINT64_C(0x4020000000000000));
16789}