Implement Altivec intrinsics

[lu-zero]

• fn vec_abs(vector_signed_char) -> vector_signed_char

• fn vec_abs(vector_signed_short) -> vector_signed_short

• fn vec_abs(vector_signed_int) -> vector_signed_int

• fn vec_abs(vector_float) -> vector_float

• fn vec_abss(vector_signed_char) -> vector_signed_char

• fn vec_abss(vector_signed_short) -> vector_signed_short

• fn vec_abss(vector_signed_int) -> vector_signed_int

• fn vec_add(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_add(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_add(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_add(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_add(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_add(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_add(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_add(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_add(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_add(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_add(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_add(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_add(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_add(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_add(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_add(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_add(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_add(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_add(vector_float, vector_float) -> vector_float

• fn vec_addc(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_adds(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_adds(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_adds(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_adds(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_adds(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_adds(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_adds(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_adds(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_adds(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_adds(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_adds(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_adds(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_adds(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_adds(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_adds(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_adds(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_adds(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_adds(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_and(vector_float, vector_float) -> vector_float

• fn vec_and(vector_float, vector_bool_int) -> vector_float

• fn vec_and(vector_bool_int, vector_float) -> vector_float

• fn vec_and(vector_bool_long_long_int, vector_bool_long_long) -> vector_bool_long_long

• fn vec_and(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_and(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_and(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_and(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_and(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_and(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_and(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_and(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_and(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_and(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_and(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_and(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_and(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_and(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_and(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_and(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_and(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_and(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_and(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_and(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_and(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_andc(vector_float, vector_float) -> vector_float

• fn vec_andc(vector_float, vector_bool_int) -> vector_float

• fn vec_andc(vector_bool_int, vector_float) -> vector_float

• fn vec_andc(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_andc(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_andc(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_andc(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_andc(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_andc(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_andc(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_andc(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_andc(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_andc(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_andc(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_andc(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_andc(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_andc(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_andc(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_andc(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_andc(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_andc(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_andc(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_andc(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_andc(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_avg(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_avg(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_avg(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_avg(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_avg(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_avg(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_copysign(vector_float) -> vector_float

• fn vec_ceil(vector_float) -> vector_float

• fn vec_cmpb(vector_float, vector_float) -> vector_signed_int

• fn vec_cmpeq(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_cmpeq(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_cmpeq(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_cmpeq(vector_signed_char, vector_signed_char) -> vector_bool_char

• fn vec_cmpeq(vector_unsigned_char, vector_unsigned_char) -> vector_bool_char

• fn vec_cmpeq(vector_signed_short, vector_signed_short) -> vector_bool_short

• fn vec_cmpeq(vector_unsigned_short, vector_unsigned_short) -> vector_bool_short

• fn vec_cmpeq(vector_signed_int, vector_signed_int) -> vector_bool_int

• fn vec_cmpeq(vector_unsigned_int, vector_unsigned_int) -> vector_bool_int

• fn vec_cmpeq(vector_float, vector_float) -> vector_bool_int

• fn vec_cmpge(vector_float, vector_float) -> vector_bool_int

• fn vec_cmpgt(vector_unsigned_char, vector_unsigned_char) -> vector_bool_char

• fn vec_cmpgt(vector_signed_char, vector_signed_char) -> vector_bool_char

• fn vec_cmpgt(vector_unsigned_short, vector_unsigned_short) -> vector_bool_short

• fn vec_cmpgt(vector_signed_short, vector_signed_short) -> vector_bool_short

• fn vec_cmpgt(vector_unsigned_int, vector_unsigned_int) -> vector_bool_int

• fn vec_cmpgt(vector_signed_int, vector_signed_int) -> vector_bool_int

• fn vec_cmpgt(vector_float, vector_float) -> vector_bool_int

• fn vec_cmple(vector_float, vector_float) -> vector_bool_int

• fn vec_cmplt(vector_unsigned_char, vector_unsigned_char) -> vector_bool_char

• fn vec_cmplt(vector_signed_char, vector_signed_char) -> vector_bool_char

• fn vec_cmplt(vector_unsigned_short, vector_unsigned_short) -> vector_bool_short

• fn vec_cmplt(vector_signed_short, vector_signed_short) -> vector_bool_short

• fn vec_cmplt(vector_unsigned_int, vector_unsigned_int) -> vector_bool_int

• fn vec_cmplt(vector_signed_int, vector_signed_int) -> vector_bool_int

• fn vec_cmplt(vector_float, vector_float) -> vector_bool_int

• fn vec_cpsgn(vector_float, vector_float) -> vector_float

The following require to have rust-lang/rust#61180 addressed

• fn vec_ctf(vector_unsigned_int, i32) -> vector_float
• fn vec_ctf(vector_signed_int, i32) -> vector_float
• fn vec_cts(vector_float, i32) -> vector_signed_int
• fn vec_ctu(vector_float, i32) -> vector_unsigned_int

The data stream functions had been deprecated since a long time ago, thus removed.

• fn vec_expte(vector_float) -> vector_float

• fn vec_floor(vector_float) -> vector_float

• fn vec_float(vector_signed_int) -> vector_float

• fn vec_float(vector_unsigned_int) -> vector_float

• fn vec_float2(vector_signed_long_long, vector_signed_long_long) -> vector_float

• fn vec_float2(vector_unsigned_long_long, vector_signed_long_long) -> vector_float

• fn vec_floate(vector_double) -> vector_float

• fn vec_floate(vector_signed_long_long) -> vector_float

• fn vec_floate(vector_unsigned_long_long) -> vector_float

• fn vec_floato(vector_double) -> vector_float

• fn vec_floato(vector_signed_long_long) -> vector_float

• fn vec_floato(vector_unsigned_long_long) -> vector_float

• fn vec_ld(&mut i32, &vector_float) -> vector_float

• fn vec_ld(&mut i32, &i32) -> vector_float

• fn vec_ld(&mut i32, &vector_bool_int) -> vector_bool_int

• fn vec_ld(&mut i32, &vector_signed_int) -> vector_signed_int

• fn vec_ld(&mut i32, &i32) -> vector_signed_int

• fn vec_ld(&mut i32, &i64) -> vector_signed_int

• fn vec_ld(&mut i32, &vector_unsigned_int) -> vector_unsigned_int

• fn vec_ld(&mut i32, &u32) -> vector_unsigned_int

• fn vec_ld(&mut i32, &u64) -> vector_unsigned_int

• fn vec_ld(&mut i32, &vector_bool_short) -> vector_bool_short

• fn vec_ld(&mut i32, &vector_pixel) -> vector_pixel

• fn vec_ld(&mut i32, &vector_signed_short) -> vector_signed_short

• fn vec_ld(&mut i32, &i16) -> vector_signed_short

• fn vec_ld(&mut i32, &vector_unsigned_short) -> vector_unsigned_short

• fn vec_ld(&mut i32, &u16) -> vector_unsigned_short

• fn vec_ld(&mut i32, &vector_bool_char) -> vector_bool_char

• fn vec_ld(&mut i32, &vector_signed_char) -> vector_signed_char

• fn vec_ld(&mut i32, &i8) -> vector_signed_char

• fn vec_ld(&mut i32, &vector_unsigned_char) -> vector_unsigned_char

• fn vec_ld(&mut i32, &u8) -> vector_unsigned_char

• fn vec_lde(&mut i32, &i8) -> vector_signed_char

• fn vec_lde(&mut i32, &u8) -> vector_unsigned_char

• fn vec_lde(&mut i32, &i16) -> vector_signed_short

• fn vec_lde(&mut i32, &u16) -> vector_unsigned_short

• fn vec_lde(&mut i32, &i32) -> vector_float

• fn vec_lde(&mut i32, &i32) -> vector_signed_int

• fn vec_lde(&mut i32, &u32) -> vector_unsigned_int

• fn vec_lde(&mut i32, &i64) -> vector_signed_int

• fn vec_lde(&mut i32, &u64) -> vector_unsigned_int

• fn vec_ldl(&mut i32, &vector_float) -> vector_float

• fn vec_ldl(&mut i32, &i32) -> vector_float

• fn vec_ldl(&mut i32, &vector_bool_int) -> vector_bool_int

• fn vec_ldl(&mut i32, &vector_signed_int) -> vector_signed_int

• fn vec_ldl(&mut i32, &i32) -> vector_signed_int

• fn vec_ldl(&mut i32, &i64) -> vector_signed_int

• fn vec_ldl(&mut i32, &vector_unsigned_int) -> vector_unsigned_int

• fn vec_ldl(&mut i32, &u32) -> vector_unsigned_int

• fn vec_ldl(&mut i32, &u64) -> vector_unsigned_int

• fn vec_ldl(&mut i32, &vector_bool_short) -> vector_bool_short

• fn vec_ldl(&mut i32, &vector_pixel) -> vector_pixel

• fn vec_ldl(&mut i32, &vector_signed_short) -> vector_signed_short

• fn vec_ldl(&mut i32, &i16) -> vector_signed_short

• fn vec_ldl(&mut i32, &vector_unsigned_short) -> vector_unsigned_short

• fn vec_ldl(&mut i32, &u16) -> vector_unsigned_short

• fn vec_ldl(&mut i32, &vector_bool_char) -> vector_bool_char

• fn vec_ldl(&mut i32, &vector_signed_char) -> vector_signed_char

• fn vec_ldl(&mut i32, &i8) -> vector_signed_char

• fn vec_ldl(&mut i32, &vector_unsigned_char) -> vector_unsigned_char

• fn vec_ldl(&mut i32, &u8) -> vector_unsigned_char

• fn vec_loge(vector_float) -> vector_float

• fn vec_madd(vector_float, vector_float, vector_float) -> vector_float

• fn vec_madds(vector_signed_short, vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_max(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_max(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_max(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_max(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_max(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_max(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_max(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_max(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_max(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_max(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_max(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_max(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_max(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_max(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_max(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_max(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_max(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_max(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_max(vector_float, vector_float) -> vector_float

• fn vec_mergeh(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_mergeh(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_mergeh(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_mergeh(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_mergeh(vector_pixel, vector_pixel) -> vector_pixel

• fn vec_mergeh(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_mergeh(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_mergeh(vector_float, vector_float) -> vector_float

• fn vec_mergeh(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_mergeh(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_mergeh(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_mergel(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_mergel(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_mergel(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_mergel(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_mergel(vector_pixel, vector_pixel) -> vector_pixel

• fn vec_mergel(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_mergel(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_mergel(vector_float, vector_float) -> vector_float

• fn vec_mergel(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_mergel(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_mergel(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_mfvscr(()) -> vector_unsigned_short

• fn vec_min(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_min(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_min(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_min(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_min(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_min(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_min(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_min(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_min(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_min(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_min(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_min(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_min(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_min(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_min(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_min(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_min(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_min(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_min(vector_float, vector_float) -> vector_float

• fn vec_mladd(vector_signed_short, vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_mladd(vector_signed_short, vector_unsigned_short, vector_unsigned_short) -> vector_signed_short

• fn vec_mladd(vector_unsigned_short, vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_mladd(vector_unsigned_short, vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_mradds(vector_signed_short, vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_msum(vector_unsigned_char, vector_unsigned_char, vector_unsigned_int) -> vector_unsigned_int

• fn vec_msum(vector_signed_char, vector_unsigned_char, vector_signed_int) -> vector_signed_int

• fn vec_msum(vector_unsigned_short, vector_unsigned_short, vector_unsigned_int) -> vector_unsigned_int

• fn vec_msum(vector_signed_short, vector_signed_short, vector_signed_int) -> vector_signed_int

• fn vec_msums(vector_unsigned_short, vector_unsigned_short, vector_unsigned_int) -> vector_unsigned_int

• fn vec_msums(vector_signed_short, vector_signed_short, vector_signed_int) -> vector_signed_int

• fn vec_mtvscr(vector_signed_int) -> ()

• fn vec_mtvscr(vector_unsigned_int) -> ()

• fn vec_mtvscr(vector_bool_int) -> ()

• fn vec_mtvscr(vector_signed_short) -> ()

• fn vec_mtvscr(vector_unsigned_short) -> ()

• fn vec_mtvscr(vector_bool_short) -> ()

• fn vec_mtvscr(vector_pixel) -> ()

• fn vec_mtvscr(vector_signed_char) -> ()

• fn vec_mtvscr(vector_unsigned_char) -> ()

• fn vec_mtvscr(vector_bool_char) -> ()

• fn vec_mule(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_short

• fn vec_mule(vector_signed_char, vector_signed_char) -> vector_signed_short

• fn vec_mule(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_int

• fn vec_mule(vector_signed_short, vector_signed_short) -> vector_signed_int

• fn vec_mule(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_long_long

• fn vec_mule(vector_signed_int, vector_signed_int) -> vector_signed_long_long

• fn vec_mulo(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_short

• fn vec_mulo(vector_signed_char, vector_signed_char) -> vector_signed_short

• fn vec_mulo(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_int

• fn vec_mulo(vector_signed_short, vector_signed_short) -> vector_signed_int

• fn vec_mulo(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_long_long

• fn vec_mulo(vector_signed_int, vector_signed_int) -> vector_signed_long_long

• fn vec_nmsub(vector_float, vector_float, vector_float) -> vector_float

• fn vec_nabs(vector_signed_char) -> vector_signed_char

• fn vec_nabs(vector_signed_short) -> vector_signed_short

• fn vec_nabs(vector_signed_int) -> vector_signed_int

• fn vec_nabs(vector_float) -> vector_float

• fn vec_nabs(vector_double) -> vector_double

• fn vec_neg(vector_signed_char) -> vector_signed_char

• fn vec_neg(vector_signed_short) -> vector_signed_short

• fn vec_neg(vector_signed_int) -> vector_signed_int

• fn vec_neg(vector_signed_long_long) -> vector_signed_long_long

• fn vec_neg(vector_float) -> vector_float_char

• fn vec_neg(vector_double) -> vector_double

• fn vec_nor(vector_float, vector_float) -> vector_float

• fn vec_nor(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_nor(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_nor(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_nor(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_nor(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_nor(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_nor(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_nor(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_nor(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_or(vector_float, vector_float) -> vector_float

• fn vec_or(vector_float, vector_bool_int) -> vector_float

• fn vec_or(vector_bool_int, vector_float) -> vector_float

• fn vec_or(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_or(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_or(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_or(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_or(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_or(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_or(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_or(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_or(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_or(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_or(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_or(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_or(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_or(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_or(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_or(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_or(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_or(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_or(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_or(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_or(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_pack(vector_signed_short, vector_signed_short) -> vector_signed_char

• fn vec_pack(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_char

• fn vec_pack(vector_bool_short, vector_bool_short) -> vector_bool_char

• fn vec_pack(vector_signed_int, vector_signed_int) -> vector_signed_short

• fn vec_pack(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_short

• fn vec_pack(vector_bool_int, vector_bool_int) -> vector_bool_short

• fn vec_packpx(vector_unsigned_int, vector_unsigned_int) -> vector_pixel

• fn vec_packs(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_char

• fn vec_packs(vector_signed_short, vector_signed_short) -> vector_signed_char

• fn vec_packs(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_short

• fn vec_packs(vector_signed_int, vector_signed_int) -> vector_signed_short

• fn vec_packsu(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_char

• fn vec_packsu(vector_signed_short, vector_signed_short) -> vector_unsigned_char

• fn vec_packsu(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_short

• fn vec_packsu(vector_signed_int, vector_signed_int) -> vector_unsigned_short

• fn vec_perm(vector_float, vector_float, vector_unsigned_char) -> vector_float

• fn vec_perm(vector_signed_int, vector_signed_int, vector_unsigned_char) -> vector_signed_int

• fn vec_perm(vector_unsigned_int, vector_unsigned_int, vector_unsigned_char) -> vector_unsigned_int

• fn vec_perm(vector_bool_int, vector_bool_int, vector_unsigned_char) -> vector_bool_int

• fn vec_perm(vector_signed_short, vector_signed_short, vector_unsigned_char) -> vector_signed_short

• fn vec_perm(vector_unsigned_short, vector_unsigned_short, vector_unsigned_char) -> vector_unsigned_short

• fn vec_perm(vector_bool_short, vector_bool_short, vector_unsigned_char) -> vector_bool_short

• fn vec_perm(vector_pixel, vector_pixel, vector_unsigned_char) -> vector_pixel

• fn vec_perm(vector_signed_char, vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_perm(vector_unsigned_char, vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_perm(vector_bool_char, vector_bool_char, vector_unsigned_char) -> vector_bool_char

• fn vec_re(vector_float) -> vector_float

• fn vec_reve(vector_bool_char) -> vector_bool_char

• fn vec_reve(vector_signed_char) -> vector_signed_char

• fn vec_reve(vector_unsigned_char) -> vector_unsigned_char

• fn vec_reve(vector_bool_int) -> vector_bool_int

• fn vec_reve(vector_signed_int) -> vector_signed_int

• fn vec_reve(vector_unsigned_int) -> vector_unsigned_int

• fn vec_reve(vector_bool_long_long) -> vector_bool_long_long

• fn vec_reve(vector_signed_long_long) -> vector_signed_long_long

• fn vec_reve(vector_unsigned_long_long) -> vector_unsigned_long_long

• fn vec_reve(vector_bool_short) -> vector_bool_short

• fn vec_reve(vector_signed_short) -> vector_signed_short

• fn vec_reve(vector_unsigned_short) -> vector_unsigned_short

• fn vec_rl(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_rl(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_rl(vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_rl(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_rl(vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_rl(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_round(vector_float) -> vector_float

• fn vec_recip(vector_float, vector_float) -> vector_float

• fn vec_rsqrt(vector_float) -> vector_float

• fn vec_rsqrte(vector_float) -> vector_float

• fn vec_sel(vector_float, vector_float, vector_bool_int) -> vector_float

• fn vec_sel(vector_float, vector_float, vector_unsigned_int) -> vector_float

• fn vec_sel(vector_signed_int, vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_sel(vector_signed_int, vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_sel(vector_unsigned_int, vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_sel(vector_unsigned_int, vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sel(vector_bool_int, vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_sel(vector_bool_int, vector_bool_int, vector_unsigned_int) -> vector_bool_int

• fn vec_sel(vector_signed_short, vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_sel(vector_signed_short, vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_sel(vector_unsigned_short, vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_sel(vector_unsigned_short, vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sel(vector_bool_short, vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_sel(vector_bool_short, vector_bool_short, vector_unsigned_short) -> vector_bool_short

• fn vec_sel(vector_signed_char, vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_sel(vector_signed_char, vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_sel(vector_unsigned_char, vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_sel(vector_unsigned_char, vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sel(vector_bool_char, vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_sel(vector_bool_char, vector_bool_char, vector_unsigned_char) -> vector_bool_char

• fn vec_signed(vector_double) -> vector_signed_long_long

• fn vec_signed(vector_float) -> vector_signed_int

• fn vec_signede(vector_double) -> vector_signed_int

• fn vec_signedo(vector_double) -> vector_signed_int

• fn vec_signed2(vector_double, vector_double) -> vector_signed_int

• fn vec_sl(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_sl(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sl(vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_sl(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sl(vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_sl(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sld(vector_float, vector_float, i32) -> vector_float

• fn vec_sld(vector_double, vector_double, i32) -> vector_double

• fn vec_sld(vector_signed_int, vector_signed_int, i32) -> vector_signed_int

• fn vec_sld(vector_unsigned_int, vector_unsigned_int, i32) -> vector_unsigned_int

• fn vec_sld(vector_bool_int, vector_bool_int, i32) -> vector_bool_int

• fn vec_sld(vector_signed_short, vector_signed_short, i32) -> vector_signed_short

• fn vec_sld(vector_unsigned_short, vector_unsigned_short, i32) -> vector_unsigned_short

• fn vec_sld(vector_bool_short, vector_bool_short, i32) -> vector_bool_short

• fn vec_sld(vector_pixel, vector_pixel, i32) -> vector_pixel

• fn vec_sld(vector_signed_char, vector_signed_char, i32) -> vector_signed_char

• fn vec_sld(vector_unsigned_char, vector_unsigned_char, i32) -> vector_unsigned_char

• fn vec_sld(vector_bool_char, vector_bool_char, i32) -> vector_bool_char

• fn vec_sldw(vector_signed_char, vector_signed_char, i32) -> vector_signed_char

• fn vec_sldw(vector_unsigned_char, vector_unsigned_char, i32) -> vector_unsigned_char

• fn vec_sldw(vector_signed_short, vector_signed_short, i32) -> vector_signed_short

• fn vec_sldw(vector_unsigned_short, vector_unsigned_short, i32) -> vector_unsigned_short

• fn vec_sldw(vector_signed_int, vector_signed_int, i32) -> vector_signed_int

• fn vec_sldw(vector_unsigned_int, vector_unsigned_int, i32) -> vector_unsigned_int

• fn vec_sll(vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_sll(vector_signed_int, vector_unsigned_short) -> vector_signed_int

• fn vec_sll(vector_signed_int, vector_unsigned_char) -> vector_signed_int

• fn vec_sll(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sll(vector_unsigned_int, vector_unsigned_short) -> vector_unsigned_int

• fn vec_sll(vector_unsigned_int, vector_unsigned_char) -> vector_unsigned_int

• fn vec_sll(vector_bool_int, vector_unsigned_int) -> vector_bool_int

• fn vec_sll(vector_bool_int, vector_unsigned_short) -> vector_bool_int

• fn vec_sll(vector_bool_int, vector_unsigned_char) -> vector_bool_int

• fn vec_sll(vector_signed_short, vector_unsigned_int) -> vector_signed_short

• fn vec_sll(vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_sll(vector_signed_short, vector_unsigned_char) -> vector_signed_short

• fn vec_sll(vector_unsigned_short, vector_unsigned_int) -> vector_unsigned_short

• fn vec_sll(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sll(vector_unsigned_short, vector_unsigned_char) -> vector_unsigned_short

• fn vec_sll(vector_long_long_int, vector_unsigned_char) -> vector_long_long_int

• fn vec_sll(vector_unsigned_long_long_int, vector_unsigned_char) -> vector_unsigned_long_long_int

• fn vec_sll(vector_bool_short, vector_unsigned_int) -> vector_bool_short

• fn vec_sll(vector_bool_short, vector_unsigned_short) -> vector_bool_short

• fn vec_sll(vector_bool_short, vector_unsigned_char) -> vector_bool_short

• fn vec_sll(vector_pixel, vector_unsigned_int) -> vector_pixel

• fn vec_sll(vector_pixel, vector_unsigned_short) -> vector_pixel

• fn vec_sll(vector_pixel, vector_unsigned_char) -> vector_pixel

• fn vec_sll(vector_signed_char, vector_unsigned_int) -> vector_signed_char

• fn vec_sll(vector_signed_char, vector_unsigned_short) -> vector_signed_char

• fn vec_sll(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_sll(vector_unsigned_char, vector_unsigned_int) -> vector_unsigned_char

• fn vec_sll(vector_unsigned_char, vector_unsigned_short) -> vector_unsigned_char

• fn vec_sll(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sll(vector_bool_char, vector_unsigned_int) -> vector_bool_char

• fn vec_sll(vector_bool_char, vector_unsigned_short) -> vector_bool_char

• fn vec_sll(vector_bool_char, vector_unsigned_char) -> vector_bool_char

• fn vec_slo(vector_float, vector_signed_char) -> vector_float

• fn vec_slo(vector_float, vector_unsigned_char) -> vector_float

• fn vec_slo(vector_signed_int, vector_signed_char) -> vector_signed_int

• fn vec_slo(vector_signed_int, vector_unsigned_char) -> vector_signed_int

• fn vec_slo(vector_unsigned_int, vector_signed_char) -> vector_unsigned_int

• fn vec_slo(vector_unsigned_int, vector_unsigned_char) -> vector_unsigned_int

• fn vec_slo(vector_signed_short, vector_signed_char) -> vector_signed_short

• fn vec_slo(vector_signed_short, vector_unsigned_char) -> vector_signed_short

• fn vec_slo(vector_unsigned_short, vector_signed_char) -> vector_unsigned_short

• fn vec_slo(vector_unsigned_short, vector_unsigned_char) -> vector_unsigned_short

• fn vec_slo(vector_pixel, vector_signed_char) -> vector_pixel

• fn vec_slo(vector_pixel, vector_unsigned_char) -> vector_pixel

• fn vec_slo(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_slo(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_slo(vector_unsigned_char, vector_signed_char) -> vector_unsigned_char

• fn vec_slo(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_slo(vector_signed_long_long, vector_signed_char) -> vector_signed_long_long

• fn vec_slo(vector_signed_long_long, vector_unsigned_char) -> vector_signed_long_long

• fn vec_slo(vector_unsigned_long_long, vector_signed_char) -> vector_unsigned_long_long

• fn vec_slo(vector_unsigned_long_long, vector_unsigned_char) -> vector_unsigned_long_long

• fn vec_splat(vector_signed_char, i32) -> vector_signed_char

• fn vec_splat(vector_unsigned_char, i32) -> vector_unsigned_char

• fn vec_splat(vector_bool_char, i32) -> vector_bool_char

• fn vec_splat(vector_signed_short, i32) -> vector_signed_short

• fn vec_splat(vector_unsigned_short, i32) -> vector_unsigned_short

• fn vec_splat(vector_bool_short, i32) -> vector_bool_short

• fn vec_splat(vector_pixel, i32) -> vector_pixel

• fn vec_splat(vector_float, i32) -> vector_float

• fn vec_splat(vector_signed_int, i32) -> vector_signed_int

• fn vec_splat(vector_unsigned_int, i32) -> vector_unsigned_int

• fn vec_splat(vector_bool_int, i32) -> vector_bool_int

• fn vec_splat(vector_signed_long, i32) -> vector_signed_long

• fn vec_splat(vector_unsigned_long, i32) -> vector_unsigned_long

• fn vec_splats(i8) -> vector_signed_char

• fn vec_splats(u8) -> vector_unsigned_char

• fn vec_splats(i16) -> vector_signed_short

• fn vec_splats(u16) -> vector_unsigned_short

• fn vec_splats(i32) -> vector_signed_int

• fn vec_splats(u32) -> vector_unsigned_int

• fn vec_splats(f32) -> vector_float

• fn vec_splat_s8(i32) -> vector_signed_char

• fn vec_splat_s16(i32) -> vector_signed_short

• fn vec_splat_s32(i32) -> vector_signed_int

• fn vec_splat_u8(i32) -> vector_unsigned_char

• fn vec_splat_u16(i32) -> vector_unsigned_short

• fn vec_splat_u32(i32) -> vector_unsigned_int

• fn vec_sr(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_sr(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sr(vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_sr(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sr(vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_sr(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sra(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_sra(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sra(vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_sra(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sra(vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_sra(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_srl(vector_signed_int, vector_unsigned_int) -> vector_signed_int

• fn vec_srl(vector_signed_int, vector_unsigned_short) -> vector_signed_int

• fn vec_srl(vector_signed_int, vector_unsigned_char) -> vector_signed_int

• fn vec_srl(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_srl(vector_unsigned_int, vector_unsigned_short) -> vector_unsigned_int

• fn vec_srl(vector_unsigned_int, vector_unsigned_char) -> vector_unsigned_int

• fn vec_srl(vector_bool_int, vector_unsigned_int) -> vector_bool_int

• fn vec_srl(vector_bool_int, vector_unsigned_short) -> vector_bool_int

• fn vec_srl(vector_bool_int, vector_unsigned_char) -> vector_bool_int

• fn vec_srl(vector_signed_short, vector_unsigned_int) -> vector_signed_short

• fn vec_srl(vector_signed_short, vector_unsigned_short) -> vector_signed_short

• fn vec_srl(vector_signed_short, vector_unsigned_char) -> vector_signed_short

• fn vec_srl(vector_unsigned_short, vector_unsigned_int) -> vector_unsigned_short

• fn vec_srl(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_srl(vector_unsigned_short, vector_unsigned_char) -> vector_unsigned_short

• fn vec_srl(vector_long_long_int, vector_unsigned_char) -> vector_long_long_int

• fn vec_srl(vector_unsigned_long_long_int, vector_unsigned_char) -> vector_unsigned_long_long_int

• fn vec_srl(vector_bool_short, vector_unsigned_int) -> vector_bool_short

• fn vec_srl(vector_bool_short, vector_unsigned_short) -> vector_bool_short

• fn vec_srl(vector_bool_short, vector_unsigned_char) -> vector_bool_short

• fn vec_srl(vector_pixel, vector_unsigned_int) -> vector_pixel

• fn vec_srl(vector_pixel, vector_unsigned_short) -> vector_pixel

• fn vec_srl(vector_pixel, vector_unsigned_char) -> vector_pixel

• fn vec_srl(vector_signed_char, vector_unsigned_int) -> vector_signed_char

• fn vec_srl(vector_signed_char, vector_unsigned_short) -> vector_signed_char

• fn vec_srl(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_srl(vector_unsigned_char, vector_unsigned_int) -> vector_unsigned_char

• fn vec_srl(vector_unsigned_char, vector_unsigned_short) -> vector_unsigned_char

• fn vec_srl(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_srl(vector_bool_char, vector_unsigned_int) -> vector_bool_char

• fn vec_srl(vector_bool_char, vector_unsigned_short) -> vector_bool_char

• fn vec_srl(vector_bool_char, vector_unsigned_char) -> vector_bool_char

• fn vec_sro(vector_float, vector_signed_char) -> vector_float

• fn vec_sro(vector_float, vector_unsigned_char) -> vector_float

• fn vec_sro(vector_signed_int, vector_signed_char) -> vector_signed_int

• fn vec_sro(vector_signed_int, vector_unsigned_char) -> vector_signed_int

• fn vec_sro(vector_unsigned_int, vector_signed_char) -> vector_unsigned_int

• fn vec_sro(vector_unsigned_int, vector_unsigned_char) -> vector_unsigned_int

• fn vec_sro(vector_signed_short, vector_signed_char) -> vector_signed_short

• fn vec_sro(vector_signed_short, vector_unsigned_char) -> vector_signed_short

• fn vec_sro(vector_unsigned_short, vector_signed_char) -> vector_unsigned_short

• fn vec_sro(vector_unsigned_short, vector_unsigned_char) -> vector_unsigned_short

• fn vec_sro(vector_long_long_int, vector_char) -> vector_long_long_int

• fn vec_sro(vector_long_long_int, vector_unsigned_char) -> vector_long_long_int

• fn vec_sro(vector_unsigned_long_long_int, vector_char) -> vector_unsigned_long_long_int

• fn vec_sro(vector_unsigned_long_long_int, vector_unsigned_char) -> vector_unsigned_long_long_int

• fn vec_sro(vector_pixel, vector_signed_char) -> vector_pixel

• fn vec_sro(vector_pixel, vector_unsigned_char) -> vector_pixel

• fn vec_sro(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_sro(vector_signed_char, vector_unsigned_char) -> vector_signed_char

• fn vec_sro(vector_unsigned_char, vector_signed_char) -> vector_unsigned_char

• fn vec_sro(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_st(vector_float, &mut i32, vector_float) -> ()

• fn vec_st(vector_float, &mut i32, &mut i32) -> ()

• fn vec_st(vector_signed_int, &mut i32, vector_signed_int) -> ()

• fn vec_st(vector_signed_int, &mut i32, &mut i32) -> ()

• fn vec_st(vector_unsigned_int, &mut i32, vector_unsigned_int) -> ()

• fn vec_st(vector_unsigned_int, &mut i32, &mut u32) -> ()

• fn vec_st(vector_bool_int, &mut i32, vector_bool_int) -> ()

• fn vec_st(vector_bool_int, &mut i32, &mut u32) -> ()

• fn vec_st(vector_bool_int, &mut i32, &mut i32) -> ()

• fn vec_st(vector_signed_short, &mut i32, vector_signed_short) -> ()

• fn vec_st(vector_signed_short, &mut i32, &mut i16) -> ()

• fn vec_st(vector_unsigned_short, &mut i32, vector_unsigned_short) -> ()

• fn vec_st(vector_unsigned_short, &mut i32, &mut u16) -> ()

• fn vec_st(vector_bool_short, &mut i32, vector_bool_short) -> ()

• fn vec_st(vector_bool_short, &mut i32, &mut u16) -> ()

• fn vec_st(vector_pixel, &mut i32, vector_pixel) -> ()

• fn vec_st(vector_pixel, &mut i32, &mut u16) -> ()

• fn vec_st(vector_pixel, &mut i32, &mut i16) -> ()

• fn vec_st(vector_bool_short, &mut i32, &mut i16) -> ()

• fn vec_st(vector_signed_char, &mut i32, vector_signed_char) -> ()

• fn vec_st(vector_signed_char, &mut i32, &mut i8) -> ()

• fn vec_st(vector_unsigned_char, &mut i32, vector_unsigned_char) -> ()

• fn vec_st(vector_unsigned_char, &mut i32, &mut u8) -> ()

• fn vec_st(vector_bool_char, &mut i32, vector_bool_char) -> ()

• fn vec_st(vector_bool_char, &mut i32, &mut u8) -> ()

• fn vec_st(vector_bool_char, &mut i32, &mut i8) -> ()

• fn vec_ste(vector_signed_char, &mut i32, &mut i8) -> ()

• fn vec_ste(vector_unsigned_char, &mut i32, &mut u8) -> ()

• fn vec_ste(vector_bool_char, &mut i32, &mut i8) -> ()

• fn vec_ste(vector_bool_char, &mut i32, &mut u8) -> ()

• fn vec_ste(vector_signed_short, &mut i32, &mut i16) -> ()

• fn vec_ste(vector_unsigned_short, &mut i32, &mut u16) -> ()

• fn vec_ste(vector_bool_short, &mut i32, &mut i16) -> ()

• fn vec_ste(vector_bool_short, &mut i32, &mut u16) -> ()

• fn vec_ste(vector_pixel, &mut i32, &mut i16) -> ()

• fn vec_ste(vector_pixel, &mut i32, &mut u16) -> ()

• fn vec_ste(vector_float, &mut i32, &mut i32) -> ()

• fn vec_ste(vector_signed_int, &mut i32, &mut i32) -> ()

• fn vec_ste(vector_unsigned_int, &mut i32, &mut u32) -> ()

• fn vec_ste(vector_bool_int, &mut i32, &mut i32) -> ()

• fn vec_ste(vector_bool_int, &mut i32, &mut u32) -> ()

• fn vec_stvewx(vector_float, &mut i32, &mut i32) -> ()

• fn vec_stvewx(vector_signed_int, &mut i32, &mut i32) -> ()

• fn vec_stvewx(vector_unsigned_int, &mut i32, &mut u32) -> ()

• fn vec_stvewx(vector_bool_int, &mut i32, &mut i32) -> ()

• fn vec_stvewx(vector_bool_int, &mut i32, &mut u32) -> ()

• fn vec_stvehx(vector_signed_short, &mut i32, &mut i16) -> ()

• fn vec_stvehx(vector_unsigned_short, &mut i32, &mut u16) -> ()

• fn vec_stvehx(vector_bool_short, &mut i32, &mut i16) -> ()

• fn vec_stvehx(vector_bool_short, &mut i32, &mut u16) -> ()

• fn vec_stvehx(vector_pixel, &mut i32, &mut i16) -> ()

• fn vec_stvehx(vector_pixel, &mut i32, &mut u16) -> ()

• fn vec_stvebx(vector_signed_char, &mut i32, &mut i8) -> ()

• fn vec_stvebx(vector_unsigned_char, &mut i32, &mut u8) -> ()

• fn vec_stvebx(vector_bool_char, &mut i32, &mut i8) -> ()

• fn vec_stvebx(vector_bool_char, &mut i32, &mut u8) -> ()

• fn vec_stl(vector_float, &mut i32, vector_float) -> ()

• fn vec_stl(vector_float, &mut i32, &mut i32) -> ()

• fn vec_stl(vector_signed_int, &mut i32, vector_signed_int) -> ()

• fn vec_stl(vector_signed_int, &mut i32, &mut i32) -> ()

• fn vec_stl(vector_unsigned_int, &mut i32, vector_unsigned_int) -> ()

• fn vec_stl(vector_unsigned_int, &mut i32, &mut u32) -> ()

• fn vec_stl(vector_bool_int, &mut i32, vector_bool_int) -> ()

• fn vec_stl(vector_bool_int, &mut i32, &mut u32) -> ()

• fn vec_stl(vector_bool_int, &mut i32, &mut i32) -> ()

• fn vec_stl(vector_signed_short, &mut i32, vector_signed_short) -> ()

• fn vec_stl(vector_signed_short, &mut i32, &mut i16) -> ()

• fn vec_stl(vector_unsigned_short, &mut i32, vector_unsigned_short) -> ()

• fn vec_stl(vector_unsigned_short, &mut i32, &mut u16) -> ()

• fn vec_stl(vector_bool_short, &mut i32, vector_bool_short) -> ()

• fn vec_stl(vector_bool_short, &mut i32, &mut u16) -> ()

• fn vec_stl(vector_bool_short, &mut i32, &mut i16) -> ()

• fn vec_stl(vector_pixel, &mut i32, vector_pixel) -> ()

• fn vec_stl(vector_pixel, &mut i32, &mut u16) -> ()

• fn vec_stl(vector_pixel, &mut i32, &mut i16) -> ()

• fn vec_stl(vector_signed_char, &mut i32, vector_signed_char) -> ()

• fn vec_stl(vector_signed_char, &mut i32, &mut i8) -> ()

• fn vec_stl(vector_unsigned_char, &mut i32, vector_unsigned_char) -> ()

• fn vec_stl(vector_unsigned_char, &mut i32, &mut u8) -> ()

• fn vec_stl(vector_bool_char, &mut i32, vector_bool_char) -> ()

• fn vec_stl(vector_bool_char, &mut i32, &mut u8) -> ()

• fn vec_stl(vector_bool_char, &mut i32, &mut i8) -> ()

• fn vec_sub(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_sub(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_sub(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_sub(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sub(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_sub(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_sub(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_sub(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_sub(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_sub(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sub(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_sub(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_sub(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_sub(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_sub(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_sub(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sub(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_sub(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sub(vector_float, vector_float) -> vector_float

• fn vec_subc(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_subc(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_subc(vector_signed___int128, vector_signed___int128) -> vector_signed___int128

• fn vec_subc(vector_unsigned___int128, vector_unsigned___int128) -> vector_unsigned___int128

• fn vec_sube(vector_signed_int, vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_sube(vector_unsigned_int, vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sube(vector_signed___int128, vector_signed___int128, vector_signed___int128) -> vector_signed___int128

• fn vec_sube(vector_unsigned___int128, vector_unsigned___int128, vector_unsigned___int128) -> vector_unsigned___int128

• fn vec_subec(vector_signed_int, vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_subec(vector_unsigned_int, vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_subec(vector_signed___int128, vector_signed___int128, vector_signed___int128) -> vector_signed___int128

• fn vec_subec(vector_unsigned___int128, vector_unsigned___int128, vector_unsigned___int128) -> vector_unsigned___int128

• fn vec_subs(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_subs(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_subs(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_subs(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_subs(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_subs(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_subs(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_subs(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_subs(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_subs(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_subs(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_subs(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_subs(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_subs(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_subs(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_subs(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_subs(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_subs(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_sum4s(vector_unsigned_char, vector_unsigned_int) -> vector_unsigned_int

• fn vec_sum4s(vector_signed_char, vector_signed_int) -> vector_signed_int

• fn vec_sum4s(vector_signed_short, vector_signed_int) -> vector_signed_int

• fn vec_sum2s(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_sums(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_trunc(vector_float) -> vector_float

• fn vec_unpackh(vector_signed_char) -> vector_signed_short

• fn vec_unpackh(vector_bool_char) -> vector_bool_short

• fn vec_unpackh(vector_signed_short) -> vector_signed_int

• fn vec_unpackh(vector_bool_short) -> vector_bool_int

• fn vec_unpackh(vector_pixel) -> vector_unsigned_int

• fn vec_unpackh(vector_float) -> vector_double

• fn vec_unpackl(vector_signed_char) -> vector_signed_short

• fn vec_unpackl(vector_bool_char) -> vector_bool_short

• fn vec_unpackl(vector_pixel) -> vector_unsigned_int

• fn vec_unpackl(vector_signed_short) -> vector_signed_int

• fn vec_unpackl(vector_bool_short) -> vector_bool_int

• fn vec_unpackl(vector_float) -> vector_double

• fn vec_xor(vector_float, vector_float) -> vector_float

• fn vec_xor(vector_float, vector_bool_int) -> vector_float

• fn vec_xor(vector_bool_int, vector_float) -> vector_float

• fn vec_xor(vector_bool_int, vector_bool_int) -> vector_bool_int

• fn vec_xor(vector_bool_int, vector_signed_int) -> vector_signed_int

• fn vec_xor(vector_signed_int, vector_bool_int) -> vector_signed_int

• fn vec_xor(vector_signed_int, vector_signed_int) -> vector_signed_int

• fn vec_xor(vector_bool_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_xor(vector_unsigned_int, vector_bool_int) -> vector_unsigned_int

• fn vec_xor(vector_unsigned_int, vector_unsigned_int) -> vector_unsigned_int

• fn vec_xor(vector_bool_short, vector_bool_short) -> vector_bool_short

• fn vec_xor(vector_bool_short, vector_signed_short) -> vector_signed_short

• fn vec_xor(vector_signed_short, vector_bool_short) -> vector_signed_short

• fn vec_xor(vector_signed_short, vector_signed_short) -> vector_signed_short

• fn vec_xor(vector_bool_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_xor(vector_unsigned_short, vector_bool_short) -> vector_unsigned_short

• fn vec_xor(vector_unsigned_short, vector_unsigned_short) -> vector_unsigned_short

• fn vec_xor(vector_bool_char, vector_signed_char) -> vector_signed_char

• fn vec_xor(vector_bool_char, vector_bool_char) -> vector_bool_char

• fn vec_xor(vector_signed_char, vector_bool_char) -> vector_signed_char

• fn vec_xor(vector_signed_char, vector_signed_char) -> vector_signed_char

• fn vec_xor(vector_bool_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_xor(vector_unsigned_char, vector_bool_char) -> vector_unsigned_char

• fn vec_xor(vector_unsigned_char, vector_unsigned_char) -> vector_unsigned_char

• fn vec_all_eq(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_all_eq(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_all_eq(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_all_eq(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_all_eq(vector_bool_char, vector_bool_char) -> &mut i32

• fn vec_all_eq(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_all_eq(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_all_eq(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_all_eq(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_all_eq(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_all_eq(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_all_eq(vector_bool_short, vector_bool_short) -> &mut i32

• fn vec_all_eq(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_all_eq(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_all_eq(vector_pixel, vector_pixel) -> &mut i32

• fn vec_all_eq(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_all_eq(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_all_eq(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_all_eq(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_all_eq(vector_bool_int, vector_bool_int) -> &mut i32

• fn vec_all_eq(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_all_eq(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_all_eq(vector_float, vector_float) -> &mut i32

• fn vec_all_ge(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_all_ge(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_all_ge(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_all_ge(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_all_ge(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_all_ge(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_all_ge(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_all_ge(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_all_ge(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_all_ge(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_all_ge(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_all_ge(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_all_ge(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_all_ge(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_all_ge(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_all_ge(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_all_ge(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_all_ge(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_all_ge(vector_float, vector_float) -> &mut i32

• fn vec_all_gt(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_all_gt(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_all_gt(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_all_gt(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_all_gt(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_all_gt(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_all_gt(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_all_gt(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_all_gt(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_all_gt(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_all_gt(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_all_gt(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_all_gt(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_all_gt(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_all_gt(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_all_gt(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_all_gt(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_all_gt(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_all_gt(vector_float, vector_float) -> &mut i32

• fn vec_all_in(vector_float, vector_float) -> &mut i32

• fn vec_all_le(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_all_le(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_all_le(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_all_le(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_all_le(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_all_le(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_all_le(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_all_le(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_all_le(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_all_le(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_all_le(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_all_le(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_all_le(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_all_le(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_all_le(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_all_le(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_all_le(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_all_le(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_all_le(vector_float, vector_float) -> &mut i32

• fn vec_all_lt(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_all_lt(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_all_lt(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_all_lt(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_all_lt(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_all_lt(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_all_lt(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_all_lt(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_all_lt(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_all_lt(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_all_lt(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_all_lt(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_all_lt(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_all_lt(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_all_lt(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_all_lt(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_all_lt(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_all_lt(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_all_lt(vector_float, vector_float) -> &mut i32

• fn vec_all_nan(vector_float) -> &mut i32

• fn vec_all_ne(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_all_ne(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_all_ne(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_all_ne(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_all_ne(vector_bool_char, vector_bool_char) -> &mut i32

• fn vec_all_ne(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_all_ne(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_all_ne(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_all_ne(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_all_ne(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_all_ne(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_all_ne(vector_bool_short, vector_bool_short) -> &mut i32

• fn vec_all_ne(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_all_ne(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_all_ne(vector_pixel, vector_pixel) -> &mut i32

• fn vec_all_ne(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_all_ne(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_all_ne(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_all_ne(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_all_ne(vector_bool_int, vector_bool_int) -> &mut i32

• fn vec_all_ne(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_all_ne(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_all_ne(vector_float, vector_float) -> &mut i32

• fn vec_all_nge(vector_float, vector_float) -> &mut i32

• fn vec_all_ngt(vector_float, vector_float) -> &mut i32

• fn vec_all_nle(vector_float, vector_float) -> &mut i32

• fn vec_all_nlt(vector_float, vector_float) -> &mut i32

• fn vec_all_numeric(vector_float) -> &mut i32

• fn vec_any_eq(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_any_eq(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_any_eq(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_any_eq(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_any_eq(vector_bool_char, vector_bool_char) -> &mut i32

• fn vec_any_eq(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_any_eq(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_any_eq(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_any_eq(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_any_eq(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_any_eq(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_any_eq(vector_bool_short, vector_bool_short) -> &mut i32

• fn vec_any_eq(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_any_eq(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_any_eq(vector_pixel, vector_pixel) -> &mut i32

• fn vec_any_eq(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_any_eq(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_any_eq(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_any_eq(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_any_eq(vector_bool_int, vector_bool_int) -> &mut i32

• fn vec_any_eq(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_any_eq(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_any_eq(vector_float, vector_float) -> &mut i32

• fn vec_any_ge(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_any_ge(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_any_ge(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_any_ge(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_any_ge(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_any_ge(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_any_ge(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_any_ge(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_any_ge(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_any_ge(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_any_ge(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_any_ge(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_any_ge(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_any_ge(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_any_ge(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_any_ge(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_any_ge(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_any_ge(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_any_ge(vector_float, vector_float) -> &mut i32

• fn vec_any_gt(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_any_gt(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_any_gt(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_any_gt(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_any_gt(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_any_gt(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_any_gt(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_any_gt(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_any_gt(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_any_gt(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_any_gt(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_any_gt(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_any_gt(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_any_gt(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_any_gt(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_any_gt(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_any_gt(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_any_gt(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_any_gt(vector_float, vector_float) -> &mut i32

• fn vec_any_le(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_any_le(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_any_le(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_any_le(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_any_le(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_any_le(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_any_le(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_any_le(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_any_le(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_any_le(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_any_le(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_any_le(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_any_le(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_any_le(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_any_le(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_any_le(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_any_le(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_any_le(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_any_le(vector_float, vector_float) -> &mut i32

• fn vec_any_lt(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_any_lt(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_any_lt(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_any_lt(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_any_lt(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_any_lt(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_any_lt(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_any_lt(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_any_lt(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_any_lt(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_any_lt(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_any_lt(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_any_lt(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_any_lt(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_any_lt(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_any_lt(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_any_lt(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_any_lt(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_any_lt(vector_float, vector_float) -> &mut i32

• fn vec_any_nan(vector_float) -> &mut i32

• fn vec_any_ne(vector_signed_char, vector_bool_char) -> &mut i32

• fn vec_any_ne(vector_signed_char, vector_signed_char) -> &mut i32

• fn vec_any_ne(vector_unsigned_char, vector_bool_char) -> &mut i32

• fn vec_any_ne(vector_unsigned_char, vector_unsigned_char) -> &mut i32

• fn vec_any_ne(vector_bool_char, vector_bool_char) -> &mut i32

• fn vec_any_ne(vector_bool_char, vector_unsigned_char) -> &mut i32

• fn vec_any_ne(vector_bool_char, vector_signed_char) -> &mut i32

• fn vec_any_ne(vector_signed_short, vector_bool_short) -> &mut i32

• fn vec_any_ne(vector_signed_short, vector_signed_short) -> &mut i32

• fn vec_any_ne(vector_unsigned_short, vector_bool_short) -> &mut i32

• fn vec_any_ne(vector_unsigned_short, vector_unsigned_short) -> &mut i32

• fn vec_any_ne(vector_bool_short, vector_bool_short) -> &mut i32

• fn vec_any_ne(vector_bool_short, vector_unsigned_short) -> &mut i32

• fn vec_any_ne(vector_bool_short, vector_signed_short) -> &mut i32

• fn vec_any_ne(vector_pixel, vector_pixel) -> &mut i32

• fn vec_any_ne(vector_signed_int, vector_bool_int) -> &mut i32

• fn vec_any_ne(vector_signed_int, vector_signed_int) -> &mut i32

• fn vec_any_ne(vector_unsigned_int, vector_bool_int) -> &mut i32

• fn vec_any_ne(vector_unsigned_int, vector_unsigned_int) -> &mut i32

• fn vec_any_ne(vector_bool_int, vector_bool_int) -> &mut i32

• fn vec_any_ne(vector_bool_int, vector_unsigned_int) -> &mut i32

• fn vec_any_ne(vector_bool_int, vector_signed_int) -> &mut i32

• fn vec_any_ne(vector_float, vector_float) -> &mut i32

• fn vec_any_nge(vector_float, vector_float) -> &mut i32

• fn vec_any_ngt(vector_float, vector_float) -> &mut i32

• fn vec_any_nle(vector_float, vector_float) -> &mut i32

• fn vec_any_nlt(vector_float, vector_float) -> &mut i32

• fn vec_any_numeric(vector_float) -> &mut i32

• fn vec_any_out(vector_float, vector_float) -> &mut i32

Generated by this script