From 1bc5aee63eb72b341f506ad058502cd0361f0d10 Mon Sep 17 00:00:00 2001 From: Ben Cheng Date: Tue, 25 Mar 2014 22:37:19 -0700 Subject: Initial checkin of GCC 4.9.0 from trunk (r208799). Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba --- gcc-4.9/gcc/testsuite/gcc.dg/vmx/ops.c | 3831 ++++++++++++++++++++++++++++++++ 1 file changed, 3831 insertions(+) create mode 100644 gcc-4.9/gcc/testsuite/gcc.dg/vmx/ops.c (limited to 'gcc-4.9/gcc/testsuite/gcc.dg/vmx/ops.c') diff --git a/gcc-4.9/gcc/testsuite/gcc.dg/vmx/ops.c b/gcc-4.9/gcc/testsuite/gcc.dg/vmx/ops.c new file mode 100644 index 0000000..b39ad1d --- /dev/null +++ b/gcc-4.9/gcc/testsuite/gcc.dg/vmx/ops.c @@ -0,0 +1,3831 @@ +/* { dg-do compile } */ +#include +#include +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]); +} -- cgit v1.1