obtained gcc-4.6.4.tar.bz2 from upstream website;upstream

verified gcc-4.6.4.tar.bz2.sig;
imported gcc-4.6.4 source tree from verified upstream tarball.

downloading a git-generated archive based on the 'upstream' tag
should provide you with a source tree that is binary identical
to the one extracted from the above tarball.

if you have obtained the source via the command 'git clone',
however, do note that line-endings of files in your working
directory might differ from line-endings of the respective
files in the upstream repository.

1 files changed, 3831 insertions, 0 deletions

diff --git a/gcc/testsuite/gcc.dg/vmx/ops.c b/gcc/testsuite/gcc.dg/vmx/ops.c
new file mode 100644
index 000000000..b39ad1d65
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vmx/ops.c
@@ -0,0 +1,3831 @@
+/* { dg-do compile } */
+#include <altivec.h>
+#include <stdlib.h>
+extern char * *var_char_ptr;
+extern float * *var_float_ptr;
+extern int * *var_int_ptr;
+extern int *var_cc24f;
+extern int *var_cc24fd;
+extern int *var_cc24fr;
+extern int *var_cc24t;
+extern int *var_cc24td;
+extern int *var_cc24tr;
+extern int *var_cc26f;
+extern int *var_cc26fd;
+extern int *var_cc26fr;
+extern int *var_cc26t;
+extern int *var_cc26td;
+extern int *var_cc26tr;
+extern int *var_int;
+extern short * *var_short_ptr;
+extern signed char * *var_signed_char_ptr;
+extern unsigned char * *var_unsigned_char_ptr;
+extern unsigned int * *var_unsigned_int_ptr;
+extern unsigned short * *var_unsigned_short_ptr;
+extern vector bool char * *var_vec_b8_ptr;
+extern vector bool char *var_vec_b8;
+extern vector bool int * *var_vec_b32_ptr;
+extern vector bool int *var_vec_b32;
+extern vector bool short * *var_vec_b16_ptr;
+extern vector bool short *var_vec_b16;
+extern vector float * *var_vec_f32_ptr;
+extern vector float *var_vec_f32;
+extern vector pixel * *var_vec_p16_ptr;
+extern vector pixel *var_vec_p16;
+extern vector signed char * *var_vec_s8_ptr;
+extern vector signed char *var_vec_s8;
+extern vector signed int * *var_vec_s32_ptr;
+extern vector signed int *var_vec_s32;
+extern vector signed short * *var_vec_s16_ptr;
+extern vector signed short *var_vec_s16;
+extern vector unsigned char * *var_vec_u8_ptr;
+extern vector unsigned char *var_vec_u8;
+extern vector unsigned int * *var_vec_u32_ptr;
+extern vector unsigned int *var_vec_u32;
+extern vector unsigned short * *var_vec_u16_ptr;
+extern vector unsigned short *var_vec_u16;
+extern vector unsigned short *var_volatile_vec_u16;
+void f0() {
+  *var_cc24f++ = vec_any_le(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_le(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24f++ = vec_any_ne(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24f++ = vec_any_nge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24f++ = vec_any_ngt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24fd++ = vec_any_nan(var_vec_f32[0]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24fr++ = vec_any_ge(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24fr++ = vec_any_nle(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24fr++ = vec_any_nlt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_eq(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24t++ = vec_all_ge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_s8[0], var_vec_b8[1]);
+}
+void f1() {
+  *var_cc24t++ = vec_all_gt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24t++ = vec_all_gt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc24td++ = vec_all_numeric(var_vec_f32[0]);
+  *var_cc24tr++ = vec_all_le(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc24tr++ = vec_all_lt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_eq(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_ge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26f++ = vec_any_gt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26f++ = vec_any_out(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26fd++ = vec_any_numeric(var_vec_f32[0]);
+  *var_cc26fr++ = vec_any_le(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26fr++ = vec_any_lt(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_in(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_b8[0], var_vec_u8[1]);
+}
+void f2() {
+  *var_cc26t++ = vec_all_le(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_le(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_p16[0], var_vec_p16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26t++ = vec_all_ne(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26t++ = vec_all_nge(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26t++ = vec_all_ngt(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26td++ = vec_all_nan(var_vec_f32[0]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b16[0], var_vec_s16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b16[0], var_vec_u16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b32[0], var_vec_s32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b32[0], var_vec_u32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b8[0], var_vec_s8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_b8[0], var_vec_u8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s16[0], var_vec_b16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s16[0], var_vec_s16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s32[0], var_vec_b32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s32[0], var_vec_s32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s8[0], var_vec_b8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_s8[0], var_vec_s8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u16[0], var_vec_b16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u16[0], var_vec_u16[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u32[0], var_vec_b32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u32[0], var_vec_u32[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u8[0], var_vec_b8[1]);
+  *var_cc26tr++ = vec_all_ge(var_vec_u8[0], var_vec_u8[1]);
+  *var_cc26tr++ = vec_all_nle(var_vec_f32[0], var_vec_f32[1]);
+  *var_cc26tr++ = vec_all_nlt(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b16++ = vec_and(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_andc(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_cmpeq(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_cmpeq(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_cmpgt(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_cmpgt(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_ld(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_ldl(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_lvx(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_lvxl(var_int[0], var_vec_b16_ptr[1]);
+  *var_vec_b16++ = vec_mergeh(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_mergel(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_nor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_or(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_pack(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b16++ = vec_perm(var_vec_b16[0], var_vec_b16[1], var_vec_u8[2]);
+  *var_vec_b16++ = vec_sel(var_vec_b16[0], var_vec_b16[1], var_vec_b16[2]);
+  *var_vec_b16++ = vec_sel(var_vec_b16[0], var_vec_b16[1], var_vec_u16[2]);
+  *var_vec_b16++ = vec_sll(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_sll(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_sll(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 0);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 1);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 2);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 3);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 4);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 5);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 6);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 7);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 8);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 9);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 10);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 11);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 12);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 13);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 14);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 15);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 16);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 17);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 18);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 19);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 20);
+}
+void f3() {
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 21);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 22);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 23);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 24);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 25);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 26);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 27);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 28);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 29);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 30);
+  *var_vec_b16++ = vec_splat(var_vec_b16[0], 31);
+  *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_srl(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_unpackh(var_vec_b8[0]);
+  *var_vec_b16++ = vec_unpackl(var_vec_b8[0]);
+  *var_vec_b16++ = vec_vand(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vandc(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vcmpequh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_vcmpequh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vcmpgtsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_b16++ = vec_vcmpgtuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vmrghh(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vmrglh(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vnor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_vperm(var_vec_b16[0], var_vec_b16[1], var_vec_u8[2]);
+  *var_vec_b16++ = vec_vpkuwum(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b16++ = vec_vsel(var_vec_b16[0], var_vec_b16[1], var_vec_b16[2]);
+  *var_vec_b16++ = vec_vsel(var_vec_b16[0], var_vec_b16[1], var_vec_u16[2]);
+  *var_vec_b16++ = vec_vsl(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vsl(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_vsl(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 0);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 1);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 2);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 3);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 4);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 5);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 6);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 7);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 8);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 9);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 10);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 11);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 12);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 13);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 14);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 15);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 16);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 17);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 18);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 19);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 20);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 21);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 22);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 23);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 24);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 25);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 26);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 27);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 28);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 29);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 30);
+  *var_vec_b16++ = vec_vsplth(var_vec_b16[0], 31);
+  *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u32[1]);
+  *var_vec_b16++ = vec_vsr(var_vec_b16[0], var_vec_u8[1]);
+  *var_vec_b16++ = vec_vupkhsb(var_vec_b8[0]);
+  *var_vec_b16++ = vec_vupklsb(var_vec_b8[0]);
+  *var_vec_b16++ = vec_vxor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b16++ = vec_xor(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b32++ = vec_and(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_andc(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_cmpeq(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_cmpeq(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_cmpeq(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_cmpge(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_cmpgt(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_cmpgt(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_cmpgt(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_ld(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_ldl(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_lvx(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_lvxl(var_int[0], var_vec_b32_ptr[1]);
+  *var_vec_b32++ = vec_mergeh(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_mergel(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_nor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_or(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_perm(var_vec_b32[0], var_vec_b32[1], var_vec_u8[2]);
+  *var_vec_b32++ = vec_sel(var_vec_b32[0], var_vec_b32[1], var_vec_b32[2]);
+  *var_vec_b32++ = vec_sel(var_vec_b32[0], var_vec_b32[1], var_vec_u32[2]);
+  *var_vec_b32++ = vec_sll(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_sll(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_sll(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 0);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 1);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 2);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 3);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 4);
+}
+void f4() {
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 5);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 6);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 7);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 8);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 9);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 10);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 11);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 12);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 13);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 14);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 15);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 16);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 17);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 18);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 19);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 20);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 21);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 22);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 23);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 24);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 25);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 26);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 27);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 28);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 29);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 30);
+  *var_vec_b32++ = vec_splat(var_vec_b32[0], 31);
+  *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_srl(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_unpackh(var_vec_b16[0]);
+  *var_vec_b32++ = vec_unpackl(var_vec_b16[0]);
+  *var_vec_b32++ = vec_vand(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vandc(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vcmpeqfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_vcmpequw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_vcmpequw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vcmpgefp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_vcmpgtfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_b32++ = vec_vcmpgtsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_b32++ = vec_vcmpgtuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vmrghw(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vmrglw(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vnor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_vperm(var_vec_b32[0], var_vec_b32[1], var_vec_u8[2]);
+  *var_vec_b32++ = vec_vsel(var_vec_b32[0], var_vec_b32[1], var_vec_b32[2]);
+  *var_vec_b32++ = vec_vsel(var_vec_b32[0], var_vec_b32[1], var_vec_u32[2]);
+  *var_vec_b32++ = vec_vsl(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_vsl(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vsl(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 0);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 1);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 2);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 3);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 4);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 5);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 6);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 7);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 8);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 9);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 10);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 11);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 12);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 13);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 14);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 15);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 16);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 17);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 18);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 19);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 20);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 21);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 22);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 23);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 24);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 25);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 26);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 27);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 28);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 29);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 30);
+  *var_vec_b32++ = vec_vspltw(var_vec_b32[0], 31);
+  *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u16[1]);
+  *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_b32++ = vec_vsr(var_vec_b32[0], var_vec_u8[1]);
+  *var_vec_b32++ = vec_vupkhsh(var_vec_b16[0]);
+  *var_vec_b32++ = vec_vupklsh(var_vec_b16[0]);
+  *var_vec_b32++ = vec_vxor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b32++ = vec_xor(var_vec_b32[0], var_vec_b32[1]);
+  *var_vec_b8++ = vec_and(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_andc(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_cmpeq(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_cmpeq(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_cmpgt(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_cmpgt(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_ld(var_int[0], var_vec_b8_ptr[1]);
+  *var_vec_b8++ = vec_ldl(var_int[0], var_vec_b8_ptr[1]);
+  *var_vec_b8++ = vec_lvx(var_int[0], var_vec_b8_ptr[1]);
+  *var_vec_b8++ = vec_lvxl(var_int[0], var_vec_b8_ptr[1]);
+}
+void f5() {
+  *var_vec_b8++ = vec_mergeh(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_mergel(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_nor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_or(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_pack(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b8++ = vec_perm(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_sel(var_vec_b8[0], var_vec_b8[1], var_vec_b8[2]);
+  *var_vec_b8++ = vec_sel(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_sll(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_sll(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_sll(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 0);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 1);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 2);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 3);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 4);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 5);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 6);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 7);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 8);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 9);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 10);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 11);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 12);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 13);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 14);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 15);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 16);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 17);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 18);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 19);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 20);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 21);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 22);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 23);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 24);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 25);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 26);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 27);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 28);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 29);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 30);
+  *var_vec_b8++ = vec_splat(var_vec_b8[0], 31);
+  *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_srl(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vand(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vandc(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vcmpequb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_vcmpequb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vcmpgtsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_b8++ = vec_vcmpgtub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vmrghb(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vmrglb(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vnor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_vperm(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_vpkuhum(var_vec_b16[0], var_vec_b16[1]);
+  *var_vec_b8++ = vec_vsel(var_vec_b8[0], var_vec_b8[1], var_vec_b8[2]);
+  *var_vec_b8++ = vec_vsel(var_vec_b8[0], var_vec_b8[1], var_vec_u8[2]);
+  *var_vec_b8++ = vec_vsl(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_vsl(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_vsl(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 0);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 1);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 2);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 3);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 4);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 5);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 6);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 7);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 8);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 9);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 10);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 11);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 12);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 13);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 14);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 15);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 16);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 17);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 18);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 19);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 20);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 21);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 22);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 23);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 24);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 25);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 26);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 27);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 28);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 29);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 30);
+  *var_vec_b8++ = vec_vspltb(var_vec_b8[0], 31);
+  *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u16[1]);
+  *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u32[1]);
+  *var_vec_b8++ = vec_vsr(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_b8++ = vec_vxor(var_vec_b8[0], var_vec_b8[1]);
+  *var_vec_b8++ = vec_xor(var_vec_b8[0], var_vec_b8[1]);
+}
+void f6() {
+  *var_vec_f32++ = vec_add(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_and(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_and(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_and(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_andc(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_andc(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_andc(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_ceil(var_vec_f32[0]);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 0);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 1);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 2);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 3);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 4);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 5);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 6);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 7);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 8);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 9);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 10);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 11);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 12);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 13);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 14);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 15);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 16);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 17);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 18);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 19);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 20);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 21);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 22);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 23);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 24);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 25);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 26);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 27);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 28);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 29);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 30);
+  *var_vec_f32++ = vec_ctf(var_vec_s32[0], 31);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 0);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 1);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 2);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 3);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 4);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 5);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 6);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 7);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 8);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 9);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 10);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 11);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 12);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 13);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 14);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 15);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 16);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 17);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 18);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 19);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 20);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 21);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 22);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 23);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 24);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 25);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 26);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 27);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 28);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 29);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 30);
+  *var_vec_f32++ = vec_ctf(var_vec_u32[0], 31);
+  *var_vec_f32++ = vec_expte(var_vec_f32[0]);
+  *var_vec_f32++ = vec_floor(var_vec_f32[0]);
+  *var_vec_f32++ = vec_ld(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_ld(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_lde(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_ldl(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_ldl(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_loge(var_vec_f32[0]);
+  *var_vec_f32++ = vec_lvewx(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_lvx(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_lvx(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_lvxl(var_int[0], var_float_ptr[1]);
+  *var_vec_f32++ = vec_lvxl(var_int[0], var_vec_f32_ptr[1]);
+  *var_vec_f32++ = vec_madd(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_max(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_mergeh(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_mergel(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_min(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_nmsub(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_nor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_or(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_or(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_or(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_perm(var_vec_f32[0], var_vec_f32[1], var_vec_u8[2]);
+  *var_vec_f32++ = vec_re(var_vec_f32[0]);
+  *var_vec_f32++ = vec_round(var_vec_f32[0]);
+  *var_vec_f32++ = vec_rsqrte(var_vec_f32[0]);
+  *var_vec_f32++ = vec_sel(var_vec_f32[0], var_vec_f32[1], var_vec_b32[2]);
+}
+void f7() {
+  *var_vec_f32++ = vec_sel(var_vec_f32[0], var_vec_f32[1], var_vec_u32[2]);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 0);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 1);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 2);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 3);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 4);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 5);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 6);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 7);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 8);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 9);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 10);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 11);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 12);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 13);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 14);
+  *var_vec_f32++ = vec_sld(var_vec_f32[0], var_vec_f32[1], 15);
+  *var_vec_f32++ = vec_slo(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_slo(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 0);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 1);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 2);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 3);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 4);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 5);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 6);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 7);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 8);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 9);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 10);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 11);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 12);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 13);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 14);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 15);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 16);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 17);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 18);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 19);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 20);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 21);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 22);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 23);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 24);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 25);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 26);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 27);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 28);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 29);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 30);
+  *var_vec_f32++ = vec_splat(var_vec_f32[0], 31);
+  *var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_sro(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_sub(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_trunc(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vaddfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vand(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vand(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vand(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vandc(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vandc(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vandc(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 0);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 1);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 2);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 3);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 4);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 5);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 6);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 7);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 8);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 9);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 10);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 11);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 12);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 13);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 14);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 15);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 16);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 17);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 18);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 19);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 20);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 21);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 22);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 23);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 24);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 25);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 26);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 27);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 28);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 29);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 30);
+  *var_vec_f32++ = vec_vcfsx(var_vec_s32[0], 31);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 0);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 1);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 2);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 3);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 4);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 5);
+}
+void f8() {
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 6);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 7);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 8);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 9);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 10);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 11);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 12);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 13);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 14);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 15);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 16);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 17);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 18);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 19);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 20);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 21);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 22);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 23);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 24);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 25);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 26);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 27);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 28);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 29);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 30);
+  *var_vec_f32++ = vec_vcfux(var_vec_u32[0], 31);
+  *var_vec_f32++ = vec_vexptefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vlogefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vmaddfp(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_vmaxfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vminfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vmrghw(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vmrglw(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vnmsubfp(var_vec_f32[0], var_vec_f32[1], var_vec_f32[2]);
+  *var_vec_f32++ = vec_vnor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vor(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vor(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vperm(var_vec_f32[0], var_vec_f32[1], var_vec_u8[2]);
+  *var_vec_f32++ = vec_vrefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfim(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfin(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfip(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrfiz(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vrsqrtefp(var_vec_f32[0]);
+  *var_vec_f32++ = vec_vsel(var_vec_f32[0], var_vec_f32[1], var_vec_b32[2]);
+  *var_vec_f32++ = vec_vsel(var_vec_f32[0], var_vec_f32[1], var_vec_u32[2]);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 0);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 1);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 2);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 3);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 4);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 5);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 6);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 7);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 8);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 9);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 10);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 11);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 12);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 13);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 14);
+  *var_vec_f32++ = vec_vsldoi(var_vec_f32[0], var_vec_f32[1], 15);
+  *var_vec_f32++ = vec_vslo(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_vslo(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 0);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 1);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 2);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 3);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 4);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 5);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 6);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 7);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 8);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 9);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 10);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 11);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 12);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 13);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 14);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 15);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 16);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 17);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 18);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 19);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 20);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 21);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 22);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 23);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 24);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 25);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 26);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 27);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 28);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 29);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 30);
+  *var_vec_f32++ = vec_vspltw(var_vec_f32[0], 31);
+  *var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_s8[1]);
+  *var_vec_f32++ = vec_vsro(var_vec_f32[0], var_vec_u8[1]);
+  *var_vec_f32++ = vec_vsubfp(var_vec_f32[0], var_vec_f32[1]);
+}
+void f9() {
+  *var_vec_f32++ = vec_vxor(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_vxor(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_vxor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_xor(var_vec_b32[0], var_vec_f32[1]);
+  *var_vec_f32++ = vec_xor(var_vec_f32[0], var_vec_b32[1]);
+  *var_vec_f32++ = vec_xor(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_p16++ = vec_ld(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_ldl(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_lvx(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_lvxl(var_int[0], var_vec_p16_ptr[1]);
+  *var_vec_p16++ = vec_mergeh(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_mergel(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_packpx(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_perm(var_vec_p16[0], var_vec_p16[1], var_vec_u8[2]);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 0);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 1);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 2);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 3);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 4);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 5);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 6);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 7);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 8);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 9);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 10);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 11);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 12);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 13);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 14);
+  *var_vec_p16++ = vec_sld(var_vec_p16[0], var_vec_p16[1], 15);
+  *var_vec_p16++ = vec_sll(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_sll(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_sll(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_slo(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_slo(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 0);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 1);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 2);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 3);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 4);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 5);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 6);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 7);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 8);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 9);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 10);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 11);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 12);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 13);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 14);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 15);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 16);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 17);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 18);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 19);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 20);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 21);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 22);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 23);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 24);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 25);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 26);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 27);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 28);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 29);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 30);
+  *var_vec_p16++ = vec_splat(var_vec_p16[0], 31);
+  *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_srl(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_sro(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_sro(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vmrghh(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_vmrglh(var_vec_p16[0], var_vec_p16[1]);
+  *var_vec_p16++ = vec_vperm(var_vec_p16[0], var_vec_p16[1], var_vec_u8[2]);
+  *var_vec_p16++ = vec_vpkpx(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_vsl(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_vsl(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_vsl(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 0);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 1);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 2);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 3);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 4);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 5);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 6);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 7);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 8);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 9);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 10);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 11);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 12);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 13);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 14);
+  *var_vec_p16++ = vec_vsldoi(var_vec_p16[0], var_vec_p16[1], 15);
+  *var_vec_p16++ = vec_vslo(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_vslo(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 0);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 1);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 2);
+}
+void f10() {
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 3);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 4);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 5);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 6);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 7);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 8);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 9);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 10);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 11);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 12);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 13);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 14);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 15);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 16);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 17);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 18);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 19);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 20);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 21);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 22);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 23);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 24);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 25);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 26);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 27);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 28);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 29);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 30);
+  *var_vec_p16++ = vec_vsplth(var_vec_p16[0], 31);
+  *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u16[1]);
+  *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u32[1]);
+  *var_vec_p16++ = vec_vsr(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_p16++ = vec_vsro(var_vec_p16[0], var_vec_s8[1]);
+  *var_vec_p16++ = vec_vsro(var_vec_p16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_add(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_add(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_add(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_adds(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_adds(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_adds(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_and(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_and(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_and(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_andc(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_andc(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_andc(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_avg(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_ld(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_ld(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_lde(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_ldl(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_ldl(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_lvehx(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_lvx(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_lvx(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_lvxl(var_int[0], var_short_ptr[1]);
+  *var_vec_s16++ = vec_lvxl(var_int[0], var_vec_s16_ptr[1]);
+  *var_vec_s16++ = vec_madds(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_max(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_max(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_max(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_mergeh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_mergel(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_min(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_min(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_min(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_mladd(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_mladd(var_vec_s16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_mladd(var_vec_u16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_mradds(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_mule(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_mulo(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_nor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_or(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_or(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_or(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_pack(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_packs(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_perm(var_vec_s16[0], var_vec_s16[1], var_vec_u8[2]);
+  *var_vec_s16++ = vec_rl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_sel(var_vec_s16[0], var_vec_s16[1], var_vec_b16[2]);
+  *var_vec_s16++ = vec_sel(var_vec_s16[0], var_vec_s16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_sl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 0);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 1);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 2);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 3);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 4);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 5);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 6);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 7);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 8);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 9);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 10);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 11);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 12);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 13);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 14);
+  *var_vec_s16++ = vec_sld(var_vec_s16[0], var_vec_s16[1], 15);
+  *var_vec_s16++ = vec_sll(var_vec_s16[0], var_vec_u16[1]);
+}
+void f11() {
+  *var_vec_s16++ = vec_sll(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_sll(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_slo(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_slo(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 0);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 1);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 2);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 3);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 4);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 5);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 6);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 7);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 8);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 9);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 10);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 11);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 12);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 13);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 14);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 15);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 16);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 17);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 18);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 19);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 20);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 21);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 22);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 23);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 24);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 25);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 26);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 27);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 28);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 29);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 30);
+  *var_vec_s16++ = vec_splat(var_vec_s16[0], 31);
+  *var_vec_s16++ = vec_splat_s16( 0);
+  *var_vec_s16++ = vec_splat_s16( 1);
+  *var_vec_s16++ = vec_splat_s16( 2);
+  *var_vec_s16++ = vec_splat_s16( 3);
+  *var_vec_s16++ = vec_splat_s16( 4);
+  *var_vec_s16++ = vec_splat_s16( 5);
+  *var_vec_s16++ = vec_splat_s16( 6);
+  *var_vec_s16++ = vec_splat_s16( 7);
+  *var_vec_s16++ = vec_splat_s16( 8);
+  *var_vec_s16++ = vec_splat_s16( 9);
+  *var_vec_s16++ = vec_splat_s16( -1);
+  *var_vec_s16++ = vec_splat_s16( -2);
+  *var_vec_s16++ = vec_splat_s16( -3);
+  *var_vec_s16++ = vec_splat_s16( -4);
+  *var_vec_s16++ = vec_splat_s16( -5);
+  *var_vec_s16++ = vec_splat_s16( -6);
+  *var_vec_s16++ = vec_splat_s16( -7);
+  *var_vec_s16++ = vec_splat_s16( -8);
+  *var_vec_s16++ = vec_splat_s16( -9);
+  *var_vec_s16++ = vec_splat_s16( 10);
+  *var_vec_s16++ = vec_splat_s16( 11);
+  *var_vec_s16++ = vec_splat_s16( 12);
+  *var_vec_s16++ = vec_splat_s16( 13);
+  *var_vec_s16++ = vec_splat_s16( 14);
+  *var_vec_s16++ = vec_splat_s16( 15);
+  *var_vec_s16++ = vec_splat_s16(-10);
+  *var_vec_s16++ = vec_splat_s16(-11);
+  *var_vec_s16++ = vec_splat_s16(-12);
+  *var_vec_s16++ = vec_splat_s16(-13);
+  *var_vec_s16++ = vec_splat_s16(-14);
+  *var_vec_s16++ = vec_splat_s16(-15);
+  *var_vec_s16++ = vec_splat_s16(-16);
+  *var_vec_s16++ = vec_sr(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_sra(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_srl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_srl(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_srl(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_sro(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_sro(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_sub(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_sub(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_sub(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_subs(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_subs(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_subs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_unpackh(var_vec_s8[0]);
+  *var_vec_s16++ = vec_unpackl(var_vec_s8[0]);
+  *var_vec_s16++ = vec_vaddshs(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vaddshs(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vaddshs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vadduhm(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vadduhm(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vadduhm(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vand(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vand(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vand(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vandc(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vandc(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vandc(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vavgsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmaxsh(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmaxsh(var_vec_s16[0], var_vec_b16[1]);
+}
+void f12() {
+  *var_vec_s16++ = vec_vmaxsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmhaddshs(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vmhraddshs(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vminsh(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vminsh(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vminsh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmladduhm(var_vec_s16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vmladduhm(var_vec_s16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_vmladduhm(var_vec_u16[0], var_vec_s16[1], var_vec_s16[2]);
+  *var_vec_s16++ = vec_vmrghh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmrglh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vmulesb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vmulosb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vnor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vor(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vor(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vperm(var_vec_s16[0], var_vec_s16[1], var_vec_u8[2]);
+  *var_vec_s16++ = vec_vpkswss(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_vpkuwum(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s16++ = vec_vrlh(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsel(var_vec_s16[0], var_vec_s16[1], var_vec_b16[2]);
+  *var_vec_s16++ = vec_vsel(var_vec_s16[0], var_vec_s16[1], var_vec_u16[2]);
+  *var_vec_s16++ = vec_vsl(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsl(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_vsl(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 0);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 1);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 2);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 3);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 4);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 5);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 6);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 7);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 8);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 9);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 10);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 11);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 12);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 13);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 14);
+  *var_vec_s16++ = vec_vsldoi(var_vec_s16[0], var_vec_s16[1], 15);
+  *var_vec_s16++ = vec_vslh(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vslo(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vslo(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 0);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 1);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 2);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 3);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 4);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 5);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 6);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 7);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 8);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 9);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 10);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 11);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 12);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 13);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 14);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 15);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 16);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 17);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 18);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 19);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 20);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 21);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 22);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 23);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 24);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 25);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 26);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 27);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 28);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 29);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 30);
+  *var_vec_s16++ = vec_vsplth(var_vec_s16[0], 31);
+  *var_vec_s16++ = vec_vspltish( 0);
+  *var_vec_s16++ = vec_vspltish( 1);
+  *var_vec_s16++ = vec_vspltish( 2);
+  *var_vec_s16++ = vec_vspltish( 3);
+  *var_vec_s16++ = vec_vspltish( 4);
+  *var_vec_s16++ = vec_vspltish( 5);
+  *var_vec_s16++ = vec_vspltish( 6);
+  *var_vec_s16++ = vec_vspltish( 7);
+  *var_vec_s16++ = vec_vspltish( 8);
+  *var_vec_s16++ = vec_vspltish( 9);
+  *var_vec_s16++ = vec_vspltish( -1);
+  *var_vec_s16++ = vec_vspltish( -2);
+  *var_vec_s16++ = vec_vspltish( -3);
+  *var_vec_s16++ = vec_vspltish( -4);
+  *var_vec_s16++ = vec_vspltish( -5);
+  *var_vec_s16++ = vec_vspltish( -6);
+  *var_vec_s16++ = vec_vspltish( -7);
+  *var_vec_s16++ = vec_vspltish( -8);
+  *var_vec_s16++ = vec_vspltish( -9);
+  *var_vec_s16++ = vec_vspltish( 10);
+  *var_vec_s16++ = vec_vspltish( 11);
+  *var_vec_s16++ = vec_vspltish( 12);
+  *var_vec_s16++ = vec_vspltish( 13);
+}
+void f13() {
+  *var_vec_s16++ = vec_vspltish( 14);
+  *var_vec_s16++ = vec_vspltish( 15);
+  *var_vec_s16++ = vec_vspltish(-10);
+  *var_vec_s16++ = vec_vspltish(-11);
+  *var_vec_s16++ = vec_vspltish(-12);
+  *var_vec_s16++ = vec_vspltish(-13);
+  *var_vec_s16++ = vec_vspltish(-14);
+  *var_vec_s16++ = vec_vspltish(-15);
+  *var_vec_s16++ = vec_vspltish(-16);
+  *var_vec_s16++ = vec_vsr(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsr(var_vec_s16[0], var_vec_u32[1]);
+  *var_vec_s16++ = vec_vsr(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsrah(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsrh(var_vec_s16[0], var_vec_u16[1]);
+  *var_vec_s16++ = vec_vsro(var_vec_s16[0], var_vec_s8[1]);
+  *var_vec_s16++ = vec_vsro(var_vec_s16[0], var_vec_u8[1]);
+  *var_vec_s16++ = vec_vsubshs(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vsubshs(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vsubshs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vsubuhm(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vsubuhm(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vsubuhm(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vupkhsb(var_vec_s8[0]);
+  *var_vec_s16++ = vec_vupklsb(var_vec_s8[0]);
+  *var_vec_s16++ = vec_vxor(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_vxor(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_vxor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_xor(var_vec_b16[0], var_vec_s16[1]);
+  *var_vec_s16++ = vec_xor(var_vec_s16[0], var_vec_b16[1]);
+  *var_vec_s16++ = vec_xor(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_add(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_add(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_add(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_adds(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_adds(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_adds(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_and(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_and(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_and(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_andc(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_andc(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_andc(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_avg(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_cmpb(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 0);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 1);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 2);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 3);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 4);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 5);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 6);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 7);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 8);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 9);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 10);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 11);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 12);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 13);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 14);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 15);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 16);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 17);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 18);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 19);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 20);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 21);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 22);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 23);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 24);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 25);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 26);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 27);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 28);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 29);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 30);
+  *var_vec_s32++ = vec_cts(var_vec_f32[0], 31);
+  *var_vec_s32++ = vec_ld(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_ld(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_lde(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_ldl(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_ldl(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_lvewx(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_lvx(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_lvx(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_lvxl(var_int[0], var_int_ptr[1]);
+  *var_vec_s32++ = vec_lvxl(var_int[0], var_vec_s32_ptr[1]);
+  *var_vec_s32++ = vec_max(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_max(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_max(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_mergeh(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_mergel(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_min(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_min(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_min(var_vec_s32[0], var_vec_s32[1]);
+}
+void f14() {
+  *var_vec_s32++ = vec_msum(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_msum(var_vec_s8[0], var_vec_u8[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_msums(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_mule(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_mulo(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_nor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_or(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_or(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_or(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_perm(var_vec_s32[0], var_vec_s32[1], var_vec_u8[2]);
+  *var_vec_s32++ = vec_rl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_sel(var_vec_s32[0], var_vec_s32[1], var_vec_b32[2]);
+  *var_vec_s32++ = vec_sel(var_vec_s32[0], var_vec_s32[1], var_vec_u32[2]);
+  *var_vec_s32++ = vec_sl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 0);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 1);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 2);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 3);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 4);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 5);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 6);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 7);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 8);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 9);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 10);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 11);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 12);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 13);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 14);
+  *var_vec_s32++ = vec_sld(var_vec_s32[0], var_vec_s32[1], 15);
+  *var_vec_s32++ = vec_sll(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_sll(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_sll(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_slo(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_slo(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 0);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 1);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 2);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 3);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 4);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 5);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 6);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 7);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 8);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 9);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 10);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 11);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 12);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 13);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 14);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 15);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 16);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 17);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 18);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 19);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 20);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 21);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 22);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 23);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 24);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 25);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 26);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 27);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 28);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 29);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 30);
+  *var_vec_s32++ = vec_splat(var_vec_s32[0], 31);
+  *var_vec_s32++ = vec_splat_s32( 0);
+  *var_vec_s32++ = vec_splat_s32( 1);
+  *var_vec_s32++ = vec_splat_s32( 2);
+  *var_vec_s32++ = vec_splat_s32( 3);
+  *var_vec_s32++ = vec_splat_s32( 4);
+  *var_vec_s32++ = vec_splat_s32( 5);
+  *var_vec_s32++ = vec_splat_s32( 6);
+  *var_vec_s32++ = vec_splat_s32( 7);
+  *var_vec_s32++ = vec_splat_s32( 8);
+  *var_vec_s32++ = vec_splat_s32( 9);
+  *var_vec_s32++ = vec_splat_s32( -1);
+  *var_vec_s32++ = vec_splat_s32( -2);
+  *var_vec_s32++ = vec_splat_s32( -3);
+  *var_vec_s32++ = vec_splat_s32( -4);
+  *var_vec_s32++ = vec_splat_s32( -5);
+  *var_vec_s32++ = vec_splat_s32( -6);
+  *var_vec_s32++ = vec_splat_s32( -7);
+  *var_vec_s32++ = vec_splat_s32( -8);
+  *var_vec_s32++ = vec_splat_s32( -9);
+  *var_vec_s32++ = vec_splat_s32( 10);
+  *var_vec_s32++ = vec_splat_s32( 11);
+  *var_vec_s32++ = vec_splat_s32( 12);
+  *var_vec_s32++ = vec_splat_s32( 13);
+  *var_vec_s32++ = vec_splat_s32( 14);
+  *var_vec_s32++ = vec_splat_s32( 15);
+  *var_vec_s32++ = vec_splat_s32(-10);
+  *var_vec_s32++ = vec_splat_s32(-11);
+  *var_vec_s32++ = vec_splat_s32(-12);
+  *var_vec_s32++ = vec_splat_s32(-13);
+  *var_vec_s32++ = vec_splat_s32(-14);
+  *var_vec_s32++ = vec_splat_s32(-15);
+  *var_vec_s32++ = vec_splat_s32(-16);
+  *var_vec_s32++ = vec_sr(var_vec_s32[0], var_vec_u32[1]);
+}
+void f15() {
+  *var_vec_s32++ = vec_sra(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_srl(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_srl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_srl(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_sro(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_sro(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_sub(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sub(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_sub(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_subs(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_subs(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_subs(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sum2s(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sum4s(var_vec_s16[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sum4s(var_vec_s8[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_sums(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_unpackh(var_vec_s16[0]);
+  *var_vec_s32++ = vec_unpackl(var_vec_s16[0]);
+  *var_vec_s32++ = vec_vaddsws(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vaddsws(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vaddsws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vadduwm(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vadduwm(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vadduwm(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vand(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vand(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vand(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vandc(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vandc(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vandc(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vavgsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vcmpbfp(var_vec_f32[0], var_vec_f32[1]);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 0);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 1);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 2);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 3);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 4);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 5);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 6);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 7);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 8);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 9);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 10);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 11);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 12);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 13);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 14);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 15);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 16);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 17);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 18);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 19);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 20);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 21);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 22);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 23);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 24);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 25);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 26);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 27);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 28);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 29);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 30);
+  *var_vec_s32++ = vec_vctsxs(var_vec_f32[0], 31);
+  *var_vec_s32++ = vec_vmaxsw(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmaxsw(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vmaxsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vminsw(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vminsw(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vminsw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmrghw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmrglw(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vmsummbm(var_vec_s8[0], var_vec_u8[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_vmsumshm(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_vmsumshs(var_vec_s16[0], var_vec_s16[1], var_vec_s32[2]);
+  *var_vec_s32++ = vec_vmulesh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_vmulosh(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s32++ = vec_vnor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vor(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vor(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vperm(var_vec_s32[0], var_vec_s32[1], var_vec_u8[2]);
+  *var_vec_s32++ = vec_vrlw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsel(var_vec_s32[0], var_vec_s32[1], var_vec_b32[2]);
+  *var_vec_s32++ = vec_vsel(var_vec_s32[0], var_vec_s32[1], var_vec_u32[2]);
+  *var_vec_s32++ = vec_vsl(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_vsl(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsl(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 0);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 1);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 2);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 3);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 4);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 5);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 6);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 7);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 8);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 9);
+}
+void f16() {
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 10);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 11);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 12);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 13);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 14);
+  *var_vec_s32++ = vec_vsldoi(var_vec_s32[0], var_vec_s32[1], 15);
+  *var_vec_s32++ = vec_vslo(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_vslo(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vslw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vspltisw( 0);
+  *var_vec_s32++ = vec_vspltisw( 1);
+  *var_vec_s32++ = vec_vspltisw( 2);
+  *var_vec_s32++ = vec_vspltisw( 3);
+  *var_vec_s32++ = vec_vspltisw( 4);
+  *var_vec_s32++ = vec_vspltisw( 5);
+  *var_vec_s32++ = vec_vspltisw( 6);
+  *var_vec_s32++ = vec_vspltisw( 7);
+  *var_vec_s32++ = vec_vspltisw( 8);
+  *var_vec_s32++ = vec_vspltisw( 9);
+  *var_vec_s32++ = vec_vspltisw( -1);
+  *var_vec_s32++ = vec_vspltisw( -2);
+  *var_vec_s32++ = vec_vspltisw( -3);
+  *var_vec_s32++ = vec_vspltisw( -4);
+  *var_vec_s32++ = vec_vspltisw( -5);
+  *var_vec_s32++ = vec_vspltisw( -6);
+  *var_vec_s32++ = vec_vspltisw( -7);
+  *var_vec_s32++ = vec_vspltisw( -8);
+  *var_vec_s32++ = vec_vspltisw( -9);
+  *var_vec_s32++ = vec_vspltisw( 10);
+  *var_vec_s32++ = vec_vspltisw( 11);
+  *var_vec_s32++ = vec_vspltisw( 12);
+  *var_vec_s32++ = vec_vspltisw( 13);
+  *var_vec_s32++ = vec_vspltisw( 14);
+  *var_vec_s32++ = vec_vspltisw( 15);
+  *var_vec_s32++ = vec_vspltisw(-10);
+  *var_vec_s32++ = vec_vspltisw(-11);
+  *var_vec_s32++ = vec_vspltisw(-12);
+  *var_vec_s32++ = vec_vspltisw(-13);
+  *var_vec_s32++ = vec_vspltisw(-14);
+  *var_vec_s32++ = vec_vspltisw(-15);
+  *var_vec_s32++ = vec_vspltisw(-16);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 0);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 1);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 2);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 3);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 4);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 5);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 6);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 7);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 8);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 9);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 10);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 11);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 12);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 13);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 14);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 15);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 16);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 17);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 18);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 19);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 20);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 21);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 22);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 23);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 24);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 25);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 26);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 27);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 28);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 29);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 30);
+  *var_vec_s32++ = vec_vspltw(var_vec_s32[0], 31);
+  *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u16[1]);
+  *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsr(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vsraw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsro(var_vec_s32[0], var_vec_s8[1]);
+  *var_vec_s32++ = vec_vsro(var_vec_s32[0], var_vec_u8[1]);
+  *var_vec_s32++ = vec_vsrw(var_vec_s32[0], var_vec_u32[1]);
+  *var_vec_s32++ = vec_vsubsws(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsubsws(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vsubsws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsubuwm(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsubuwm(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vsubuwm(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsum2sws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsum4sbs(var_vec_s8[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsum4shs(var_vec_s16[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vsumsws(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vupkhsh(var_vec_s16[0]);
+  *var_vec_s32++ = vec_vupklsh(var_vec_s16[0]);
+  *var_vec_s32++ = vec_vxor(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_vxor(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_vxor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_xor(var_vec_b32[0], var_vec_s32[1]);
+  *var_vec_s32++ = vec_xor(var_vec_s32[0], var_vec_b32[1]);
+  *var_vec_s32++ = vec_xor(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_s8++ = vec_add(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_add(var_vec_s8[0], var_vec_b8[1]);
+}
+void f17() {
+  *var_vec_s8++ = vec_add(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_adds(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_adds(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_adds(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_and(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_and(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_and(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_andc(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_andc(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_andc(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_avg(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_ld(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_ld(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_lde(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_ldl(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_ldl(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_lvebx(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_lvx(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_lvx(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_lvxl(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_s8++ = vec_lvxl(var_int[0], var_vec_s8_ptr[1]);
+  *var_vec_s8++ = vec_max(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_max(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_max(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_mergeh(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_mergel(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_min(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_min(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_min(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_nor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_or(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_or(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_or(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_pack(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_packs(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_perm(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_rl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sel(var_vec_s8[0], var_vec_s8[1], var_vec_b8[2]);
+  *var_vec_s8++ = vec_sel(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_sl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 0);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 1);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 2);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 3);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 4);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 5);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 6);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 7);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 8);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 9);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 10);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 11);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 12);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 13);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 14);
+  *var_vec_s8++ = vec_sld(var_vec_s8[0], var_vec_s8[1], 15);
+  *var_vec_s8++ = vec_sll(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_sll(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_sll(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_slo(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_slo(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 0);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 1);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 2);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 3);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 4);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 5);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 6);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 7);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 8);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 9);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 10);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 11);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 12);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 13);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 14);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 15);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 16);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 17);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 18);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 19);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 20);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 21);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 22);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 23);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 24);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 25);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 26);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 27);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 28);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 29);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 30);
+  *var_vec_s8++ = vec_splat(var_vec_s8[0], 31);
+  *var_vec_s8++ = vec_splat_s8( 0);
+  *var_vec_s8++ = vec_splat_s8( 1);
+  *var_vec_s8++ = vec_splat_s8( 2);
+  *var_vec_s8++ = vec_splat_s8( 3);
+  *var_vec_s8++ = vec_splat_s8( 4);
+  *var_vec_s8++ = vec_splat_s8( 5);
+  *var_vec_s8++ = vec_splat_s8( 6);
+}
+void f18() {
+  *var_vec_s8++ = vec_splat_s8( 7);
+  *var_vec_s8++ = vec_splat_s8( 8);
+  *var_vec_s8++ = vec_splat_s8( 9);
+  *var_vec_s8++ = vec_splat_s8( -1);
+  *var_vec_s8++ = vec_splat_s8( -2);
+  *var_vec_s8++ = vec_splat_s8( -3);
+  *var_vec_s8++ = vec_splat_s8( -4);
+  *var_vec_s8++ = vec_splat_s8( -5);
+  *var_vec_s8++ = vec_splat_s8( -6);
+  *var_vec_s8++ = vec_splat_s8( -7);
+  *var_vec_s8++ = vec_splat_s8( -8);
+  *var_vec_s8++ = vec_splat_s8( -9);
+  *var_vec_s8++ = vec_splat_s8( 10);
+  *var_vec_s8++ = vec_splat_s8( 11);
+  *var_vec_s8++ = vec_splat_s8( 12);
+  *var_vec_s8++ = vec_splat_s8( 13);
+  *var_vec_s8++ = vec_splat_s8( 14);
+  *var_vec_s8++ = vec_splat_s8( 15);
+  *var_vec_s8++ = vec_splat_s8(-10);
+  *var_vec_s8++ = vec_splat_s8(-11);
+  *var_vec_s8++ = vec_splat_s8(-12);
+  *var_vec_s8++ = vec_splat_s8(-13);
+  *var_vec_s8++ = vec_splat_s8(-14);
+  *var_vec_s8++ = vec_splat_s8(-15);
+  *var_vec_s8++ = vec_splat_s8(-16);
+  *var_vec_s8++ = vec_sr(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sra(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_srl(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_srl(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_srl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sro(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_sro(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_sub(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_sub(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_sub(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_subs(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_subs(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_subs(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddsbs(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddsbs(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vaddsbs(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddubm(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vaddubm(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vaddubm(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vand(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vand(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vand(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vandc(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vandc(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vandc(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vavgsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmaxsb(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmaxsb(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vmaxsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vminsb(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vminsb(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vminsb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmrghb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vmrglb(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vnor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vor(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vor(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vperm(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_vpkshss(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_vpkuhum(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_s8++ = vec_vrlb(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsel(var_vec_s8[0], var_vec_s8[1], var_vec_b8[2]);
+  *var_vec_s8++ = vec_vsel(var_vec_s8[0], var_vec_s8[1], var_vec_u8[2]);
+  *var_vec_s8++ = vec_vsl(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_vsl(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_vsl(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vslb(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 0);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 1);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 2);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 3);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 4);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 5);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 6);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 7);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 8);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 9);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 10);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 11);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 12);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 13);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 14);
+  *var_vec_s8++ = vec_vsldoi(var_vec_s8[0], var_vec_s8[1], 15);
+  *var_vec_s8++ = vec_vslo(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vslo(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 0);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 1);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 2);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 3);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 4);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 5);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 6);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 7);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 8);
+}
+void f19() {
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 9);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 10);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 11);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 12);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 13);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 14);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 15);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 16);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 17);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 18);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 19);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 20);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 21);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 22);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 23);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 24);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 25);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 26);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 27);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 28);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 29);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 30);
+  *var_vec_s8++ = vec_vspltb(var_vec_s8[0], 31);
+  *var_vec_s8++ = vec_vspltisb( 0);
+  *var_vec_s8++ = vec_vspltisb( 1);
+  *var_vec_s8++ = vec_vspltisb( 2);
+  *var_vec_s8++ = vec_vspltisb( 3);
+  *var_vec_s8++ = vec_vspltisb( 4);
+  *var_vec_s8++ = vec_vspltisb( 5);
+  *var_vec_s8++ = vec_vspltisb( 6);
+  *var_vec_s8++ = vec_vspltisb( 7);
+  *var_vec_s8++ = vec_vspltisb( 8);
+  *var_vec_s8++ = vec_vspltisb( 9);
+  *var_vec_s8++ = vec_vspltisb( -1);
+  *var_vec_s8++ = vec_vspltisb( -2);
+  *var_vec_s8++ = vec_vspltisb( -3);
+  *var_vec_s8++ = vec_vspltisb( -4);
+  *var_vec_s8++ = vec_vspltisb( -5);
+  *var_vec_s8++ = vec_vspltisb( -6);
+  *var_vec_s8++ = vec_vspltisb( -7);
+  *var_vec_s8++ = vec_vspltisb( -8);
+  *var_vec_s8++ = vec_vspltisb( -9);
+  *var_vec_s8++ = vec_vspltisb( 10);
+  *var_vec_s8++ = vec_vspltisb( 11);
+  *var_vec_s8++ = vec_vspltisb( 12);
+  *var_vec_s8++ = vec_vspltisb( 13);
+  *var_vec_s8++ = vec_vspltisb( 14);
+  *var_vec_s8++ = vec_vspltisb( 15);
+  *var_vec_s8++ = vec_vspltisb(-10);
+  *var_vec_s8++ = vec_vspltisb(-11);
+  *var_vec_s8++ = vec_vspltisb(-12);
+  *var_vec_s8++ = vec_vspltisb(-13);
+  *var_vec_s8++ = vec_vspltisb(-14);
+  *var_vec_s8++ = vec_vspltisb(-15);
+  *var_vec_s8++ = vec_vspltisb(-16);
+  *var_vec_s8++ = vec_vsr(var_vec_s8[0], var_vec_u16[1]);
+  *var_vec_s8++ = vec_vsr(var_vec_s8[0], var_vec_u32[1]);
+  *var_vec_s8++ = vec_vsr(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsrab(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsrb(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsro(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsro(var_vec_s8[0], var_vec_u8[1]);
+  *var_vec_s8++ = vec_vsubsbs(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsubsbs(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vsubsbs(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsububm(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vsububm(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vsububm(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vxor(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_vxor(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_vxor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_xor(var_vec_b8[0], var_vec_s8[1]);
+  *var_vec_s8++ = vec_xor(var_vec_s8[0], var_vec_b8[1]);
+  *var_vec_s8++ = vec_xor(var_vec_s8[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_add(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_add(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_add(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_adds(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_adds(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_adds(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_and(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_and(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_and(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_andc(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_andc(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_andc(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_avg(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_ld(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_ld(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_lde(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_ldl(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_ldl(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_lvehx(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_lvx(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_lvx(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_lvxl(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u16++ = vec_lvxl(var_int[0], var_vec_u16_ptr[1]);
+  *var_vec_u16++ = vec_max(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_max(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_max(var_vec_u16[0], var_vec_u16[1]);
+}
+void f20() {
+  *var_vec_u16++ = vec_mergeh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_mergel(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_min(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_min(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_min(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_mladd(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_mule(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_mulo(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_nor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_or(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_or(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_or(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_pack(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_packs(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_packsu(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_u16++ = vec_packsu(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_perm(var_vec_u16[0], var_vec_u16[1], var_vec_u8[2]);
+  *var_vec_u16++ = vec_rl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sel(var_vec_u16[0], var_vec_u16[1], var_vec_b16[2]);
+  *var_vec_u16++ = vec_sel(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_sl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 0);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 1);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 2);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 3);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 4);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 5);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 6);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 7);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 8);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 9);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 10);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 11);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 12);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 13);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 14);
+  *var_vec_u16++ = vec_sld(var_vec_u16[0], var_vec_u16[1], 15);
+  *var_vec_u16++ = vec_sll(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sll(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_sll(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_slo(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_slo(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 0);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 1);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 2);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 3);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 4);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 5);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 6);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 7);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 8);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 9);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 10);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 11);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 12);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 13);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 14);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 15);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 16);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 17);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 18);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 19);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 20);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 21);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 22);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 23);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 24);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 25);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 26);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 27);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 28);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 29);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 30);
+  *var_vec_u16++ = vec_splat(var_vec_u16[0], 31);
+  *var_vec_u16++ = vec_splat_u16( 0);
+  *var_vec_u16++ = vec_splat_u16( 1);
+  *var_vec_u16++ = vec_splat_u16( 2);
+  *var_vec_u16++ = vec_splat_u16( 3);
+  *var_vec_u16++ = vec_splat_u16( 4);
+  *var_vec_u16++ = vec_splat_u16( 5);
+  *var_vec_u16++ = vec_splat_u16( 6);
+  *var_vec_u16++ = vec_splat_u16( 7);
+  *var_vec_u16++ = vec_splat_u16( 8);
+  *var_vec_u16++ = vec_splat_u16( 9);
+  *var_vec_u16++ = vec_splat_u16( -1);
+  *var_vec_u16++ = vec_splat_u16( -2);
+  *var_vec_u16++ = vec_splat_u16( -3);
+  *var_vec_u16++ = vec_splat_u16( -4);
+  *var_vec_u16++ = vec_splat_u16( -5);
+  *var_vec_u16++ = vec_splat_u16( -6);
+  *var_vec_u16++ = vec_splat_u16( -7);
+  *var_vec_u16++ = vec_splat_u16( -8);
+  *var_vec_u16++ = vec_splat_u16( -9);
+  *var_vec_u16++ = vec_splat_u16( 10);
+  *var_vec_u16++ = vec_splat_u16( 11);
+  *var_vec_u16++ = vec_splat_u16( 12);
+  *var_vec_u16++ = vec_splat_u16( 13);
+  *var_vec_u16++ = vec_splat_u16( 14);
+  *var_vec_u16++ = vec_splat_u16( 15);
+  *var_vec_u16++ = vec_splat_u16(-10);
+}
+void f21() {
+  *var_vec_u16++ = vec_splat_u16(-11);
+  *var_vec_u16++ = vec_splat_u16(-12);
+  *var_vec_u16++ = vec_splat_u16(-13);
+  *var_vec_u16++ = vec_splat_u16(-14);
+  *var_vec_u16++ = vec_splat_u16(-15);
+  *var_vec_u16++ = vec_splat_u16(-16);
+  *var_vec_u16++ = vec_sr(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sra(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_srl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_srl(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_srl(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_sro(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_sro(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_sub(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_sub(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_sub(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_subs(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_subs(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_subs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhm(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhm(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vadduhm(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhs(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vadduhs(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vadduhs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vand(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vand(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vand(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vandc(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vandc(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vandc(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vavguh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmaxuh(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmaxuh(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vmaxuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vminuh(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vminuh(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vminuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmladduhm(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_vmrghh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmrglh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vmuleub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vmuloub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vnor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vor(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vor(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vperm(var_vec_u16[0], var_vec_u16[1], var_vec_u8[2]);
+  *var_vec_u16++ = vec_vpkswus(var_vec_s32[0], var_vec_s32[1]);
+  *var_vec_u16++ = vec_vpkuwum(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vpkuwus(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vrlh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsel(var_vec_u16[0], var_vec_u16[1], var_vec_b16[2]);
+  *var_vec_u16++ = vec_vsel(var_vec_u16[0], var_vec_u16[1], var_vec_u16[2]);
+  *var_vec_u16++ = vec_vsl(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsl(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vsl(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 0);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 1);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 2);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 3);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 4);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 5);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 6);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 7);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 8);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 9);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 10);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 11);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 12);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 13);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 14);
+  *var_vec_u16++ = vec_vsldoi(var_vec_u16[0], var_vec_u16[1], 15);
+  *var_vec_u16++ = vec_vslh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vslo(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_vslo(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 0);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 1);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 2);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 3);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 4);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 5);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 6);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 7);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 8);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 9);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 10);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 11);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 12);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 13);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 14);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 15);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 16);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 17);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 18);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 19);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 20);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 21);
+}
+void f22() {
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 22);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 23);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 24);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 25);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 26);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 27);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 28);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 29);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 30);
+  *var_vec_u16++ = vec_vsplth(var_vec_u16[0], 31);
+  *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u32[1]);
+  *var_vec_u16++ = vec_vsr(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsrah(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsrh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsro(var_vec_u16[0], var_vec_s8[1]);
+  *var_vec_u16++ = vec_vsro(var_vec_u16[0], var_vec_u8[1]);
+  *var_vec_u16++ = vec_vsubuhm(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsubuhm(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vsubuhm(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsubuhs(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vsubuhs(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vsubuhs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vxor(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_vxor(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_vxor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_xor(var_vec_b16[0], var_vec_u16[1]);
+  *var_vec_u16++ = vec_xor(var_vec_u16[0], var_vec_b16[1]);
+  *var_vec_u16++ = vec_xor(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_add(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_add(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_add(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_addc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_adds(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_adds(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_adds(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_and(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_and(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_and(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_andc(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_andc(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_andc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_avg(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 0);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 1);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 2);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 3);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 4);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 5);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 6);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 7);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 8);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 9);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 10);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 11);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 12);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 13);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 14);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 15);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 16);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 17);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 18);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 19);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 20);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 21);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 22);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 23);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 24);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 25);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 26);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 27);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 28);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 29);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 30);
+  *var_vec_u32++ = vec_ctu(var_vec_f32[0], 31);
+  *var_vec_u32++ = vec_ld(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_ld(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_lde(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_ldl(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_ldl(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_lvewx(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_lvx(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_lvx(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_lvxl(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u32++ = vec_lvxl(var_int[0], var_vec_u32_ptr[1]);
+  *var_vec_u32++ = vec_max(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_max(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_max(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_mergeh(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_mergel(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_min(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_min(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_min(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_msum(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+}
+void f23() {
+  *var_vec_u32++ = vec_msum(var_vec_u8[0], var_vec_u8[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_msums(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_mule(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_mulo(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_nor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_or(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_or(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_or(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_perm(var_vec_u32[0], var_vec_u32[1], var_vec_u8[2]);
+  *var_vec_u32++ = vec_rl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sel(var_vec_u32[0], var_vec_u32[1], var_vec_b32[2]);
+  *var_vec_u32++ = vec_sel(var_vec_u32[0], var_vec_u32[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_sl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 0);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 1);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 2);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 3);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 4);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 5);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 6);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 7);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 8);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 9);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 10);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 11);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 12);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 13);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 14);
+  *var_vec_u32++ = vec_sld(var_vec_u32[0], var_vec_u32[1], 15);
+  *var_vec_u32++ = vec_sll(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_sll(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sll(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_slo(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_slo(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 0);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 1);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 2);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 3);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 4);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 5);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 6);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 7);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 8);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 9);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 10);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 11);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 12);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 13);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 14);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 15);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 16);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 17);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 18);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 19);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 20);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 21);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 22);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 23);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 24);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 25);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 26);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 27);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 28);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 29);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 30);
+  *var_vec_u32++ = vec_splat(var_vec_u32[0], 31);
+  *var_vec_u32++ = vec_splat_u32( 0);
+  *var_vec_u32++ = vec_splat_u32( 1);
+  *var_vec_u32++ = vec_splat_u32( 2);
+  *var_vec_u32++ = vec_splat_u32( 3);
+  *var_vec_u32++ = vec_splat_u32( 4);
+  *var_vec_u32++ = vec_splat_u32( 5);
+  *var_vec_u32++ = vec_splat_u32( 6);
+  *var_vec_u32++ = vec_splat_u32( 7);
+  *var_vec_u32++ = vec_splat_u32( 8);
+  *var_vec_u32++ = vec_splat_u32( 9);
+  *var_vec_u32++ = vec_splat_u32( -1);
+  *var_vec_u32++ = vec_splat_u32( -2);
+  *var_vec_u32++ = vec_splat_u32( -3);
+  *var_vec_u32++ = vec_splat_u32( -4);
+  *var_vec_u32++ = vec_splat_u32( -5);
+  *var_vec_u32++ = vec_splat_u32( -6);
+  *var_vec_u32++ = vec_splat_u32( -7);
+  *var_vec_u32++ = vec_splat_u32( -8);
+  *var_vec_u32++ = vec_splat_u32( -9);
+  *var_vec_u32++ = vec_splat_u32( 10);
+  *var_vec_u32++ = vec_splat_u32( 11);
+  *var_vec_u32++ = vec_splat_u32( 12);
+  *var_vec_u32++ = vec_splat_u32( 13);
+  *var_vec_u32++ = vec_splat_u32( 14);
+  *var_vec_u32++ = vec_splat_u32( 15);
+  *var_vec_u32++ = vec_splat_u32(-10);
+  *var_vec_u32++ = vec_splat_u32(-11);
+  *var_vec_u32++ = vec_splat_u32(-12);
+  *var_vec_u32++ = vec_splat_u32(-13);
+  *var_vec_u32++ = vec_splat_u32(-14);
+  *var_vec_u32++ = vec_splat_u32(-15);
+  *var_vec_u32++ = vec_splat_u32(-16);
+  *var_vec_u32++ = vec_sr(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sra(var_vec_u32[0], var_vec_u32[1]);
+}
+void f24() {
+  *var_vec_u32++ = vec_srl(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_srl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_srl(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_sro(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_sro(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_sub(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sub(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_sub(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_subc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_subs(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_subs(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_subs(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_sum4s(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_unpackh(var_vec_p16[0]);
+  *var_vec_u32++ = vec_unpackl(var_vec_p16[0]);
+  *var_vec_u32++ = vec_vaddcuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduwm(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduwm(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vadduwm(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduws(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vadduws(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vadduws(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vand(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vand(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vand(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vandc(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vandc(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vandc(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vavguw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 0);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 1);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 2);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 3);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 4);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 5);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 6);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 7);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 8);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 9);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 10);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 11);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 12);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 13);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 14);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 15);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 16);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 17);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 18);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 19);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 20);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 21);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 22);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 23);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 24);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 25);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 26);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 27);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 28);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 29);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 30);
+  *var_vec_u32++ = vec_vctuxs(var_vec_f32[0], 31);
+  *var_vec_u32++ = vec_vmaxuw(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmaxuw(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vmaxuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vminuw(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vminuw(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vminuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmrghw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmrglw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vmsumubm(var_vec_u8[0], var_vec_u8[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vmsumuhm(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vmsumuhs(var_vec_u16[0], var_vec_u16[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vmuleuh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vmulouh(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vnor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vor(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vor(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vperm(var_vec_u32[0], var_vec_u32[1], var_vec_u8[2]);
+  *var_vec_u32++ = vec_vrlw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsel(var_vec_u32[0], var_vec_u32[1], var_vec_b32[2]);
+  *var_vec_u32++ = vec_vsel(var_vec_u32[0], var_vec_u32[1], var_vec_u32[2]);
+  *var_vec_u32++ = vec_vsl(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vsl(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsl(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 0);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 1);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 2);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 3);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 4);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 5);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 6);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 7);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 8);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 9);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 10);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 11);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 12);
+}
+void f25() {
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 13);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 14);
+  *var_vec_u32++ = vec_vsldoi(var_vec_u32[0], var_vec_u32[1], 15);
+  *var_vec_u32++ = vec_vslo(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_vslo(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vslw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 0);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 1);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 2);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 3);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 4);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 5);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 6);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 7);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 8);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 9);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 10);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 11);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 12);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 13);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 14);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 15);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 16);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 17);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 18);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 19);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 20);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 21);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 22);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 23);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 24);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 25);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 26);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 27);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 28);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 29);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 30);
+  *var_vec_u32++ = vec_vspltw(var_vec_u32[0], 31);
+  *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u16[1]);
+  *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsr(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vsraw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsro(var_vec_u32[0], var_vec_s8[1]);
+  *var_vec_u32++ = vec_vsro(var_vec_u32[0], var_vec_u8[1]);
+  *var_vec_u32++ = vec_vsrw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubcuw(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuwm(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuwm(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vsubuwm(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuws(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsubuws(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vsubuws(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vsum4ubs(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vupkhpx(var_vec_p16[0]);
+  *var_vec_u32++ = vec_vupklpx(var_vec_p16[0]);
+  *var_vec_u32++ = vec_vxor(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_vxor(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_vxor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_xor(var_vec_b32[0], var_vec_u32[1]);
+  *var_vec_u32++ = vec_xor(var_vec_u32[0], var_vec_b32[1]);
+  *var_vec_u32++ = vec_xor(var_vec_u32[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_add(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_add(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_add(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_adds(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_adds(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_adds(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_and(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_and(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_and(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_andc(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_andc(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_andc(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_avg(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_ld(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_ld(var_int[0], var_vec_u8_ptr[1]);
+  *var_vec_u8++ = vec_lde(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_ldl(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_ldl(var_int[0], var_vec_u8_ptr[1]);
+  *var_vec_u8++ = vec_lvebx(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_float_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_short_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsl(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_float_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_short_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_signed_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_int_ptr[1]);
+  *var_vec_u8++ = vec_lvsr(var_int[0], var_unsigned_short_ptr[1]);
+  *var_vec_u8++ = vec_lvx(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvx(var_int[0], var_vec_u8_ptr[1]);
+}
+void f26() {
+  *var_vec_u8++ = vec_lvxl(var_int[0], var_unsigned_char_ptr[1]);
+  *var_vec_u8++ = vec_lvxl(var_int[0], var_vec_u8_ptr[1]);
+  *var_vec_u8++ = vec_max(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_max(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_max(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_mergeh(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_mergel(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_min(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_min(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_min(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_nor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_or(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_or(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_or(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_pack(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_packs(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_packsu(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_u8++ = vec_packsu(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_perm(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_rl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sel(var_vec_u8[0], var_vec_u8[1], var_vec_b8[2]);
+  *var_vec_u8++ = vec_sel(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_sl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 0);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 1);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 2);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 3);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 4);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 5);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 6);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 7);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 8);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 9);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 10);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 11);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 12);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 13);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 14);
+  *var_vec_u8++ = vec_sld(var_vec_u8[0], var_vec_u8[1], 15);
+  *var_vec_u8++ = vec_sll(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_sll(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_sll(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_slo(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_slo(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 0);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 1);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 2);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 3);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 4);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 5);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 6);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 7);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 8);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 9);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 10);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 11);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 12);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 13);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 14);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 15);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 16);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 17);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 18);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 19);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 20);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 21);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 22);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 23);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 24);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 25);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 26);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 27);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 28);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 29);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 30);
+  *var_vec_u8++ = vec_splat(var_vec_u8[0], 31);
+  *var_vec_u8++ = vec_splat_u8( 0);
+  *var_vec_u8++ = vec_splat_u8( 1);
+  *var_vec_u8++ = vec_splat_u8( 2);
+  *var_vec_u8++ = vec_splat_u8( 3);
+  *var_vec_u8++ = vec_splat_u8( 4);
+  *var_vec_u8++ = vec_splat_u8( 5);
+  *var_vec_u8++ = vec_splat_u8( 6);
+  *var_vec_u8++ = vec_splat_u8( 7);
+  *var_vec_u8++ = vec_splat_u8( 8);
+  *var_vec_u8++ = vec_splat_u8( 9);
+  *var_vec_u8++ = vec_splat_u8( -1);
+  *var_vec_u8++ = vec_splat_u8( -2);
+  *var_vec_u8++ = vec_splat_u8( -3);
+  *var_vec_u8++ = vec_splat_u8( -4);
+  *var_vec_u8++ = vec_splat_u8( -5);
+  *var_vec_u8++ = vec_splat_u8( -6);
+  *var_vec_u8++ = vec_splat_u8( -7);
+  *var_vec_u8++ = vec_splat_u8( -8);
+  *var_vec_u8++ = vec_splat_u8( -9);
+  *var_vec_u8++ = vec_splat_u8( 10);
+  *var_vec_u8++ = vec_splat_u8( 11);
+  *var_vec_u8++ = vec_splat_u8( 12);
+  *var_vec_u8++ = vec_splat_u8( 13);
+  *var_vec_u8++ = vec_splat_u8( 14);
+}
+void f27() {
+  *var_vec_u8++ = vec_splat_u8( 15);
+  *var_vec_u8++ = vec_splat_u8(-10);
+  *var_vec_u8++ = vec_splat_u8(-11);
+  *var_vec_u8++ = vec_splat_u8(-12);
+  *var_vec_u8++ = vec_splat_u8(-13);
+  *var_vec_u8++ = vec_splat_u8(-14);
+  *var_vec_u8++ = vec_splat_u8(-15);
+  *var_vec_u8++ = vec_splat_u8(-16);
+  *var_vec_u8++ = vec_sr(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sra(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_srl(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_srl(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_srl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sro(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_sro(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sub(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_sub(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_sub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_subs(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_subs(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_subs(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubm(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubm(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vaddubm(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubs(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vaddubs(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vaddubs(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vand(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vand(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vand(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vandc(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vandc(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vandc(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vavgub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmaxub(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmaxub(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vmaxub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vminub(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vminub(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vminub(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmrghb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vmrglb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vnor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vor(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vor(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vperm(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_vpkshus(var_vec_s16[0], var_vec_s16[1]);
+  *var_vec_u8++ = vec_vpkuhum(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vpkuhus(var_vec_u16[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vrlb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsel(var_vec_u8[0], var_vec_u8[1], var_vec_b8[2]);
+  *var_vec_u8++ = vec_vsel(var_vec_u8[0], var_vec_u8[1], var_vec_u8[2]);
+  *var_vec_u8++ = vec_vsl(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vsl(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_vsl(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vslb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 0);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 1);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 2);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 3);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 4);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 5);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 6);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 7);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 8);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 9);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 10);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 11);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 12);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 13);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 14);
+  *var_vec_u8++ = vec_vsldoi(var_vec_u8[0], var_vec_u8[1], 15);
+  *var_vec_u8++ = vec_vslo(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_vslo(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 0);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 1);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 2);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 3);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 4);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 5);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 6);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 7);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 8);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 9);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 10);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 11);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 12);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 13);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 14);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 15);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 16);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 17);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 18);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 19);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 20);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 21);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 22);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 23);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 24);
+}
+void f28() {
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 25);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 26);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 27);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 28);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 29);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 30);
+  *var_vec_u8++ = vec_vspltb(var_vec_u8[0], 31);
+  *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u16[1]);
+  *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u32[1]);
+  *var_vec_u8++ = vec_vsr(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsrab(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsrb(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsro(var_vec_u8[0], var_vec_s8[1]);
+  *var_vec_u8++ = vec_vsro(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububm(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububm(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vsububm(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububs(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vsububs(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vsububs(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vxor(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_vxor(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_vxor(var_vec_u8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_xor(var_vec_b8[0], var_vec_u8[1]);
+  *var_vec_u8++ = vec_xor(var_vec_u8[0], var_vec_b8[1]);
+  *var_vec_u8++ = vec_xor(var_vec_u8[0], var_vec_u8[1]);
+  *var_volatile_vec_u16++ = vec_mfvscr();
+  if(!vec_all_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(!vec_all_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(!vec_all_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(!vec_all_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(!vec_all_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(!vec_all_in(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(!vec_all_le(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+}
+void f29() {
+  if(!vec_all_le(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_le(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(!vec_all_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(!vec_all_nan(var_vec_f32[0])) *var_cc26td++;
+  if(!vec_all_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(!vec_all_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(!vec_all_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(!vec_all_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(!vec_all_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(!vec_all_numeric(var_vec_f32[0])) *var_cc24td++;
+  if(!vec_any_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(!vec_any_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(!vec_any_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(!vec_any_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+}
+void f30() {
+  if(!vec_any_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(!vec_any_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(!vec_any_le(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(!vec_any_le(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_le(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(!vec_any_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc26fr++;
+  if(!vec_any_nan(var_vec_f32[0])) *var_cc24fd++;
+  if(!vec_any_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(!vec_any_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(!vec_any_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(!vec_any_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(!vec_any_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(!vec_any_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(!vec_any_numeric(var_vec_f32[0])) *var_cc26fd++;
+  if(!vec_any_out(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_all_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+}
+void f31() {
+  if(vec_all_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(vec_all_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc26tr++;
+  if(vec_all_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc26tr++;
+  if(vec_all_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc24t++;
+  if(vec_all_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc24t++;
+  if(vec_all_in(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(vec_all_le(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_le(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc24tr++;
+  if(vec_all_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc24tr++;
+  if(vec_all_nan(var_vec_f32[0])) *var_cc26td++;
+  if(vec_all_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc26t++;
+}
+void f32() {
+  if(vec_all_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc26t++;
+  if(vec_all_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc26t++;
+  if(vec_all_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc26t++;
+  if(vec_all_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(vec_all_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc26tr++;
+  if(vec_all_numeric(var_vec_f32[0])) *var_cc24td++;
+  if(vec_any_eq(var_vec_b16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_p16[0], var_vec_p16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_eq(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_ge(var_vec_b16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_b8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_any_ge(var_vec_s16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s16[0], var_vec_s16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s32[0], var_vec_s32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_s8[0], var_vec_s8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u16[0], var_vec_b16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u16[0], var_vec_u16[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u32[0], var_vec_b32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u32[0], var_vec_u32[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u8[0], var_vec_b8[1])) *var_cc24fr++;
+  if(vec_any_ge(var_vec_u8[0], var_vec_u8[1])) *var_cc24fr++;
+  if(vec_any_gt(var_vec_b16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_b8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s16[0], var_vec_s16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s32[0], var_vec_s32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_s8[0], var_vec_s8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u16[0], var_vec_b16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u16[0], var_vec_u16[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u32[0], var_vec_b32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u32[0], var_vec_u32[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u8[0], var_vec_b8[1])) *var_cc26f++;
+  if(vec_any_gt(var_vec_u8[0], var_vec_u8[1])) *var_cc26f++;
+  if(vec_any_le(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(vec_any_le(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_le(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_lt(var_vec_b16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_b8[0], var_vec_u8[1])) *var_cc26fr++;
+}
+void f33() {
+  if(vec_any_lt(var_vec_f32[0], var_vec_f32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s16[0], var_vec_s16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s32[0], var_vec_s32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_s8[0], var_vec_s8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u16[0], var_vec_b16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u16[0], var_vec_u16[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u32[0], var_vec_b32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u32[0], var_vec_u32[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u8[0], var_vec_b8[1])) *var_cc26fr++;
+  if(vec_any_lt(var_vec_u8[0], var_vec_u8[1])) *var_cc26fr++;
+  if(vec_any_nan(var_vec_f32[0])) *var_cc24fd++;
+  if(vec_any_ne(var_vec_b16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_b8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_p16[0], var_vec_p16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s16[0], var_vec_s16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s32[0], var_vec_s32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_s8[0], var_vec_s8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u16[0], var_vec_b16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u16[0], var_vec_u16[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u32[0], var_vec_b32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u32[0], var_vec_u32[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u8[0], var_vec_b8[1])) *var_cc24f++;
+  if(vec_any_ne(var_vec_u8[0], var_vec_u8[1])) *var_cc24f++;
+  if(vec_any_nge(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(vec_any_ngt(var_vec_f32[0], var_vec_f32[1])) *var_cc24f++;
+  if(vec_any_nle(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(vec_any_nlt(var_vec_f32[0], var_vec_f32[1])) *var_cc24fr++;
+  if(vec_any_numeric(var_vec_f32[0])) *var_cc26fd++;
+  if(vec_any_out(var_vec_f32[0], var_vec_f32[1])) *var_cc26f++;
+  vec_dss( 0);
+  vec_dss( 1);
+  vec_dss( 2);
+  vec_dss( 3);
+  vec_dssall();
+  vec_dst(var_float_ptr[0], var_int[1], 0);
+  vec_dst(var_float_ptr[0], var_int[1], 1);
+  vec_dst(var_float_ptr[0], var_int[1], 2);
+  vec_dst(var_float_ptr[0], var_int[1], 3);
+  vec_dst(var_int_ptr[0], var_int[1], 0);
+  vec_dst(var_int_ptr[0], var_int[1], 1);
+  vec_dst(var_int_ptr[0], var_int[1], 2);
+  vec_dst(var_int_ptr[0], var_int[1], 3);
+  vec_dst(var_short_ptr[0], var_int[1], 0);
+  vec_dst(var_short_ptr[0], var_int[1], 1);
+  vec_dst(var_short_ptr[0], var_int[1], 2);
+  vec_dst(var_short_ptr[0], var_int[1], 3);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dst(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dst(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_f32_ptr[0], var_int[1], 3);
+}
+void f34() {
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_u16_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dst(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_dstst(var_float_ptr[0], var_int[1], 0);
+  vec_dstst(var_float_ptr[0], var_int[1], 1);
+  vec_dstst(var_float_ptr[0], var_int[1], 2);
+  vec_dstst(var_float_ptr[0], var_int[1], 3);
+  vec_dstst(var_int_ptr[0], var_int[1], 0);
+  vec_dstst(var_int_ptr[0], var_int[1], 1);
+  vec_dstst(var_int_ptr[0], var_int[1], 2);
+  vec_dstst(var_int_ptr[0], var_int[1], 3);
+  vec_dstst(var_short_ptr[0], var_int[1], 0);
+  vec_dstst(var_short_ptr[0], var_int[1], 1);
+  vec_dstst(var_short_ptr[0], var_int[1], 2);
+  vec_dstst(var_short_ptr[0], var_int[1], 3);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dstst(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dstst(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_f32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_u16_ptr[0], var_int[1], 3);
+}
+void f35() {
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dstst(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_dststt(var_float_ptr[0], var_int[1], 0);
+  vec_dststt(var_float_ptr[0], var_int[1], 1);
+  vec_dststt(var_float_ptr[0], var_int[1], 2);
+  vec_dststt(var_float_ptr[0], var_int[1], 3);
+  vec_dststt(var_int_ptr[0], var_int[1], 0);
+  vec_dststt(var_int_ptr[0], var_int[1], 1);
+  vec_dststt(var_int_ptr[0], var_int[1], 2);
+  vec_dststt(var_int_ptr[0], var_int[1], 3);
+  vec_dststt(var_short_ptr[0], var_int[1], 0);
+  vec_dststt(var_short_ptr[0], var_int[1], 1);
+  vec_dststt(var_short_ptr[0], var_int[1], 2);
+  vec_dststt(var_short_ptr[0], var_int[1], 3);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dststt(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dststt(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_f32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_u16_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dststt(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_dstt(var_float_ptr[0], var_int[1], 0);
+  vec_dstt(var_float_ptr[0], var_int[1], 1);
+  vec_dstt(var_float_ptr[0], var_int[1], 2);
+  vec_dstt(var_float_ptr[0], var_int[1], 3);
+  vec_dstt(var_int_ptr[0], var_int[1], 0);
+  vec_dstt(var_int_ptr[0], var_int[1], 1);
+  vec_dstt(var_int_ptr[0], var_int[1], 2);
+  vec_dstt(var_int_ptr[0], var_int[1], 3);
+}
+void f36() {
+  vec_dstt(var_short_ptr[0], var_int[1], 0);
+  vec_dstt(var_short_ptr[0], var_int[1], 1);
+  vec_dstt(var_short_ptr[0], var_int[1], 2);
+  vec_dstt(var_short_ptr[0], var_int[1], 3);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 0);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 1);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 2);
+  vec_dstt(var_signed_char_ptr[0], var_int[1], 3);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_char_ptr[0], var_int[1], 3);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_int_ptr[0], var_int[1], 3);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 0);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 1);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 2);
+  vec_dstt(var_unsigned_short_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_b16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_b32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_b8_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_f32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_p16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_s16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_s32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_s8_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_u16_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_u32_ptr[0], var_int[1], 3);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 0);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 1);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 2);
+  vec_dstt(var_vec_u8_ptr[0], var_int[1], 3);
+  vec_mtvscr(var_vec_b16[0]);
+  vec_mtvscr(var_vec_b32[0]);
+  vec_mtvscr(var_vec_b8[0]);
+  vec_mtvscr(var_vec_p16[0]);
+  vec_mtvscr(var_vec_s16[0]);
+  vec_mtvscr(var_vec_s32[0]);
+  vec_mtvscr(var_vec_s8[0]);
+  vec_mtvscr(var_vec_u16[0]);
+  vec_mtvscr(var_vec_u32[0]);
+  vec_mtvscr(var_vec_u8[0]);
+  vec_st(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_st(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_st(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_st(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_st(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_st(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_st(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_st(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_st(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_st(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_st(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_st(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_st(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_st(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_st(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_st(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_st(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_st(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+  vec_ste(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_ste(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+}
+void f37() {
+  vec_ste(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_ste(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_ste(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_ste(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_ste(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stl(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_stl(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_stl(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_stl(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stl(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_stl(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_stl(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stl(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_stl(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stl(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_stl(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stl(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_stl(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stl(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_stl(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stl(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_stl(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stl(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+  vec_stvebx(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stvebx(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stvehx(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stvehx(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stvewx(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stvewx(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stvewx(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stvx(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_stvx(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_stvx(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_stvx(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stvx(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_stvx(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_stvx(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stvx(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_stvx(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stvx(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_stvx(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stvx(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_stvx(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stvx(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_stvx(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stvx(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_stvx(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stvx(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+  vec_stvxl(var_vec_b16[0], var_int[1], var_vec_b16_ptr[2]);
+  vec_stvxl(var_vec_b32[0], var_int[1], var_vec_b32_ptr[2]);
+  vec_stvxl(var_vec_b8[0], var_int[1], var_vec_b8_ptr[2]);
+  vec_stvxl(var_vec_f32[0], var_int[1], var_float_ptr[2]);
+  vec_stvxl(var_vec_f32[0], var_int[1], var_vec_f32_ptr[2]);
+  vec_stvxl(var_vec_p16[0], var_int[1], var_vec_p16_ptr[2]);
+  vec_stvxl(var_vec_s16[0], var_int[1], var_short_ptr[2]);
+  vec_stvxl(var_vec_s16[0], var_int[1], var_vec_s16_ptr[2]);
+  vec_stvxl(var_vec_s32[0], var_int[1], var_int_ptr[2]);
+  vec_stvxl(var_vec_s32[0], var_int[1], var_vec_s32_ptr[2]);
+  vec_stvxl(var_vec_s8[0], var_int[1], var_signed_char_ptr[2]);
+  vec_stvxl(var_vec_s8[0], var_int[1], var_vec_s8_ptr[2]);
+  vec_stvxl(var_vec_u16[0], var_int[1], var_unsigned_short_ptr[2]);
+  vec_stvxl(var_vec_u16[0], var_int[1], var_vec_u16_ptr[2]);
+  vec_stvxl(var_vec_u32[0], var_int[1], var_unsigned_int_ptr[2]);
+  vec_stvxl(var_vec_u32[0], var_int[1], var_vec_u32_ptr[2]);
+  vec_stvxl(var_vec_u8[0], var_int[1], var_unsigned_char_ptr[2]);
+  vec_stvxl(var_vec_u8[0], var_int[1], var_vec_u8_ptr[2]);
+}