src/simd/internal/simdref/simdref.go

// Code generated by 'refgen'. DO NOT EDIT.

package simdref

import "simd/internal/spec"

type (
	Mask16s    struct{ v []spec.Mask16 }
	Mask16x8   struct{ v []spec.Mask16 }
	Mask16x16  struct{ v []spec.Mask16 }
	Mask16x32  struct{ v []spec.Mask16 }
	Mask32s    struct{ v []spec.Mask32 }
	Mask32x4   struct{ v []spec.Mask32 }
	Mask32x8   struct{ v []spec.Mask32 }
	Mask32x16  struct{ v []spec.Mask32 }
	Mask64s    struct{ v []spec.Mask64 }
	Mask64x2   struct{ v []spec.Mask64 }
	Mask64x4   struct{ v []spec.Mask64 }
	Mask64x8   struct{ v []spec.Mask64 }
	Mask8s     struct{ v []spec.Mask8 }
	Mask8x16   struct{ v []spec.Mask8 }
	Mask8x32   struct{ v []spec.Mask8 }
	Mask8x64   struct{ v []spec.Mask8 }
	Float32s   struct{ v []float32 }
	Float32x4  struct{ v []float32 }
	Float32x8  struct{ v []float32 }
	Float32x16 struct{ v []float32 }
	Float64s   struct{ v []float64 }
	Float64x2  struct{ v []float64 }
	Float64x4  struct{ v []float64 }
	Float64x8  struct{ v []float64 }
	Int16s     struct{ v []int16 }
	Int16x8    struct{ v []int16 }
	Int16x16   struct{ v []int16 }
	Int16x32   struct{ v []int16 }
	Int32s     struct{ v []int32 }
	Int32x4    struct{ v []int32 }
	Int32x8    struct{ v []int32 }
	Int32x16   struct{ v []int32 }
	Int64s     struct{ v []int64 }
	Int64x2    struct{ v []int64 }
	Int64x4    struct{ v []int64 }
	Int64x8    struct{ v []int64 }
	Int8s      struct{ v []int8 }
	Int8x16    struct{ v []int8 }
	Int8x32    struct{ v []int8 }
	Int8x64    struct{ v []int8 }
	Uint16s    struct{ v []uint16 }
	Uint16x8   struct{ v []uint16 }
	Uint16x16  struct{ v []uint16 }
	Uint16x32  struct{ v []uint16 }
	Uint32s    struct{ v []uint32 }
	Uint32x4   struct{ v []uint32 }
	Uint32x8   struct{ v []uint32 }
	Uint32x16  struct{ v []uint32 }
	Uint64s    struct{ v []uint64 }
	Uint64x2   struct{ v []uint64 }
	Uint64x4   struct{ v []uint64 }
	Uint64x8   struct{ v []uint64 }
	Uint8s     struct{ v []uint8 }
	Uint8x16   struct{ v []uint8 }
	Uint8x32   struct{ v []uint8 }
	Uint8x64   struct{ v []uint8 }
)

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int8x16) OnesCount() (z Int8x16) {
	return Int8x16{spec.OnesCount[int8, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int8x32) OnesCount() (z Int8x32) {
	return Int8x32{spec.OnesCount[int8, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int8x64) OnesCount() (z Int8x64) {
	return Int8x64{spec.OnesCount[int8, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int8s) OnesCount() (z Int8s) {
	return Int8s{spec.OnesCount[int8, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int16x8) OnesCount() (z Int16x8) {
	return Int16x8{spec.OnesCount[int16, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int16x16) OnesCount() (z Int16x16) {
	return Int16x16{spec.OnesCount[int16, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int16x32) OnesCount() (z Int16x32) {
	return Int16x32{spec.OnesCount[int16, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int16s) OnesCount() (z Int16s) {
	return Int16s{spec.OnesCount[int16, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int32x4) OnesCount() (z Int32x4) {
	return Int32x4{spec.OnesCount[int32, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int32x8) OnesCount() (z Int32x8) {
	return Int32x8{spec.OnesCount[int32, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int32x16) OnesCount() (z Int32x16) {
	return Int32x16{spec.OnesCount[int32, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int32s) OnesCount() (z Int32s) {
	return Int32s{spec.OnesCount[int32, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int64x2) OnesCount() (z Int64x2) {
	return Int64x2{spec.OnesCount[int64, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int64x4) OnesCount() (z Int64x4) {
	return Int64x4{spec.OnesCount[int64, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int64x8) OnesCount() (z Int64x8) {
	return Int64x8{spec.OnesCount[int64, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Int64s) OnesCount() (z Int64s) {
	return Int64s{spec.OnesCount[int64, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint8x16) OnesCount() (z Uint8x16) {
	return Uint8x16{spec.OnesCount[uint8, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint8x32) OnesCount() (z Uint8x32) {
	return Uint8x32{spec.OnesCount[uint8, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint8x64) OnesCount() (z Uint8x64) {
	return Uint8x64{spec.OnesCount[uint8, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint8s) OnesCount() (z Uint8s) {
	return Uint8s{spec.OnesCount[uint8, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint16x8) OnesCount() (z Uint16x8) {
	return Uint16x8{spec.OnesCount[uint16, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint16x16) OnesCount() (z Uint16x16) {
	return Uint16x16{spec.OnesCount[uint16, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint16x32) OnesCount() (z Uint16x32) {
	return Uint16x32{spec.OnesCount[uint16, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint16s) OnesCount() (z Uint16s) {
	return Uint16s{spec.OnesCount[uint16, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint32x4) OnesCount() (z Uint32x4) {
	return Uint32x4{spec.OnesCount[uint32, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint32x8) OnesCount() (z Uint32x8) {
	return Uint32x8{spec.OnesCount[uint32, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint32x16) OnesCount() (z Uint32x16) {
	return Uint32x16{spec.OnesCount[uint32, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint32s) OnesCount() (z Uint32s) {
	return Uint32s{spec.OnesCount[uint32, spec.WidthScalable](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint64x2) OnesCount() (z Uint64x2) {
	return Uint64x2{spec.OnesCount[uint64, spec.Width128](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint64x4) OnesCount() (z Uint64x4) {
	return Uint64x4{spec.OnesCount[uint64, spec.Width256](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint64x8) OnesCount() (z Uint64x8) {
	return Uint64x8{spec.OnesCount[uint64, spec.Width512](x.v)}
}

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
func (x Uint64s) OnesCount() (z Uint64s) {
	return Uint64s{spec.OnesCount[uint64, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int8x16) LeadingZeros() (z Int8x16) {
	return Int8x16{spec.LeadingZeros[int8, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int8x32) LeadingZeros() (z Int8x32) {
	return Int8x32{spec.LeadingZeros[int8, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int8x64) LeadingZeros() (z Int8x64) {
	return Int8x64{spec.LeadingZeros[int8, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int8s) LeadingZeros() (z Int8s) {
	return Int8s{spec.LeadingZeros[int8, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int16x8) LeadingZeros() (z Int16x8) {
	return Int16x8{spec.LeadingZeros[int16, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int16x16) LeadingZeros() (z Int16x16) {
	return Int16x16{spec.LeadingZeros[int16, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int16x32) LeadingZeros() (z Int16x32) {
	return Int16x32{spec.LeadingZeros[int16, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int16s) LeadingZeros() (z Int16s) {
	return Int16s{spec.LeadingZeros[int16, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int32x4) LeadingZeros() (z Int32x4) {
	return Int32x4{spec.LeadingZeros[int32, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int32x8) LeadingZeros() (z Int32x8) {
	return Int32x8{spec.LeadingZeros[int32, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int32x16) LeadingZeros() (z Int32x16) {
	return Int32x16{spec.LeadingZeros[int32, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int32s) LeadingZeros() (z Int32s) {
	return Int32s{spec.LeadingZeros[int32, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int64x2) LeadingZeros() (z Int64x2) {
	return Int64x2{spec.LeadingZeros[int64, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int64x4) LeadingZeros() (z Int64x4) {
	return Int64x4{spec.LeadingZeros[int64, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int64x8) LeadingZeros() (z Int64x8) {
	return Int64x8{spec.LeadingZeros[int64, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Int64s) LeadingZeros() (z Int64s) {
	return Int64s{spec.LeadingZeros[int64, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint8x16) LeadingZeros() (z Uint8x16) {
	return Uint8x16{spec.LeadingZeros[uint8, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint8x32) LeadingZeros() (z Uint8x32) {
	return Uint8x32{spec.LeadingZeros[uint8, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint8x64) LeadingZeros() (z Uint8x64) {
	return Uint8x64{spec.LeadingZeros[uint8, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint8s) LeadingZeros() (z Uint8s) {
	return Uint8s{spec.LeadingZeros[uint8, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint16x8) LeadingZeros() (z Uint16x8) {
	return Uint16x8{spec.LeadingZeros[uint16, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint16x16) LeadingZeros() (z Uint16x16) {
	return Uint16x16{spec.LeadingZeros[uint16, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint16x32) LeadingZeros() (z Uint16x32) {
	return Uint16x32{spec.LeadingZeros[uint16, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint16s) LeadingZeros() (z Uint16s) {
	return Uint16s{spec.LeadingZeros[uint16, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint32x4) LeadingZeros() (z Uint32x4) {
	return Uint32x4{spec.LeadingZeros[uint32, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint32x8) LeadingZeros() (z Uint32x8) {
	return Uint32x8{spec.LeadingZeros[uint32, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint32x16) LeadingZeros() (z Uint32x16) {
	return Uint32x16{spec.LeadingZeros[uint32, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint32s) LeadingZeros() (z Uint32s) {
	return Uint32s{spec.LeadingZeros[uint32, spec.WidthScalable](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint64x2) LeadingZeros() (z Uint64x2) {
	return Uint64x2{spec.LeadingZeros[uint64, spec.Width128](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint64x4) LeadingZeros() (z Uint64x4) {
	return Uint64x4{spec.LeadingZeros[uint64, spec.Width256](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint64x8) LeadingZeros() (z Uint64x8) {
	return Uint64x8{spec.LeadingZeros[uint64, spec.Width512](x.v)}
}

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.LeadingZeros(x[i])
func (x Uint64s) LeadingZeros() (z Uint64s) {
	return Uint64s{spec.LeadingZeros[uint64, spec.WidthScalable](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint8x16) TrailingZeros() (z Uint8x16) {
	return Uint8x16{spec.TrailingZeros[uint8, spec.Width128](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint8x32) TrailingZeros() (z Uint8x32) {
	return Uint8x32{spec.TrailingZeros[uint8, spec.Width256](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint8x64) TrailingZeros() (z Uint8x64) {
	return Uint8x64{spec.TrailingZeros[uint8, spec.Width512](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint8s) TrailingZeros() (z Uint8s) {
	return Uint8s{spec.TrailingZeros[uint8, spec.WidthScalable](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint16x8) TrailingZeros() (z Uint16x8) {
	return Uint16x8{spec.TrailingZeros[uint16, spec.Width128](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint16x16) TrailingZeros() (z Uint16x16) {
	return Uint16x16{spec.TrailingZeros[uint16, spec.Width256](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint16x32) TrailingZeros() (z Uint16x32) {
	return Uint16x32{spec.TrailingZeros[uint16, spec.Width512](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint16s) TrailingZeros() (z Uint16s) {
	return Uint16s{spec.TrailingZeros[uint16, spec.WidthScalable](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint32x4) TrailingZeros() (z Uint32x4) {
	return Uint32x4{spec.TrailingZeros[uint32, spec.Width128](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint32x8) TrailingZeros() (z Uint32x8) {
	return Uint32x8{spec.TrailingZeros[uint32, spec.Width256](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint32x16) TrailingZeros() (z Uint32x16) {
	return Uint32x16{spec.TrailingZeros[uint32, spec.Width512](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint32s) TrailingZeros() (z Uint32s) {
	return Uint32s{spec.TrailingZeros[uint32, spec.WidthScalable](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint64x2) TrailingZeros() (z Uint64x2) {
	return Uint64x2{spec.TrailingZeros[uint64, spec.Width128](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint64x4) TrailingZeros() (z Uint64x4) {
	return Uint64x4{spec.TrailingZeros[uint64, spec.Width256](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint64x8) TrailingZeros() (z Uint64x8) {
	return Uint64x8{spec.TrailingZeros[uint64, spec.Width512](x.v)}
}

// TrailingZeros counts the trailing zero bits of each element in x,
// starting from the least significant bit.
// If an element is 0, the result is 64.
//
//	z[i] = bits.TrailingZeros(x[i])
func (x Uint64s) TrailingZeros() (z Uint64s) {
	return Uint64s{spec.TrailingZeros[uint64, spec.WidthScalable](x.v)}
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 16.
func (x Mask8x16) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask8, spec.Width128](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 32.
func (x Mask8x32) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask8, spec.Width256](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 64.
func (x Mask8x64) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask8, spec.Width512](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns x.Len().
func (x Mask8s) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask8, spec.WidthScalable](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 8.
func (x Mask16x8) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask16, spec.Width128](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 16.
func (x Mask16x16) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask16, spec.Width256](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 32.
func (x Mask16x32) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask16, spec.Width512](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns x.Len().
func (x Mask16s) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask16, spec.WidthScalable](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 4.
func (x Mask32x4) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask32, spec.Width128](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 8.
func (x Mask32x8) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask32, spec.Width256](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 16.
func (x Mask32x16) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask32, spec.Width512](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns x.Len().
func (x Mask32s) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask32, spec.WidthScalable](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 2.
func (x Mask64x2) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask64, spec.Width128](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 4.
func (x Mask64x4) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask64, spec.Width256](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns 8.
func (x Mask64x8) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask64, spec.Width512](x.v)
}

// TrailingZeros returns the number of low-order false (zero) elements in mask
// x. If the mask is entirely false, it returns x.Len().
func (x Mask64s) TrailingZeros() int {
	return spec.TrailingZerosMask[spec.Mask64, spec.WidthScalable](x.v)
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint8x16) CarrylessMultiplyEven(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.CarrylessMultiplyEven[uint8, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint8x32) CarrylessMultiplyEven(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.CarrylessMultiplyEven[uint8, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint8x64) CarrylessMultiplyEven(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.CarrylessMultiplyEven[uint8, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint8s) CarrylessMultiplyEven(y Uint8s) (z Uint8s) {
	return Uint8s{spec.CarrylessMultiplyEven[uint8, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint16x8) CarrylessMultiplyEven(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.CarrylessMultiplyEven[uint16, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint16x16) CarrylessMultiplyEven(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.CarrylessMultiplyEven[uint16, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint16x32) CarrylessMultiplyEven(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.CarrylessMultiplyEven[uint16, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint16s) CarrylessMultiplyEven(y Uint16s) (z Uint16s) {
	return Uint16s{spec.CarrylessMultiplyEven[uint16, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint32x4) CarrylessMultiplyEven(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.CarrylessMultiplyEven[uint32, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint32x8) CarrylessMultiplyEven(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.CarrylessMultiplyEven[uint32, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint32x16) CarrylessMultiplyEven(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.CarrylessMultiplyEven[uint32, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint32s) CarrylessMultiplyEven(y Uint32s) (z Uint32s) {
	return Uint32s{spec.CarrylessMultiplyEven[uint32, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint64x2) CarrylessMultiplyEven(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.CarrylessMultiplyEven[uint64, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint64x4) CarrylessMultiplyEven(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.CarrylessMultiplyEven[uint64, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint64x8) CarrylessMultiplyEven(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.CarrylessMultiplyEven[uint64, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEven computes the elementwise carryless multiplication of
// even-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i])
//
// A carryless multiplication uses bitwise XOR instead of add-with-carry.
// For example, to compute the carryless multiply of 0b1110 and 0b1011:
//
//	     1110
//	   ⊗ 1011
//	  ───────
//	     1110
//	    1110
//	   0000
//	⊕ 1110
//	  ───────
//	  1100010
//
// Carryless multiply can also be viewed as multiplying polynomials with
// coefficients from GF(2). For example, the above example can be represented as
//
//	  (x^3 + x^2 + x^1) * (x^3 + x^1 + x^0)
//	= (x^6 + x^5 + (1^1)x^4 + (1^1)x^3 + (1^1)x^2 + x^1)
//	= (x^6 + x^5 + x^1)
func (x Uint64s) CarrylessMultiplyEven(y Uint64s) (z Uint64s) {
	return Uint64s{spec.CarrylessMultiplyEven[uint64, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x16) CarrylessMultiplyEvenOdd(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.CarrylessMultiplyEvenOdd[uint8, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x32) CarrylessMultiplyEvenOdd(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.CarrylessMultiplyEvenOdd[uint8, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x64) CarrylessMultiplyEvenOdd(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.CarrylessMultiplyEvenOdd[uint8, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8s) CarrylessMultiplyEvenOdd(y Uint8s) (z Uint8s) {
	return Uint8s{spec.CarrylessMultiplyEvenOdd[uint8, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x8) CarrylessMultiplyEvenOdd(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.CarrylessMultiplyEvenOdd[uint16, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x16) CarrylessMultiplyEvenOdd(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.CarrylessMultiplyEvenOdd[uint16, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x32) CarrylessMultiplyEvenOdd(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.CarrylessMultiplyEvenOdd[uint16, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16s) CarrylessMultiplyEvenOdd(y Uint16s) (z Uint16s) {
	return Uint16s{spec.CarrylessMultiplyEvenOdd[uint16, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x4) CarrylessMultiplyEvenOdd(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.CarrylessMultiplyEvenOdd[uint32, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x8) CarrylessMultiplyEvenOdd(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.CarrylessMultiplyEvenOdd[uint32, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x16) CarrylessMultiplyEvenOdd(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.CarrylessMultiplyEvenOdd[uint32, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32s) CarrylessMultiplyEvenOdd(y Uint32s) (z Uint32s) {
	return Uint32s{spec.CarrylessMultiplyEvenOdd[uint32, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x2) CarrylessMultiplyEvenOdd(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.CarrylessMultiplyEvenOdd[uint64, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x4) CarrylessMultiplyEvenOdd(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.CarrylessMultiplyEvenOdd[uint64, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x8) CarrylessMultiplyEvenOdd(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.CarrylessMultiplyEvenOdd[uint64, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyEvenOdd computes the elementwise carryless multiplication of
// even-indexed elements of x and odd-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64s) CarrylessMultiplyEvenOdd(y Uint64s) (z Uint64s) {
	return Uint64s{spec.CarrylessMultiplyEvenOdd[uint64, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x16) CarrylessMultiplyOdd(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.CarrylessMultiplyOdd[uint8, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x32) CarrylessMultiplyOdd(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.CarrylessMultiplyOdd[uint8, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x64) CarrylessMultiplyOdd(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.CarrylessMultiplyOdd[uint8, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8s) CarrylessMultiplyOdd(y Uint8s) (z Uint8s) {
	return Uint8s{spec.CarrylessMultiplyOdd[uint8, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x8) CarrylessMultiplyOdd(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.CarrylessMultiplyOdd[uint16, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x16) CarrylessMultiplyOdd(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.CarrylessMultiplyOdd[uint16, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x32) CarrylessMultiplyOdd(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.CarrylessMultiplyOdd[uint16, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16s) CarrylessMultiplyOdd(y Uint16s) (z Uint16s) {
	return Uint16s{spec.CarrylessMultiplyOdd[uint16, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x4) CarrylessMultiplyOdd(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.CarrylessMultiplyOdd[uint32, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x8) CarrylessMultiplyOdd(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.CarrylessMultiplyOdd[uint32, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x16) CarrylessMultiplyOdd(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.CarrylessMultiplyOdd[uint32, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32s) CarrylessMultiplyOdd(y Uint32s) (z Uint32s) {
	return Uint32s{spec.CarrylessMultiplyOdd[uint32, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x2) CarrylessMultiplyOdd(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.CarrylessMultiplyOdd[uint64, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x4) CarrylessMultiplyOdd(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.CarrylessMultiplyOdd[uint64, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x8) CarrylessMultiplyOdd(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.CarrylessMultiplyOdd[uint64, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOdd computes the elementwise carryless multiplication of
// odd-indexed elements of x and y. The result of each carryless multiply is
// twice the width of the input elements. The high bits are stored in elements
// z[2*i+1] and the low bits are stored in elements z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i+1])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64s) CarrylessMultiplyOdd(y Uint64s) (z Uint64s) {
	return Uint64s{spec.CarrylessMultiplyOdd[uint64, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x16) CarrylessMultiplyOddEven(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.CarrylessMultiplyOddEven[uint8, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x32) CarrylessMultiplyOddEven(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.CarrylessMultiplyOddEven[uint8, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8x64) CarrylessMultiplyOddEven(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.CarrylessMultiplyOddEven[uint8, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint8s) CarrylessMultiplyOddEven(y Uint8s) (z Uint8s) {
	return Uint8s{spec.CarrylessMultiplyOddEven[uint8, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x8) CarrylessMultiplyOddEven(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.CarrylessMultiplyOddEven[uint16, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x16) CarrylessMultiplyOddEven(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.CarrylessMultiplyOddEven[uint16, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16x32) CarrylessMultiplyOddEven(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.CarrylessMultiplyOddEven[uint16, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint16s) CarrylessMultiplyOddEven(y Uint16s) (z Uint16s) {
	return Uint16s{spec.CarrylessMultiplyOddEven[uint16, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x4) CarrylessMultiplyOddEven(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.CarrylessMultiplyOddEven[uint32, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x8) CarrylessMultiplyOddEven(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.CarrylessMultiplyOddEven[uint32, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32x16) CarrylessMultiplyOddEven(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.CarrylessMultiplyOddEven[uint32, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint32s) CarrylessMultiplyOddEven(y Uint32s) (z Uint32s) {
	return Uint32s{spec.CarrylessMultiplyOddEven[uint32, spec.WidthScalable](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x2) CarrylessMultiplyOddEven(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.CarrylessMultiplyOddEven[uint64, spec.Width128](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x4) CarrylessMultiplyOddEven(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.CarrylessMultiplyOddEven[uint64, spec.Width256](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64x8) CarrylessMultiplyOddEven(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.CarrylessMultiplyOddEven[uint64, spec.Width512](x.v, y.v)}
}

// CarrylessMultiplyOddEven computes the elementwise carryless multiplication of
// odd-indexed elements of x and even-indexed elements of y. The result of each
// carryless multiply is twice the width of the input elements. The high bits
// are stored in elements z[2*i+1] and the low bits are stored in elements
// z[2*i].
//
//	concat(z[2*i+1], z[2*i]) = clmul(x[2*i+1], y[2*i])
//
// See [CarrylessMultiplyEven] for details about carryless multiply.
func (x Uint64s) CarrylessMultiplyOddEven(y Uint64s) (z Uint64s) {
	return Uint64s{spec.CarrylessMultiplyOddEven[uint64, spec.WidthScalable](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float32x4) Equal(y Float32x4) (z Mask32x4) {
	return Mask32x4{spec.Equal[float32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float32x8) Equal(y Float32x8) (z Mask32x8) {
	return Mask32x8{spec.Equal[float32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float32x16) Equal(y Float32x16) (z Mask32x16) {
	return Mask32x16{spec.Equal[float32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float32s) Equal(y Float32s) (z Mask32s) {
	return Mask32s{spec.Equal[float32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float64x2) Equal(y Float64x2) (z Mask64x2) {
	return Mask64x2{spec.Equal[float64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float64x4) Equal(y Float64x4) (z Mask64x4) {
	return Mask64x4{spec.Equal[float64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float64x8) Equal(y Float64x8) (z Mask64x8) {
	return Mask64x8{spec.Equal[float64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Float64s) Equal(y Float64s) (z Mask64s) {
	return Mask64s{spec.Equal[float64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int8x16) Equal(y Int8x16) (z Mask8x16) {
	return Mask8x16{spec.Equal[int8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int8x32) Equal(y Int8x32) (z Mask8x32) {
	return Mask8x32{spec.Equal[int8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int8x64) Equal(y Int8x64) (z Mask8x64) {
	return Mask8x64{spec.Equal[int8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int8s) Equal(y Int8s) (z Mask8s) {
	return Mask8s{spec.Equal[int8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int16x8) Equal(y Int16x8) (z Mask16x8) {
	return Mask16x8{spec.Equal[int16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int16x16) Equal(y Int16x16) (z Mask16x16) {
	return Mask16x16{spec.Equal[int16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int16x32) Equal(y Int16x32) (z Mask16x32) {
	return Mask16x32{spec.Equal[int16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int16s) Equal(y Int16s) (z Mask16s) {
	return Mask16s{spec.Equal[int16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int32x4) Equal(y Int32x4) (z Mask32x4) {
	return Mask32x4{spec.Equal[int32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int32x8) Equal(y Int32x8) (z Mask32x8) {
	return Mask32x8{spec.Equal[int32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int32x16) Equal(y Int32x16) (z Mask32x16) {
	return Mask32x16{spec.Equal[int32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int32s) Equal(y Int32s) (z Mask32s) {
	return Mask32s{spec.Equal[int32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int64x2) Equal(y Int64x2) (z Mask64x2) {
	return Mask64x2{spec.Equal[int64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int64x4) Equal(y Int64x4) (z Mask64x4) {
	return Mask64x4{spec.Equal[int64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int64x8) Equal(y Int64x8) (z Mask64x8) {
	return Mask64x8{spec.Equal[int64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Int64s) Equal(y Int64s) (z Mask64s) {
	return Mask64s{spec.Equal[int64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint8x16) Equal(y Uint8x16) (z Mask8x16) {
	return Mask8x16{spec.Equal[uint8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint8x32) Equal(y Uint8x32) (z Mask8x32) {
	return Mask8x32{spec.Equal[uint8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint8x64) Equal(y Uint8x64) (z Mask8x64) {
	return Mask8x64{spec.Equal[uint8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint8s) Equal(y Uint8s) (z Mask8s) {
	return Mask8s{spec.Equal[uint8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint16x8) Equal(y Uint16x8) (z Mask16x8) {
	return Mask16x8{spec.Equal[uint16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint16x16) Equal(y Uint16x16) (z Mask16x16) {
	return Mask16x16{spec.Equal[uint16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint16x32) Equal(y Uint16x32) (z Mask16x32) {
	return Mask16x32{spec.Equal[uint16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint16s) Equal(y Uint16s) (z Mask16s) {
	return Mask16s{spec.Equal[uint16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint32x4) Equal(y Uint32x4) (z Mask32x4) {
	return Mask32x4{spec.Equal[uint32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint32x8) Equal(y Uint32x8) (z Mask32x8) {
	return Mask32x8{spec.Equal[uint32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint32x16) Equal(y Uint32x16) (z Mask32x16) {
	return Mask32x16{spec.Equal[uint32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint32s) Equal(y Uint32s) (z Mask32s) {
	return Mask32s{spec.Equal[uint32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint64x2) Equal(y Uint64x2) (z Mask64x2) {
	return Mask64x2{spec.Equal[uint64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint64x4) Equal(y Uint64x4) (z Mask64x4) {
	return Mask64x4{spec.Equal[uint64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint64x8) Equal(y Uint64x8) (z Mask64x8) {
	return Mask64x8{spec.Equal[uint64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Uint64s) Equal(y Uint64s) (z Mask64s) {
	return Mask64s{spec.Equal[uint64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask8x16) Equal(y Mask8x16) (z Mask8x16) {
	return Mask8x16{spec.Equal[spec.Mask8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask8x32) Equal(y Mask8x32) (z Mask8x32) {
	return Mask8x32{spec.Equal[spec.Mask8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask8x64) Equal(y Mask8x64) (z Mask8x64) {
	return Mask8x64{spec.Equal[spec.Mask8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask8s) Equal(y Mask8s) (z Mask8s) {
	return Mask8s{spec.Equal[spec.Mask8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask16x8) Equal(y Mask16x8) (z Mask16x8) {
	return Mask16x8{spec.Equal[spec.Mask16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask16x16) Equal(y Mask16x16) (z Mask16x16) {
	return Mask16x16{spec.Equal[spec.Mask16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask16x32) Equal(y Mask16x32) (z Mask16x32) {
	return Mask16x32{spec.Equal[spec.Mask16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask16s) Equal(y Mask16s) (z Mask16s) {
	return Mask16s{spec.Equal[spec.Mask16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask32x4) Equal(y Mask32x4) (z Mask32x4) {
	return Mask32x4{spec.Equal[spec.Mask32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask32x8) Equal(y Mask32x8) (z Mask32x8) {
	return Mask32x8{spec.Equal[spec.Mask32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask32x16) Equal(y Mask32x16) (z Mask32x16) {
	return Mask32x16{spec.Equal[spec.Mask32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask32s) Equal(y Mask32s) (z Mask32s) {
	return Mask32s{spec.Equal[spec.Mask32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask64x2) Equal(y Mask64x2) (z Mask64x2) {
	return Mask64x2{spec.Equal[spec.Mask64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask64x4) Equal(y Mask64x4) (z Mask64x4) {
	return Mask64x4{spec.Equal[spec.Mask64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask64x8) Equal(y Mask64x8) (z Mask64x8) {
	return Mask64x8{spec.Equal[spec.Mask64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask64s) Equal(y Mask64s) (z Mask64s) {
	return Mask64s{spec.Equal[spec.Mask64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float32x4) NotEqual(y Float32x4) (z Mask32x4) {
	return Mask32x4{spec.NotEqual[float32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float32x8) NotEqual(y Float32x8) (z Mask32x8) {
	return Mask32x8{spec.NotEqual[float32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float32x16) NotEqual(y Float32x16) (z Mask32x16) {
	return Mask32x16{spec.NotEqual[float32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float32s) NotEqual(y Float32s) (z Mask32s) {
	return Mask32s{spec.NotEqual[float32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float64x2) NotEqual(y Float64x2) (z Mask64x2) {
	return Mask64x2{spec.NotEqual[float64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float64x4) NotEqual(y Float64x4) (z Mask64x4) {
	return Mask64x4{spec.NotEqual[float64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float64x8) NotEqual(y Float64x8) (z Mask64x8) {
	return Mask64x8{spec.NotEqual[float64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Float64s) NotEqual(y Float64s) (z Mask64s) {
	return Mask64s{spec.NotEqual[float64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int8x16) NotEqual(y Int8x16) (z Mask8x16) {
	return Mask8x16{spec.NotEqual[int8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int8x32) NotEqual(y Int8x32) (z Mask8x32) {
	return Mask8x32{spec.NotEqual[int8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int8x64) NotEqual(y Int8x64) (z Mask8x64) {
	return Mask8x64{spec.NotEqual[int8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int8s) NotEqual(y Int8s) (z Mask8s) {
	return Mask8s{spec.NotEqual[int8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int16x8) NotEqual(y Int16x8) (z Mask16x8) {
	return Mask16x8{spec.NotEqual[int16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int16x16) NotEqual(y Int16x16) (z Mask16x16) {
	return Mask16x16{spec.NotEqual[int16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int16x32) NotEqual(y Int16x32) (z Mask16x32) {
	return Mask16x32{spec.NotEqual[int16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int16s) NotEqual(y Int16s) (z Mask16s) {
	return Mask16s{spec.NotEqual[int16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int32x4) NotEqual(y Int32x4) (z Mask32x4) {
	return Mask32x4{spec.NotEqual[int32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int32x8) NotEqual(y Int32x8) (z Mask32x8) {
	return Mask32x8{spec.NotEqual[int32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int32x16) NotEqual(y Int32x16) (z Mask32x16) {
	return Mask32x16{spec.NotEqual[int32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int32s) NotEqual(y Int32s) (z Mask32s) {
	return Mask32s{spec.NotEqual[int32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int64x2) NotEqual(y Int64x2) (z Mask64x2) {
	return Mask64x2{spec.NotEqual[int64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int64x4) NotEqual(y Int64x4) (z Mask64x4) {
	return Mask64x4{spec.NotEqual[int64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int64x8) NotEqual(y Int64x8) (z Mask64x8) {
	return Mask64x8{spec.NotEqual[int64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Int64s) NotEqual(y Int64s) (z Mask64s) {
	return Mask64s{spec.NotEqual[int64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint8x16) NotEqual(y Uint8x16) (z Mask8x16) {
	return Mask8x16{spec.NotEqual[uint8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint8x32) NotEqual(y Uint8x32) (z Mask8x32) {
	return Mask8x32{spec.NotEqual[uint8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint8x64) NotEqual(y Uint8x64) (z Mask8x64) {
	return Mask8x64{spec.NotEqual[uint8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint8s) NotEqual(y Uint8s) (z Mask8s) {
	return Mask8s{spec.NotEqual[uint8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint16x8) NotEqual(y Uint16x8) (z Mask16x8) {
	return Mask16x8{spec.NotEqual[uint16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint16x16) NotEqual(y Uint16x16) (z Mask16x16) {
	return Mask16x16{spec.NotEqual[uint16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint16x32) NotEqual(y Uint16x32) (z Mask16x32) {
	return Mask16x32{spec.NotEqual[uint16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint16s) NotEqual(y Uint16s) (z Mask16s) {
	return Mask16s{spec.NotEqual[uint16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint32x4) NotEqual(y Uint32x4) (z Mask32x4) {
	return Mask32x4{spec.NotEqual[uint32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint32x8) NotEqual(y Uint32x8) (z Mask32x8) {
	return Mask32x8{spec.NotEqual[uint32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint32x16) NotEqual(y Uint32x16) (z Mask32x16) {
	return Mask32x16{spec.NotEqual[uint32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint32s) NotEqual(y Uint32s) (z Mask32s) {
	return Mask32s{spec.NotEqual[uint32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint64x2) NotEqual(y Uint64x2) (z Mask64x2) {
	return Mask64x2{spec.NotEqual[uint64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint64x4) NotEqual(y Uint64x4) (z Mask64x4) {
	return Mask64x4{spec.NotEqual[uint64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint64x8) NotEqual(y Uint64x8) (z Mask64x8) {
	return Mask64x8{spec.NotEqual[uint64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Uint64s) NotEqual(y Uint64s) (z Mask64s) {
	return Mask64s{spec.NotEqual[uint64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask8x16) NotEqual(y Mask8x16) (z Mask8x16) {
	return Mask8x16{spec.NotEqual[spec.Mask8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask8x32) NotEqual(y Mask8x32) (z Mask8x32) {
	return Mask8x32{spec.NotEqual[spec.Mask8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask8x64) NotEqual(y Mask8x64) (z Mask8x64) {
	return Mask8x64{spec.NotEqual[spec.Mask8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask8s) NotEqual(y Mask8s) (z Mask8s) {
	return Mask8s{spec.NotEqual[spec.Mask8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask16x8) NotEqual(y Mask16x8) (z Mask16x8) {
	return Mask16x8{spec.NotEqual[spec.Mask16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask16x16) NotEqual(y Mask16x16) (z Mask16x16) {
	return Mask16x16{spec.NotEqual[spec.Mask16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask16x32) NotEqual(y Mask16x32) (z Mask16x32) {
	return Mask16x32{spec.NotEqual[spec.Mask16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask16s) NotEqual(y Mask16s) (z Mask16s) {
	return Mask16s{spec.NotEqual[spec.Mask16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask32x4) NotEqual(y Mask32x4) (z Mask32x4) {
	return Mask32x4{spec.NotEqual[spec.Mask32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask32x8) NotEqual(y Mask32x8) (z Mask32x8) {
	return Mask32x8{spec.NotEqual[spec.Mask32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask32x16) NotEqual(y Mask32x16) (z Mask32x16) {
	return Mask32x16{spec.NotEqual[spec.Mask32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask32s) NotEqual(y Mask32s) (z Mask32s) {
	return Mask32s{spec.NotEqual[spec.Mask32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask64x2) NotEqual(y Mask64x2) (z Mask64x2) {
	return Mask64x2{spec.NotEqual[spec.Mask64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask64x4) NotEqual(y Mask64x4) (z Mask64x4) {
	return Mask64x4{spec.NotEqual[spec.Mask64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask64x8) NotEqual(y Mask64x8) (z Mask64x8) {
	return Mask64x8{spec.NotEqual[spec.Mask64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// NotEqual returns a mask indicating which elements of x and y are not equal.
func (x Mask64s) NotEqual(y Mask64s) (z Mask64s) {
	return Mask64s{spec.NotEqual[spec.Mask64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float32x4) Less(y Float32x4) (z Mask32x4) {
	return Mask32x4{spec.Less[float32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float32x8) Less(y Float32x8) (z Mask32x8) {
	return Mask32x8{spec.Less[float32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float32x16) Less(y Float32x16) (z Mask32x16) {
	return Mask32x16{spec.Less[float32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float32s) Less(y Float32s) (z Mask32s) {
	return Mask32s{spec.Less[float32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float64x2) Less(y Float64x2) (z Mask64x2) {
	return Mask64x2{spec.Less[float64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float64x4) Less(y Float64x4) (z Mask64x4) {
	return Mask64x4{spec.Less[float64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float64x8) Less(y Float64x8) (z Mask64x8) {
	return Mask64x8{spec.Less[float64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Float64s) Less(y Float64s) (z Mask64s) {
	return Mask64s{spec.Less[float64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int8x16) Less(y Int8x16) (z Mask8x16) {
	return Mask8x16{spec.Less[int8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int8x32) Less(y Int8x32) (z Mask8x32) {
	return Mask8x32{spec.Less[int8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int8x64) Less(y Int8x64) (z Mask8x64) {
	return Mask8x64{spec.Less[int8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int8s) Less(y Int8s) (z Mask8s) {
	return Mask8s{spec.Less[int8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int16x8) Less(y Int16x8) (z Mask16x8) {
	return Mask16x8{spec.Less[int16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int16x16) Less(y Int16x16) (z Mask16x16) {
	return Mask16x16{spec.Less[int16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int16x32) Less(y Int16x32) (z Mask16x32) {
	return Mask16x32{spec.Less[int16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int16s) Less(y Int16s) (z Mask16s) {
	return Mask16s{spec.Less[int16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int32x4) Less(y Int32x4) (z Mask32x4) {
	return Mask32x4{spec.Less[int32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int32x8) Less(y Int32x8) (z Mask32x8) {
	return Mask32x8{spec.Less[int32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int32x16) Less(y Int32x16) (z Mask32x16) {
	return Mask32x16{spec.Less[int32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int32s) Less(y Int32s) (z Mask32s) {
	return Mask32s{spec.Less[int32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int64x2) Less(y Int64x2) (z Mask64x2) {
	return Mask64x2{spec.Less[int64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int64x4) Less(y Int64x4) (z Mask64x4) {
	return Mask64x4{spec.Less[int64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int64x8) Less(y Int64x8) (z Mask64x8) {
	return Mask64x8{spec.Less[int64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Int64s) Less(y Int64s) (z Mask64s) {
	return Mask64s{spec.Less[int64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint8x16) Less(y Uint8x16) (z Mask8x16) {
	return Mask8x16{spec.Less[uint8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint8x32) Less(y Uint8x32) (z Mask8x32) {
	return Mask8x32{spec.Less[uint8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint8x64) Less(y Uint8x64) (z Mask8x64) {
	return Mask8x64{spec.Less[uint8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint8s) Less(y Uint8s) (z Mask8s) {
	return Mask8s{spec.Less[uint8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint16x8) Less(y Uint16x8) (z Mask16x8) {
	return Mask16x8{spec.Less[uint16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint16x16) Less(y Uint16x16) (z Mask16x16) {
	return Mask16x16{spec.Less[uint16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint16x32) Less(y Uint16x32) (z Mask16x32) {
	return Mask16x32{spec.Less[uint16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint16s) Less(y Uint16s) (z Mask16s) {
	return Mask16s{spec.Less[uint16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint32x4) Less(y Uint32x4) (z Mask32x4) {
	return Mask32x4{spec.Less[uint32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint32x8) Less(y Uint32x8) (z Mask32x8) {
	return Mask32x8{spec.Less[uint32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint32x16) Less(y Uint32x16) (z Mask32x16) {
	return Mask32x16{spec.Less[uint32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint32s) Less(y Uint32s) (z Mask32s) {
	return Mask32s{spec.Less[uint32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint64x2) Less(y Uint64x2) (z Mask64x2) {
	return Mask64x2{spec.Less[uint64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint64x4) Less(y Uint64x4) (z Mask64x4) {
	return Mask64x4{spec.Less[uint64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint64x8) Less(y Uint64x8) (z Mask64x8) {
	return Mask64x8{spec.Less[uint64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Less returns a mask indicating which elements of x are less than y.
//
//	z[i] = x[i] < y[i]
func (x Uint64s) Less(y Uint64s) (z Mask64s) {
	return Mask64s{spec.Less[uint64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float32x4) LessEqual(y Float32x4) (z Mask32x4) {
	return Mask32x4{spec.LessEqual[float32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float32x8) LessEqual(y Float32x8) (z Mask32x8) {
	return Mask32x8{spec.LessEqual[float32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float32x16) LessEqual(y Float32x16) (z Mask32x16) {
	return Mask32x16{spec.LessEqual[float32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float32s) LessEqual(y Float32s) (z Mask32s) {
	return Mask32s{spec.LessEqual[float32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float64x2) LessEqual(y Float64x2) (z Mask64x2) {
	return Mask64x2{spec.LessEqual[float64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float64x4) LessEqual(y Float64x4) (z Mask64x4) {
	return Mask64x4{spec.LessEqual[float64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float64x8) LessEqual(y Float64x8) (z Mask64x8) {
	return Mask64x8{spec.LessEqual[float64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Float64s) LessEqual(y Float64s) (z Mask64s) {
	return Mask64s{spec.LessEqual[float64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int8x16) LessEqual(y Int8x16) (z Mask8x16) {
	return Mask8x16{spec.LessEqual[int8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int8x32) LessEqual(y Int8x32) (z Mask8x32) {
	return Mask8x32{spec.LessEqual[int8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int8x64) LessEqual(y Int8x64) (z Mask8x64) {
	return Mask8x64{spec.LessEqual[int8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int8s) LessEqual(y Int8s) (z Mask8s) {
	return Mask8s{spec.LessEqual[int8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int16x8) LessEqual(y Int16x8) (z Mask16x8) {
	return Mask16x8{spec.LessEqual[int16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int16x16) LessEqual(y Int16x16) (z Mask16x16) {
	return Mask16x16{spec.LessEqual[int16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int16x32) LessEqual(y Int16x32) (z Mask16x32) {
	return Mask16x32{spec.LessEqual[int16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int16s) LessEqual(y Int16s) (z Mask16s) {
	return Mask16s{spec.LessEqual[int16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int32x4) LessEqual(y Int32x4) (z Mask32x4) {
	return Mask32x4{spec.LessEqual[int32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int32x8) LessEqual(y Int32x8) (z Mask32x8) {
	return Mask32x8{spec.LessEqual[int32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int32x16) LessEqual(y Int32x16) (z Mask32x16) {
	return Mask32x16{spec.LessEqual[int32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int32s) LessEqual(y Int32s) (z Mask32s) {
	return Mask32s{spec.LessEqual[int32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int64x2) LessEqual(y Int64x2) (z Mask64x2) {
	return Mask64x2{spec.LessEqual[int64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int64x4) LessEqual(y Int64x4) (z Mask64x4) {
	return Mask64x4{spec.LessEqual[int64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int64x8) LessEqual(y Int64x8) (z Mask64x8) {
	return Mask64x8{spec.LessEqual[int64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Int64s) LessEqual(y Int64s) (z Mask64s) {
	return Mask64s{spec.LessEqual[int64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint8x16) LessEqual(y Uint8x16) (z Mask8x16) {
	return Mask8x16{spec.LessEqual[uint8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint8x32) LessEqual(y Uint8x32) (z Mask8x32) {
	return Mask8x32{spec.LessEqual[uint8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint8x64) LessEqual(y Uint8x64) (z Mask8x64) {
	return Mask8x64{spec.LessEqual[uint8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint8s) LessEqual(y Uint8s) (z Mask8s) {
	return Mask8s{spec.LessEqual[uint8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint16x8) LessEqual(y Uint16x8) (z Mask16x8) {
	return Mask16x8{spec.LessEqual[uint16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint16x16) LessEqual(y Uint16x16) (z Mask16x16) {
	return Mask16x16{spec.LessEqual[uint16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint16x32) LessEqual(y Uint16x32) (z Mask16x32) {
	return Mask16x32{spec.LessEqual[uint16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint16s) LessEqual(y Uint16s) (z Mask16s) {
	return Mask16s{spec.LessEqual[uint16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint32x4) LessEqual(y Uint32x4) (z Mask32x4) {
	return Mask32x4{spec.LessEqual[uint32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint32x8) LessEqual(y Uint32x8) (z Mask32x8) {
	return Mask32x8{spec.LessEqual[uint32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint32x16) LessEqual(y Uint32x16) (z Mask32x16) {
	return Mask32x16{spec.LessEqual[uint32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint32s) LessEqual(y Uint32s) (z Mask32s) {
	return Mask32s{spec.LessEqual[uint32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint64x2) LessEqual(y Uint64x2) (z Mask64x2) {
	return Mask64x2{spec.LessEqual[uint64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint64x4) LessEqual(y Uint64x4) (z Mask64x4) {
	return Mask64x4{spec.LessEqual[uint64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint64x8) LessEqual(y Uint64x8) (z Mask64x8) {
	return Mask64x8{spec.LessEqual[uint64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// LessEqual returns a mask indicating which elements of x are less than or
// equal to y.
//
//	z[i] = x[i] <= y[i]
func (x Uint64s) LessEqual(y Uint64s) (z Mask64s) {
	return Mask64s{spec.LessEqual[uint64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float32x4) Greater(y Float32x4) (z Mask32x4) {
	return Mask32x4{spec.Greater[float32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float32x8) Greater(y Float32x8) (z Mask32x8) {
	return Mask32x8{spec.Greater[float32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float32x16) Greater(y Float32x16) (z Mask32x16) {
	return Mask32x16{spec.Greater[float32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float32s) Greater(y Float32s) (z Mask32s) {
	return Mask32s{spec.Greater[float32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float64x2) Greater(y Float64x2) (z Mask64x2) {
	return Mask64x2{spec.Greater[float64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float64x4) Greater(y Float64x4) (z Mask64x4) {
	return Mask64x4{spec.Greater[float64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float64x8) Greater(y Float64x8) (z Mask64x8) {
	return Mask64x8{spec.Greater[float64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Float64s) Greater(y Float64s) (z Mask64s) {
	return Mask64s{spec.Greater[float64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int8x16) Greater(y Int8x16) (z Mask8x16) {
	return Mask8x16{spec.Greater[int8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int8x32) Greater(y Int8x32) (z Mask8x32) {
	return Mask8x32{spec.Greater[int8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int8x64) Greater(y Int8x64) (z Mask8x64) {
	return Mask8x64{spec.Greater[int8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int8s) Greater(y Int8s) (z Mask8s) {
	return Mask8s{spec.Greater[int8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int16x8) Greater(y Int16x8) (z Mask16x8) {
	return Mask16x8{spec.Greater[int16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int16x16) Greater(y Int16x16) (z Mask16x16) {
	return Mask16x16{spec.Greater[int16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int16x32) Greater(y Int16x32) (z Mask16x32) {
	return Mask16x32{spec.Greater[int16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int16s) Greater(y Int16s) (z Mask16s) {
	return Mask16s{spec.Greater[int16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int32x4) Greater(y Int32x4) (z Mask32x4) {
	return Mask32x4{spec.Greater[int32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int32x8) Greater(y Int32x8) (z Mask32x8) {
	return Mask32x8{spec.Greater[int32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int32x16) Greater(y Int32x16) (z Mask32x16) {
	return Mask32x16{spec.Greater[int32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int32s) Greater(y Int32s) (z Mask32s) {
	return Mask32s{spec.Greater[int32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int64x2) Greater(y Int64x2) (z Mask64x2) {
	return Mask64x2{spec.Greater[int64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int64x4) Greater(y Int64x4) (z Mask64x4) {
	return Mask64x4{spec.Greater[int64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int64x8) Greater(y Int64x8) (z Mask64x8) {
	return Mask64x8{spec.Greater[int64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Int64s) Greater(y Int64s) (z Mask64s) {
	return Mask64s{spec.Greater[int64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint8x16) Greater(y Uint8x16) (z Mask8x16) {
	return Mask8x16{spec.Greater[uint8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint8x32) Greater(y Uint8x32) (z Mask8x32) {
	return Mask8x32{spec.Greater[uint8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint8x64) Greater(y Uint8x64) (z Mask8x64) {
	return Mask8x64{spec.Greater[uint8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint8s) Greater(y Uint8s) (z Mask8s) {
	return Mask8s{spec.Greater[uint8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint16x8) Greater(y Uint16x8) (z Mask16x8) {
	return Mask16x8{spec.Greater[uint16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint16x16) Greater(y Uint16x16) (z Mask16x16) {
	return Mask16x16{spec.Greater[uint16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint16x32) Greater(y Uint16x32) (z Mask16x32) {
	return Mask16x32{spec.Greater[uint16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint16s) Greater(y Uint16s) (z Mask16s) {
	return Mask16s{spec.Greater[uint16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint32x4) Greater(y Uint32x4) (z Mask32x4) {
	return Mask32x4{spec.Greater[uint32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint32x8) Greater(y Uint32x8) (z Mask32x8) {
	return Mask32x8{spec.Greater[uint32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint32x16) Greater(y Uint32x16) (z Mask32x16) {
	return Mask32x16{spec.Greater[uint32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint32s) Greater(y Uint32s) (z Mask32s) {
	return Mask32s{spec.Greater[uint32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint64x2) Greater(y Uint64x2) (z Mask64x2) {
	return Mask64x2{spec.Greater[uint64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint64x4) Greater(y Uint64x4) (z Mask64x4) {
	return Mask64x4{spec.Greater[uint64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint64x8) Greater(y Uint64x8) (z Mask64x8) {
	return Mask64x8{spec.Greater[uint64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
func (x Uint64s) Greater(y Uint64s) (z Mask64s) {
	return Mask64s{spec.Greater[uint64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float32x4) GreaterEqual(y Float32x4) (z Mask32x4) {
	return Mask32x4{spec.GreaterEqual[float32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float32x8) GreaterEqual(y Float32x8) (z Mask32x8) {
	return Mask32x8{spec.GreaterEqual[float32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float32x16) GreaterEqual(y Float32x16) (z Mask32x16) {
	return Mask32x16{spec.GreaterEqual[float32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float32s) GreaterEqual(y Float32s) (z Mask32s) {
	return Mask32s{spec.GreaterEqual[float32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float64x2) GreaterEqual(y Float64x2) (z Mask64x2) {
	return Mask64x2{spec.GreaterEqual[float64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float64x4) GreaterEqual(y Float64x4) (z Mask64x4) {
	return Mask64x4{spec.GreaterEqual[float64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float64x8) GreaterEqual(y Float64x8) (z Mask64x8) {
	return Mask64x8{spec.GreaterEqual[float64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Float64s) GreaterEqual(y Float64s) (z Mask64s) {
	return Mask64s{spec.GreaterEqual[float64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int8x16) GreaterEqual(y Int8x16) (z Mask8x16) {
	return Mask8x16{spec.GreaterEqual[int8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int8x32) GreaterEqual(y Int8x32) (z Mask8x32) {
	return Mask8x32{spec.GreaterEqual[int8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int8x64) GreaterEqual(y Int8x64) (z Mask8x64) {
	return Mask8x64{spec.GreaterEqual[int8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int8s) GreaterEqual(y Int8s) (z Mask8s) {
	return Mask8s{spec.GreaterEqual[int8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int16x8) GreaterEqual(y Int16x8) (z Mask16x8) {
	return Mask16x8{spec.GreaterEqual[int16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int16x16) GreaterEqual(y Int16x16) (z Mask16x16) {
	return Mask16x16{spec.GreaterEqual[int16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int16x32) GreaterEqual(y Int16x32) (z Mask16x32) {
	return Mask16x32{spec.GreaterEqual[int16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int16s) GreaterEqual(y Int16s) (z Mask16s) {
	return Mask16s{spec.GreaterEqual[int16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int32x4) GreaterEqual(y Int32x4) (z Mask32x4) {
	return Mask32x4{spec.GreaterEqual[int32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int32x8) GreaterEqual(y Int32x8) (z Mask32x8) {
	return Mask32x8{spec.GreaterEqual[int32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int32x16) GreaterEqual(y Int32x16) (z Mask32x16) {
	return Mask32x16{spec.GreaterEqual[int32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int32s) GreaterEqual(y Int32s) (z Mask32s) {
	return Mask32s{spec.GreaterEqual[int32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int64x2) GreaterEqual(y Int64x2) (z Mask64x2) {
	return Mask64x2{spec.GreaterEqual[int64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int64x4) GreaterEqual(y Int64x4) (z Mask64x4) {
	return Mask64x4{spec.GreaterEqual[int64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int64x8) GreaterEqual(y Int64x8) (z Mask64x8) {
	return Mask64x8{spec.GreaterEqual[int64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Int64s) GreaterEqual(y Int64s) (z Mask64s) {
	return Mask64s{spec.GreaterEqual[int64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint8x16) GreaterEqual(y Uint8x16) (z Mask8x16) {
	return Mask8x16{spec.GreaterEqual[uint8, spec.Width128, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint8x32) GreaterEqual(y Uint8x32) (z Mask8x32) {
	return Mask8x32{spec.GreaterEqual[uint8, spec.Width256, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint8x64) GreaterEqual(y Uint8x64) (z Mask8x64) {
	return Mask8x64{spec.GreaterEqual[uint8, spec.Width512, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint8s) GreaterEqual(y Uint8s) (z Mask8s) {
	return Mask8s{spec.GreaterEqual[uint8, spec.WidthScalable, spec.Mask8](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint16x8) GreaterEqual(y Uint16x8) (z Mask16x8) {
	return Mask16x8{spec.GreaterEqual[uint16, spec.Width128, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint16x16) GreaterEqual(y Uint16x16) (z Mask16x16) {
	return Mask16x16{spec.GreaterEqual[uint16, spec.Width256, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint16x32) GreaterEqual(y Uint16x32) (z Mask16x32) {
	return Mask16x32{spec.GreaterEqual[uint16, spec.Width512, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint16s) GreaterEqual(y Uint16s) (z Mask16s) {
	return Mask16s{spec.GreaterEqual[uint16, spec.WidthScalable, spec.Mask16](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint32x4) GreaterEqual(y Uint32x4) (z Mask32x4) {
	return Mask32x4{spec.GreaterEqual[uint32, spec.Width128, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint32x8) GreaterEqual(y Uint32x8) (z Mask32x8) {
	return Mask32x8{spec.GreaterEqual[uint32, spec.Width256, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint32x16) GreaterEqual(y Uint32x16) (z Mask32x16) {
	return Mask32x16{spec.GreaterEqual[uint32, spec.Width512, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint32s) GreaterEqual(y Uint32s) (z Mask32s) {
	return Mask32s{spec.GreaterEqual[uint32, spec.WidthScalable, spec.Mask32](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint64x2) GreaterEqual(y Uint64x2) (z Mask64x2) {
	return Mask64x2{spec.GreaterEqual[uint64, spec.Width128, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint64x4) GreaterEqual(y Uint64x4) (z Mask64x4) {
	return Mask64x4{spec.GreaterEqual[uint64, spec.Width256, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint64x8) GreaterEqual(y Uint64x8) (z Mask64x8) {
	return Mask64x8{spec.GreaterEqual[uint64, spec.Width512, spec.Mask64](x.v, y.v)}
}

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
func (x Uint64s) GreaterEqual(y Uint64s) (z Mask64s) {
	return Mask64s{spec.GreaterEqual[uint64, spec.WidthScalable, spec.Mask64](x.v, y.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float32x4) ToMask() (z Mask32x4) {
	return Mask32x4{spec.ToMask[float32, spec.Width128, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float32x8) ToMask() (z Mask32x8) {
	return Mask32x8{spec.ToMask[float32, spec.Width256, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float32x16) ToMask() (z Mask32x16) {
	return Mask32x16{spec.ToMask[float32, spec.Width512, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float32s) ToMask() (z Mask32s) {
	return Mask32s{spec.ToMask[float32, spec.WidthScalable, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float64x2) ToMask() (z Mask64x2) {
	return Mask64x2{spec.ToMask[float64, spec.Width128, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float64x4) ToMask() (z Mask64x4) {
	return Mask64x4{spec.ToMask[float64, spec.Width256, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float64x8) ToMask() (z Mask64x8) {
	return Mask64x8{spec.ToMask[float64, spec.Width512, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Float64s) ToMask() (z Mask64s) {
	return Mask64s{spec.ToMask[float64, spec.WidthScalable, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int8x16) ToMask() (z Mask8x16) {
	return Mask8x16{spec.ToMask[int8, spec.Width128, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int8x32) ToMask() (z Mask8x32) {
	return Mask8x32{spec.ToMask[int8, spec.Width256, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int8x64) ToMask() (z Mask8x64) {
	return Mask8x64{spec.ToMask[int8, spec.Width512, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int8s) ToMask() (z Mask8s) {
	return Mask8s{spec.ToMask[int8, spec.WidthScalable, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int16x8) ToMask() (z Mask16x8) {
	return Mask16x8{spec.ToMask[int16, spec.Width128, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int16x16) ToMask() (z Mask16x16) {
	return Mask16x16{spec.ToMask[int16, spec.Width256, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int16x32) ToMask() (z Mask16x32) {
	return Mask16x32{spec.ToMask[int16, spec.Width512, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int16s) ToMask() (z Mask16s) {
	return Mask16s{spec.ToMask[int16, spec.WidthScalable, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int32x4) ToMask() (z Mask32x4) {
	return Mask32x4{spec.ToMask[int32, spec.Width128, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int32x8) ToMask() (z Mask32x8) {
	return Mask32x8{spec.ToMask[int32, spec.Width256, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int32x16) ToMask() (z Mask32x16) {
	return Mask32x16{spec.ToMask[int32, spec.Width512, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int32s) ToMask() (z Mask32s) {
	return Mask32s{spec.ToMask[int32, spec.WidthScalable, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int64x2) ToMask() (z Mask64x2) {
	return Mask64x2{spec.ToMask[int64, spec.Width128, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int64x4) ToMask() (z Mask64x4) {
	return Mask64x4{spec.ToMask[int64, spec.Width256, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int64x8) ToMask() (z Mask64x8) {
	return Mask64x8{spec.ToMask[int64, spec.Width512, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Int64s) ToMask() (z Mask64s) {
	return Mask64s{spec.ToMask[int64, spec.WidthScalable, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint8x16) ToMask() (z Mask8x16) {
	return Mask8x16{spec.ToMask[uint8, spec.Width128, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint8x32) ToMask() (z Mask8x32) {
	return Mask8x32{spec.ToMask[uint8, spec.Width256, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint8x64) ToMask() (z Mask8x64) {
	return Mask8x64{spec.ToMask[uint8, spec.Width512, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint8s) ToMask() (z Mask8s) {
	return Mask8s{spec.ToMask[uint8, spec.WidthScalable, spec.Mask8](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint16x8) ToMask() (z Mask16x8) {
	return Mask16x8{spec.ToMask[uint16, spec.Width128, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint16x16) ToMask() (z Mask16x16) {
	return Mask16x16{spec.ToMask[uint16, spec.Width256, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint16x32) ToMask() (z Mask16x32) {
	return Mask16x32{spec.ToMask[uint16, spec.Width512, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint16s) ToMask() (z Mask16s) {
	return Mask16s{spec.ToMask[uint16, spec.WidthScalable, spec.Mask16](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint32x4) ToMask() (z Mask32x4) {
	return Mask32x4{spec.ToMask[uint32, spec.Width128, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint32x8) ToMask() (z Mask32x8) {
	return Mask32x8{spec.ToMask[uint32, spec.Width256, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint32x16) ToMask() (z Mask32x16) {
	return Mask32x16{spec.ToMask[uint32, spec.Width512, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint32s) ToMask() (z Mask32s) {
	return Mask32s{spec.ToMask[uint32, spec.WidthScalable, spec.Mask32](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint64x2) ToMask() (z Mask64x2) {
	return Mask64x2{spec.ToMask[uint64, spec.Width128, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint64x4) ToMask() (z Mask64x4) {
	return Mask64x4{spec.ToMask[uint64, spec.Width256, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint64x8) ToMask() (z Mask64x8) {
	return Mask64x8{spec.ToMask[uint64, spec.Width512, spec.Mask64](x.v)}
}

// ToMask returns a mask indicating which elements of x are non-zero.
//
//	z[i] = x[i] != 0
func (x Uint64s) ToMask() (z Mask64s) {
	return Mask64s{spec.ToMask[uint64, spec.WidthScalable, spec.Mask64](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float32x4) IsNaN() (z Mask32x4) {
	return Mask32x4{spec.IsNaN[float32, spec.Width128, spec.Mask32](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float32x8) IsNaN() (z Mask32x8) {
	return Mask32x8{spec.IsNaN[float32, spec.Width256, spec.Mask32](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float32x16) IsNaN() (z Mask32x16) {
	return Mask32x16{spec.IsNaN[float32, spec.Width512, spec.Mask32](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float32s) IsNaN() (z Mask32s) {
	return Mask32s{spec.IsNaN[float32, spec.WidthScalable, spec.Mask32](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float64x2) IsNaN() (z Mask64x2) {
	return Mask64x2{spec.IsNaN[float64, spec.Width128, spec.Mask64](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float64x4) IsNaN() (z Mask64x4) {
	return Mask64x4{spec.IsNaN[float64, spec.Width256, spec.Mask64](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float64x8) IsNaN() (z Mask64x8) {
	return Mask64x8{spec.IsNaN[float64, spec.Width512, spec.Mask64](x.v)}
}

// IsNan returns a mask indicating which elements of x are NaN.
//
//	z[i] = math.IsNaN(x[i])
func (x Float64s) IsNaN() (z Mask64s) {
	return Mask64s{spec.IsNaN[float64, spec.WidthScalable, spec.Mask64](x.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float32x4) Masked(mask Mask32x4) (z Float32x4) {
	return Float32x4{spec.Masked[float32, spec.Width128, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float32x8) Masked(mask Mask32x8) (z Float32x8) {
	return Float32x8{spec.Masked[float32, spec.Width256, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float32x16) Masked(mask Mask32x16) (z Float32x16) {
	return Float32x16{spec.Masked[float32, spec.Width512, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float32s) Masked(mask Mask32s) (z Float32s) {
	return Float32s{spec.Masked[float32, spec.WidthScalable, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float64x2) Masked(mask Mask64x2) (z Float64x2) {
	return Float64x2{spec.Masked[float64, spec.Width128, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float64x4) Masked(mask Mask64x4) (z Float64x4) {
	return Float64x4{spec.Masked[float64, spec.Width256, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float64x8) Masked(mask Mask64x8) (z Float64x8) {
	return Float64x8{spec.Masked[float64, spec.Width512, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Float64s) Masked(mask Mask64s) (z Float64s) {
	return Float64s{spec.Masked[float64, spec.WidthScalable, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int8x16) Masked(mask Mask8x16) (z Int8x16) {
	return Int8x16{spec.Masked[int8, spec.Width128, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int8x32) Masked(mask Mask8x32) (z Int8x32) {
	return Int8x32{spec.Masked[int8, spec.Width256, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int8x64) Masked(mask Mask8x64) (z Int8x64) {
	return Int8x64{spec.Masked[int8, spec.Width512, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int8s) Masked(mask Mask8s) (z Int8s) {
	return Int8s{spec.Masked[int8, spec.WidthScalable, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int16x8) Masked(mask Mask16x8) (z Int16x8) {
	return Int16x8{spec.Masked[int16, spec.Width128, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int16x16) Masked(mask Mask16x16) (z Int16x16) {
	return Int16x16{spec.Masked[int16, spec.Width256, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int16x32) Masked(mask Mask16x32) (z Int16x32) {
	return Int16x32{spec.Masked[int16, spec.Width512, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int16s) Masked(mask Mask16s) (z Int16s) {
	return Int16s{spec.Masked[int16, spec.WidthScalable, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int32x4) Masked(mask Mask32x4) (z Int32x4) {
	return Int32x4{spec.Masked[int32, spec.Width128, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int32x8) Masked(mask Mask32x8) (z Int32x8) {
	return Int32x8{spec.Masked[int32, spec.Width256, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int32x16) Masked(mask Mask32x16) (z Int32x16) {
	return Int32x16{spec.Masked[int32, spec.Width512, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int32s) Masked(mask Mask32s) (z Int32s) {
	return Int32s{spec.Masked[int32, spec.WidthScalable, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int64x2) Masked(mask Mask64x2) (z Int64x2) {
	return Int64x2{spec.Masked[int64, spec.Width128, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int64x4) Masked(mask Mask64x4) (z Int64x4) {
	return Int64x4{spec.Masked[int64, spec.Width256, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int64x8) Masked(mask Mask64x8) (z Int64x8) {
	return Int64x8{spec.Masked[int64, spec.Width512, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Int64s) Masked(mask Mask64s) (z Int64s) {
	return Int64s{spec.Masked[int64, spec.WidthScalable, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint8x16) Masked(mask Mask8x16) (z Uint8x16) {
	return Uint8x16{spec.Masked[uint8, spec.Width128, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint8x32) Masked(mask Mask8x32) (z Uint8x32) {
	return Uint8x32{spec.Masked[uint8, spec.Width256, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint8x64) Masked(mask Mask8x64) (z Uint8x64) {
	return Uint8x64{spec.Masked[uint8, spec.Width512, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint8s) Masked(mask Mask8s) (z Uint8s) {
	return Uint8s{spec.Masked[uint8, spec.WidthScalable, spec.Mask8](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint16x8) Masked(mask Mask16x8) (z Uint16x8) {
	return Uint16x8{spec.Masked[uint16, spec.Width128, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint16x16) Masked(mask Mask16x16) (z Uint16x16) {
	return Uint16x16{spec.Masked[uint16, spec.Width256, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint16x32) Masked(mask Mask16x32) (z Uint16x32) {
	return Uint16x32{spec.Masked[uint16, spec.Width512, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint16s) Masked(mask Mask16s) (z Uint16s) {
	return Uint16s{spec.Masked[uint16, spec.WidthScalable, spec.Mask16](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint32x4) Masked(mask Mask32x4) (z Uint32x4) {
	return Uint32x4{spec.Masked[uint32, spec.Width128, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint32x8) Masked(mask Mask32x8) (z Uint32x8) {
	return Uint32x8{spec.Masked[uint32, spec.Width256, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint32x16) Masked(mask Mask32x16) (z Uint32x16) {
	return Uint32x16{spec.Masked[uint32, spec.Width512, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint32s) Masked(mask Mask32s) (z Uint32s) {
	return Uint32s{spec.Masked[uint32, spec.WidthScalable, spec.Mask32](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint64x2) Masked(mask Mask64x2) (z Uint64x2) {
	return Uint64x2{spec.Masked[uint64, spec.Width128, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint64x4) Masked(mask Mask64x4) (z Uint64x4) {
	return Uint64x4{spec.Masked[uint64, spec.Width256, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint64x8) Masked(mask Mask64x8) (z Uint64x8) {
	return Uint64x8{spec.Masked[uint64, spec.Width512, spec.Mask64](x.v, mask.v)}
}

// Masked returns a vector with elements from x where mask is true, and zero
// elsewhere.
//
//	z[i] = if mask[i] { x[i] } else { 0 }
func (x Uint64s) Masked(mask Mask64s) (z Uint64s) {
	return Uint64s{spec.Masked[uint64, spec.WidthScalable, spec.Mask64](x.v, mask.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float32x4) IfElse(mask Mask32x4, y Float32x4) (z Float32x4) {
	return Float32x4{spec.IfElse[float32, spec.Width128, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float32x8) IfElse(mask Mask32x8, y Float32x8) (z Float32x8) {
	return Float32x8{spec.IfElse[float32, spec.Width256, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float32x16) IfElse(mask Mask32x16, y Float32x16) (z Float32x16) {
	return Float32x16{spec.IfElse[float32, spec.Width512, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float32s) IfElse(mask Mask32s, y Float32s) (z Float32s) {
	return Float32s{spec.IfElse[float32, spec.WidthScalable, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float64x2) IfElse(mask Mask64x2, y Float64x2) (z Float64x2) {
	return Float64x2{spec.IfElse[float64, spec.Width128, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float64x4) IfElse(mask Mask64x4, y Float64x4) (z Float64x4) {
	return Float64x4{spec.IfElse[float64, spec.Width256, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float64x8) IfElse(mask Mask64x8, y Float64x8) (z Float64x8) {
	return Float64x8{spec.IfElse[float64, spec.Width512, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Float64s) IfElse(mask Mask64s, y Float64s) (z Float64s) {
	return Float64s{spec.IfElse[float64, spec.WidthScalable, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int8x16) IfElse(mask Mask8x16, y Int8x16) (z Int8x16) {
	return Int8x16{spec.IfElse[int8, spec.Width128, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int8x32) IfElse(mask Mask8x32, y Int8x32) (z Int8x32) {
	return Int8x32{spec.IfElse[int8, spec.Width256, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int8x64) IfElse(mask Mask8x64, y Int8x64) (z Int8x64) {
	return Int8x64{spec.IfElse[int8, spec.Width512, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int8s) IfElse(mask Mask8s, y Int8s) (z Int8s) {
	return Int8s{spec.IfElse[int8, spec.WidthScalable, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int16x8) IfElse(mask Mask16x8, y Int16x8) (z Int16x8) {
	return Int16x8{spec.IfElse[int16, spec.Width128, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int16x16) IfElse(mask Mask16x16, y Int16x16) (z Int16x16) {
	return Int16x16{spec.IfElse[int16, spec.Width256, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int16x32) IfElse(mask Mask16x32, y Int16x32) (z Int16x32) {
	return Int16x32{spec.IfElse[int16, spec.Width512, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int16s) IfElse(mask Mask16s, y Int16s) (z Int16s) {
	return Int16s{spec.IfElse[int16, spec.WidthScalable, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int32x4) IfElse(mask Mask32x4, y Int32x4) (z Int32x4) {
	return Int32x4{spec.IfElse[int32, spec.Width128, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int32x8) IfElse(mask Mask32x8, y Int32x8) (z Int32x8) {
	return Int32x8{spec.IfElse[int32, spec.Width256, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int32x16) IfElse(mask Mask32x16, y Int32x16) (z Int32x16) {
	return Int32x16{spec.IfElse[int32, spec.Width512, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int32s) IfElse(mask Mask32s, y Int32s) (z Int32s) {
	return Int32s{spec.IfElse[int32, spec.WidthScalable, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int64x2) IfElse(mask Mask64x2, y Int64x2) (z Int64x2) {
	return Int64x2{spec.IfElse[int64, spec.Width128, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int64x4) IfElse(mask Mask64x4, y Int64x4) (z Int64x4) {
	return Int64x4{spec.IfElse[int64, spec.Width256, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int64x8) IfElse(mask Mask64x8, y Int64x8) (z Int64x8) {
	return Int64x8{spec.IfElse[int64, spec.Width512, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Int64s) IfElse(mask Mask64s, y Int64s) (z Int64s) {
	return Int64s{spec.IfElse[int64, spec.WidthScalable, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint8x16) IfElse(mask Mask8x16, y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.IfElse[uint8, spec.Width128, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint8x32) IfElse(mask Mask8x32, y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.IfElse[uint8, spec.Width256, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint8x64) IfElse(mask Mask8x64, y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.IfElse[uint8, spec.Width512, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint8s) IfElse(mask Mask8s, y Uint8s) (z Uint8s) {
	return Uint8s{spec.IfElse[uint8, spec.WidthScalable, spec.Mask8](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint16x8) IfElse(mask Mask16x8, y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.IfElse[uint16, spec.Width128, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint16x16) IfElse(mask Mask16x16, y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.IfElse[uint16, spec.Width256, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint16x32) IfElse(mask Mask16x32, y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.IfElse[uint16, spec.Width512, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint16s) IfElse(mask Mask16s, y Uint16s) (z Uint16s) {
	return Uint16s{spec.IfElse[uint16, spec.WidthScalable, spec.Mask16](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint32x4) IfElse(mask Mask32x4, y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.IfElse[uint32, spec.Width128, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint32x8) IfElse(mask Mask32x8, y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.IfElse[uint32, spec.Width256, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint32x16) IfElse(mask Mask32x16, y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.IfElse[uint32, spec.Width512, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint32s) IfElse(mask Mask32s, y Uint32s) (z Uint32s) {
	return Uint32s{spec.IfElse[uint32, spec.WidthScalable, spec.Mask32](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint64x2) IfElse(mask Mask64x2, y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.IfElse[uint64, spec.Width128, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint64x4) IfElse(mask Mask64x4, y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.IfElse[uint64, spec.Width256, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint64x8) IfElse(mask Mask64x8, y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.IfElse[uint64, spec.Width512, spec.Mask64](x.v, mask.v, y.v)}
}

// IfElse returns a vector with elements from x where mask is true, and y where
// mask is false.
//
//	z[i] = if mask[i] { x[i] } else { y[i] }
func (x Uint64s) IfElse(mask Mask64s, y Uint64s) (z Uint64s) {
	return Uint64s{spec.IfElse[uint64, spec.WidthScalable, spec.Mask64](x.v, mask.v, y.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Float32x4) ConvertToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertToZ[float32, spec.Width128, float64, spec.Width256](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float32x4) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[float32, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float32x4) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float32, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[float32, spec.Width128, int32, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x4) ConvertToInt64() (z Int64x4) {
	return Int64x4{spec.ConvertToZ[float32, spec.Width128, int64, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float32x4) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[float32, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float32x4) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float32, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[float32, spec.Width128, uint32, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x4) ConvertToUint64() (z Uint64x4) {
	return Uint64x4{spec.ConvertToZ[float32, spec.Width128, uint64, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Float32x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[float32, spec.Width256, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Float32x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[float32, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float32, spec.Width256, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[float32, spec.Width256, int32, spec.Width256](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[float32, spec.Width256, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Float32x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[float32, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float32, spec.Width256, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[float32, spec.Width256, uint32, spec.Width256](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[float32, spec.Width256, uint64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x16) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[float32, spec.Width512, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x16) ConvertToInt16() (z Int16x16) {
	return Int16x16{spec.ConvertToZ[float32, spec.Width512, int16, spec.Width256](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x16) ConvertToInt32() (z Int32x16) {
	return Int32x16{spec.ConvertToZ[float32, spec.Width512, int32, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x16) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[float32, spec.Width512, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x16) ConvertToUint16() (z Uint16x16) {
	return Uint16x16{spec.ConvertToZ[float32, spec.Width512, uint16, spec.Width256](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32x16) ConvertToUint32() (z Uint32x16) {
	return Uint32x16{spec.ConvertToZ[float32, spec.Width512, uint32, spec.Width512](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32s) ConvertToInt32() (z Int32s) {
	return Int32s{spec.ConvertToZ[float32, spec.WidthScalable, int32, spec.WidthScalable](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float32s) ConvertToUint32() (z Uint32s) {
	return Uint32s{spec.ConvertToZ[float32, spec.WidthScalable, uint32, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
//
// The results are rounded to the nearest representable value, or ±inf if they
// cannot be represented.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[float64, spec.Width128, float32, spec.Width128](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[float64, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float64, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[float64, spec.Width128, int32, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x2) ConvertToInt64() (z Int64x2) {
	return Int64x2{spec.ConvertToZ[float64, spec.Width128, int64, spec.Width128](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[float64, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float64, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Float64x2) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[float64, spec.Width128, uint32, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x2) ConvertToUint64() (z Uint64x2) {
	return Uint64x2{spec.ConvertToZ[float64, spec.Width128, uint64, spec.Width128](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
//
// The results are rounded to the nearest representable value, or ±inf if they
// cannot be represented.
func (x Float64x4) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[float64, spec.Width256, float32, spec.Width128](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float64x4) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[float64, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float64x4) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float64, spec.Width256, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[float64, spec.Width256, int32, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x4) ConvertToInt64() (z Int64x4) {
	return Int64x4{spec.ConvertToZ[float64, spec.Width256, int64, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float64x4) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[float64, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Float64x4) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float64, spec.Width256, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[float64, spec.Width256, uint32, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x4) ConvertToUint64() (z Uint64x4) {
	return Uint64x4{spec.ConvertToZ[float64, spec.Width256, uint64, spec.Width256](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
//
// The results are rounded to the nearest representable value, or ±inf if they
// cannot be represented.
func (x Float64x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[float64, spec.Width512, float32, spec.Width256](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Float64x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[float64, spec.Width512, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float64, spec.Width512, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[float64, spec.Width512, int32, spec.Width256](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[float64, spec.Width512, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Float64x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[float64, spec.Width512, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float64, spec.Width512, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[float64, spec.Width512, uint32, spec.Width256](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[float64, spec.Width512, uint64, spec.Width512](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64s) ConvertToInt64() (z Int64s) {
	return Int64s{spec.ConvertToZ[float64, spec.WidthScalable, int64, spec.WidthScalable](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
func (x Float64s) ConvertToUint64() (z Uint64s) {
	return Uint64s{spec.ConvertToZ[float64, spec.WidthScalable, uint64, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int8x16) ConvertToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertToZ[int8, spec.Width128, float32, spec.Width512](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Int8x16) ConvertToInt16() (z Int16x16) {
	return Int16x16{spec.ConvertToZ[int8, spec.Width128, int16, spec.Width256](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Int8x16) ConvertToInt32() (z Int32x16) {
	return Int32x16{spec.ConvertToZ[int8, spec.Width128, int32, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int8x16) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int8, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int8x16) ConvertToUint16() (z Uint16x16) {
	return Uint16x16{spec.ConvertToZ[int8, spec.Width128, uint16, spec.Width256](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int8x16) ConvertToUint32() (z Uint32x16) {
	return Uint32x16{spec.ConvertToZ[int8, spec.Width128, uint32, spec.Width512](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Int8x32) ConvertToInt16() (z Int16x32) {
	return Int16x32{spec.ConvertToZ[int8, spec.Width256, int16, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int8x32) ConvertToUint8() (z Uint8x32) {
	return Uint8x32{spec.ConvertToZ[int8, spec.Width256, uint8, spec.Width256](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int8x32) ConvertToUint16() (z Uint16x32) {
	return Uint16x32{spec.ConvertToZ[int8, spec.Width256, uint16, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int8x64) ConvertToUint8() (z Uint8x64) {
	return Uint8x64{spec.ConvertToZ[int8, spec.Width512, uint8, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int8s) ConvertToUint8() (z Uint8s) {
	return Uint8s{spec.ConvertToZ[int8, spec.WidthScalable, uint8, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int16x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[int16, spec.Width128, float32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int16x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[int16, spec.Width128, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Int16x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int16, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Int16x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[int16, spec.Width128, int32, spec.Width256](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Int16x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[int16, spec.Width128, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Int16x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int16, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int16x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int16, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int16x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[int16, spec.Width128, uint32, spec.Width256](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int16x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[int16, spec.Width128, uint64, spec.Width512](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int16x16) ConvertToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertToZ[int16, spec.Width256, float32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Int16x16) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int16, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Int16x16) ConvertToInt32() (z Int32x16) {
	return Int32x16{spec.ConvertToZ[int16, spec.Width256, int32, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int16x16) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int16, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int16x16) ConvertToUint16() (z Uint16x16) {
	return Uint16x16{spec.ConvertToZ[int16, spec.Width256, uint16, spec.Width256](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int16x16) ConvertToUint32() (z Uint32x16) {
	return Uint32x16{spec.ConvertToZ[int16, spec.Width256, uint32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Int16x32) ConvertToInt8() (z Int8x32) {
	return Int8x32{spec.ConvertToZ[int16, spec.Width512, int8, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int16x32) ConvertToUint8() (z Uint8x32) {
	return Uint8x32{spec.ConvertToZ[int16, spec.Width512, uint8, spec.Width256](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int16x32) ConvertToUint16() (z Uint16x32) {
	return Uint16x32{spec.ConvertToZ[int16, spec.Width512, uint16, spec.Width512](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int16s) ConvertToUint16() (z Uint16s) {
	return Uint16s{spec.ConvertToZ[int16, spec.WidthScalable, uint16, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int32x4) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[int32, spec.Width128, float32, spec.Width128](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int32x4) ConvertToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertToZ[int32, spec.Width128, float64, spec.Width256](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int32x4) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int32, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int32x4) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int32, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Int32x4) ConvertToInt64() (z Int64x4) {
	return Int64x4{spec.ConvertToZ[int32, spec.Width128, int64, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int32x4) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int32, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int32x4) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int32, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int32x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[int32, spec.Width128, uint32, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int32x4) ConvertToUint64() (z Uint64x4) {
	return Uint64x4{spec.ConvertToZ[int32, spec.Width128, uint64, spec.Width256](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int32x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[int32, spec.Width256, float32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int32x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[int32, spec.Width256, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Int32x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int32, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Int32x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int32, spec.Width256, int16, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Int32x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[int32, spec.Width256, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Int32x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int32, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int32x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int32, spec.Width256, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int32x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[int32, spec.Width256, uint32, spec.Width256](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int32x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[int32, spec.Width256, uint64, spec.Width512](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int32x16) ConvertToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertToZ[int32, spec.Width512, float32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Int32x16) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int32, spec.Width512, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Int32x16) ConvertToInt16() (z Int16x16) {
	return Int16x16{spec.ConvertToZ[int32, spec.Width512, int16, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Int32x16) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int32, spec.Width512, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int32x16) ConvertToUint16() (z Uint16x16) {
	return Uint16x16{spec.ConvertToZ[int32, spec.Width512, uint16, spec.Width256](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int32x16) ConvertToUint32() (z Uint32x16) {
	return Uint32x16{spec.ConvertToZ[int32, spec.Width512, uint32, spec.Width512](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int32s) ConvertToFloat32() (z Float32s) {
	return Float32s{spec.ConvertToZ[int32, spec.WidthScalable, float32, spec.WidthScalable](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int32s) ConvertToUint32() (z Uint32s) {
	return Uint32s{spec.ConvertToZ[int32, spec.WidthScalable, uint32, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[int64, spec.Width128, float32, spec.Width128](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int64x2) ConvertToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertToZ[int64, spec.Width128, float64, spec.Width128](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int64, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int64, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[int64, spec.Width128, int32, spec.Width128](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int64, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int64, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Int64x2) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[int64, spec.Width128, uint32, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int64x2) ConvertToUint64() (z Uint64x2) {
	return Uint64x2{spec.ConvertToZ[int64, spec.Width128, uint64, spec.Width128](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int64x4) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[int64, spec.Width256, float32, spec.Width128](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int64x4) ConvertToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertToZ[int64, spec.Width256, float64, spec.Width256](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int64x4) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int64, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int64x4) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int64, spec.Width256, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Int64x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[int64, spec.Width256, int32, spec.Width128](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int64x4) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int64, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Int64x4) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int64, spec.Width256, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int64x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[int64, spec.Width256, uint32, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int64x4) ConvertToUint64() (z Uint64x4) {
	return Uint64x4{spec.ConvertToZ[int64, spec.Width256, uint64, spec.Width256](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Int64x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[int64, spec.Width512, float32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int64x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[int64, spec.Width512, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Int64x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[int64, spec.Width512, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Int64x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int64, spec.Width512, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Int64x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[int64, spec.Width512, int32, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Int64x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[int64, spec.Width512, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Int64x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int64, spec.Width512, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Int64x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[int64, spec.Width512, uint32, spec.Width256](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int64x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[int64, spec.Width512, uint64, spec.Width512](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Int64s) ConvertToFloat64() (z Float64s) {
	return Float64s{spec.ConvertToZ[int64, spec.WidthScalable, float64, spec.WidthScalable](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Int64s) ConvertToUint64() (z Uint64s) {
	return Uint64s{spec.ConvertToZ[int64, spec.WidthScalable, uint64, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint8x16) ConvertToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertToZ[uint8, spec.Width128, float32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint8x16) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint8, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint8x16) ConvertToInt16() (z Int16x16) {
	return Int16x16{spec.ConvertToZ[uint8, spec.Width128, int16, spec.Width256](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint8x16) ConvertToInt32() (z Int32x16) {
	return Int32x16{spec.ConvertToZ[uint8, spec.Width128, int32, spec.Width512](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Uint8x16) ConvertToUint16() (z Uint16x16) {
	return Uint16x16{spec.ConvertToZ[uint8, spec.Width128, uint16, spec.Width256](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Uint8x16) ConvertToUint32() (z Uint32x16) {
	return Uint32x16{spec.ConvertToZ[uint8, spec.Width128, uint32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint8x32) ConvertToInt8() (z Int8x32) {
	return Int8x32{spec.ConvertToZ[uint8, spec.Width256, int8, spec.Width256](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint8x32) ConvertToInt16() (z Int16x32) {
	return Int16x32{spec.ConvertToZ[uint8, spec.Width256, int16, spec.Width512](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Uint8x32) ConvertToUint16() (z Uint16x32) {
	return Uint16x32{spec.ConvertToZ[uint8, spec.Width256, uint16, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint8x64) ConvertToInt8() (z Int8x64) {
	return Int8x64{spec.ConvertToZ[uint8, spec.Width512, int8, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint8s) ConvertToInt8() (z Int8s) {
	return Int8s{spec.ConvertToZ[uint8, spec.WidthScalable, int8, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint16x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[uint16, spec.Width128, float32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint16x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[uint16, spec.Width128, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Uint16x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint16, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint16x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint16, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint16x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[uint16, spec.Width128, int32, spec.Width256](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint16x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[uint16, spec.Width128, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Uint16x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint16, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Uint16x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[uint16, spec.Width128, uint32, spec.Width256](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Uint16x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[uint16, spec.Width128, uint64, spec.Width512](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint16x16) ConvertToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertToZ[uint16, spec.Width256, float32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint16x16) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint16, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint16x16) ConvertToInt16() (z Int16x16) {
	return Int16x16{spec.ConvertToZ[uint16, spec.Width256, int16, spec.Width256](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint16x16) ConvertToInt32() (z Int32x16) {
	return Int32x16{spec.ConvertToZ[uint16, spec.Width256, int32, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Uint16x16) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint16, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Uint16x16) ConvertToUint32() (z Uint32x16) {
	return Uint32x16{spec.ConvertToZ[uint16, spec.Width256, uint32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint16x32) ConvertToInt8() (z Int8x32) {
	return Int8x32{spec.ConvertToZ[uint16, spec.Width512, int8, spec.Width256](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint16x32) ConvertToInt16() (z Int16x32) {
	return Int16x32{spec.ConvertToZ[uint16, spec.Width512, int16, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Uint16x32) ConvertToUint8() (z Uint8x32) {
	return Uint8x32{spec.ConvertToZ[uint16, spec.Width512, uint8, spec.Width256](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint16s) ConvertToInt16() (z Int16s) {
	return Int16s{spec.ConvertToZ[uint16, spec.WidthScalable, int16, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint32x4) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[uint32, spec.Width128, float32, spec.Width128](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint32x4) ConvertToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertToZ[uint32, spec.Width128, float64, spec.Width256](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint32x4) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint32, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint32x4) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint32, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint32x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[uint32, spec.Width128, int32, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint32x4) ConvertToInt64() (z Int64x4) {
	return Int64x4{spec.ConvertToZ[uint32, spec.Width128, int64, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint32x4) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint32, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint32x4) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint32, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Uint32x4) ConvertToUint64() (z Uint64x4) {
	return Uint64x4{spec.ConvertToZ[uint32, spec.Width128, uint64, spec.Width256](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint32x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[uint32, spec.Width256, float32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint32x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[uint32, spec.Width256, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Uint32x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint32, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint32x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint32, spec.Width256, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint32x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[uint32, spec.Width256, int32, spec.Width256](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint32x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[uint32, spec.Width256, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Uint32x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint32, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Uint32x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint32, spec.Width256, uint16, spec.Width128](x.v)}
}

// ConvertToUint64 converts each element of x to uint64.
func (x Uint32x8) ConvertToUint64() (z Uint64x8) {
	return Uint64x8{spec.ConvertToZ[uint32, spec.Width256, uint64, spec.Width512](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint32x16) ConvertToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertToZ[uint32, spec.Width512, float32, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
func (x Uint32x16) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint32, spec.Width512, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint32x16) ConvertToInt16() (z Int16x16) {
	return Int16x16{spec.ConvertToZ[uint32, spec.Width512, int16, spec.Width256](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint32x16) ConvertToInt32() (z Int32x16) {
	return Int32x16{spec.ConvertToZ[uint32, spec.Width512, int32, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
func (x Uint32x16) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint32, spec.Width512, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Uint32x16) ConvertToUint16() (z Uint16x16) {
	return Uint16x16{spec.ConvertToZ[uint32, spec.Width512, uint16, spec.Width256](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint32s) ConvertToFloat32() (z Float32s) {
	return Float32s{spec.ConvertToZ[uint32, spec.WidthScalable, float32, spec.WidthScalable](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint32s) ConvertToInt32() (z Int32s) {
	return Int32s{spec.ConvertToZ[uint32, spec.WidthScalable, int32, spec.WidthScalable](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[uint64, spec.Width128, float32, spec.Width128](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint64x2) ConvertToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertToZ[uint64, spec.Width128, float64, spec.Width128](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint64, spec.Width128, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint64, spec.Width128, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[uint64, spec.Width128, int32, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint64x2) ConvertToInt64() (z Int64x2) {
	return Int64x2{spec.ConvertToZ[uint64, spec.Width128, int64, spec.Width128](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint64, spec.Width128, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint64, spec.Width128, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
//
// The low 2 elements of the result are set. The rest are zero.
func (x Uint64x2) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[uint64, spec.Width128, uint32, spec.Width128](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint64x4) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[uint64, spec.Width256, float32, spec.Width128](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint64x4) ConvertToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertToZ[uint64, spec.Width256, float64, spec.Width256](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint64x4) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint64, spec.Width256, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint64x4) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint64, spec.Width256, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint64x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[uint64, spec.Width256, int32, spec.Width128](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint64x4) ConvertToInt64() (z Int64x4) {
	return Int64x4{spec.ConvertToZ[uint64, spec.Width256, int64, spec.Width256](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint64x4) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint64, spec.Width256, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
//
// The low 4 elements of the result are set. The rest are zero.
func (x Uint64x4) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint64, spec.Width256, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Uint64x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[uint64, spec.Width256, uint32, spec.Width128](x.v)}
}

// ConvertToFloat32 converts each element of x to float32.
func (x Uint64x8) ConvertToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertToZ[uint64, spec.Width512, float32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint64x8) ConvertToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertToZ[uint64, spec.Width512, float64, spec.Width512](x.v)}
}

// ConvertToInt8 converts each element of x to int8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Uint64x8) ConvertToInt8() (z Int8x16) {
	return Int8x16{spec.ConvertToZ[uint64, spec.Width512, int8, spec.Width128](x.v)}
}

// ConvertToInt16 converts each element of x to int16.
func (x Uint64x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint64, spec.Width512, int16, spec.Width128](x.v)}
}

// ConvertToInt32 converts each element of x to int32.
func (x Uint64x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[uint64, spec.Width512, int32, spec.Width256](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint64x8) ConvertToInt64() (z Int64x8) {
	return Int64x8{spec.ConvertToZ[uint64, spec.Width512, int64, spec.Width512](x.v)}
}

// ConvertToUint8 converts each element of x to uint8.
//
// The low 8 elements of the result are set. The rest are zero.
func (x Uint64x8) ConvertToUint8() (z Uint8x16) {
	return Uint8x16{spec.ConvertToZ[uint64, spec.Width512, uint8, spec.Width128](x.v)}
}

// ConvertToUint16 converts each element of x to uint16.
func (x Uint64x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint64, spec.Width512, uint16, spec.Width128](x.v)}
}

// ConvertToUint32 converts each element of x to uint32.
func (x Uint64x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[uint64, spec.Width512, uint32, spec.Width256](x.v)}
}

// ConvertToFloat64 converts each element of x to float64.
func (x Uint64s) ConvertToFloat64() (z Float64s) {
	return Float64s{spec.ConvertToZ[uint64, spec.WidthScalable, float64, spec.WidthScalable](x.v)}
}

// ConvertToInt64 converts each element of x to int64.
func (x Uint64s) ConvertToInt64() (z Int64s) {
	return Int64s{spec.ConvertToZ[uint64, spec.WidthScalable, int64, spec.WidthScalable](x.v)}
}

// ExtendLo8ToInt16 sign-extends
// the lowest 8 vector elements to int16.
func (x Int8x16) ExtendLo8ToInt16() (z Int16x8) {
	return Int16x8{spec.ExtendLoLToZ[int8, spec.Width128, int16](x.v)}
}

// ExtendLo4ToInt32 sign-extends
// the lowest 4 vector elements to int32.
func (x Int8x16) ExtendLo4ToInt32() (z Int32x4) {
	return Int32x4{spec.ExtendLoLToZ[int8, spec.Width128, int32](x.v)}
}

// ExtendLo2ToInt64 sign-extends
// the lowest 2 vector elements to int64.
func (x Int8x16) ExtendLo2ToInt64() (z Int64x2) {
	return Int64x2{spec.ExtendLoLToZ[int8, spec.Width128, int64](x.v)}
}

// ExtendLo16ToInt16 sign-extends
// the lowest 16 vector elements to int16.
func (x Int8x32) ExtendLo16ToInt16() (z Int16x16) {
	return Int16x16{spec.ExtendLoLToZ[int8, spec.Width256, int16](x.v)}
}

// ExtendLo8ToInt32 sign-extends
// the lowest 8 vector elements to int32.
func (x Int8x32) ExtendLo8ToInt32() (z Int32x8) {
	return Int32x8{spec.ExtendLoLToZ[int8, spec.Width256, int32](x.v)}
}

// ExtendLo4ToInt64 sign-extends
// the lowest 4 vector elements to int64.
func (x Int8x32) ExtendLo4ToInt64() (z Int64x4) {
	return Int64x4{spec.ExtendLoLToZ[int8, spec.Width256, int64](x.v)}
}

// ExtendLo32ToInt16 sign-extends
// the lowest 32 vector elements to int16.
func (x Int8x64) ExtendLo32ToInt16() (z Int16x32) {
	return Int16x32{spec.ExtendLoLToZ[int8, spec.Width512, int16](x.v)}
}

// ExtendLo16ToInt32 sign-extends
// the lowest 16 vector elements to int32.
func (x Int8x64) ExtendLo16ToInt32() (z Int32x16) {
	return Int32x16{spec.ExtendLoLToZ[int8, spec.Width512, int32](x.v)}
}

// ExtendLo8ToInt64 sign-extends
// the lowest 8 vector elements to int64.
func (x Int8x64) ExtendLo8ToInt64() (z Int64x8) {
	return Int64x8{spec.ExtendLoLToZ[int8, spec.Width512, int64](x.v)}
}

// ExtendLo4ToInt32 sign-extends
// the lowest 4 vector elements to int32.
func (x Int16x8) ExtendLo4ToInt32() (z Int32x4) {
	return Int32x4{spec.ExtendLoLToZ[int16, spec.Width128, int32](x.v)}
}

// ExtendLo2ToInt64 sign-extends
// the lowest 2 vector elements to int64.
func (x Int16x8) ExtendLo2ToInt64() (z Int64x2) {
	return Int64x2{spec.ExtendLoLToZ[int16, spec.Width128, int64](x.v)}
}

// ExtendLo8ToInt32 sign-extends
// the lowest 8 vector elements to int32.
func (x Int16x16) ExtendLo8ToInt32() (z Int32x8) {
	return Int32x8{spec.ExtendLoLToZ[int16, spec.Width256, int32](x.v)}
}

// ExtendLo4ToInt64 sign-extends
// the lowest 4 vector elements to int64.
func (x Int16x16) ExtendLo4ToInt64() (z Int64x4) {
	return Int64x4{spec.ExtendLoLToZ[int16, spec.Width256, int64](x.v)}
}

// ExtendLo16ToInt32 sign-extends
// the lowest 16 vector elements to int32.
func (x Int16x32) ExtendLo16ToInt32() (z Int32x16) {
	return Int32x16{spec.ExtendLoLToZ[int16, spec.Width512, int32](x.v)}
}

// ExtendLo8ToInt64 sign-extends
// the lowest 8 vector elements to int64.
func (x Int16x32) ExtendLo8ToInt64() (z Int64x8) {
	return Int64x8{spec.ExtendLoLToZ[int16, spec.Width512, int64](x.v)}
}

// ExtendLo2ToInt64 sign-extends
// the lowest 2 vector elements to int64.
func (x Int32x4) ExtendLo2ToInt64() (z Int64x2) {
	return Int64x2{spec.ExtendLoLToZ[int32, spec.Width128, int64](x.v)}
}

// ExtendLo4ToInt64 sign-extends
// the lowest 4 vector elements to int64.
func (x Int32x8) ExtendLo4ToInt64() (z Int64x4) {
	return Int64x4{spec.ExtendLoLToZ[int32, spec.Width256, int64](x.v)}
}

// ExtendLo8ToInt64 sign-extends
// the lowest 8 vector elements to int64.
func (x Int32x16) ExtendLo8ToInt64() (z Int64x8) {
	return Int64x8{spec.ExtendLoLToZ[int32, spec.Width512, int64](x.v)}
}

// ExtendLo8ToUint16 zero-extends
// the lowest 8 vector elements to uint16.
func (x Uint8x16) ExtendLo8ToUint16() (z Uint16x8) {
	return Uint16x8{spec.ExtendLoLToZ[uint8, spec.Width128, uint16](x.v)}
}

// ExtendLo4ToUint32 zero-extends
// the lowest 4 vector elements to uint32.
func (x Uint8x16) ExtendLo4ToUint32() (z Uint32x4) {
	return Uint32x4{spec.ExtendLoLToZ[uint8, spec.Width128, uint32](x.v)}
}

// ExtendLo2ToUint64 zero-extends
// the lowest 2 vector elements to uint64.
func (x Uint8x16) ExtendLo2ToUint64() (z Uint64x2) {
	return Uint64x2{spec.ExtendLoLToZ[uint8, spec.Width128, uint64](x.v)}
}

// ExtendLo16ToUint16 zero-extends
// the lowest 16 vector elements to uint16.
func (x Uint8x32) ExtendLo16ToUint16() (z Uint16x16) {
	return Uint16x16{spec.ExtendLoLToZ[uint8, spec.Width256, uint16](x.v)}
}

// ExtendLo8ToUint32 zero-extends
// the lowest 8 vector elements to uint32.
func (x Uint8x32) ExtendLo8ToUint32() (z Uint32x8) {
	return Uint32x8{spec.ExtendLoLToZ[uint8, spec.Width256, uint32](x.v)}
}

// ExtendLo4ToUint64 zero-extends
// the lowest 4 vector elements to uint64.
func (x Uint8x32) ExtendLo4ToUint64() (z Uint64x4) {
	return Uint64x4{spec.ExtendLoLToZ[uint8, spec.Width256, uint64](x.v)}
}

// ExtendLo32ToUint16 zero-extends
// the lowest 32 vector elements to uint16.
func (x Uint8x64) ExtendLo32ToUint16() (z Uint16x32) {
	return Uint16x32{spec.ExtendLoLToZ[uint8, spec.Width512, uint16](x.v)}
}

// ExtendLo16ToUint32 zero-extends
// the lowest 16 vector elements to uint32.
func (x Uint8x64) ExtendLo16ToUint32() (z Uint32x16) {
	return Uint32x16{spec.ExtendLoLToZ[uint8, spec.Width512, uint32](x.v)}
}

// ExtendLo8ToUint64 zero-extends
// the lowest 8 vector elements to uint64.
func (x Uint8x64) ExtendLo8ToUint64() (z Uint64x8) {
	return Uint64x8{spec.ExtendLoLToZ[uint8, spec.Width512, uint64](x.v)}
}

// ExtendLo4ToUint32 zero-extends
// the lowest 4 vector elements to uint32.
func (x Uint16x8) ExtendLo4ToUint32() (z Uint32x4) {
	return Uint32x4{spec.ExtendLoLToZ[uint16, spec.Width128, uint32](x.v)}
}

// ExtendLo2ToUint64 zero-extends
// the lowest 2 vector elements to uint64.
func (x Uint16x8) ExtendLo2ToUint64() (z Uint64x2) {
	return Uint64x2{spec.ExtendLoLToZ[uint16, spec.Width128, uint64](x.v)}
}

// ExtendLo8ToUint32 zero-extends
// the lowest 8 vector elements to uint32.
func (x Uint16x16) ExtendLo8ToUint32() (z Uint32x8) {
	return Uint32x8{spec.ExtendLoLToZ[uint16, spec.Width256, uint32](x.v)}
}

// ExtendLo4ToUint64 zero-extends
// the lowest 4 vector elements to uint64.
func (x Uint16x16) ExtendLo4ToUint64() (z Uint64x4) {
	return Uint64x4{spec.ExtendLoLToZ[uint16, spec.Width256, uint64](x.v)}
}

// ExtendLo16ToUint32 zero-extends
// the lowest 16 vector elements to uint32.
func (x Uint16x32) ExtendLo16ToUint32() (z Uint32x16) {
	return Uint32x16{spec.ExtendLoLToZ[uint16, spec.Width512, uint32](x.v)}
}

// ExtendLo8ToUint64 zero-extends
// the lowest 8 vector elements to uint64.
func (x Uint16x32) ExtendLo8ToUint64() (z Uint64x8) {
	return Uint64x8{spec.ExtendLoLToZ[uint16, spec.Width512, uint64](x.v)}
}

// ExtendLo2ToUint64 zero-extends
// the lowest 2 vector elements to uint64.
func (x Uint32x4) ExtendLo2ToUint64() (z Uint64x2) {
	return Uint64x2{spec.ExtendLoLToZ[uint32, spec.Width128, uint64](x.v)}
}

// ExtendLo4ToUint64 zero-extends
// the lowest 4 vector elements to uint64.
func (x Uint32x8) ExtendLo4ToUint64() (z Uint64x4) {
	return Uint64x4{spec.ExtendLoLToZ[uint32, spec.Width256, uint64](x.v)}
}

// ExtendLo8ToUint64 zero-extends
// the lowest 8 vector elements to uint64.
func (x Uint32x16) ExtendLo8ToUint64() (z Uint64x8) {
	return Uint64x8{spec.ExtendLoLToZ[uint32, spec.Width512, uint64](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Float32x4) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[float32, spec.Width128, float64](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Float32x8) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[float32, spec.Width256, float64](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Float32x16) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[float32, spec.Width512, float64](x.v)}
}

// ConvertLo4ToFloat32 converts the low-indexed 4 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Int8x16) ConvertLo4ToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertLoLToZ[int8, spec.Width128, float32](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int8x16) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[int8, spec.Width128, float64](x.v)}
}

// ConvertLo8ToFloat32 converts the low-indexed 8 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Int8x32) ConvertLo8ToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertLoLToZ[int8, spec.Width256, float32](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int8x32) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[int8, spec.Width256, float64](x.v)}
}

// ConvertLo16ToFloat32 converts the low-indexed 16 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Int8x64) ConvertLo16ToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertLoLToZ[int8, spec.Width512, float32](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int8x64) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[int8, spec.Width512, float64](x.v)}
}

// ConvertLo4ToFloat32 converts the low-indexed 4 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Int16x8) ConvertLo4ToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertLoLToZ[int16, spec.Width128, float32](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int16x8) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[int16, spec.Width128, float64](x.v)}
}

// ConvertLo8ToFloat32 converts the low-indexed 8 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Int16x16) ConvertLo8ToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertLoLToZ[int16, spec.Width256, float32](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int16x16) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[int16, spec.Width256, float64](x.v)}
}

// ConvertLo16ToFloat32 converts the low-indexed 16 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Int16x32) ConvertLo16ToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertLoLToZ[int16, spec.Width512, float32](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int16x32) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[int16, spec.Width512, float64](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int32x4) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[int32, spec.Width128, float64](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int32x8) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[int32, spec.Width256, float64](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Int32x16) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[int32, spec.Width512, float64](x.v)}
}

// ConvertLo4ToFloat32 converts the low-indexed 4 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Uint8x16) ConvertLo4ToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertLoLToZ[uint8, spec.Width128, float32](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint8x16) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[uint8, spec.Width128, float64](x.v)}
}

// ConvertLo8ToFloat32 converts the low-indexed 8 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Uint8x32) ConvertLo8ToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertLoLToZ[uint8, spec.Width256, float32](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint8x32) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[uint8, spec.Width256, float64](x.v)}
}

// ConvertLo16ToFloat32 converts the low-indexed 16 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Uint8x64) ConvertLo16ToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertLoLToZ[uint8, spec.Width512, float32](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint8x64) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[uint8, spec.Width512, float64](x.v)}
}

// ConvertLo4ToFloat32 converts the low-indexed 4 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Uint16x8) ConvertLo4ToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertLoLToZ[uint16, spec.Width128, float32](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint16x8) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[uint16, spec.Width128, float64](x.v)}
}

// ConvertLo8ToFloat32 converts the low-indexed 8 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Uint16x16) ConvertLo8ToFloat32() (z Float32x8) {
	return Float32x8{spec.ConvertLoLToZ[uint16, spec.Width256, float32](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint16x16) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[uint16, spec.Width256, float64](x.v)}
}

// ConvertLo16ToFloat32 converts the low-indexed 16 elements of x to float32.
//
//	z[i] = float32(x[i])
func (x Uint16x32) ConvertLo16ToFloat32() (z Float32x16) {
	return Float32x16{spec.ConvertLoLToZ[uint16, spec.Width512, float32](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint16x32) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[uint16, spec.Width512, float64](x.v)}
}

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint32x4) ConvertLo2ToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertLoLToZ[uint32, spec.Width128, float64](x.v)}
}

// ConvertLo4ToFloat64 converts the low-indexed 4 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint32x8) ConvertLo4ToFloat64() (z Float64x4) {
	return Float64x4{spec.ConvertLoLToZ[uint32, spec.Width256, float64](x.v)}
}

// ConvertLo8ToFloat64 converts the low-indexed 8 elements of x to float64.
//
//	z[i] = float64(x[i])
func (x Uint32x16) ConvertLo8ToFloat64() (z Float64x8) {
	return Float64x8{spec.ConvertLoLToZ[uint32, spec.Width512, float64](x.v)}
}

// BroadcastFloat32x4 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat32x4(x float32) (z Float32x4) {
	return Float32x4{spec.BroadcastZ[float32, spec.Width128](x)}
}

// BroadcastFloat32x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat32x8(x float32) (z Float32x8) {
	return Float32x8{spec.BroadcastZ[float32, spec.Width256](x)}
}

// BroadcastFloat32x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat32x16(x float32) (z Float32x16) {
	return Float32x16{spec.BroadcastZ[float32, spec.Width512](x)}
}

// BroadcastFloat32s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat32s(x float32) (z Float32s) {
	return Float32s{spec.BroadcastZ[float32, spec.WidthScalable](x)}
}

// BroadcastFloat64x2 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat64x2(x float64) (z Float64x2) {
	return Float64x2{spec.BroadcastZ[float64, spec.Width128](x)}
}

// BroadcastFloat64x4 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat64x4(x float64) (z Float64x4) {
	return Float64x4{spec.BroadcastZ[float64, spec.Width256](x)}
}

// BroadcastFloat64x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat64x8(x float64) (z Float64x8) {
	return Float64x8{spec.BroadcastZ[float64, spec.Width512](x)}
}

// BroadcastFloat64s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastFloat64s(x float64) (z Float64s) {
	return Float64s{spec.BroadcastZ[float64, spec.WidthScalable](x)}
}

// BroadcastInt8x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt8x16(x int8) (z Int8x16) {
	return Int8x16{spec.BroadcastZ[int8, spec.Width128](x)}
}

// BroadcastInt8x32 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt8x32(x int8) (z Int8x32) {
	return Int8x32{spec.BroadcastZ[int8, spec.Width256](x)}
}

// BroadcastInt8x64 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt8x64(x int8) (z Int8x64) {
	return Int8x64{spec.BroadcastZ[int8, spec.Width512](x)}
}

// BroadcastInt8s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt8s(x int8) (z Int8s) {
	return Int8s{spec.BroadcastZ[int8, spec.WidthScalable](x)}
}

// BroadcastInt16x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt16x8(x int16) (z Int16x8) {
	return Int16x8{spec.BroadcastZ[int16, spec.Width128](x)}
}

// BroadcastInt16x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt16x16(x int16) (z Int16x16) {
	return Int16x16{spec.BroadcastZ[int16, spec.Width256](x)}
}

// BroadcastInt16x32 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt16x32(x int16) (z Int16x32) {
	return Int16x32{spec.BroadcastZ[int16, spec.Width512](x)}
}

// BroadcastInt16s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt16s(x int16) (z Int16s) {
	return Int16s{spec.BroadcastZ[int16, spec.WidthScalable](x)}
}

// BroadcastInt32x4 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt32x4(x int32) (z Int32x4) {
	return Int32x4{spec.BroadcastZ[int32, spec.Width128](x)}
}

// BroadcastInt32x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt32x8(x int32) (z Int32x8) {
	return Int32x8{spec.BroadcastZ[int32, spec.Width256](x)}
}

// BroadcastInt32x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt32x16(x int32) (z Int32x16) {
	return Int32x16{spec.BroadcastZ[int32, spec.Width512](x)}
}

// BroadcastInt32s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt32s(x int32) (z Int32s) {
	return Int32s{spec.BroadcastZ[int32, spec.WidthScalable](x)}
}

// BroadcastInt64x2 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt64x2(x int64) (z Int64x2) {
	return Int64x2{spec.BroadcastZ[int64, spec.Width128](x)}
}

// BroadcastInt64x4 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt64x4(x int64) (z Int64x4) {
	return Int64x4{spec.BroadcastZ[int64, spec.Width256](x)}
}

// BroadcastInt64x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt64x8(x int64) (z Int64x8) {
	return Int64x8{spec.BroadcastZ[int64, spec.Width512](x)}
}

// BroadcastInt64s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastInt64s(x int64) (z Int64s) {
	return Int64s{spec.BroadcastZ[int64, spec.WidthScalable](x)}
}

// BroadcastUint8x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint8x16(x uint8) (z Uint8x16) {
	return Uint8x16{spec.BroadcastZ[uint8, spec.Width128](x)}
}

// BroadcastUint8x32 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint8x32(x uint8) (z Uint8x32) {
	return Uint8x32{spec.BroadcastZ[uint8, spec.Width256](x)}
}

// BroadcastUint8x64 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint8x64(x uint8) (z Uint8x64) {
	return Uint8x64{spec.BroadcastZ[uint8, spec.Width512](x)}
}

// BroadcastUint8s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint8s(x uint8) (z Uint8s) {
	return Uint8s{spec.BroadcastZ[uint8, spec.WidthScalable](x)}
}

// BroadcastUint16x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint16x8(x uint16) (z Uint16x8) {
	return Uint16x8{spec.BroadcastZ[uint16, spec.Width128](x)}
}

// BroadcastUint16x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint16x16(x uint16) (z Uint16x16) {
	return Uint16x16{spec.BroadcastZ[uint16, spec.Width256](x)}
}

// BroadcastUint16x32 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint16x32(x uint16) (z Uint16x32) {
	return Uint16x32{spec.BroadcastZ[uint16, spec.Width512](x)}
}

// BroadcastUint16s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint16s(x uint16) (z Uint16s) {
	return Uint16s{spec.BroadcastZ[uint16, spec.WidthScalable](x)}
}

// BroadcastUint32x4 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint32x4(x uint32) (z Uint32x4) {
	return Uint32x4{spec.BroadcastZ[uint32, spec.Width128](x)}
}

// BroadcastUint32x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint32x8(x uint32) (z Uint32x8) {
	return Uint32x8{spec.BroadcastZ[uint32, spec.Width256](x)}
}

// BroadcastUint32x16 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint32x16(x uint32) (z Uint32x16) {
	return Uint32x16{spec.BroadcastZ[uint32, spec.Width512](x)}
}

// BroadcastUint32s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint32s(x uint32) (z Uint32s) {
	return Uint32s{spec.BroadcastZ[uint32, spec.WidthScalable](x)}
}

// BroadcastUint64x2 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint64x2(x uint64) (z Uint64x2) {
	return Uint64x2{spec.BroadcastZ[uint64, spec.Width128](x)}
}

// BroadcastUint64x4 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint64x4(x uint64) (z Uint64x4) {
	return Uint64x4{spec.BroadcastZ[uint64, spec.Width256](x)}
}

// BroadcastUint64x8 returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint64x8(x uint64) (z Uint64x8) {
	return Uint64x8{spec.BroadcastZ[uint64, spec.Width512](x)}
}

// BroadcastUint64s returns a vector with the input x assigned to all elements of the
// result.
func BroadcastUint64s(x uint64) (z Uint64s) {
	return Uint64s{spec.BroadcastZ[uint64, spec.WidthScalable](x)}
}

// LoadFloat32x4 loads a slice into a vector. If len(s) < 4, it panics.
func LoadFloat32x4(s []float32) (z Float32x4) {
	return Float32x4{spec.LoadZ[float32, spec.Width128](s)}
}

// LoadFloat32x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadFloat32x8(s []float32) (z Float32x8) {
	return Float32x8{spec.LoadZ[float32, spec.Width256](s)}
}

// LoadFloat32x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadFloat32x16(s []float32) (z Float32x16) {
	return Float32x16{spec.LoadZ[float32, spec.Width512](s)}
}

// LoadFloat32s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadFloat32s(s []float32) (z Float32s) {
	return Float32s{spec.LoadZ[float32, spec.WidthScalable](s)}
}

// LoadFloat64x2 loads a slice into a vector. If len(s) < 2, it panics.
func LoadFloat64x2(s []float64) (z Float64x2) {
	return Float64x2{spec.LoadZ[float64, spec.Width128](s)}
}

// LoadFloat64x4 loads a slice into a vector. If len(s) < 4, it panics.
func LoadFloat64x4(s []float64) (z Float64x4) {
	return Float64x4{spec.LoadZ[float64, spec.Width256](s)}
}

// LoadFloat64x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadFloat64x8(s []float64) (z Float64x8) {
	return Float64x8{spec.LoadZ[float64, spec.Width512](s)}
}

// LoadFloat64s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadFloat64s(s []float64) (z Float64s) {
	return Float64s{spec.LoadZ[float64, spec.WidthScalable](s)}
}

// LoadInt8x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadInt8x16(s []int8) (z Int8x16) {
	return Int8x16{spec.LoadZ[int8, spec.Width128](s)}
}

// LoadInt8x32 loads a slice into a vector. If len(s) < 32, it panics.
func LoadInt8x32(s []int8) (z Int8x32) {
	return Int8x32{spec.LoadZ[int8, spec.Width256](s)}
}

// LoadInt8x64 loads a slice into a vector. If len(s) < 64, it panics.
func LoadInt8x64(s []int8) (z Int8x64) {
	return Int8x64{spec.LoadZ[int8, spec.Width512](s)}
}

// LoadInt8s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadInt8s(s []int8) (z Int8s) {
	return Int8s{spec.LoadZ[int8, spec.WidthScalable](s)}
}

// LoadInt16x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadInt16x8(s []int16) (z Int16x8) {
	return Int16x8{spec.LoadZ[int16, spec.Width128](s)}
}

// LoadInt16x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadInt16x16(s []int16) (z Int16x16) {
	return Int16x16{spec.LoadZ[int16, spec.Width256](s)}
}

// LoadInt16x32 loads a slice into a vector. If len(s) < 32, it panics.
func LoadInt16x32(s []int16) (z Int16x32) {
	return Int16x32{spec.LoadZ[int16, spec.Width512](s)}
}

// LoadInt16s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadInt16s(s []int16) (z Int16s) {
	return Int16s{spec.LoadZ[int16, spec.WidthScalable](s)}
}

// LoadInt32x4 loads a slice into a vector. If len(s) < 4, it panics.
func LoadInt32x4(s []int32) (z Int32x4) {
	return Int32x4{spec.LoadZ[int32, spec.Width128](s)}
}

// LoadInt32x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadInt32x8(s []int32) (z Int32x8) {
	return Int32x8{spec.LoadZ[int32, spec.Width256](s)}
}

// LoadInt32x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadInt32x16(s []int32) (z Int32x16) {
	return Int32x16{spec.LoadZ[int32, spec.Width512](s)}
}

// LoadInt32s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadInt32s(s []int32) (z Int32s) {
	return Int32s{spec.LoadZ[int32, spec.WidthScalable](s)}
}

// LoadInt64x2 loads a slice into a vector. If len(s) < 2, it panics.
func LoadInt64x2(s []int64) (z Int64x2) {
	return Int64x2{spec.LoadZ[int64, spec.Width128](s)}
}

// LoadInt64x4 loads a slice into a vector. If len(s) < 4, it panics.
func LoadInt64x4(s []int64) (z Int64x4) {
	return Int64x4{spec.LoadZ[int64, spec.Width256](s)}
}

// LoadInt64x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadInt64x8(s []int64) (z Int64x8) {
	return Int64x8{spec.LoadZ[int64, spec.Width512](s)}
}

// LoadInt64s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadInt64s(s []int64) (z Int64s) {
	return Int64s{spec.LoadZ[int64, spec.WidthScalable](s)}
}

// LoadUint8x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadUint8x16(s []uint8) (z Uint8x16) {
	return Uint8x16{spec.LoadZ[uint8, spec.Width128](s)}
}

// LoadUint8x32 loads a slice into a vector. If len(s) < 32, it panics.
func LoadUint8x32(s []uint8) (z Uint8x32) {
	return Uint8x32{spec.LoadZ[uint8, spec.Width256](s)}
}

// LoadUint8x64 loads a slice into a vector. If len(s) < 64, it panics.
func LoadUint8x64(s []uint8) (z Uint8x64) {
	return Uint8x64{spec.LoadZ[uint8, spec.Width512](s)}
}

// LoadUint8s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadUint8s(s []uint8) (z Uint8s) {
	return Uint8s{spec.LoadZ[uint8, spec.WidthScalable](s)}
}

// LoadUint16x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadUint16x8(s []uint16) (z Uint16x8) {
	return Uint16x8{spec.LoadZ[uint16, spec.Width128](s)}
}

// LoadUint16x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadUint16x16(s []uint16) (z Uint16x16) {
	return Uint16x16{spec.LoadZ[uint16, spec.Width256](s)}
}

// LoadUint16x32 loads a slice into a vector. If len(s) < 32, it panics.
func LoadUint16x32(s []uint16) (z Uint16x32) {
	return Uint16x32{spec.LoadZ[uint16, spec.Width512](s)}
}

// LoadUint16s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadUint16s(s []uint16) (z Uint16s) {
	return Uint16s{spec.LoadZ[uint16, spec.WidthScalable](s)}
}

// LoadUint32x4 loads a slice into a vector. If len(s) < 4, it panics.
func LoadUint32x4(s []uint32) (z Uint32x4) {
	return Uint32x4{spec.LoadZ[uint32, spec.Width128](s)}
}

// LoadUint32x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadUint32x8(s []uint32) (z Uint32x8) {
	return Uint32x8{spec.LoadZ[uint32, spec.Width256](s)}
}

// LoadUint32x16 loads a slice into a vector. If len(s) < 16, it panics.
func LoadUint32x16(s []uint32) (z Uint32x16) {
	return Uint32x16{spec.LoadZ[uint32, spec.Width512](s)}
}

// LoadUint32s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadUint32s(s []uint32) (z Uint32s) {
	return Uint32s{spec.LoadZ[uint32, spec.WidthScalable](s)}
}

// LoadUint64x2 loads a slice into a vector. If len(s) < 2, it panics.
func LoadUint64x2(s []uint64) (z Uint64x2) {
	return Uint64x2{spec.LoadZ[uint64, spec.Width128](s)}
}

// LoadUint64x4 loads a slice into a vector. If len(s) < 4, it panics.
func LoadUint64x4(s []uint64) (z Uint64x4) {
	return Uint64x4{spec.LoadZ[uint64, spec.Width256](s)}
}

// LoadUint64x8 loads a slice into a vector. If len(s) < 8, it panics.
func LoadUint64x8(s []uint64) (z Uint64x8) {
	return Uint64x8{spec.LoadZ[uint64, spec.Width512](s)}
}

// LoadUint64s loads a slice into a vector. If len(s) < z.Len(), it panics.
func LoadUint64s(s []uint64) (z Uint64s) {
	return Uint64s{spec.LoadZ[uint64, spec.WidthScalable](s)}
}

// LoadFloat32x4Array loads an array into a vector.
func LoadFloat32x4Array(x *[4]float32) (z Float32x4) {
	var tmp0 spec.Array[float32, spec.Width128] = x[:]
	return Float32x4{spec.LoadZArray[float32, spec.Width128](&tmp0)}
}

// LoadFloat32x8Array loads an array into a vector.
func LoadFloat32x8Array(x *[8]float32) (z Float32x8) {
	var tmp0 spec.Array[float32, spec.Width256] = x[:]
	return Float32x8{spec.LoadZArray[float32, spec.Width256](&tmp0)}
}

// LoadFloat32x16Array loads an array into a vector.
func LoadFloat32x16Array(x *[16]float32) (z Float32x16) {
	var tmp0 spec.Array[float32, spec.Width512] = x[:]
	return Float32x16{spec.LoadZArray[float32, spec.Width512](&tmp0)}
}

// LoadFloat64x2Array loads an array into a vector.
func LoadFloat64x2Array(x *[2]float64) (z Float64x2) {
	var tmp0 spec.Array[float64, spec.Width128] = x[:]
	return Float64x2{spec.LoadZArray[float64, spec.Width128](&tmp0)}
}

// LoadFloat64x4Array loads an array into a vector.
func LoadFloat64x4Array(x *[4]float64) (z Float64x4) {
	var tmp0 spec.Array[float64, spec.Width256] = x[:]
	return Float64x4{spec.LoadZArray[float64, spec.Width256](&tmp0)}
}

// LoadFloat64x8Array loads an array into a vector.
func LoadFloat64x8Array(x *[8]float64) (z Float64x8) {
	var tmp0 spec.Array[float64, spec.Width512] = x[:]
	return Float64x8{spec.LoadZArray[float64, spec.Width512](&tmp0)}
}

// LoadInt8x16Array loads an array into a vector.
func LoadInt8x16Array(x *[16]int8) (z Int8x16) {
	var tmp0 spec.Array[int8, spec.Width128] = x[:]
	return Int8x16{spec.LoadZArray[int8, spec.Width128](&tmp0)}
}

// LoadInt8x32Array loads an array into a vector.
func LoadInt8x32Array(x *[32]int8) (z Int8x32) {
	var tmp0 spec.Array[int8, spec.Width256] = x[:]
	return Int8x32{spec.LoadZArray[int8, spec.Width256](&tmp0)}
}

// LoadInt8x64Array loads an array into a vector.
func LoadInt8x64Array(x *[64]int8) (z Int8x64) {
	var tmp0 spec.Array[int8, spec.Width512] = x[:]
	return Int8x64{spec.LoadZArray[int8, spec.Width512](&tmp0)}
}

// LoadInt16x8Array loads an array into a vector.
func LoadInt16x8Array(x *[8]int16) (z Int16x8) {
	var tmp0 spec.Array[int16, spec.Width128] = x[:]
	return Int16x8{spec.LoadZArray[int16, spec.Width128](&tmp0)}
}

// LoadInt16x16Array loads an array into a vector.
func LoadInt16x16Array(x *[16]int16) (z Int16x16) {
	var tmp0 spec.Array[int16, spec.Width256] = x[:]
	return Int16x16{spec.LoadZArray[int16, spec.Width256](&tmp0)}
}

// LoadInt16x32Array loads an array into a vector.
func LoadInt16x32Array(x *[32]int16) (z Int16x32) {
	var tmp0 spec.Array[int16, spec.Width512] = x[:]
	return Int16x32{spec.LoadZArray[int16, spec.Width512](&tmp0)}
}

// LoadInt32x4Array loads an array into a vector.
func LoadInt32x4Array(x *[4]int32) (z Int32x4) {
	var tmp0 spec.Array[int32, spec.Width128] = x[:]
	return Int32x4{spec.LoadZArray[int32, spec.Width128](&tmp0)}
}

// LoadInt32x8Array loads an array into a vector.
func LoadInt32x8Array(x *[8]int32) (z Int32x8) {
	var tmp0 spec.Array[int32, spec.Width256] = x[:]
	return Int32x8{spec.LoadZArray[int32, spec.Width256](&tmp0)}
}

// LoadInt32x16Array loads an array into a vector.
func LoadInt32x16Array(x *[16]int32) (z Int32x16) {
	var tmp0 spec.Array[int32, spec.Width512] = x[:]
	return Int32x16{spec.LoadZArray[int32, spec.Width512](&tmp0)}
}

// LoadInt64x2Array loads an array into a vector.
func LoadInt64x2Array(x *[2]int64) (z Int64x2) {
	var tmp0 spec.Array[int64, spec.Width128] = x[:]
	return Int64x2{spec.LoadZArray[int64, spec.Width128](&tmp0)}
}

// LoadInt64x4Array loads an array into a vector.
func LoadInt64x4Array(x *[4]int64) (z Int64x4) {
	var tmp0 spec.Array[int64, spec.Width256] = x[:]
	return Int64x4{spec.LoadZArray[int64, spec.Width256](&tmp0)}
}

// LoadInt64x8Array loads an array into a vector.
func LoadInt64x8Array(x *[8]int64) (z Int64x8) {
	var tmp0 spec.Array[int64, spec.Width512] = x[:]
	return Int64x8{spec.LoadZArray[int64, spec.Width512](&tmp0)}
}

// LoadUint8x16Array loads an array into a vector.
func LoadUint8x16Array(x *[16]uint8) (z Uint8x16) {
	var tmp0 spec.Array[uint8, spec.Width128] = x[:]
	return Uint8x16{spec.LoadZArray[uint8, spec.Width128](&tmp0)}
}

// LoadUint8x32Array loads an array into a vector.
func LoadUint8x32Array(x *[32]uint8) (z Uint8x32) {
	var tmp0 spec.Array[uint8, spec.Width256] = x[:]
	return Uint8x32{spec.LoadZArray[uint8, spec.Width256](&tmp0)}
}

// LoadUint8x64Array loads an array into a vector.
func LoadUint8x64Array(x *[64]uint8) (z Uint8x64) {
	var tmp0 spec.Array[uint8, spec.Width512] = x[:]
	return Uint8x64{spec.LoadZArray[uint8, spec.Width512](&tmp0)}
}

// LoadUint16x8Array loads an array into a vector.
func LoadUint16x8Array(x *[8]uint16) (z Uint16x8) {
	var tmp0 spec.Array[uint16, spec.Width128] = x[:]
	return Uint16x8{spec.LoadZArray[uint16, spec.Width128](&tmp0)}
}

// LoadUint16x16Array loads an array into a vector.
func LoadUint16x16Array(x *[16]uint16) (z Uint16x16) {
	var tmp0 spec.Array[uint16, spec.Width256] = x[:]
	return Uint16x16{spec.LoadZArray[uint16, spec.Width256](&tmp0)}
}

// LoadUint16x32Array loads an array into a vector.
func LoadUint16x32Array(x *[32]uint16) (z Uint16x32) {
	var tmp0 spec.Array[uint16, spec.Width512] = x[:]
	return Uint16x32{spec.LoadZArray[uint16, spec.Width512](&tmp0)}
}

// LoadUint32x4Array loads an array into a vector.
func LoadUint32x4Array(x *[4]uint32) (z Uint32x4) {
	var tmp0 spec.Array[uint32, spec.Width128] = x[:]
	return Uint32x4{spec.LoadZArray[uint32, spec.Width128](&tmp0)}
}

// LoadUint32x8Array loads an array into a vector.
func LoadUint32x8Array(x *[8]uint32) (z Uint32x8) {
	var tmp0 spec.Array[uint32, spec.Width256] = x[:]
	return Uint32x8{spec.LoadZArray[uint32, spec.Width256](&tmp0)}
}

// LoadUint32x16Array loads an array into a vector.
func LoadUint32x16Array(x *[16]uint32) (z Uint32x16) {
	var tmp0 spec.Array[uint32, spec.Width512] = x[:]
	return Uint32x16{spec.LoadZArray[uint32, spec.Width512](&tmp0)}
}

// LoadUint64x2Array loads an array into a vector.
func LoadUint64x2Array(x *[2]uint64) (z Uint64x2) {
	var tmp0 spec.Array[uint64, spec.Width128] = x[:]
	return Uint64x2{spec.LoadZArray[uint64, spec.Width128](&tmp0)}
}

// LoadUint64x4Array loads an array into a vector.
func LoadUint64x4Array(x *[4]uint64) (z Uint64x4) {
	var tmp0 spec.Array[uint64, spec.Width256] = x[:]
	return Uint64x4{spec.LoadZArray[uint64, spec.Width256](&tmp0)}
}

// LoadUint64x8Array loads an array into a vector.
func LoadUint64x8Array(x *[8]uint64) (z Uint64x8) {
	var tmp0 spec.Array[uint64, spec.Width512] = x[:]
	return Uint64x8{spec.LoadZArray[uint64, spec.Width512](&tmp0)}
}

// LoadFloat32x4Part loads n=min(len(s), 4) elements from slice s as a
// vector and returns the vector and n. If len(s) < 4, the
// remaining vector elements will be zero.
func LoadFloat32x4Part(s []float32) (z Float32x4, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.Width128](s)
	return Float32x4{r1}, r2
}

// LoadFloat32x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadFloat32x8Part(s []float32) (z Float32x8, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.Width256](s)
	return Float32x8{r1}, r2
}

// LoadFloat32x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadFloat32x16Part(s []float32) (z Float32x16, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.Width512](s)
	return Float32x16{r1}, r2
}

// LoadFloat32sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadFloat32sPart(s []float32) (z Float32s, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.WidthScalable](s)
	return Float32s{r1}, r2
}

// LoadFloat64x2Part loads n=min(len(s), 2) elements from slice s as a
// vector and returns the vector and n. If len(s) < 2, the
// remaining vector elements will be zero.
func LoadFloat64x2Part(s []float64) (z Float64x2, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.Width128](s)
	return Float64x2{r1}, r2
}

// LoadFloat64x4Part loads n=min(len(s), 4) elements from slice s as a
// vector and returns the vector and n. If len(s) < 4, the
// remaining vector elements will be zero.
func LoadFloat64x4Part(s []float64) (z Float64x4, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.Width256](s)
	return Float64x4{r1}, r2
}

// LoadFloat64x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadFloat64x8Part(s []float64) (z Float64x8, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.Width512](s)
	return Float64x8{r1}, r2
}

// LoadFloat64sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadFloat64sPart(s []float64) (z Float64s, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.WidthScalable](s)
	return Float64s{r1}, r2
}

// LoadInt8x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadInt8x16Part(s []int8) (z Int8x16, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.Width128](s)
	return Int8x16{r1}, r2
}

// LoadInt8x32Part loads n=min(len(s), 32) elements from slice s as a
// vector and returns the vector and n. If len(s) < 32, the
// remaining vector elements will be zero.
func LoadInt8x32Part(s []int8) (z Int8x32, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.Width256](s)
	return Int8x32{r1}, r2
}

// LoadInt8x64Part loads n=min(len(s), 64) elements from slice s as a
// vector and returns the vector and n. If len(s) < 64, the
// remaining vector elements will be zero.
func LoadInt8x64Part(s []int8) (z Int8x64, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.Width512](s)
	return Int8x64{r1}, r2
}

// LoadInt8sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadInt8sPart(s []int8) (z Int8s, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.WidthScalable](s)
	return Int8s{r1}, r2
}

// LoadInt16x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadInt16x8Part(s []int16) (z Int16x8, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.Width128](s)
	return Int16x8{r1}, r2
}

// LoadInt16x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadInt16x16Part(s []int16) (z Int16x16, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.Width256](s)
	return Int16x16{r1}, r2
}

// LoadInt16x32Part loads n=min(len(s), 32) elements from slice s as a
// vector and returns the vector and n. If len(s) < 32, the
// remaining vector elements will be zero.
func LoadInt16x32Part(s []int16) (z Int16x32, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.Width512](s)
	return Int16x32{r1}, r2
}

// LoadInt16sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadInt16sPart(s []int16) (z Int16s, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.WidthScalable](s)
	return Int16s{r1}, r2
}

// LoadInt32x4Part loads n=min(len(s), 4) elements from slice s as a
// vector and returns the vector and n. If len(s) < 4, the
// remaining vector elements will be zero.
func LoadInt32x4Part(s []int32) (z Int32x4, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.Width128](s)
	return Int32x4{r1}, r2
}

// LoadInt32x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadInt32x8Part(s []int32) (z Int32x8, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.Width256](s)
	return Int32x8{r1}, r2
}

// LoadInt32x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadInt32x16Part(s []int32) (z Int32x16, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.Width512](s)
	return Int32x16{r1}, r2
}

// LoadInt32sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadInt32sPart(s []int32) (z Int32s, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.WidthScalable](s)
	return Int32s{r1}, r2
}

// LoadInt64x2Part loads n=min(len(s), 2) elements from slice s as a
// vector and returns the vector and n. If len(s) < 2, the
// remaining vector elements will be zero.
func LoadInt64x2Part(s []int64) (z Int64x2, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.Width128](s)
	return Int64x2{r1}, r2
}

// LoadInt64x4Part loads n=min(len(s), 4) elements from slice s as a
// vector and returns the vector and n. If len(s) < 4, the
// remaining vector elements will be zero.
func LoadInt64x4Part(s []int64) (z Int64x4, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.Width256](s)
	return Int64x4{r1}, r2
}

// LoadInt64x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadInt64x8Part(s []int64) (z Int64x8, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.Width512](s)
	return Int64x8{r1}, r2
}

// LoadInt64sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadInt64sPart(s []int64) (z Int64s, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.WidthScalable](s)
	return Int64s{r1}, r2
}

// LoadUint8x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadUint8x16Part(s []uint8) (z Uint8x16, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.Width128](s)
	return Uint8x16{r1}, r2
}

// LoadUint8x32Part loads n=min(len(s), 32) elements from slice s as a
// vector and returns the vector and n. If len(s) < 32, the
// remaining vector elements will be zero.
func LoadUint8x32Part(s []uint8) (z Uint8x32, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.Width256](s)
	return Uint8x32{r1}, r2
}

// LoadUint8x64Part loads n=min(len(s), 64) elements from slice s as a
// vector and returns the vector and n. If len(s) < 64, the
// remaining vector elements will be zero.
func LoadUint8x64Part(s []uint8) (z Uint8x64, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.Width512](s)
	return Uint8x64{r1}, r2
}

// LoadUint8sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadUint8sPart(s []uint8) (z Uint8s, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.WidthScalable](s)
	return Uint8s{r1}, r2
}

// LoadUint16x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadUint16x8Part(s []uint16) (z Uint16x8, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.Width128](s)
	return Uint16x8{r1}, r2
}

// LoadUint16x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadUint16x16Part(s []uint16) (z Uint16x16, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.Width256](s)
	return Uint16x16{r1}, r2
}

// LoadUint16x32Part loads n=min(len(s), 32) elements from slice s as a
// vector and returns the vector and n. If len(s) < 32, the
// remaining vector elements will be zero.
func LoadUint16x32Part(s []uint16) (z Uint16x32, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.Width512](s)
	return Uint16x32{r1}, r2
}

// LoadUint16sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadUint16sPart(s []uint16) (z Uint16s, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.WidthScalable](s)
	return Uint16s{r1}, r2
}

// LoadUint32x4Part loads n=min(len(s), 4) elements from slice s as a
// vector and returns the vector and n. If len(s) < 4, the
// remaining vector elements will be zero.
func LoadUint32x4Part(s []uint32) (z Uint32x4, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.Width128](s)
	return Uint32x4{r1}, r2
}

// LoadUint32x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadUint32x8Part(s []uint32) (z Uint32x8, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.Width256](s)
	return Uint32x8{r1}, r2
}

// LoadUint32x16Part loads n=min(len(s), 16) elements from slice s as a
// vector and returns the vector and n. If len(s) < 16, the
// remaining vector elements will be zero.
func LoadUint32x16Part(s []uint32) (z Uint32x16, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.Width512](s)
	return Uint32x16{r1}, r2
}

// LoadUint32sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadUint32sPart(s []uint32) (z Uint32s, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.WidthScalable](s)
	return Uint32s{r1}, r2
}

// LoadUint64x2Part loads n=min(len(s), 2) elements from slice s as a
// vector and returns the vector and n. If len(s) < 2, the
// remaining vector elements will be zero.
func LoadUint64x2Part(s []uint64) (z Uint64x2, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.Width128](s)
	return Uint64x2{r1}, r2
}

// LoadUint64x4Part loads n=min(len(s), 4) elements from slice s as a
// vector and returns the vector and n. If len(s) < 4, the
// remaining vector elements will be zero.
func LoadUint64x4Part(s []uint64) (z Uint64x4, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.Width256](s)
	return Uint64x4{r1}, r2
}

// LoadUint64x8Part loads n=min(len(s), 8) elements from slice s as a
// vector and returns the vector and n. If len(s) < 8, the
// remaining vector elements will be zero.
func LoadUint64x8Part(s []uint64) (z Uint64x8, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.Width512](s)
	return Uint64x8{r1}, r2
}

// LoadUint64sPart loads n=min(len(s), z.Len()) elements from slice s as a
// vector and returns the vector and n. If len(s) < z.Len(), the
// remaining vector elements will be zero.
func LoadUint64sPart(s []uint64) (z Uint64s, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.WidthScalable](s)
	return Uint64s{r1}, r2
}

// Store stores the elements of x into a slice. If len(s) < 4, it panics.
func (x Float32x4) Store(s []float32) {
	spec.Store[float32, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Float32x8) Store(s []float32) {
	spec.Store[float32, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Float32x16) Store(s []float32) {
	spec.Store[float32, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Float32s) Store(s []float32) {
	spec.Store[float32, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 2, it panics.
func (x Float64x2) Store(s []float64) {
	spec.Store[float64, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 4, it panics.
func (x Float64x4) Store(s []float64) {
	spec.Store[float64, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Float64x8) Store(s []float64) {
	spec.Store[float64, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Float64s) Store(s []float64) {
	spec.Store[float64, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Int8x16) Store(s []int8) {
	spec.Store[int8, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 32, it panics.
func (x Int8x32) Store(s []int8) {
	spec.Store[int8, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 64, it panics.
func (x Int8x64) Store(s []int8) {
	spec.Store[int8, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Int8s) Store(s []int8) {
	spec.Store[int8, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Int16x8) Store(s []int16) {
	spec.Store[int16, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Int16x16) Store(s []int16) {
	spec.Store[int16, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 32, it panics.
func (x Int16x32) Store(s []int16) {
	spec.Store[int16, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Int16s) Store(s []int16) {
	spec.Store[int16, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 4, it panics.
func (x Int32x4) Store(s []int32) {
	spec.Store[int32, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Int32x8) Store(s []int32) {
	spec.Store[int32, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Int32x16) Store(s []int32) {
	spec.Store[int32, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Int32s) Store(s []int32) {
	spec.Store[int32, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 2, it panics.
func (x Int64x2) Store(s []int64) {
	spec.Store[int64, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 4, it panics.
func (x Int64x4) Store(s []int64) {
	spec.Store[int64, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Int64x8) Store(s []int64) {
	spec.Store[int64, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Int64s) Store(s []int64) {
	spec.Store[int64, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Uint8x16) Store(s []uint8) {
	spec.Store[uint8, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 32, it panics.
func (x Uint8x32) Store(s []uint8) {
	spec.Store[uint8, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 64, it panics.
func (x Uint8x64) Store(s []uint8) {
	spec.Store[uint8, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Uint8s) Store(s []uint8) {
	spec.Store[uint8, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Uint16x8) Store(s []uint16) {
	spec.Store[uint16, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Uint16x16) Store(s []uint16) {
	spec.Store[uint16, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 32, it panics.
func (x Uint16x32) Store(s []uint16) {
	spec.Store[uint16, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Uint16s) Store(s []uint16) {
	spec.Store[uint16, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 4, it panics.
func (x Uint32x4) Store(s []uint32) {
	spec.Store[uint32, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Uint32x8) Store(s []uint32) {
	spec.Store[uint32, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 16, it panics.
func (x Uint32x16) Store(s []uint32) {
	spec.Store[uint32, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Uint32s) Store(s []uint32) {
	spec.Store[uint32, spec.WidthScalable](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 2, it panics.
func (x Uint64x2) Store(s []uint64) {
	spec.Store[uint64, spec.Width128](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 4, it panics.
func (x Uint64x4) Store(s []uint64) {
	spec.Store[uint64, spec.Width256](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < 8, it panics.
func (x Uint64x8) Store(s []uint64) {
	spec.Store[uint64, spec.Width512](x.v, s)
}

// Store stores the elements of x into a slice. If len(s) < x.Len(), it panics.
func (x Uint64s) Store(s []uint64) {
	spec.Store[uint64, spec.WidthScalable](x.v, s)
}

// StoreArray stores the elements of x to an array.
func (x Float32x4) StoreArray(y *[4]float32) {
	var tmp0 spec.Array[float32, spec.Width128] = y[:]
	spec.StoreArray[float32, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Float32x8) StoreArray(y *[8]float32) {
	var tmp0 spec.Array[float32, spec.Width256] = y[:]
	spec.StoreArray[float32, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Float32x16) StoreArray(y *[16]float32) {
	var tmp0 spec.Array[float32, spec.Width512] = y[:]
	spec.StoreArray[float32, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Float64x2) StoreArray(y *[2]float64) {
	var tmp0 spec.Array[float64, spec.Width128] = y[:]
	spec.StoreArray[float64, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Float64x4) StoreArray(y *[4]float64) {
	var tmp0 spec.Array[float64, spec.Width256] = y[:]
	spec.StoreArray[float64, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Float64x8) StoreArray(y *[8]float64) {
	var tmp0 spec.Array[float64, spec.Width512] = y[:]
	spec.StoreArray[float64, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int8x16) StoreArray(y *[16]int8) {
	var tmp0 spec.Array[int8, spec.Width128] = y[:]
	spec.StoreArray[int8, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int8x32) StoreArray(y *[32]int8) {
	var tmp0 spec.Array[int8, spec.Width256] = y[:]
	spec.StoreArray[int8, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int8x64) StoreArray(y *[64]int8) {
	var tmp0 spec.Array[int8, spec.Width512] = y[:]
	spec.StoreArray[int8, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int16x8) StoreArray(y *[8]int16) {
	var tmp0 spec.Array[int16, spec.Width128] = y[:]
	spec.StoreArray[int16, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int16x16) StoreArray(y *[16]int16) {
	var tmp0 spec.Array[int16, spec.Width256] = y[:]
	spec.StoreArray[int16, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int16x32) StoreArray(y *[32]int16) {
	var tmp0 spec.Array[int16, spec.Width512] = y[:]
	spec.StoreArray[int16, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int32x4) StoreArray(y *[4]int32) {
	var tmp0 spec.Array[int32, spec.Width128] = y[:]
	spec.StoreArray[int32, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int32x8) StoreArray(y *[8]int32) {
	var tmp0 spec.Array[int32, spec.Width256] = y[:]
	spec.StoreArray[int32, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int32x16) StoreArray(y *[16]int32) {
	var tmp0 spec.Array[int32, spec.Width512] = y[:]
	spec.StoreArray[int32, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int64x2) StoreArray(y *[2]int64) {
	var tmp0 spec.Array[int64, spec.Width128] = y[:]
	spec.StoreArray[int64, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int64x4) StoreArray(y *[4]int64) {
	var tmp0 spec.Array[int64, spec.Width256] = y[:]
	spec.StoreArray[int64, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Int64x8) StoreArray(y *[8]int64) {
	var tmp0 spec.Array[int64, spec.Width512] = y[:]
	spec.StoreArray[int64, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint8x16) StoreArray(y *[16]uint8) {
	var tmp0 spec.Array[uint8, spec.Width128] = y[:]
	spec.StoreArray[uint8, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint8x32) StoreArray(y *[32]uint8) {
	var tmp0 spec.Array[uint8, spec.Width256] = y[:]
	spec.StoreArray[uint8, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint8x64) StoreArray(y *[64]uint8) {
	var tmp0 spec.Array[uint8, spec.Width512] = y[:]
	spec.StoreArray[uint8, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint16x8) StoreArray(y *[8]uint16) {
	var tmp0 spec.Array[uint16, spec.Width128] = y[:]
	spec.StoreArray[uint16, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint16x16) StoreArray(y *[16]uint16) {
	var tmp0 spec.Array[uint16, spec.Width256] = y[:]
	spec.StoreArray[uint16, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint16x32) StoreArray(y *[32]uint16) {
	var tmp0 spec.Array[uint16, spec.Width512] = y[:]
	spec.StoreArray[uint16, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint32x4) StoreArray(y *[4]uint32) {
	var tmp0 spec.Array[uint32, spec.Width128] = y[:]
	spec.StoreArray[uint32, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint32x8) StoreArray(y *[8]uint32) {
	var tmp0 spec.Array[uint32, spec.Width256] = y[:]
	spec.StoreArray[uint32, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint32x16) StoreArray(y *[16]uint32) {
	var tmp0 spec.Array[uint32, spec.Width512] = y[:]
	spec.StoreArray[uint32, spec.Width512](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint64x2) StoreArray(y *[2]uint64) {
	var tmp0 spec.Array[uint64, spec.Width128] = y[:]
	spec.StoreArray[uint64, spec.Width128](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint64x4) StoreArray(y *[4]uint64) {
	var tmp0 spec.Array[uint64, spec.Width256] = y[:]
	spec.StoreArray[uint64, spec.Width256](x.v, &tmp0)
}

// StoreArray stores the elements of x to an array.
func (x Uint64x8) StoreArray(y *[8]uint64) {
	var tmp0 spec.Array[uint64, spec.Width512] = y[:]
	spec.StoreArray[uint64, spec.Width512](x.v, &tmp0)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Float32x4) StoreArrayMasked(y *[4]float32, mask Mask32x4) {
	var tmp0 spec.Array[float32, spec.Width128] = y[:]
	spec.StoreArrayMasked[float32, spec.Width128, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Float32x8) StoreArrayMasked(y *[8]float32, mask Mask32x8) {
	var tmp0 spec.Array[float32, spec.Width256] = y[:]
	spec.StoreArrayMasked[float32, spec.Width256, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Float32x16) StoreArrayMasked(y *[16]float32, mask Mask32x16) {
	var tmp0 spec.Array[float32, spec.Width512] = y[:]
	spec.StoreArrayMasked[float32, spec.Width512, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Float64x2) StoreArrayMasked(y *[2]float64, mask Mask64x2) {
	var tmp0 spec.Array[float64, spec.Width128] = y[:]
	spec.StoreArrayMasked[float64, spec.Width128, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Float64x4) StoreArrayMasked(y *[4]float64, mask Mask64x4) {
	var tmp0 spec.Array[float64, spec.Width256] = y[:]
	spec.StoreArrayMasked[float64, spec.Width256, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Float64x8) StoreArrayMasked(y *[8]float64, mask Mask64x8) {
	var tmp0 spec.Array[float64, spec.Width512] = y[:]
	spec.StoreArrayMasked[float64, spec.Width512, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int8x16) StoreArrayMasked(y *[16]int8, mask Mask8x16) {
	var tmp0 spec.Array[int8, spec.Width128] = y[:]
	spec.StoreArrayMasked[int8, spec.Width128, spec.Mask8](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int8x32) StoreArrayMasked(y *[32]int8, mask Mask8x32) {
	var tmp0 spec.Array[int8, spec.Width256] = y[:]
	spec.StoreArrayMasked[int8, spec.Width256, spec.Mask8](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int8x64) StoreArrayMasked(y *[64]int8, mask Mask8x64) {
	var tmp0 spec.Array[int8, spec.Width512] = y[:]
	spec.StoreArrayMasked[int8, spec.Width512, spec.Mask8](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int16x8) StoreArrayMasked(y *[8]int16, mask Mask16x8) {
	var tmp0 spec.Array[int16, spec.Width128] = y[:]
	spec.StoreArrayMasked[int16, spec.Width128, spec.Mask16](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int16x16) StoreArrayMasked(y *[16]int16, mask Mask16x16) {
	var tmp0 spec.Array[int16, spec.Width256] = y[:]
	spec.StoreArrayMasked[int16, spec.Width256, spec.Mask16](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int16x32) StoreArrayMasked(y *[32]int16, mask Mask16x32) {
	var tmp0 spec.Array[int16, spec.Width512] = y[:]
	spec.StoreArrayMasked[int16, spec.Width512, spec.Mask16](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int32x4) StoreArrayMasked(y *[4]int32, mask Mask32x4) {
	var tmp0 spec.Array[int32, spec.Width128] = y[:]
	spec.StoreArrayMasked[int32, spec.Width128, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int32x8) StoreArrayMasked(y *[8]int32, mask Mask32x8) {
	var tmp0 spec.Array[int32, spec.Width256] = y[:]
	spec.StoreArrayMasked[int32, spec.Width256, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int32x16) StoreArrayMasked(y *[16]int32, mask Mask32x16) {
	var tmp0 spec.Array[int32, spec.Width512] = y[:]
	spec.StoreArrayMasked[int32, spec.Width512, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int64x2) StoreArrayMasked(y *[2]int64, mask Mask64x2) {
	var tmp0 spec.Array[int64, spec.Width128] = y[:]
	spec.StoreArrayMasked[int64, spec.Width128, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int64x4) StoreArrayMasked(y *[4]int64, mask Mask64x4) {
	var tmp0 spec.Array[int64, spec.Width256] = y[:]
	spec.StoreArrayMasked[int64, spec.Width256, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Int64x8) StoreArrayMasked(y *[8]int64, mask Mask64x8) {
	var tmp0 spec.Array[int64, spec.Width512] = y[:]
	spec.StoreArrayMasked[int64, spec.Width512, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint8x16) StoreArrayMasked(y *[16]uint8, mask Mask8x16) {
	var tmp0 spec.Array[uint8, spec.Width128] = y[:]
	spec.StoreArrayMasked[uint8, spec.Width128, spec.Mask8](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint8x32) StoreArrayMasked(y *[32]uint8, mask Mask8x32) {
	var tmp0 spec.Array[uint8, spec.Width256] = y[:]
	spec.StoreArrayMasked[uint8, spec.Width256, spec.Mask8](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint8x64) StoreArrayMasked(y *[64]uint8, mask Mask8x64) {
	var tmp0 spec.Array[uint8, spec.Width512] = y[:]
	spec.StoreArrayMasked[uint8, spec.Width512, spec.Mask8](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint16x8) StoreArrayMasked(y *[8]uint16, mask Mask16x8) {
	var tmp0 spec.Array[uint16, spec.Width128] = y[:]
	spec.StoreArrayMasked[uint16, spec.Width128, spec.Mask16](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint16x16) StoreArrayMasked(y *[16]uint16, mask Mask16x16) {
	var tmp0 spec.Array[uint16, spec.Width256] = y[:]
	spec.StoreArrayMasked[uint16, spec.Width256, spec.Mask16](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint16x32) StoreArrayMasked(y *[32]uint16, mask Mask16x32) {
	var tmp0 spec.Array[uint16, spec.Width512] = y[:]
	spec.StoreArrayMasked[uint16, spec.Width512, spec.Mask16](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint32x4) StoreArrayMasked(y *[4]uint32, mask Mask32x4) {
	var tmp0 spec.Array[uint32, spec.Width128] = y[:]
	spec.StoreArrayMasked[uint32, spec.Width128, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint32x8) StoreArrayMasked(y *[8]uint32, mask Mask32x8) {
	var tmp0 spec.Array[uint32, spec.Width256] = y[:]
	spec.StoreArrayMasked[uint32, spec.Width256, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint32x16) StoreArrayMasked(y *[16]uint32, mask Mask32x16) {
	var tmp0 spec.Array[uint32, spec.Width512] = y[:]
	spec.StoreArrayMasked[uint32, spec.Width512, spec.Mask32](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint64x2) StoreArrayMasked(y *[2]uint64, mask Mask64x2) {
	var tmp0 spec.Array[uint64, spec.Width128] = y[:]
	spec.StoreArrayMasked[uint64, spec.Width128, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint64x4) StoreArrayMasked(y *[4]uint64, mask Mask64x4) {
	var tmp0 spec.Array[uint64, spec.Width256] = y[:]
	spec.StoreArrayMasked[uint64, spec.Width256, spec.Mask64](x.v, &tmp0, mask.v)
}

// StoreArrayMasked stores the masked elements of x to an array. It does not
// modify elements of y that are false in the mask.
func (x Uint64x8) StoreArrayMasked(y *[8]uint64, mask Mask64x8) {
	var tmp0 spec.Array[uint64, spec.Width512] = y[:]
	spec.StoreArrayMasked[uint64, spec.Width512, spec.Mask64](x.v, &tmp0, mask.v)
}

// StorePart stores n=min(len(s), 4) elements of x into s and returns n.
func (x Float32x4) StorePart(s []float32) (n int) {
	return spec.StorePart[float32, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Float32x8) StorePart(s []float32) (n int) {
	return spec.StorePart[float32, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Float32x16) StorePart(s []float32) (n int) {
	return spec.StorePart[float32, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Float32s) StorePart(s []float32) (n int) {
	return spec.StorePart[float32, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 2) elements of x into s and returns n.
func (x Float64x2) StorePart(s []float64) (n int) {
	return spec.StorePart[float64, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 4) elements of x into s and returns n.
func (x Float64x4) StorePart(s []float64) (n int) {
	return spec.StorePart[float64, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Float64x8) StorePart(s []float64) (n int) {
	return spec.StorePart[float64, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Float64s) StorePart(s []float64) (n int) {
	return spec.StorePart[float64, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Int8x16) StorePart(s []int8) (n int) {
	return spec.StorePart[int8, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 32) elements of x into s and returns n.
func (x Int8x32) StorePart(s []int8) (n int) {
	return spec.StorePart[int8, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 64) elements of x into s and returns n.
func (x Int8x64) StorePart(s []int8) (n int) {
	return spec.StorePart[int8, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Int8s) StorePart(s []int8) (n int) {
	return spec.StorePart[int8, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Int16x8) StorePart(s []int16) (n int) {
	return spec.StorePart[int16, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Int16x16) StorePart(s []int16) (n int) {
	return spec.StorePart[int16, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 32) elements of x into s and returns n.
func (x Int16x32) StorePart(s []int16) (n int) {
	return spec.StorePart[int16, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Int16s) StorePart(s []int16) (n int) {
	return spec.StorePart[int16, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 4) elements of x into s and returns n.
func (x Int32x4) StorePart(s []int32) (n int) {
	return spec.StorePart[int32, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Int32x8) StorePart(s []int32) (n int) {
	return spec.StorePart[int32, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Int32x16) StorePart(s []int32) (n int) {
	return spec.StorePart[int32, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Int32s) StorePart(s []int32) (n int) {
	return spec.StorePart[int32, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 2) elements of x into s and returns n.
func (x Int64x2) StorePart(s []int64) (n int) {
	return spec.StorePart[int64, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 4) elements of x into s and returns n.
func (x Int64x4) StorePart(s []int64) (n int) {
	return spec.StorePart[int64, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Int64x8) StorePart(s []int64) (n int) {
	return spec.StorePart[int64, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Int64s) StorePart(s []int64) (n int) {
	return spec.StorePart[int64, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Uint8x16) StorePart(s []uint8) (n int) {
	return spec.StorePart[uint8, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 32) elements of x into s and returns n.
func (x Uint8x32) StorePart(s []uint8) (n int) {
	return spec.StorePart[uint8, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 64) elements of x into s and returns n.
func (x Uint8x64) StorePart(s []uint8) (n int) {
	return spec.StorePart[uint8, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Uint8s) StorePart(s []uint8) (n int) {
	return spec.StorePart[uint8, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Uint16x8) StorePart(s []uint16) (n int) {
	return spec.StorePart[uint16, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Uint16x16) StorePart(s []uint16) (n int) {
	return spec.StorePart[uint16, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 32) elements of x into s and returns n.
func (x Uint16x32) StorePart(s []uint16) (n int) {
	return spec.StorePart[uint16, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Uint16s) StorePart(s []uint16) (n int) {
	return spec.StorePart[uint16, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 4) elements of x into s and returns n.
func (x Uint32x4) StorePart(s []uint32) (n int) {
	return spec.StorePart[uint32, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Uint32x8) StorePart(s []uint32) (n int) {
	return spec.StorePart[uint32, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 16) elements of x into s and returns n.
func (x Uint32x16) StorePart(s []uint32) (n int) {
	return spec.StorePart[uint32, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Uint32s) StorePart(s []uint32) (n int) {
	return spec.StorePart[uint32, spec.WidthScalable](x.v, s)
}

// StorePart stores n=min(len(s), 2) elements of x into s and returns n.
func (x Uint64x2) StorePart(s []uint64) (n int) {
	return spec.StorePart[uint64, spec.Width128](x.v, s)
}

// StorePart stores n=min(len(s), 4) elements of x into s and returns n.
func (x Uint64x4) StorePart(s []uint64) (n int) {
	return spec.StorePart[uint64, spec.Width256](x.v, s)
}

// StorePart stores n=min(len(s), 8) elements of x into s and returns n.
func (x Uint64x8) StorePart(s []uint64) (n int) {
	return spec.StorePart[uint64, spec.Width512](x.v, s)
}

// StorePart stores n=min(len(s), x.Len()) elements of x into s and returns n.
func (x Uint64s) StorePart(s []uint64) (n int) {
	return spec.StorePart[uint64, spec.WidthScalable](x.v, s)
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int8x16) And(y Int8x16) (z Int8x16) {
	return Int8x16{spec.And[int8, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int8x32) And(y Int8x32) (z Int8x32) {
	return Int8x32{spec.And[int8, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int8x64) And(y Int8x64) (z Int8x64) {
	return Int8x64{spec.And[int8, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int8s) And(y Int8s) (z Int8s) {
	return Int8s{spec.And[int8, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int16x8) And(y Int16x8) (z Int16x8) {
	return Int16x8{spec.And[int16, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int16x16) And(y Int16x16) (z Int16x16) {
	return Int16x16{spec.And[int16, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int16x32) And(y Int16x32) (z Int16x32) {
	return Int16x32{spec.And[int16, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int16s) And(y Int16s) (z Int16s) {
	return Int16s{spec.And[int16, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int32x4) And(y Int32x4) (z Int32x4) {
	return Int32x4{spec.And[int32, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int32x8) And(y Int32x8) (z Int32x8) {
	return Int32x8{spec.And[int32, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int32x16) And(y Int32x16) (z Int32x16) {
	return Int32x16{spec.And[int32, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int32s) And(y Int32s) (z Int32s) {
	return Int32s{spec.And[int32, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int64x2) And(y Int64x2) (z Int64x2) {
	return Int64x2{spec.And[int64, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int64x4) And(y Int64x4) (z Int64x4) {
	return Int64x4{spec.And[int64, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int64x8) And(y Int64x8) (z Int64x8) {
	return Int64x8{spec.And[int64, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Int64s) And(y Int64s) (z Int64s) {
	return Int64s{spec.And[int64, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint8x16) And(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.And[uint8, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint8x32) And(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.And[uint8, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint8x64) And(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.And[uint8, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint8s) And(y Uint8s) (z Uint8s) {
	return Uint8s{spec.And[uint8, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint16x8) And(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.And[uint16, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint16x16) And(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.And[uint16, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint16x32) And(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.And[uint16, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint16s) And(y Uint16s) (z Uint16s) {
	return Uint16s{spec.And[uint16, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint32x4) And(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.And[uint32, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint32x8) And(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.And[uint32, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint32x16) And(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.And[uint32, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint32s) And(y Uint32s) (z Uint32s) {
	return Uint32s{spec.And[uint32, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint64x2) And(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.And[uint64, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint64x4) And(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.And[uint64, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint64x8) And(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.And[uint64, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Uint64s) And(y Uint64s) (z Uint64s) {
	return Uint64s{spec.And[uint64, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask8x16) And(y Mask8x16) (z Mask8x16) {
	return Mask8x16{spec.And[spec.Mask8, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask8x32) And(y Mask8x32) (z Mask8x32) {
	return Mask8x32{spec.And[spec.Mask8, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask8x64) And(y Mask8x64) (z Mask8x64) {
	return Mask8x64{spec.And[spec.Mask8, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask8s) And(y Mask8s) (z Mask8s) {
	return Mask8s{spec.And[spec.Mask8, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask16x8) And(y Mask16x8) (z Mask16x8) {
	return Mask16x8{spec.And[spec.Mask16, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask16x16) And(y Mask16x16) (z Mask16x16) {
	return Mask16x16{spec.And[spec.Mask16, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask16x32) And(y Mask16x32) (z Mask16x32) {
	return Mask16x32{spec.And[spec.Mask16, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask16s) And(y Mask16s) (z Mask16s) {
	return Mask16s{spec.And[spec.Mask16, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask32x4) And(y Mask32x4) (z Mask32x4) {
	return Mask32x4{spec.And[spec.Mask32, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask32x8) And(y Mask32x8) (z Mask32x8) {
	return Mask32x8{spec.And[spec.Mask32, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask32x16) And(y Mask32x16) (z Mask32x16) {
	return Mask32x16{spec.And[spec.Mask32, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask32s) And(y Mask32s) (z Mask32s) {
	return Mask32s{spec.And[spec.Mask32, spec.WidthScalable](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask64x2) And(y Mask64x2) (z Mask64x2) {
	return Mask64x2{spec.And[spec.Mask64, spec.Width128](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask64x4) And(y Mask64x4) (z Mask64x4) {
	return Mask64x4{spec.And[spec.Mask64, spec.Width256](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask64x8) And(y Mask64x8) (z Mask64x8) {
	return Mask64x8{spec.And[spec.Mask64, spec.Width512](x.v, y.v)}
}

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask64s) And(y Mask64s) (z Mask64s) {
	return Mask64s{spec.And[spec.Mask64, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int8x16) AndNot(y Int8x16) (z Int8x16) {
	return Int8x16{spec.AndNot[int8, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int8x32) AndNot(y Int8x32) (z Int8x32) {
	return Int8x32{spec.AndNot[int8, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int8x64) AndNot(y Int8x64) (z Int8x64) {
	return Int8x64{spec.AndNot[int8, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int8s) AndNot(y Int8s) (z Int8s) {
	return Int8s{spec.AndNot[int8, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int16x8) AndNot(y Int16x8) (z Int16x8) {
	return Int16x8{spec.AndNot[int16, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int16x16) AndNot(y Int16x16) (z Int16x16) {
	return Int16x16{spec.AndNot[int16, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int16x32) AndNot(y Int16x32) (z Int16x32) {
	return Int16x32{spec.AndNot[int16, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int16s) AndNot(y Int16s) (z Int16s) {
	return Int16s{spec.AndNot[int16, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int32x4) AndNot(y Int32x4) (z Int32x4) {
	return Int32x4{spec.AndNot[int32, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int32x8) AndNot(y Int32x8) (z Int32x8) {
	return Int32x8{spec.AndNot[int32, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int32x16) AndNot(y Int32x16) (z Int32x16) {
	return Int32x16{spec.AndNot[int32, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int32s) AndNot(y Int32s) (z Int32s) {
	return Int32s{spec.AndNot[int32, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int64x2) AndNot(y Int64x2) (z Int64x2) {
	return Int64x2{spec.AndNot[int64, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int64x4) AndNot(y Int64x4) (z Int64x4) {
	return Int64x4{spec.AndNot[int64, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int64x8) AndNot(y Int64x8) (z Int64x8) {
	return Int64x8{spec.AndNot[int64, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Int64s) AndNot(y Int64s) (z Int64s) {
	return Int64s{spec.AndNot[int64, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint8x16) AndNot(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.AndNot[uint8, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint8x32) AndNot(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.AndNot[uint8, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint8x64) AndNot(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.AndNot[uint8, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint8s) AndNot(y Uint8s) (z Uint8s) {
	return Uint8s{spec.AndNot[uint8, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint16x8) AndNot(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.AndNot[uint16, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint16x16) AndNot(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.AndNot[uint16, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint16x32) AndNot(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.AndNot[uint16, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint16s) AndNot(y Uint16s) (z Uint16s) {
	return Uint16s{spec.AndNot[uint16, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint32x4) AndNot(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.AndNot[uint32, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint32x8) AndNot(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.AndNot[uint32, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint32x16) AndNot(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.AndNot[uint32, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint32s) AndNot(y Uint32s) (z Uint32s) {
	return Uint32s{spec.AndNot[uint32, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint64x2) AndNot(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.AndNot[uint64, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint64x4) AndNot(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.AndNot[uint64, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint64x8) AndNot(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.AndNot[uint64, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Uint64s) AndNot(y Uint64s) (z Uint64s) {
	return Uint64s{spec.AndNot[uint64, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask8x16) AndNot(y Mask8x16) (z Mask8x16) {
	return Mask8x16{spec.AndNot[spec.Mask8, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask8x32) AndNot(y Mask8x32) (z Mask8x32) {
	return Mask8x32{spec.AndNot[spec.Mask8, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask8x64) AndNot(y Mask8x64) (z Mask8x64) {
	return Mask8x64{spec.AndNot[spec.Mask8, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask8s) AndNot(y Mask8s) (z Mask8s) {
	return Mask8s{spec.AndNot[spec.Mask8, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask16x8) AndNot(y Mask16x8) (z Mask16x8) {
	return Mask16x8{spec.AndNot[spec.Mask16, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask16x16) AndNot(y Mask16x16) (z Mask16x16) {
	return Mask16x16{spec.AndNot[spec.Mask16, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask16x32) AndNot(y Mask16x32) (z Mask16x32) {
	return Mask16x32{spec.AndNot[spec.Mask16, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask16s) AndNot(y Mask16s) (z Mask16s) {
	return Mask16s{spec.AndNot[spec.Mask16, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask32x4) AndNot(y Mask32x4) (z Mask32x4) {
	return Mask32x4{spec.AndNot[spec.Mask32, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask32x8) AndNot(y Mask32x8) (z Mask32x8) {
	return Mask32x8{spec.AndNot[spec.Mask32, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask32x16) AndNot(y Mask32x16) (z Mask32x16) {
	return Mask32x16{spec.AndNot[spec.Mask32, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask32s) AndNot(y Mask32s) (z Mask32s) {
	return Mask32s{spec.AndNot[spec.Mask32, spec.WidthScalable](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask64x2) AndNot(y Mask64x2) (z Mask64x2) {
	return Mask64x2{spec.AndNot[spec.Mask64, spec.Width128](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask64x4) AndNot(y Mask64x4) (z Mask64x4) {
	return Mask64x4{spec.AndNot[spec.Mask64, spec.Width256](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask64x8) AndNot(y Mask64x8) (z Mask64x8) {
	return Mask64x8{spec.AndNot[spec.Mask64, spec.Width512](x.v, y.v)}
}

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask64s) AndNot(y Mask64s) (z Mask64s) {
	return Mask64s{spec.AndNot[spec.Mask64, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int8x16) Or(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Or[int8, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int8x32) Or(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Or[int8, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int8x64) Or(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Or[int8, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int8s) Or(y Int8s) (z Int8s) {
	return Int8s{spec.Or[int8, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int16x8) Or(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Or[int16, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int16x16) Or(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Or[int16, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int16x32) Or(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Or[int16, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int16s) Or(y Int16s) (z Int16s) {
	return Int16s{spec.Or[int16, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int32x4) Or(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Or[int32, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int32x8) Or(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Or[int32, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int32x16) Or(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Or[int32, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int32s) Or(y Int32s) (z Int32s) {
	return Int32s{spec.Or[int32, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int64x2) Or(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Or[int64, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int64x4) Or(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Or[int64, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int64x8) Or(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Or[int64, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Int64s) Or(y Int64s) (z Int64s) {
	return Int64s{spec.Or[int64, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint8x16) Or(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Or[uint8, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint8x32) Or(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Or[uint8, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint8x64) Or(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Or[uint8, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint8s) Or(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Or[uint8, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint16x8) Or(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Or[uint16, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint16x16) Or(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Or[uint16, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint16x32) Or(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Or[uint16, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint16s) Or(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Or[uint16, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint32x4) Or(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Or[uint32, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint32x8) Or(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Or[uint32, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint32x16) Or(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Or[uint32, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint32s) Or(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Or[uint32, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint64x2) Or(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Or[uint64, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint64x4) Or(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Or[uint64, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint64x8) Or(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Or[uint64, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Uint64s) Or(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Or[uint64, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask8x16) Or(y Mask8x16) (z Mask8x16) {
	return Mask8x16{spec.Or[spec.Mask8, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask8x32) Or(y Mask8x32) (z Mask8x32) {
	return Mask8x32{spec.Or[spec.Mask8, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask8x64) Or(y Mask8x64) (z Mask8x64) {
	return Mask8x64{spec.Or[spec.Mask8, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask8s) Or(y Mask8s) (z Mask8s) {
	return Mask8s{spec.Or[spec.Mask8, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask16x8) Or(y Mask16x8) (z Mask16x8) {
	return Mask16x8{spec.Or[spec.Mask16, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask16x16) Or(y Mask16x16) (z Mask16x16) {
	return Mask16x16{spec.Or[spec.Mask16, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask16x32) Or(y Mask16x32) (z Mask16x32) {
	return Mask16x32{spec.Or[spec.Mask16, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask16s) Or(y Mask16s) (z Mask16s) {
	return Mask16s{spec.Or[spec.Mask16, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask32x4) Or(y Mask32x4) (z Mask32x4) {
	return Mask32x4{spec.Or[spec.Mask32, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask32x8) Or(y Mask32x8) (z Mask32x8) {
	return Mask32x8{spec.Or[spec.Mask32, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask32x16) Or(y Mask32x16) (z Mask32x16) {
	return Mask32x16{spec.Or[spec.Mask32, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask32s) Or(y Mask32s) (z Mask32s) {
	return Mask32s{spec.Or[spec.Mask32, spec.WidthScalable](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask64x2) Or(y Mask64x2) (z Mask64x2) {
	return Mask64x2{spec.Or[spec.Mask64, spec.Width128](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask64x4) Or(y Mask64x4) (z Mask64x4) {
	return Mask64x4{spec.Or[spec.Mask64, spec.Width256](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask64x8) Or(y Mask64x8) (z Mask64x8) {
	return Mask64x8{spec.Or[spec.Mask64, spec.Width512](x.v, y.v)}
}

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask64s) Or(y Mask64s) (z Mask64s) {
	return Mask64s{spec.Or[spec.Mask64, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int8x16) Xor(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Xor[int8, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int8x32) Xor(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Xor[int8, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int8x64) Xor(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Xor[int8, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int8s) Xor(y Int8s) (z Int8s) {
	return Int8s{spec.Xor[int8, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int16x8) Xor(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Xor[int16, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int16x16) Xor(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Xor[int16, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int16x32) Xor(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Xor[int16, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int16s) Xor(y Int16s) (z Int16s) {
	return Int16s{spec.Xor[int16, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int32x4) Xor(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Xor[int32, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int32x8) Xor(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Xor[int32, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int32x16) Xor(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Xor[int32, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int32s) Xor(y Int32s) (z Int32s) {
	return Int32s{spec.Xor[int32, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int64x2) Xor(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Xor[int64, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int64x4) Xor(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Xor[int64, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int64x8) Xor(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Xor[int64, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Int64s) Xor(y Int64s) (z Int64s) {
	return Int64s{spec.Xor[int64, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint8x16) Xor(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Xor[uint8, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint8x32) Xor(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Xor[uint8, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint8x64) Xor(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Xor[uint8, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint8s) Xor(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Xor[uint8, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint16x8) Xor(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Xor[uint16, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint16x16) Xor(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Xor[uint16, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint16x32) Xor(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Xor[uint16, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint16s) Xor(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Xor[uint16, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint32x4) Xor(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Xor[uint32, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint32x8) Xor(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Xor[uint32, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint32x16) Xor(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Xor[uint32, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint32s) Xor(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Xor[uint32, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint64x2) Xor(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Xor[uint64, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint64x4) Xor(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Xor[uint64, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint64x8) Xor(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Xor[uint64, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Uint64s) Xor(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Xor[uint64, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask8x16) Xor(y Mask8x16) (z Mask8x16) {
	return Mask8x16{spec.Xor[spec.Mask8, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask8x32) Xor(y Mask8x32) (z Mask8x32) {
	return Mask8x32{spec.Xor[spec.Mask8, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask8x64) Xor(y Mask8x64) (z Mask8x64) {
	return Mask8x64{spec.Xor[spec.Mask8, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask8s) Xor(y Mask8s) (z Mask8s) {
	return Mask8s{spec.Xor[spec.Mask8, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask16x8) Xor(y Mask16x8) (z Mask16x8) {
	return Mask16x8{spec.Xor[spec.Mask16, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask16x16) Xor(y Mask16x16) (z Mask16x16) {
	return Mask16x16{spec.Xor[spec.Mask16, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask16x32) Xor(y Mask16x32) (z Mask16x32) {
	return Mask16x32{spec.Xor[spec.Mask16, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask16s) Xor(y Mask16s) (z Mask16s) {
	return Mask16s{spec.Xor[spec.Mask16, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask32x4) Xor(y Mask32x4) (z Mask32x4) {
	return Mask32x4{spec.Xor[spec.Mask32, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask32x8) Xor(y Mask32x8) (z Mask32x8) {
	return Mask32x8{spec.Xor[spec.Mask32, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask32x16) Xor(y Mask32x16) (z Mask32x16) {
	return Mask32x16{spec.Xor[spec.Mask32, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask32s) Xor(y Mask32s) (z Mask32s) {
	return Mask32s{spec.Xor[spec.Mask32, spec.WidthScalable](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask64x2) Xor(y Mask64x2) (z Mask64x2) {
	return Mask64x2{spec.Xor[spec.Mask64, spec.Width128](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask64x4) Xor(y Mask64x4) (z Mask64x4) {
	return Mask64x4{spec.Xor[spec.Mask64, spec.Width256](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask64x8) Xor(y Mask64x8) (z Mask64x8) {
	return Mask64x8{spec.Xor[spec.Mask64, spec.Width512](x.v, y.v)}
}

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask64s) Xor(y Mask64s) (z Mask64s) {
	return Mask64s{spec.Xor[spec.Mask64, spec.WidthScalable](x.v, y.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int8x16) Not() (z Int8x16) {
	return Int8x16{spec.Not[int8, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int8x32) Not() (z Int8x32) {
	return Int8x32{spec.Not[int8, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int8x64) Not() (z Int8x64) {
	return Int8x64{spec.Not[int8, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int8s) Not() (z Int8s) {
	return Int8s{spec.Not[int8, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int16x8) Not() (z Int16x8) {
	return Int16x8{spec.Not[int16, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int16x16) Not() (z Int16x16) {
	return Int16x16{spec.Not[int16, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int16x32) Not() (z Int16x32) {
	return Int16x32{spec.Not[int16, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int16s) Not() (z Int16s) {
	return Int16s{spec.Not[int16, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int32x4) Not() (z Int32x4) {
	return Int32x4{spec.Not[int32, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int32x8) Not() (z Int32x8) {
	return Int32x8{spec.Not[int32, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int32x16) Not() (z Int32x16) {
	return Int32x16{spec.Not[int32, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int32s) Not() (z Int32s) {
	return Int32s{spec.Not[int32, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int64x2) Not() (z Int64x2) {
	return Int64x2{spec.Not[int64, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int64x4) Not() (z Int64x4) {
	return Int64x4{spec.Not[int64, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int64x8) Not() (z Int64x8) {
	return Int64x8{spec.Not[int64, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Int64s) Not() (z Int64s) {
	return Int64s{spec.Not[int64, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint8x16) Not() (z Uint8x16) {
	return Uint8x16{spec.Not[uint8, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint8x32) Not() (z Uint8x32) {
	return Uint8x32{spec.Not[uint8, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint8x64) Not() (z Uint8x64) {
	return Uint8x64{spec.Not[uint8, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint8s) Not() (z Uint8s) {
	return Uint8s{spec.Not[uint8, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint16x8) Not() (z Uint16x8) {
	return Uint16x8{spec.Not[uint16, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint16x16) Not() (z Uint16x16) {
	return Uint16x16{spec.Not[uint16, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint16x32) Not() (z Uint16x32) {
	return Uint16x32{spec.Not[uint16, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint16s) Not() (z Uint16s) {
	return Uint16s{spec.Not[uint16, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint32x4) Not() (z Uint32x4) {
	return Uint32x4{spec.Not[uint32, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint32x8) Not() (z Uint32x8) {
	return Uint32x8{spec.Not[uint32, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint32x16) Not() (z Uint32x16) {
	return Uint32x16{spec.Not[uint32, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint32s) Not() (z Uint32s) {
	return Uint32s{spec.Not[uint32, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint64x2) Not() (z Uint64x2) {
	return Uint64x2{spec.Not[uint64, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint64x4) Not() (z Uint64x4) {
	return Uint64x4{spec.Not[uint64, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint64x8) Not() (z Uint64x8) {
	return Uint64x8{spec.Not[uint64, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Uint64s) Not() (z Uint64s) {
	return Uint64s{spec.Not[uint64, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask8x16) Not() (z Mask8x16) {
	return Mask8x16{spec.Not[spec.Mask8, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask8x32) Not() (z Mask8x32) {
	return Mask8x32{spec.Not[spec.Mask8, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask8x64) Not() (z Mask8x64) {
	return Mask8x64{spec.Not[spec.Mask8, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask8s) Not() (z Mask8s) {
	return Mask8s{spec.Not[spec.Mask8, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask16x8) Not() (z Mask16x8) {
	return Mask16x8{spec.Not[spec.Mask16, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask16x16) Not() (z Mask16x16) {
	return Mask16x16{spec.Not[spec.Mask16, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask16x32) Not() (z Mask16x32) {
	return Mask16x32{spec.Not[spec.Mask16, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask16s) Not() (z Mask16s) {
	return Mask16s{spec.Not[spec.Mask16, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask32x4) Not() (z Mask32x4) {
	return Mask32x4{spec.Not[spec.Mask32, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask32x8) Not() (z Mask32x8) {
	return Mask32x8{spec.Not[spec.Mask32, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask32x16) Not() (z Mask32x16) {
	return Mask32x16{spec.Not[spec.Mask32, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask32s) Not() (z Mask32s) {
	return Mask32s{spec.Not[spec.Mask32, spec.WidthScalable](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask64x2) Not() (z Mask64x2) {
	return Mask64x2{spec.Not[spec.Mask64, spec.Width128](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask64x4) Not() (z Mask64x4) {
	return Mask64x4{spec.Not[spec.Mask64, spec.Width256](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask64x8) Not() (z Mask64x8) {
	return Mask64x8{spec.Not[spec.Mask64, spec.Width512](x.v)}
}

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask64s) Not() (z Mask64s) {
	return Mask64s{spec.Not[spec.Mask64, spec.WidthScalable](x.v)}
}

// Mask8x16FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask8x16FromBits(x uint16) (z Mask8x16) {
	return Mask8x16{spec.MaskFromBits[spec.Mask8, spec.Width128](spec.UintN(x))}
}

// Mask8x32FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask8x32FromBits(x uint32) (z Mask8x32) {
	return Mask8x32{spec.MaskFromBits[spec.Mask8, spec.Width256](spec.UintN(x))}
}

// Mask8x64FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask8x64FromBits(x uint64) (z Mask8x64) {
	return Mask8x64{spec.MaskFromBits[spec.Mask8, spec.Width512](spec.UintN(x))}
}

// Mask16x8FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask16x8FromBits(x uint8) (z Mask16x8) {
	return Mask16x8{spec.MaskFromBits[spec.Mask16, spec.Width128](spec.UintN(x))}
}

// Mask16x16FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask16x16FromBits(x uint16) (z Mask16x16) {
	return Mask16x16{spec.MaskFromBits[spec.Mask16, spec.Width256](spec.UintN(x))}
}

// Mask16x32FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask16x32FromBits(x uint32) (z Mask16x32) {
	return Mask16x32{spec.MaskFromBits[spec.Mask16, spec.Width512](spec.UintN(x))}
}

// Mask32x4FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask32x4FromBits(x uint8) (z Mask32x4) {
	return Mask32x4{spec.MaskFromBits[spec.Mask32, spec.Width128](spec.UintN(x))}
}

// Mask32x8FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask32x8FromBits(x uint8) (z Mask32x8) {
	return Mask32x8{spec.MaskFromBits[spec.Mask32, spec.Width256](spec.UintN(x))}
}

// Mask32x16FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask32x16FromBits(x uint16) (z Mask32x16) {
	return Mask32x16{spec.MaskFromBits[spec.Mask32, spec.Width512](spec.UintN(x))}
}

// Mask64x2FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask64x2FromBits(x uint8) (z Mask64x2) {
	return Mask64x2{spec.MaskFromBits[spec.Mask64, spec.Width128](spec.UintN(x))}
}

// Mask64x4FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask64x4FromBits(x uint8) (z Mask64x4) {
	return Mask64x4{spec.MaskFromBits[spec.Mask64, spec.Width256](spec.UintN(x))}
}

// Mask64x8FromBits returns bitmap x as a mask. If bit i of x is set, then mask
// element i of the result is true.
func Mask64x8FromBits(x uint8) (z Mask64x8) {
	return Mask64x8{spec.MaskFromBits[spec.Mask64, spec.Width512](spec.UintN(x))}
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask8x16) ToBits() (z uint16) {
	return uint16(spec.MaskToBits[spec.Mask8, spec.Width128](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask8x32) ToBits() (z uint32) {
	return uint32(spec.MaskToBits[spec.Mask8, spec.Width256](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask8x64) ToBits() (z uint64) {
	return uint64(spec.MaskToBits[spec.Mask8, spec.Width512](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask16x8) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask16, spec.Width128](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask16x16) ToBits() (z uint16) {
	return uint16(spec.MaskToBits[spec.Mask16, spec.Width256](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask16x32) ToBits() (z uint32) {
	return uint32(spec.MaskToBits[spec.Mask16, spec.Width512](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask32x4) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask32, spec.Width128](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask32x8) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask32, spec.Width256](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask32x16) ToBits() (z uint16) {
	return uint16(spec.MaskToBits[spec.Mask32, spec.Width512](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask64x2) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask64, spec.Width128](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask64x4) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask64, spec.Width256](x.v))
}

// ToBits returns x as a bitmap, where bit i is set if mask element i is
// true.
func (x Mask64x8) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask64, spec.Width512](x.v))
}

// ToInt8x16 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask8x16) ToInt8x16() (z Int8x16) {
	return Int8x16{spec.MaskToZ[spec.Mask8, spec.Width128, int8](x.v)}
}

// ToInt8x32 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask8x32) ToInt8x32() (z Int8x32) {
	return Int8x32{spec.MaskToZ[spec.Mask8, spec.Width256, int8](x.v)}
}

// ToInt8x64 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask8x64) ToInt8x64() (z Int8x64) {
	return Int8x64{spec.MaskToZ[spec.Mask8, spec.Width512, int8](x.v)}
}

// ToInt8s converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask8s) ToInt8s() (z Int8s) {
	return Int8s{spec.MaskToZ[spec.Mask8, spec.WidthScalable, int8](x.v)}
}

// ToInt16x8 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask16x8) ToInt16x8() (z Int16x8) {
	return Int16x8{spec.MaskToZ[spec.Mask16, spec.Width128, int16](x.v)}
}

// ToInt16x16 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask16x16) ToInt16x16() (z Int16x16) {
	return Int16x16{spec.MaskToZ[spec.Mask16, spec.Width256, int16](x.v)}
}

// ToInt16x32 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask16x32) ToInt16x32() (z Int16x32) {
	return Int16x32{spec.MaskToZ[spec.Mask16, spec.Width512, int16](x.v)}
}

// ToInt16s converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask16s) ToInt16s() (z Int16s) {
	return Int16s{spec.MaskToZ[spec.Mask16, spec.WidthScalable, int16](x.v)}
}

// ToInt32x4 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask32x4) ToInt32x4() (z Int32x4) {
	return Int32x4{spec.MaskToZ[spec.Mask32, spec.Width128, int32](x.v)}
}

// ToInt32x8 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask32x8) ToInt32x8() (z Int32x8) {
	return Int32x8{spec.MaskToZ[spec.Mask32, spec.Width256, int32](x.v)}
}

// ToInt32x16 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask32x16) ToInt32x16() (z Int32x16) {
	return Int32x16{spec.MaskToZ[spec.Mask32, spec.Width512, int32](x.v)}
}

// ToInt32s converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask32s) ToInt32s() (z Int32s) {
	return Int32s{spec.MaskToZ[spec.Mask32, spec.WidthScalable, int32](x.v)}
}

// ToInt64x2 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask64x2) ToInt64x2() (z Int64x2) {
	return Int64x2{spec.MaskToZ[spec.Mask64, spec.Width128, int64](x.v)}
}

// ToInt64x4 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask64x4) ToInt64x4() (z Int64x4) {
	return Int64x4{spec.MaskToZ[spec.Mask64, spec.Width256, int64](x.v)}
}

// ToInt64x8 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask64x8) ToInt64x8() (z Int64x8) {
	return Int64x8{spec.MaskToZ[spec.Mask64, spec.Width512, int64](x.v)}
}

// ToInt64s converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask64s) ToInt64s() (z Int64s) {
	return Int64s{spec.MaskToZ[spec.Mask64, spec.WidthScalable, int64](x.v)}
}

// All returns true when all positions in mask x are true.
func (x Mask8x16) All() bool {
	return spec.All[spec.Mask8, spec.Width128](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask8x32) All() bool {
	return spec.All[spec.Mask8, spec.Width256](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask8x64) All() bool {
	return spec.All[spec.Mask8, spec.Width512](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask8s) All() bool {
	return spec.All[spec.Mask8, spec.WidthScalable](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask16x8) All() bool {
	return spec.All[spec.Mask16, spec.Width128](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask16x16) All() bool {
	return spec.All[spec.Mask16, spec.Width256](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask16x32) All() bool {
	return spec.All[spec.Mask16, spec.Width512](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask16s) All() bool {
	return spec.All[spec.Mask16, spec.WidthScalable](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask32x4) All() bool {
	return spec.All[spec.Mask32, spec.Width128](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask32x8) All() bool {
	return spec.All[spec.Mask32, spec.Width256](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask32x16) All() bool {
	return spec.All[spec.Mask32, spec.Width512](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask32s) All() bool {
	return spec.All[spec.Mask32, spec.WidthScalable](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask64x2) All() bool {
	return spec.All[spec.Mask64, spec.Width128](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask64x4) All() bool {
	return spec.All[spec.Mask64, spec.Width256](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask64x8) All() bool {
	return spec.All[spec.Mask64, spec.Width512](x.v)
}

// All returns true when all positions in mask x are true.
func (x Mask64s) All() bool {
	return spec.All[spec.Mask64, spec.WidthScalable](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask8x16) Any() bool {
	return spec.Any[spec.Mask8, spec.Width128](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask8x32) Any() bool {
	return spec.Any[spec.Mask8, spec.Width256](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask8x64) Any() bool {
	return spec.Any[spec.Mask8, spec.Width512](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask8s) Any() bool {
	return spec.Any[spec.Mask8, spec.WidthScalable](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask16x8) Any() bool {
	return spec.Any[spec.Mask16, spec.Width128](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask16x16) Any() bool {
	return spec.Any[spec.Mask16, spec.Width256](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask16x32) Any() bool {
	return spec.Any[spec.Mask16, spec.Width512](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask16s) Any() bool {
	return spec.Any[spec.Mask16, spec.WidthScalable](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask32x4) Any() bool {
	return spec.Any[spec.Mask32, spec.Width128](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask32x8) Any() bool {
	return spec.Any[spec.Mask32, spec.Width256](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask32x16) Any() bool {
	return spec.Any[spec.Mask32, spec.Width512](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask32s) Any() bool {
	return spec.Any[spec.Mask32, spec.WidthScalable](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask64x2) Any() bool {
	return spec.Any[spec.Mask64, spec.Width128](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask64x4) Any() bool {
	return spec.Any[spec.Mask64, spec.Width256](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask64x8) Any() bool {
	return spec.Any[spec.Mask64, spec.Width512](x.v)
}

// Any returns true when any position in mask x is true.
func (x Mask64s) Any() bool {
	return spec.Any[spec.Mask64, spec.WidthScalable](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask8x16) None() bool {
	return spec.None[spec.Mask8, spec.Width128](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask8x32) None() bool {
	return spec.None[spec.Mask8, spec.Width256](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask8x64) None() bool {
	return spec.None[spec.Mask8, spec.Width512](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask8s) None() bool {
	return spec.None[spec.Mask8, spec.WidthScalable](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask16x8) None() bool {
	return spec.None[spec.Mask16, spec.Width128](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask16x16) None() bool {
	return spec.None[spec.Mask16, spec.Width256](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask16x32) None() bool {
	return spec.None[spec.Mask16, spec.Width512](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask16s) None() bool {
	return spec.None[spec.Mask16, spec.WidthScalable](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask32x4) None() bool {
	return spec.None[spec.Mask32, spec.Width128](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask32x8) None() bool {
	return spec.None[spec.Mask32, spec.Width256](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask32x16) None() bool {
	return spec.None[spec.Mask32, spec.Width512](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask32s) None() bool {
	return spec.None[spec.Mask32, spec.WidthScalable](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask64x2) None() bool {
	return spec.None[spec.Mask64, spec.Width128](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask64x4) None() bool {
	return spec.None[spec.Mask64, spec.Width256](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask64x8) None() bool {
	return spec.None[spec.Mask64, spec.Width512](x.v)
}

// None returns true when no positions in mask x are set.
func (x Mask64s) None() bool {
	return spec.None[spec.Mask64, spec.WidthScalable](x.v)
}

// Abs returns the elementwise absolute value of x.
func (x Float32x4) Abs() (z Float32x4) {
	return Float32x4{spec.AbsFloat[float32, spec.Width128](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float32x8) Abs() (z Float32x8) {
	return Float32x8{spec.AbsFloat[float32, spec.Width256](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float32x16) Abs() (z Float32x16) {
	return Float32x16{spec.AbsFloat[float32, spec.Width512](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float32s) Abs() (z Float32s) {
	return Float32s{spec.AbsFloat[float32, spec.WidthScalable](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float64x2) Abs() (z Float64x2) {
	return Float64x2{spec.AbsFloat[float64, spec.Width128](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float64x4) Abs() (z Float64x4) {
	return Float64x4{spec.AbsFloat[float64, spec.Width256](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float64x8) Abs() (z Float64x8) {
	return Float64x8{spec.AbsFloat[float64, spec.Width512](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Float64s) Abs() (z Float64s) {
	return Float64s{spec.AbsFloat[float64, spec.WidthScalable](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int8x16) Abs() (z Uint8x16) {
	return Uint8x16{spec.AbsInt[int8, spec.Width128, uint8](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int8x32) Abs() (z Uint8x32) {
	return Uint8x32{spec.AbsInt[int8, spec.Width256, uint8](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int8x64) Abs() (z Uint8x64) {
	return Uint8x64{spec.AbsInt[int8, spec.Width512, uint8](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int8s) Abs() (z Uint8s) {
	return Uint8s{spec.AbsInt[int8, spec.WidthScalable, uint8](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int16x8) Abs() (z Uint16x8) {
	return Uint16x8{spec.AbsInt[int16, spec.Width128, uint16](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int16x16) Abs() (z Uint16x16) {
	return Uint16x16{spec.AbsInt[int16, spec.Width256, uint16](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int16x32) Abs() (z Uint16x32) {
	return Uint16x32{spec.AbsInt[int16, spec.Width512, uint16](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int16s) Abs() (z Uint16s) {
	return Uint16s{spec.AbsInt[int16, spec.WidthScalable, uint16](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int32x4) Abs() (z Uint32x4) {
	return Uint32x4{spec.AbsInt[int32, spec.Width128, uint32](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int32x8) Abs() (z Uint32x8) {
	return Uint32x8{spec.AbsInt[int32, spec.Width256, uint32](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int32x16) Abs() (z Uint32x16) {
	return Uint32x16{spec.AbsInt[int32, spec.Width512, uint32](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int32s) Abs() (z Uint32s) {
	return Uint32s{spec.AbsInt[int32, spec.WidthScalable, uint32](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int64x2) Abs() (z Uint64x2) {
	return Uint64x2{spec.AbsInt[int64, spec.Width128, uint64](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int64x4) Abs() (z Uint64x4) {
	return Uint64x4{spec.AbsInt[int64, spec.Width256, uint64](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int64x8) Abs() (z Uint64x8) {
	return Uint64x8{spec.AbsInt[int64, spec.Width512, uint64](x.v)}
}

// Abs returns the elementwise absolute value of x.
func (x Int64s) Abs() (z Uint64s) {
	return Uint64s{spec.AbsInt[int64, spec.WidthScalable, uint64](x.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float32x4) Add(y Float32x4) (z Float32x4) {
	return Float32x4{spec.Add[float32, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float32x8) Add(y Float32x8) (z Float32x8) {
	return Float32x8{spec.Add[float32, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float32x16) Add(y Float32x16) (z Float32x16) {
	return Float32x16{spec.Add[float32, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float32s) Add(y Float32s) (z Float32s) {
	return Float32s{spec.Add[float32, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float64x2) Add(y Float64x2) (z Float64x2) {
	return Float64x2{spec.Add[float64, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float64x4) Add(y Float64x4) (z Float64x4) {
	return Float64x4{spec.Add[float64, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float64x8) Add(y Float64x8) (z Float64x8) {
	return Float64x8{spec.Add[float64, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Float64s) Add(y Float64s) (z Float64s) {
	return Float64s{spec.Add[float64, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int8x16) Add(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Add[int8, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int8x32) Add(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Add[int8, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int8x64) Add(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Add[int8, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int8s) Add(y Int8s) (z Int8s) {
	return Int8s{spec.Add[int8, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int16x8) Add(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Add[int16, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int16x16) Add(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Add[int16, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int16x32) Add(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Add[int16, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int16s) Add(y Int16s) (z Int16s) {
	return Int16s{spec.Add[int16, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int32x4) Add(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Add[int32, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int32x8) Add(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Add[int32, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int32x16) Add(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Add[int32, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int32s) Add(y Int32s) (z Int32s) {
	return Int32s{spec.Add[int32, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int64x2) Add(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Add[int64, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int64x4) Add(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Add[int64, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int64x8) Add(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Add[int64, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Int64s) Add(y Int64s) (z Int64s) {
	return Int64s{spec.Add[int64, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint8x16) Add(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Add[uint8, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint8x32) Add(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Add[uint8, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint8x64) Add(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Add[uint8, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint8s) Add(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Add[uint8, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint16x8) Add(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Add[uint16, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint16x16) Add(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Add[uint16, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint16x32) Add(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Add[uint16, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint16s) Add(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Add[uint16, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint32x4) Add(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Add[uint32, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint32x8) Add(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Add[uint32, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint32x16) Add(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Add[uint32, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint32s) Add(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Add[uint32, spec.WidthScalable](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint64x2) Add(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Add[uint64, spec.Width128](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint64x4) Add(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Add[uint64, spec.Width256](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint64x8) Add(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Add[uint64, spec.Width512](x.v, y.v)}
}

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
func (x Uint64s) Add(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Add[uint64, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float32x4) Sub(y Float32x4) (z Float32x4) {
	return Float32x4{spec.Sub[float32, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float32x8) Sub(y Float32x8) (z Float32x8) {
	return Float32x8{spec.Sub[float32, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float32x16) Sub(y Float32x16) (z Float32x16) {
	return Float32x16{spec.Sub[float32, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float32s) Sub(y Float32s) (z Float32s) {
	return Float32s{spec.Sub[float32, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float64x2) Sub(y Float64x2) (z Float64x2) {
	return Float64x2{spec.Sub[float64, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float64x4) Sub(y Float64x4) (z Float64x4) {
	return Float64x4{spec.Sub[float64, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float64x8) Sub(y Float64x8) (z Float64x8) {
	return Float64x8{spec.Sub[float64, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Float64s) Sub(y Float64s) (z Float64s) {
	return Float64s{spec.Sub[float64, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int8x16) Sub(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Sub[int8, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int8x32) Sub(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Sub[int8, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int8x64) Sub(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Sub[int8, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int8s) Sub(y Int8s) (z Int8s) {
	return Int8s{spec.Sub[int8, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int16x8) Sub(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Sub[int16, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int16x16) Sub(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Sub[int16, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int16x32) Sub(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Sub[int16, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int16s) Sub(y Int16s) (z Int16s) {
	return Int16s{spec.Sub[int16, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int32x4) Sub(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Sub[int32, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int32x8) Sub(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Sub[int32, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int32x16) Sub(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Sub[int32, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int32s) Sub(y Int32s) (z Int32s) {
	return Int32s{spec.Sub[int32, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int64x2) Sub(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Sub[int64, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int64x4) Sub(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Sub[int64, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int64x8) Sub(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Sub[int64, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Int64s) Sub(y Int64s) (z Int64s) {
	return Int64s{spec.Sub[int64, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint8x16) Sub(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Sub[uint8, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint8x32) Sub(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Sub[uint8, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint8x64) Sub(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Sub[uint8, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint8s) Sub(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Sub[uint8, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint16x8) Sub(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Sub[uint16, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint16x16) Sub(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Sub[uint16, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint16x32) Sub(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Sub[uint16, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint16s) Sub(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Sub[uint16, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint32x4) Sub(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Sub[uint32, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint32x8) Sub(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Sub[uint32, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint32x16) Sub(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Sub[uint32, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint32s) Sub(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Sub[uint32, spec.WidthScalable](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint64x2) Sub(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Sub[uint64, spec.Width128](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint64x4) Sub(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Sub[uint64, spec.Width256](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint64x8) Sub(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Sub[uint64, spec.Width512](x.v, y.v)}
}

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
func (x Uint64s) Sub(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Sub[uint64, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int8x16) AddSaturated(y Int8x16) (z Int8x16) {
	return Int8x16{spec.AddSaturated[int8, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int8x32) AddSaturated(y Int8x32) (z Int8x32) {
	return Int8x32{spec.AddSaturated[int8, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int8x64) AddSaturated(y Int8x64) (z Int8x64) {
	return Int8x64{spec.AddSaturated[int8, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int8s) AddSaturated(y Int8s) (z Int8s) {
	return Int8s{spec.AddSaturated[int8, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int16x8) AddSaturated(y Int16x8) (z Int16x8) {
	return Int16x8{spec.AddSaturated[int16, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int16x16) AddSaturated(y Int16x16) (z Int16x16) {
	return Int16x16{spec.AddSaturated[int16, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int16x32) AddSaturated(y Int16x32) (z Int16x32) {
	return Int16x32{spec.AddSaturated[int16, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int16s) AddSaturated(y Int16s) (z Int16s) {
	return Int16s{spec.AddSaturated[int16, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int32x4) AddSaturated(y Int32x4) (z Int32x4) {
	return Int32x4{spec.AddSaturated[int32, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int32x8) AddSaturated(y Int32x8) (z Int32x8) {
	return Int32x8{spec.AddSaturated[int32, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int32x16) AddSaturated(y Int32x16) (z Int32x16) {
	return Int32x16{spec.AddSaturated[int32, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int32s) AddSaturated(y Int32s) (z Int32s) {
	return Int32s{spec.AddSaturated[int32, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int64x2) AddSaturated(y Int64x2) (z Int64x2) {
	return Int64x2{spec.AddSaturated[int64, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int64x4) AddSaturated(y Int64x4) (z Int64x4) {
	return Int64x4{spec.AddSaturated[int64, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int64x8) AddSaturated(y Int64x8) (z Int64x8) {
	return Int64x8{spec.AddSaturated[int64, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Int64s) AddSaturated(y Int64s) (z Int64s) {
	return Int64s{spec.AddSaturated[int64, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint8x16) AddSaturated(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.AddSaturated[uint8, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint8x32) AddSaturated(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.AddSaturated[uint8, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint8x64) AddSaturated(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.AddSaturated[uint8, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint8s) AddSaturated(y Uint8s) (z Uint8s) {
	return Uint8s{spec.AddSaturated[uint8, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint16x8) AddSaturated(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.AddSaturated[uint16, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint16x16) AddSaturated(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.AddSaturated[uint16, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint16x32) AddSaturated(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.AddSaturated[uint16, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint16s) AddSaturated(y Uint16s) (z Uint16s) {
	return Uint16s{spec.AddSaturated[uint16, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint32x4) AddSaturated(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.AddSaturated[uint32, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint32x8) AddSaturated(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.AddSaturated[uint32, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint32x16) AddSaturated(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.AddSaturated[uint32, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint32s) AddSaturated(y Uint32s) (z Uint32s) {
	return Uint32s{spec.AddSaturated[uint32, spec.WidthScalable](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint64x2) AddSaturated(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.AddSaturated[uint64, spec.Width128](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint64x4) AddSaturated(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.AddSaturated[uint64, spec.Width256](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint64x8) AddSaturated(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.AddSaturated[uint64, spec.Width512](x.v, y.v)}
}

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
func (x Uint64s) AddSaturated(y Uint64s) (z Uint64s) {
	return Uint64s{spec.AddSaturated[uint64, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int8x16) SubSaturated(y Int8x16) (z Int8x16) {
	return Int8x16{spec.SubSaturated[int8, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int8x32) SubSaturated(y Int8x32) (z Int8x32) {
	return Int8x32{spec.SubSaturated[int8, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int8x64) SubSaturated(y Int8x64) (z Int8x64) {
	return Int8x64{spec.SubSaturated[int8, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int8s) SubSaturated(y Int8s) (z Int8s) {
	return Int8s{spec.SubSaturated[int8, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int16x8) SubSaturated(y Int16x8) (z Int16x8) {
	return Int16x8{spec.SubSaturated[int16, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int16x16) SubSaturated(y Int16x16) (z Int16x16) {
	return Int16x16{spec.SubSaturated[int16, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int16x32) SubSaturated(y Int16x32) (z Int16x32) {
	return Int16x32{spec.SubSaturated[int16, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int16s) SubSaturated(y Int16s) (z Int16s) {
	return Int16s{spec.SubSaturated[int16, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int32x4) SubSaturated(y Int32x4) (z Int32x4) {
	return Int32x4{spec.SubSaturated[int32, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int32x8) SubSaturated(y Int32x8) (z Int32x8) {
	return Int32x8{spec.SubSaturated[int32, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int32x16) SubSaturated(y Int32x16) (z Int32x16) {
	return Int32x16{spec.SubSaturated[int32, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int32s) SubSaturated(y Int32s) (z Int32s) {
	return Int32s{spec.SubSaturated[int32, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int64x2) SubSaturated(y Int64x2) (z Int64x2) {
	return Int64x2{spec.SubSaturated[int64, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int64x4) SubSaturated(y Int64x4) (z Int64x4) {
	return Int64x4{spec.SubSaturated[int64, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int64x8) SubSaturated(y Int64x8) (z Int64x8) {
	return Int64x8{spec.SubSaturated[int64, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Int64s) SubSaturated(y Int64s) (z Int64s) {
	return Int64s{spec.SubSaturated[int64, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint8x16) SubSaturated(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.SubSaturated[uint8, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint8x32) SubSaturated(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.SubSaturated[uint8, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint8x64) SubSaturated(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.SubSaturated[uint8, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint8s) SubSaturated(y Uint8s) (z Uint8s) {
	return Uint8s{spec.SubSaturated[uint8, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint16x8) SubSaturated(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.SubSaturated[uint16, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint16x16) SubSaturated(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.SubSaturated[uint16, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint16x32) SubSaturated(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.SubSaturated[uint16, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint16s) SubSaturated(y Uint16s) (z Uint16s) {
	return Uint16s{spec.SubSaturated[uint16, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint32x4) SubSaturated(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.SubSaturated[uint32, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint32x8) SubSaturated(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.SubSaturated[uint32, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint32x16) SubSaturated(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.SubSaturated[uint32, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint32s) SubSaturated(y Uint32s) (z Uint32s) {
	return Uint32s{spec.SubSaturated[uint32, spec.WidthScalable](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint64x2) SubSaturated(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.SubSaturated[uint64, spec.Width128](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint64x4) SubSaturated(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.SubSaturated[uint64, spec.Width256](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint64x8) SubSaturated(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.SubSaturated[uint64, spec.Width512](x.v, y.v)}
}

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
func (x Uint64s) SubSaturated(y Uint64s) (z Uint64s) {
	return Uint64s{spec.SubSaturated[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
func (x Float32x4) ConcatAddPairs(y Float32x4) (z Float32x4) {
	return Float32x4{spec.ConcatAddPairs[float32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Float32x8) ConcatAddPairs(y Float32x8) (z Float32x8) {
	return Float32x8{spec.ConcatAddPairs[float32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Float32x16) ConcatAddPairs(y Float32x16) (z Float32x16) {
	return Float32x16{spec.ConcatAddPairs[float32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Float32s) ConcatAddPairs(y Float32s) (z Float32s) {
	return Float32s{spec.ConcatAddPairs[float32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], y[0]+y[1]}
func (x Float64x2) ConcatAddPairs(y Float64x2) (z Float64x2) {
	return Float64x2{spec.ConcatAddPairs[float64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
func (x Float64x4) ConcatAddPairs(y Float64x4) (z Float64x4) {
	return Float64x4{spec.ConcatAddPairs[float64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Float64x8) ConcatAddPairs(y Float64x8) (z Float64x8) {
	return Float64x8{spec.ConcatAddPairs[float64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Float64s) ConcatAddPairs(y Float64s) (z Float64s) {
	return Float64s{spec.ConcatAddPairs[float64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int8x16) ConcatAddPairs(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatAddPairs[int8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int8x32) ConcatAddPairs(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatAddPairs[int8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int8x64) ConcatAddPairs(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatAddPairs[int8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int8s) ConcatAddPairs(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatAddPairs[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int16x8) ConcatAddPairs(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatAddPairs[int16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int16x16) ConcatAddPairs(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatAddPairs[int16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int16x32) ConcatAddPairs(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatAddPairs[int16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int16s) ConcatAddPairs(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatAddPairs[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
func (x Int32x4) ConcatAddPairs(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatAddPairs[int32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int32x8) ConcatAddPairs(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatAddPairs[int32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int32x16) ConcatAddPairs(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatAddPairs[int32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int32s) ConcatAddPairs(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatAddPairs[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], y[0]+y[1]}
func (x Int64x2) ConcatAddPairs(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatAddPairs[int64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
func (x Int64x4) ConcatAddPairs(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatAddPairs[int64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int64x8) ConcatAddPairs(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatAddPairs[int64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Int64s) ConcatAddPairs(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatAddPairs[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint8x16) ConcatAddPairs(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatAddPairs[uint8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint8x32) ConcatAddPairs(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatAddPairs[uint8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint8x64) ConcatAddPairs(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatAddPairs[uint8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint8s) ConcatAddPairs(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatAddPairs[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint16x8) ConcatAddPairs(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatAddPairs[uint16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint16x16) ConcatAddPairs(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatAddPairs[uint16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint16x32) ConcatAddPairs(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatAddPairs[uint16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint16s) ConcatAddPairs(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatAddPairs[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
func (x Uint32x4) ConcatAddPairs(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatAddPairs[uint32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint32x8) ConcatAddPairs(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatAddPairs[uint32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint32x16) ConcatAddPairs(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatAddPairs[uint32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint32s) ConcatAddPairs(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatAddPairs[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], y[0]+y[1]}
func (x Uint64x2) ConcatAddPairs(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatAddPairs[uint64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
func (x Uint64x4) ConcatAddPairs(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatAddPairs[uint64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint64x8) ConcatAddPairs(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatAddPairs[uint64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
func (x Uint64s) ConcatAddPairs(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatAddPairs[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], y[0]-y[1], y[2]-y[3]}
func (x Float32x4) ConcatSubPairs(y Float32x4) (z Float32x4) {
	return Float32x4{spec.ConcatSubPairs[float32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Float32x8) ConcatSubPairs(y Float32x8) (z Float32x8) {
	return Float32x8{spec.ConcatSubPairs[float32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Float32x16) ConcatSubPairs(y Float32x16) (z Float32x16) {
	return Float32x16{spec.ConcatSubPairs[float32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Float32s) ConcatSubPairs(y Float32s) (z Float32s) {
	return Float32s{spec.ConcatSubPairs[float32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], y[0]-y[1]}
func (x Float64x2) ConcatSubPairs(y Float64x2) (z Float64x2) {
	return Float64x2{spec.ConcatSubPairs[float64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], y[0]-y[1], y[2]-y[3]}
func (x Float64x4) ConcatSubPairs(y Float64x4) (z Float64x4) {
	return Float64x4{spec.ConcatSubPairs[float64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Float64x8) ConcatSubPairs(y Float64x8) (z Float64x8) {
	return Float64x8{spec.ConcatSubPairs[float64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Float64s) ConcatSubPairs(y Float64s) (z Float64s) {
	return Float64s{spec.ConcatSubPairs[float64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8x16) ConcatSubPairs(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatSubPairs[int8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8x32) ConcatSubPairs(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatSubPairs[int8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8x64) ConcatSubPairs(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatSubPairs[int8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8s) ConcatSubPairs(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatSubPairs[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16x8) ConcatSubPairs(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatSubPairs[int16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16x16) ConcatSubPairs(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatSubPairs[int16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16x32) ConcatSubPairs(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatSubPairs[int16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16s) ConcatSubPairs(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatSubPairs[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], y[0]-y[1], y[2]-y[3]}
func (x Int32x4) ConcatSubPairs(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatSubPairs[int32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int32x8) ConcatSubPairs(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatSubPairs[int32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int32x16) ConcatSubPairs(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatSubPairs[int32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int32s) ConcatSubPairs(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatSubPairs[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], y[0]-y[1]}
func (x Int64x2) ConcatSubPairs(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatSubPairs[int64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], y[0]-y[1], y[2]-y[3]}
func (x Int64x4) ConcatSubPairs(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatSubPairs[int64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int64x8) ConcatSubPairs(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatSubPairs[int64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int64s) ConcatSubPairs(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatSubPairs[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8x16) ConcatSubPairs(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatSubPairs[uint8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8x32) ConcatSubPairs(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatSubPairs[uint8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8x64) ConcatSubPairs(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatSubPairs[uint8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8s) ConcatSubPairs(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatSubPairs[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16x8) ConcatSubPairs(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatSubPairs[uint16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16x16) ConcatSubPairs(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatSubPairs[uint16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16x32) ConcatSubPairs(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatSubPairs[uint16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16s) ConcatSubPairs(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatSubPairs[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], y[0]-y[1], y[2]-y[3]}
func (x Uint32x4) ConcatSubPairs(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatSubPairs[uint32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint32x8) ConcatSubPairs(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatSubPairs[uint32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint32x16) ConcatSubPairs(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatSubPairs[uint32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint32s) ConcatSubPairs(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatSubPairs[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], y[0]-y[1]}
func (x Uint64x2) ConcatSubPairs(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatSubPairs[uint64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], y[0]-y[1], y[2]-y[3]}
func (x Uint64x4) ConcatSubPairs(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatSubPairs[uint64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint64x8) ConcatSubPairs(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatSubPairs[uint64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairs horizontally subtracts adjacent pairs of elements in x and y
// and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint64s) ConcatSubPairs(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatSubPairs[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int8x16) ConcatAddPairsSaturated(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatAddPairsSaturated[int8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int8x32) ConcatAddPairsSaturated(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatAddPairsSaturated[int8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int8x64) ConcatAddPairsSaturated(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatAddPairsSaturated[int8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int8s) ConcatAddPairsSaturated(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatAddPairsSaturated[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int16x8) ConcatAddPairsSaturated(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatAddPairsSaturated[int16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int16x16) ConcatAddPairsSaturated(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatAddPairsSaturated[int16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int16x32) ConcatAddPairsSaturated(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatAddPairsSaturated[int16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int16s) ConcatAddPairsSaturated(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatAddPairsSaturated[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), sat(y[0]+y[1]), sat(y[2]+y[3])}
func (x Int32x4) ConcatAddPairsSaturated(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatAddPairsSaturated[int32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int32x8) ConcatAddPairsSaturated(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatAddPairsSaturated[int32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int32x16) ConcatAddPairsSaturated(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatAddPairsSaturated[int32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int32s) ConcatAddPairsSaturated(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatAddPairsSaturated[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(y[0]+y[1])}
func (x Int64x2) ConcatAddPairsSaturated(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatAddPairsSaturated[int64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), sat(y[0]+y[1]), sat(y[2]+y[3])}
func (x Int64x4) ConcatAddPairsSaturated(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatAddPairsSaturated[int64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int64x8) ConcatAddPairsSaturated(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatAddPairsSaturated[int64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Int64s) ConcatAddPairsSaturated(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatAddPairsSaturated[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint8x16) ConcatAddPairsSaturated(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatAddPairsSaturated[uint8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint8x32) ConcatAddPairsSaturated(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatAddPairsSaturated[uint8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint8x64) ConcatAddPairsSaturated(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatAddPairsSaturated[uint8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint8s) ConcatAddPairsSaturated(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatAddPairsSaturated[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint16x8) ConcatAddPairsSaturated(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatAddPairsSaturated[uint16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint16x16) ConcatAddPairsSaturated(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatAddPairsSaturated[uint16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint16x32) ConcatAddPairsSaturated(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatAddPairsSaturated[uint16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint16s) ConcatAddPairsSaturated(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatAddPairsSaturated[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), sat(y[0]+y[1]), sat(y[2]+y[3])}
func (x Uint32x4) ConcatAddPairsSaturated(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatAddPairsSaturated[uint32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint32x8) ConcatAddPairsSaturated(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatAddPairsSaturated[uint32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint32x16) ConcatAddPairsSaturated(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatAddPairsSaturated[uint32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint32s) ConcatAddPairsSaturated(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatAddPairsSaturated[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(y[0]+y[1])}
func (x Uint64x2) ConcatAddPairsSaturated(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatAddPairsSaturated[uint64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), sat(y[0]+y[1]), sat(y[2]+y[3])}
func (x Uint64x4) ConcatAddPairsSaturated(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatAddPairsSaturated[uint64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint64x8) ConcatAddPairsSaturated(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatAddPairsSaturated[uint64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturated horizontally adds adjacent pairs of elements in x and
// y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]+x[1]), sat(x[2]+x[3]), ..., sat(y[0]+y[1]), sat(y[2]+y[3]), ...}
func (x Uint64s) ConcatAddPairsSaturated(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatAddPairsSaturated[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8x16) ConcatSubPairsSaturated(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatSubPairsSaturated[int8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8x32) ConcatSubPairsSaturated(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatSubPairsSaturated[int8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8x64) ConcatSubPairsSaturated(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatSubPairsSaturated[int8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int8s) ConcatSubPairsSaturated(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatSubPairsSaturated[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16x8) ConcatSubPairsSaturated(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatSubPairsSaturated[int16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16x16) ConcatSubPairsSaturated(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatSubPairsSaturated[int16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16x32) ConcatSubPairsSaturated(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatSubPairsSaturated[int16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int16s) ConcatSubPairsSaturated(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatSubPairsSaturated[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]-x[1]), sat(x[2]-x[3]), sat(y[0]-y[1]), sat(y[2]-y[3])}
func (x Int32x4) ConcatSubPairsSaturated(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatSubPairsSaturated[int32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int32x8) ConcatSubPairsSaturated(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatSubPairsSaturated[int32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int32x16) ConcatSubPairsSaturated(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatSubPairsSaturated[int32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int32s) ConcatSubPairsSaturated(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatSubPairsSaturated[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], y[0]-y[1]}
func (x Int64x2) ConcatSubPairsSaturated(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatSubPairsSaturated[int64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]-x[1]), sat(x[2]-x[3]), sat(y[0]-y[1]), sat(y[2]-y[3])}
func (x Int64x4) ConcatSubPairsSaturated(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatSubPairsSaturated[int64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int64x8) ConcatSubPairsSaturated(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatSubPairsSaturated[int64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Int64s) ConcatSubPairsSaturated(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatSubPairsSaturated[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8x16) ConcatSubPairsSaturated(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatSubPairsSaturated[uint8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8x32) ConcatSubPairsSaturated(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatSubPairsSaturated[uint8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8x64) ConcatSubPairsSaturated(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatSubPairsSaturated[uint8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint8s) ConcatSubPairsSaturated(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatSubPairsSaturated[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16x8) ConcatSubPairsSaturated(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatSubPairsSaturated[uint16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16x16) ConcatSubPairsSaturated(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatSubPairsSaturated[uint16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16x32) ConcatSubPairsSaturated(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatSubPairsSaturated[uint16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint16s) ConcatSubPairsSaturated(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatSubPairsSaturated[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]-x[1]), sat(x[2]-x[3]), sat(y[0]-y[1]), sat(y[2]-y[3])}
func (x Uint32x4) ConcatSubPairsSaturated(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatSubPairsSaturated[uint32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint32x8) ConcatSubPairsSaturated(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatSubPairsSaturated[uint32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint32x16) ConcatSubPairsSaturated(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatSubPairsSaturated[uint32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint32s) ConcatSubPairsSaturated(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatSubPairsSaturated[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], y[0]-y[1]}
func (x Uint64x2) ConcatSubPairsSaturated(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatSubPairsSaturated[uint64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {sat(x[0]-x[1]), sat(x[2]-x[3]), sat(y[0]-y[1]), sat(y[2]-y[3])}
func (x Uint64x4) ConcatSubPairsSaturated(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatSubPairsSaturated[uint64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint64x8) ConcatSubPairsSaturated(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatSubPairsSaturated[uint64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturated horizontally subtracts adjacent pairs of elements in
// x and y with saturation and returns the concatenated result.
//
//	z = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], y[2]-y[3], ...}
func (x Uint64s) ConcatSubPairsSaturated(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatSubPairsSaturated[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float32x4) ConcatAddPairsGrouped(y Float32x4) (z Float32x4) {
	return Float32x4{spec.ConcatAddPairsGrouped[float32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float32x8) ConcatAddPairsGrouped(y Float32x8) (z Float32x8) {
	return Float32x8{spec.ConcatAddPairsGrouped[float32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float32x16) ConcatAddPairsGrouped(y Float32x16) (z Float32x16) {
	return Float32x16{spec.ConcatAddPairsGrouped[float32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float32s) ConcatAddPairsGrouped(y Float32s) (z Float32s) {
	return Float32s{spec.ConcatAddPairsGrouped[float32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float64x2) ConcatAddPairsGrouped(y Float64x2) (z Float64x2) {
	return Float64x2{spec.ConcatAddPairsGrouped[float64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float64x4) ConcatAddPairsGrouped(y Float64x4) (z Float64x4) {
	return Float64x4{spec.ConcatAddPairsGrouped[float64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float64x8) ConcatAddPairsGrouped(y Float64x8) (z Float64x8) {
	return Float64x8{spec.ConcatAddPairsGrouped[float64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Float64s) ConcatAddPairsGrouped(y Float64s) (z Float64s) {
	return Float64s{spec.ConcatAddPairsGrouped[float64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int8x16) ConcatAddPairsGrouped(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatAddPairsGrouped[int8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int8x32) ConcatAddPairsGrouped(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatAddPairsGrouped[int8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int8x64) ConcatAddPairsGrouped(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatAddPairsGrouped[int8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int8s) ConcatAddPairsGrouped(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatAddPairsGrouped[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int16x8) ConcatAddPairsGrouped(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatAddPairsGrouped[int16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int16x16) ConcatAddPairsGrouped(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatAddPairsGrouped[int16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int16x32) ConcatAddPairsGrouped(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatAddPairsGrouped[int16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int16s) ConcatAddPairsGrouped(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatAddPairsGrouped[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int32x4) ConcatAddPairsGrouped(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatAddPairsGrouped[int32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int32x8) ConcatAddPairsGrouped(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatAddPairsGrouped[int32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int32x16) ConcatAddPairsGrouped(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatAddPairsGrouped[int32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int32s) ConcatAddPairsGrouped(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatAddPairsGrouped[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int64x2) ConcatAddPairsGrouped(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatAddPairsGrouped[int64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int64x4) ConcatAddPairsGrouped(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatAddPairsGrouped[int64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int64x8) ConcatAddPairsGrouped(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatAddPairsGrouped[int64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Int64s) ConcatAddPairsGrouped(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatAddPairsGrouped[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint8x16) ConcatAddPairsGrouped(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatAddPairsGrouped[uint8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint8x32) ConcatAddPairsGrouped(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatAddPairsGrouped[uint8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint8x64) ConcatAddPairsGrouped(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatAddPairsGrouped[uint8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint8s) ConcatAddPairsGrouped(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatAddPairsGrouped[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint16x8) ConcatAddPairsGrouped(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatAddPairsGrouped[uint16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint16x16) ConcatAddPairsGrouped(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatAddPairsGrouped[uint16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint16x32) ConcatAddPairsGrouped(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatAddPairsGrouped[uint16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint16s) ConcatAddPairsGrouped(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatAddPairsGrouped[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint32x4) ConcatAddPairsGrouped(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatAddPairsGrouped[uint32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint32x8) ConcatAddPairsGrouped(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatAddPairsGrouped[uint32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint32x16) ConcatAddPairsGrouped(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatAddPairsGrouped[uint32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint32s) ConcatAddPairsGrouped(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatAddPairsGrouped[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint64x2) ConcatAddPairsGrouped(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatAddPairsGrouped[uint64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint64x4) ConcatAddPairsGrouped(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatAddPairsGrouped[uint64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint64x8) ConcatAddPairsGrouped(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatAddPairsGrouped[uint64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatAddPairs] on each group.
func (x Uint64s) ConcatAddPairsGrouped(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatAddPairsGrouped[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float32x4) ConcatSubPairsGrouped(y Float32x4) (z Float32x4) {
	return Float32x4{spec.ConcatSubPairsGrouped[float32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float32x8) ConcatSubPairsGrouped(y Float32x8) (z Float32x8) {
	return Float32x8{spec.ConcatSubPairsGrouped[float32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float32x16) ConcatSubPairsGrouped(y Float32x16) (z Float32x16) {
	return Float32x16{spec.ConcatSubPairsGrouped[float32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float32s) ConcatSubPairsGrouped(y Float32s) (z Float32s) {
	return Float32s{spec.ConcatSubPairsGrouped[float32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float64x2) ConcatSubPairsGrouped(y Float64x2) (z Float64x2) {
	return Float64x2{spec.ConcatSubPairsGrouped[float64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float64x4) ConcatSubPairsGrouped(y Float64x4) (z Float64x4) {
	return Float64x4{spec.ConcatSubPairsGrouped[float64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float64x8) ConcatSubPairsGrouped(y Float64x8) (z Float64x8) {
	return Float64x8{spec.ConcatSubPairsGrouped[float64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Float64s) ConcatSubPairsGrouped(y Float64s) (z Float64s) {
	return Float64s{spec.ConcatSubPairsGrouped[float64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int8x16) ConcatSubPairsGrouped(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatSubPairsGrouped[int8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int8x32) ConcatSubPairsGrouped(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatSubPairsGrouped[int8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int8x64) ConcatSubPairsGrouped(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatSubPairsGrouped[int8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int8s) ConcatSubPairsGrouped(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatSubPairsGrouped[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int16x8) ConcatSubPairsGrouped(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatSubPairsGrouped[int16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int16x16) ConcatSubPairsGrouped(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatSubPairsGrouped[int16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int16x32) ConcatSubPairsGrouped(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatSubPairsGrouped[int16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int16s) ConcatSubPairsGrouped(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatSubPairsGrouped[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int32x4) ConcatSubPairsGrouped(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatSubPairsGrouped[int32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int32x8) ConcatSubPairsGrouped(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatSubPairsGrouped[int32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int32x16) ConcatSubPairsGrouped(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatSubPairsGrouped[int32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int32s) ConcatSubPairsGrouped(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatSubPairsGrouped[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int64x2) ConcatSubPairsGrouped(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatSubPairsGrouped[int64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int64x4) ConcatSubPairsGrouped(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatSubPairsGrouped[int64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int64x8) ConcatSubPairsGrouped(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatSubPairsGrouped[int64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Int64s) ConcatSubPairsGrouped(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatSubPairsGrouped[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint8x16) ConcatSubPairsGrouped(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatSubPairsGrouped[uint8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint8x32) ConcatSubPairsGrouped(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatSubPairsGrouped[uint8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint8x64) ConcatSubPairsGrouped(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatSubPairsGrouped[uint8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint8s) ConcatSubPairsGrouped(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatSubPairsGrouped[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint16x8) ConcatSubPairsGrouped(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatSubPairsGrouped[uint16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint16x16) ConcatSubPairsGrouped(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatSubPairsGrouped[uint16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint16x32) ConcatSubPairsGrouped(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatSubPairsGrouped[uint16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint16s) ConcatSubPairsGrouped(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatSubPairsGrouped[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint32x4) ConcatSubPairsGrouped(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatSubPairsGrouped[uint32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint32x8) ConcatSubPairsGrouped(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatSubPairsGrouped[uint32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint32x16) ConcatSubPairsGrouped(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatSubPairsGrouped[uint32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint32s) ConcatSubPairsGrouped(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatSubPairsGrouped[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint64x2) ConcatSubPairsGrouped(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatSubPairsGrouped[uint64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint64x4) ConcatSubPairsGrouped(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatSubPairsGrouped[uint64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint64x8) ConcatSubPairsGrouped(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatSubPairsGrouped[uint64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsGrouped divides x, y, and z into groups of 128 bits and
// performs [ConcatSubPairs] on each group.
func (x Uint64s) ConcatSubPairsGrouped(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatSubPairsGrouped[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int8x16) ConcatAddPairsSaturatedGrouped(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatAddPairsSaturatedGrouped[int8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int8x32) ConcatAddPairsSaturatedGrouped(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatAddPairsSaturatedGrouped[int8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int8x64) ConcatAddPairsSaturatedGrouped(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatAddPairsSaturatedGrouped[int8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int8s) ConcatAddPairsSaturatedGrouped(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatAddPairsSaturatedGrouped[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int16x8) ConcatAddPairsSaturatedGrouped(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatAddPairsSaturatedGrouped[int16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int16x16) ConcatAddPairsSaturatedGrouped(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatAddPairsSaturatedGrouped[int16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int16x32) ConcatAddPairsSaturatedGrouped(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatAddPairsSaturatedGrouped[int16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int16s) ConcatAddPairsSaturatedGrouped(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatAddPairsSaturatedGrouped[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int32x4) ConcatAddPairsSaturatedGrouped(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatAddPairsSaturatedGrouped[int32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int32x8) ConcatAddPairsSaturatedGrouped(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatAddPairsSaturatedGrouped[int32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int32x16) ConcatAddPairsSaturatedGrouped(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatAddPairsSaturatedGrouped[int32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int32s) ConcatAddPairsSaturatedGrouped(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatAddPairsSaturatedGrouped[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int64x2) ConcatAddPairsSaturatedGrouped(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatAddPairsSaturatedGrouped[int64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int64x4) ConcatAddPairsSaturatedGrouped(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatAddPairsSaturatedGrouped[int64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int64x8) ConcatAddPairsSaturatedGrouped(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatAddPairsSaturatedGrouped[int64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Int64s) ConcatAddPairsSaturatedGrouped(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatAddPairsSaturatedGrouped[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint8x16) ConcatAddPairsSaturatedGrouped(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatAddPairsSaturatedGrouped[uint8, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint8x32) ConcatAddPairsSaturatedGrouped(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatAddPairsSaturatedGrouped[uint8, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint8x64) ConcatAddPairsSaturatedGrouped(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatAddPairsSaturatedGrouped[uint8, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint8s) ConcatAddPairsSaturatedGrouped(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatAddPairsSaturatedGrouped[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint16x8) ConcatAddPairsSaturatedGrouped(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatAddPairsSaturatedGrouped[uint16, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint16x16) ConcatAddPairsSaturatedGrouped(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatAddPairsSaturatedGrouped[uint16, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint16x32) ConcatAddPairsSaturatedGrouped(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatAddPairsSaturatedGrouped[uint16, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint16s) ConcatAddPairsSaturatedGrouped(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatAddPairsSaturatedGrouped[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint32x4) ConcatAddPairsSaturatedGrouped(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatAddPairsSaturatedGrouped[uint32, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint32x8) ConcatAddPairsSaturatedGrouped(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatAddPairsSaturatedGrouped[uint32, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint32x16) ConcatAddPairsSaturatedGrouped(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatAddPairsSaturatedGrouped[uint32, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint32s) ConcatAddPairsSaturatedGrouped(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatAddPairsSaturatedGrouped[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint64x2) ConcatAddPairsSaturatedGrouped(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatAddPairsSaturatedGrouped[uint64, spec.Width128](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint64x4) ConcatAddPairsSaturatedGrouped(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatAddPairsSaturatedGrouped[uint64, spec.Width256](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint64x8) ConcatAddPairsSaturatedGrouped(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatAddPairsSaturatedGrouped[uint64, spec.Width512](x.v, y.v)}
}

// ConcatAddPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatAddPairsSaturated] on each group.
func (x Uint64s) ConcatAddPairsSaturatedGrouped(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatAddPairsSaturatedGrouped[uint64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int8x16) ConcatSubPairsSaturatedGrouped(y Int8x16) (z Int8x16) {
	return Int8x16{spec.ConcatSubPairsSaturatedGrouped[int8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int8x32) ConcatSubPairsSaturatedGrouped(y Int8x32) (z Int8x32) {
	return Int8x32{spec.ConcatSubPairsSaturatedGrouped[int8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int8x64) ConcatSubPairsSaturatedGrouped(y Int8x64) (z Int8x64) {
	return Int8x64{spec.ConcatSubPairsSaturatedGrouped[int8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int8s) ConcatSubPairsSaturatedGrouped(y Int8s) (z Int8s) {
	return Int8s{spec.ConcatSubPairsSaturatedGrouped[int8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int16x8) ConcatSubPairsSaturatedGrouped(y Int16x8) (z Int16x8) {
	return Int16x8{spec.ConcatSubPairsSaturatedGrouped[int16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int16x16) ConcatSubPairsSaturatedGrouped(y Int16x16) (z Int16x16) {
	return Int16x16{spec.ConcatSubPairsSaturatedGrouped[int16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int16x32) ConcatSubPairsSaturatedGrouped(y Int16x32) (z Int16x32) {
	return Int16x32{spec.ConcatSubPairsSaturatedGrouped[int16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int16s) ConcatSubPairsSaturatedGrouped(y Int16s) (z Int16s) {
	return Int16s{spec.ConcatSubPairsSaturatedGrouped[int16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int32x4) ConcatSubPairsSaturatedGrouped(y Int32x4) (z Int32x4) {
	return Int32x4{spec.ConcatSubPairsSaturatedGrouped[int32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int32x8) ConcatSubPairsSaturatedGrouped(y Int32x8) (z Int32x8) {
	return Int32x8{spec.ConcatSubPairsSaturatedGrouped[int32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int32x16) ConcatSubPairsSaturatedGrouped(y Int32x16) (z Int32x16) {
	return Int32x16{spec.ConcatSubPairsSaturatedGrouped[int32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int32s) ConcatSubPairsSaturatedGrouped(y Int32s) (z Int32s) {
	return Int32s{spec.ConcatSubPairsSaturatedGrouped[int32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int64x2) ConcatSubPairsSaturatedGrouped(y Int64x2) (z Int64x2) {
	return Int64x2{spec.ConcatSubPairsSaturatedGrouped[int64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int64x4) ConcatSubPairsSaturatedGrouped(y Int64x4) (z Int64x4) {
	return Int64x4{spec.ConcatSubPairsSaturatedGrouped[int64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int64x8) ConcatSubPairsSaturatedGrouped(y Int64x8) (z Int64x8) {
	return Int64x8{spec.ConcatSubPairsSaturatedGrouped[int64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Int64s) ConcatSubPairsSaturatedGrouped(y Int64s) (z Int64s) {
	return Int64s{spec.ConcatSubPairsSaturatedGrouped[int64, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint8x16) ConcatSubPairsSaturatedGrouped(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ConcatSubPairsSaturatedGrouped[uint8, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint8x32) ConcatSubPairsSaturatedGrouped(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ConcatSubPairsSaturatedGrouped[uint8, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint8x64) ConcatSubPairsSaturatedGrouped(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ConcatSubPairsSaturatedGrouped[uint8, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint8s) ConcatSubPairsSaturatedGrouped(y Uint8s) (z Uint8s) {
	return Uint8s{spec.ConcatSubPairsSaturatedGrouped[uint8, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint16x8) ConcatSubPairsSaturatedGrouped(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ConcatSubPairsSaturatedGrouped[uint16, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint16x16) ConcatSubPairsSaturatedGrouped(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ConcatSubPairsSaturatedGrouped[uint16, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint16x32) ConcatSubPairsSaturatedGrouped(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ConcatSubPairsSaturatedGrouped[uint16, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint16s) ConcatSubPairsSaturatedGrouped(y Uint16s) (z Uint16s) {
	return Uint16s{spec.ConcatSubPairsSaturatedGrouped[uint16, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint32x4) ConcatSubPairsSaturatedGrouped(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ConcatSubPairsSaturatedGrouped[uint32, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint32x8) ConcatSubPairsSaturatedGrouped(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ConcatSubPairsSaturatedGrouped[uint32, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint32x16) ConcatSubPairsSaturatedGrouped(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ConcatSubPairsSaturatedGrouped[uint32, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint32s) ConcatSubPairsSaturatedGrouped(y Uint32s) (z Uint32s) {
	return Uint32s{spec.ConcatSubPairsSaturatedGrouped[uint32, spec.WidthScalable](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint64x2) ConcatSubPairsSaturatedGrouped(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ConcatSubPairsSaturatedGrouped[uint64, spec.Width128](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint64x4) ConcatSubPairsSaturatedGrouped(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ConcatSubPairsSaturatedGrouped[uint64, spec.Width256](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint64x8) ConcatSubPairsSaturatedGrouped(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ConcatSubPairsSaturatedGrouped[uint64, spec.Width512](x.v, y.v)}
}

// ConcatSubPairsSaturatedGrouped divides x, y, and z into groups of 128 bits
// and performs [ConcatSubPairsSaturated] on each group.
func (x Uint64s) ConcatSubPairsSaturatedGrouped(y Uint64s) (z Uint64s) {
	return Uint64s{spec.ConcatSubPairsSaturatedGrouped[uint64, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int8x16) Average(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Average[int8, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int8x32) Average(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Average[int8, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int8x64) Average(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Average[int8, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int8s) Average(y Int8s) (z Int8s) {
	return Int8s{spec.Average[int8, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int16x8) Average(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Average[int16, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int16x16) Average(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Average[int16, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int16x32) Average(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Average[int16, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int16s) Average(y Int16s) (z Int16s) {
	return Int16s{spec.Average[int16, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int32x4) Average(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Average[int32, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int32x8) Average(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Average[int32, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int32x16) Average(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Average[int32, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int32s) Average(y Int32s) (z Int32s) {
	return Int32s{spec.Average[int32, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int64x2) Average(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Average[int64, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int64x4) Average(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Average[int64, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int64x8) Average(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Average[int64, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Int64s) Average(y Int64s) (z Int64s) {
	return Int64s{spec.Average[int64, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint8x16) Average(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Average[uint8, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint8x32) Average(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Average[uint8, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint8x64) Average(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Average[uint8, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint8s) Average(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Average[uint8, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint16x8) Average(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Average[uint16, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint16x16) Average(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Average[uint16, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint16x32) Average(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Average[uint16, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint16s) Average(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Average[uint16, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint32x4) Average(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Average[uint32, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint32x8) Average(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Average[uint32, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint32x16) Average(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Average[uint32, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint32s) Average(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Average[uint32, spec.WidthScalable](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint64x2) Average(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Average[uint64, spec.Width128](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint64x4) Average(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Average[uint64, spec.Width256](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint64x8) Average(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Average[uint64, spec.Width512](x.v, y.v)}
}

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
func (x Uint64s) Average(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Average[uint64, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float32x4) Div(y Float32x4) (z Float32x4) {
	return Float32x4{spec.Div[float32, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float32x8) Div(y Float32x8) (z Float32x8) {
	return Float32x8{spec.Div[float32, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float32x16) Div(y Float32x16) (z Float32x16) {
	return Float32x16{spec.Div[float32, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float32s) Div(y Float32s) (z Float32s) {
	return Float32s{spec.Div[float32, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float64x2) Div(y Float64x2) (z Float64x2) {
	return Float64x2{spec.Div[float64, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float64x4) Div(y Float64x4) (z Float64x4) {
	return Float64x4{spec.Div[float64, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float64x8) Div(y Float64x8) (z Float64x8) {
	return Float64x8{spec.Div[float64, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
func (x Float64s) Div(y Float64s) (z Float64s) {
	return Float64s{spec.Div[float64, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt8
// by -1 results in MinInt8, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int8x16) Div(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Div[int8, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt8
// by -1 results in MinInt8, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int8x32) Div(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Div[int8, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt8
// by -1 results in MinInt8, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int8x64) Div(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Div[int8, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt8
// by -1 results in MinInt8, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int8s) Div(y Int8s) (z Int8s) {
	return Int8s{spec.Div[int8, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt16
// by -1 results in MinInt16, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int16x8) Div(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Div[int16, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt16
// by -1 results in MinInt16, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int16x16) Div(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Div[int16, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt16
// by -1 results in MinInt16, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int16x32) Div(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Div[int16, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt16
// by -1 results in MinInt16, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int16s) Div(y Int16s) (z Int16s) {
	return Int16s{spec.Div[int16, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt32
// by -1 results in MinInt32, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int32x4) Div(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Div[int32, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt32
// by -1 results in MinInt32, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int32x8) Div(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Div[int32, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt32
// by -1 results in MinInt32, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int32x16) Div(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Div[int32, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt32
// by -1 results in MinInt32, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int32s) Div(y Int32s) (z Int32s) {
	return Int32s{spec.Div[int32, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt64
// by -1 results in MinInt64, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int64x2) Div(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Div[int64, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt64
// by -1 results in MinInt64, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int64x4) Div(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Div[int64, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt64
// by -1 results in MinInt64, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int64x8) Div(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Div[int64, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator. Also like Go's / operator, dividing MinInt64
// by -1 results in MinInt64, since the true result is unrepresentable.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Int64s) Div(y Int64s) (z Int64s) {
	return Int64s{spec.Div[int64, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint8x16) Div(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Div[uint8, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint8x32) Div(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Div[uint8, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint8x64) Div(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Div[uint8, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint8s) Div(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Div[uint8, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint16x8) Div(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Div[uint16, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint16x16) Div(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Div[uint16, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint16x32) Div(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Div[uint16, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint16s) Div(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Div[uint16, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint32x4) Div(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Div[uint32, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint32x8) Div(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Div[uint32, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint32x16) Div(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Div[uint32, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint32s) Div(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Div[uint32, spec.WidthScalable](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint64x2) Div(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Div[uint64, spec.Width128](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint64x4) Div(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Div[uint64, spec.Width256](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint64x8) Div(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Div[uint64, spec.Width512](x.v, y.v)}
}

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// The result is rounded toward zero (truncated division), just like Go's /
// operator.
// Unlike Go's / operator, division by zero does not panic and instead produces
// a zero result for that element.
func (x Uint64s) Div(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Div[uint64, spec.WidthScalable](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Float32x4) DotProductPairs(y Float32x4) (z Float64x2) {
	return Float64x2{spec.DotProductPairs[float32, spec.Width128, float64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Float32x8) DotProductPairs(y Float32x8) (z Float64x4) {
	return Float64x4{spec.DotProductPairs[float32, spec.Width256, float64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Float32x16) DotProductPairs(y Float32x16) (z Float64x8) {
	return Float64x8{spec.DotProductPairs[float32, spec.Width512, float64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Float32s) DotProductPairs(y Float32s) (z Float64s) {
	return Float64s{spec.DotProductPairs[float32, spec.WidthScalable, float64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int8x16) DotProductPairs(y Int8x16) (z Int16x8) {
	return Int16x8{spec.DotProductPairs[int8, spec.Width128, int16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int8x32) DotProductPairs(y Int8x32) (z Int16x16) {
	return Int16x16{spec.DotProductPairs[int8, spec.Width256, int16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int8x64) DotProductPairs(y Int8x64) (z Int16x32) {
	return Int16x32{spec.DotProductPairs[int8, spec.Width512, int16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int8s) DotProductPairs(y Int8s) (z Int16s) {
	return Int16s{spec.DotProductPairs[int8, spec.WidthScalable, int16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int16x8) DotProductPairs(y Int16x8) (z Int32x4) {
	return Int32x4{spec.DotProductPairs[int16, spec.Width128, int32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int16x16) DotProductPairs(y Int16x16) (z Int32x8) {
	return Int32x8{spec.DotProductPairs[int16, spec.Width256, int32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int16x32) DotProductPairs(y Int16x32) (z Int32x16) {
	return Int32x16{spec.DotProductPairs[int16, spec.Width512, int32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int16s) DotProductPairs(y Int16s) (z Int32s) {
	return Int32s{spec.DotProductPairs[int16, spec.WidthScalable, int32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int32x4) DotProductPairs(y Int32x4) (z Int64x2) {
	return Int64x2{spec.DotProductPairs[int32, spec.Width128, int64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int32x8) DotProductPairs(y Int32x8) (z Int64x4) {
	return Int64x4{spec.DotProductPairs[int32, spec.Width256, int64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int32x16) DotProductPairs(y Int32x16) (z Int64x8) {
	return Int64x8{spec.DotProductPairs[int32, spec.Width512, int64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Int32s) DotProductPairs(y Int32s) (z Int64s) {
	return Int64s{spec.DotProductPairs[int32, spec.WidthScalable, int64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint8x16) DotProductPairs(y Uint8x16) (z Uint16x8) {
	return Uint16x8{spec.DotProductPairs[uint8, spec.Width128, uint16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint8x32) DotProductPairs(y Uint8x32) (z Uint16x16) {
	return Uint16x16{spec.DotProductPairs[uint8, spec.Width256, uint16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint8x64) DotProductPairs(y Uint8x64) (z Uint16x32) {
	return Uint16x32{spec.DotProductPairs[uint8, spec.Width512, uint16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint8s) DotProductPairs(y Uint8s) (z Uint16s) {
	return Uint16s{spec.DotProductPairs[uint8, spec.WidthScalable, uint16](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint16x8) DotProductPairs(y Uint16x8) (z Uint32x4) {
	return Uint32x4{spec.DotProductPairs[uint16, spec.Width128, uint32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint16x16) DotProductPairs(y Uint16x16) (z Uint32x8) {
	return Uint32x8{spec.DotProductPairs[uint16, spec.Width256, uint32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint16x32) DotProductPairs(y Uint16x32) (z Uint32x16) {
	return Uint32x16{spec.DotProductPairs[uint16, spec.Width512, uint32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint16s) DotProductPairs(y Uint16s) (z Uint32s) {
	return Uint32s{spec.DotProductPairs[uint16, spec.WidthScalable, uint32](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint32x4) DotProductPairs(y Uint32x4) (z Uint64x2) {
	return Uint64x2{spec.DotProductPairs[uint32, spec.Width128, uint64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint32x8) DotProductPairs(y Uint32x8) (z Uint64x4) {
	return Uint64x4{spec.DotProductPairs[uint32, spec.Width256, uint64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint32x16) DotProductPairs(y Uint32x16) (z Uint64x8) {
	return Uint64x8{spec.DotProductPairs[uint32, spec.Width512, uint64](x.v, y.v)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, returning a vector of half as many elements, each with twice
// the input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[j] = w[2*j] + w[2*j+1]
func (x Uint32s) DotProductPairs(y Uint32s) (z Uint64s) {
	return Uint64s{spec.DotProductPairs[uint32, spec.WidthScalable, uint64](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint8x16) DotProductPairsSaturated(y Int8x16) (z Int16x8) {
	return Int16x8{spec.DotProductPairsSaturated[uint8, spec.Width128, int8, int16](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint8x32) DotProductPairsSaturated(y Int8x32) (z Int16x16) {
	return Int16x16{spec.DotProductPairsSaturated[uint8, spec.Width256, int8, int16](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint8x64) DotProductPairsSaturated(y Int8x64) (z Int16x32) {
	return Int16x32{spec.DotProductPairsSaturated[uint8, spec.Width512, int8, int16](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint8s) DotProductPairsSaturated(y Int8s) (z Int16s) {
	return Int16s{spec.DotProductPairsSaturated[uint8, spec.WidthScalable, int8, int16](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint16x8) DotProductPairsSaturated(y Int16x8) (z Int32x4) {
	return Int32x4{spec.DotProductPairsSaturated[uint16, spec.Width128, int16, int32](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint16x16) DotProductPairsSaturated(y Int16x16) (z Int32x8) {
	return Int32x8{spec.DotProductPairsSaturated[uint16, spec.Width256, int16, int32](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint16x32) DotProductPairsSaturated(y Int16x32) (z Int32x16) {
	return Int32x16{spec.DotProductPairsSaturated[uint16, spec.Width512, int16, int32](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint16s) DotProductPairsSaturated(y Int16s) (z Int32s) {
	return Int32s{spec.DotProductPairsSaturated[uint16, spec.WidthScalable, int16, int32](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint32x4) DotProductPairsSaturated(y Int32x4) (z Int64x2) {
	return Int64x2{spec.DotProductPairsSaturated[uint32, spec.Width128, int32, int64](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint32x8) DotProductPairsSaturated(y Int32x8) (z Int64x4) {
	return Int64x4{spec.DotProductPairsSaturated[uint32, spec.Width256, int32, int64](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint32x16) DotProductPairsSaturated(y Int32x16) (z Int64x8) {
	return Int64x8{spec.DotProductPairsSaturated[uint32, spec.Width512, int32, int64](x.v, y.v)}
}

// DotProductPairsSaturated multiplies corresponding elements of x and y, and
// sums adjacent pairs, all with saturation. It returns a vector of half as many
// elements, each with twice the input element size.
//
//	w[i] = sat(x[i] * y[i])        // Double width
//	z[j] = sat(w[2*j] + w[2*j+1])
func (x Uint32s) DotProductPairsSaturated(y Int32s) (z Int64s) {
	return Int64s{spec.DotProductPairsSaturated[uint32, spec.WidthScalable, int32, int64](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float32x4) Max(y Float32x4) (z Float32x4) {
	return Float32x4{spec.Max[float32, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float32x8) Max(y Float32x8) (z Float32x8) {
	return Float32x8{spec.Max[float32, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float32x16) Max(y Float32x16) (z Float32x16) {
	return Float32x16{spec.Max[float32, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float32s) Max(y Float32s) (z Float32s) {
	return Float32s{spec.Max[float32, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float64x2) Max(y Float64x2) (z Float64x2) {
	return Float64x2{spec.Max[float64, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float64x4) Max(y Float64x4) (z Float64x4) {
	return Float64x4{spec.Max[float64, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float64x8) Max(y Float64x8) (z Float64x8) {
	return Float64x8{spec.Max[float64, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Float64s) Max(y Float64s) (z Float64s) {
	return Float64s{spec.Max[float64, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int8x16) Max(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Max[int8, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int8x32) Max(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Max[int8, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int8x64) Max(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Max[int8, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int8s) Max(y Int8s) (z Int8s) {
	return Int8s{spec.Max[int8, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int16x8) Max(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Max[int16, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int16x16) Max(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Max[int16, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int16x32) Max(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Max[int16, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int16s) Max(y Int16s) (z Int16s) {
	return Int16s{spec.Max[int16, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int32x4) Max(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Max[int32, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int32x8) Max(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Max[int32, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int32x16) Max(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Max[int32, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int32s) Max(y Int32s) (z Int32s) {
	return Int32s{spec.Max[int32, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int64x2) Max(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Max[int64, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int64x4) Max(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Max[int64, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int64x8) Max(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Max[int64, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Int64s) Max(y Int64s) (z Int64s) {
	return Int64s{spec.Max[int64, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint8x16) Max(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Max[uint8, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint8x32) Max(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Max[uint8, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint8x64) Max(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Max[uint8, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint8s) Max(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Max[uint8, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint16x8) Max(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Max[uint16, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint16x16) Max(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Max[uint16, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint16x32) Max(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Max[uint16, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint16s) Max(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Max[uint16, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint32x4) Max(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Max[uint32, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint32x8) Max(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Max[uint32, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint32x16) Max(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Max[uint32, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint32s) Max(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Max[uint32, spec.WidthScalable](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint64x2) Max(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Max[uint64, spec.Width128](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint64x4) Max(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Max[uint64, spec.Width256](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint64x8) Max(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Max[uint64, spec.Width512](x.v, y.v)}
}

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
func (x Uint64s) Max(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Max[uint64, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float32x4) Min(y Float32x4) (z Float32x4) {
	return Float32x4{spec.Min[float32, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float32x8) Min(y Float32x8) (z Float32x8) {
	return Float32x8{spec.Min[float32, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float32x16) Min(y Float32x16) (z Float32x16) {
	return Float32x16{spec.Min[float32, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float32s) Min(y Float32s) (z Float32s) {
	return Float32s{spec.Min[float32, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float64x2) Min(y Float64x2) (z Float64x2) {
	return Float64x2{spec.Min[float64, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float64x4) Min(y Float64x4) (z Float64x4) {
	return Float64x4{spec.Min[float64, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float64x8) Min(y Float64x8) (z Float64x8) {
	return Float64x8{spec.Min[float64, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Float64s) Min(y Float64s) (z Float64s) {
	return Float64s{spec.Min[float64, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int8x16) Min(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Min[int8, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int8x32) Min(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Min[int8, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int8x64) Min(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Min[int8, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int8s) Min(y Int8s) (z Int8s) {
	return Int8s{spec.Min[int8, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int16x8) Min(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Min[int16, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int16x16) Min(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Min[int16, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int16x32) Min(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Min[int16, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int16s) Min(y Int16s) (z Int16s) {
	return Int16s{spec.Min[int16, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int32x4) Min(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Min[int32, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int32x8) Min(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Min[int32, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int32x16) Min(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Min[int32, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int32s) Min(y Int32s) (z Int32s) {
	return Int32s{spec.Min[int32, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int64x2) Min(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Min[int64, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int64x4) Min(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Min[int64, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int64x8) Min(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Min[int64, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Int64s) Min(y Int64s) (z Int64s) {
	return Int64s{spec.Min[int64, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint8x16) Min(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Min[uint8, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint8x32) Min(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Min[uint8, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint8x64) Min(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Min[uint8, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint8s) Min(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Min[uint8, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint16x8) Min(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Min[uint16, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint16x16) Min(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Min[uint16, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint16x32) Min(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Min[uint16, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint16s) Min(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Min[uint16, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint32x4) Min(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Min[uint32, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint32x8) Min(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Min[uint32, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint32x16) Min(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Min[uint32, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint32s) Min(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Min[uint32, spec.WidthScalable](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint64x2) Min(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Min[uint64, spec.Width128](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint64x4) Min(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Min[uint64, spec.Width256](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint64x8) Min(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Min[uint64, spec.Width512](x.v, y.v)}
}

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
func (x Uint64s) Min(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Min[uint64, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float32x4) Mul(y Float32x4) (z Float32x4) {
	return Float32x4{spec.Mul[float32, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float32x8) Mul(y Float32x8) (z Float32x8) {
	return Float32x8{spec.Mul[float32, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float32x16) Mul(y Float32x16) (z Float32x16) {
	return Float32x16{spec.Mul[float32, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float32s) Mul(y Float32s) (z Float32s) {
	return Float32s{spec.Mul[float32, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float64x2) Mul(y Float64x2) (z Float64x2) {
	return Float64x2{spec.Mul[float64, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float64x4) Mul(y Float64x4) (z Float64x4) {
	return Float64x4{spec.Mul[float64, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float64x8) Mul(y Float64x8) (z Float64x8) {
	return Float64x8{spec.Mul[float64, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Float64s) Mul(y Float64s) (z Float64s) {
	return Float64s{spec.Mul[float64, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int8x16) Mul(y Int8x16) (z Int8x16) {
	return Int8x16{spec.Mul[int8, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int8x32) Mul(y Int8x32) (z Int8x32) {
	return Int8x32{spec.Mul[int8, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int8x64) Mul(y Int8x64) (z Int8x64) {
	return Int8x64{spec.Mul[int8, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int8s) Mul(y Int8s) (z Int8s) {
	return Int8s{spec.Mul[int8, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int16x8) Mul(y Int16x8) (z Int16x8) {
	return Int16x8{spec.Mul[int16, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int16x16) Mul(y Int16x16) (z Int16x16) {
	return Int16x16{spec.Mul[int16, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int16x32) Mul(y Int16x32) (z Int16x32) {
	return Int16x32{spec.Mul[int16, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int16s) Mul(y Int16s) (z Int16s) {
	return Int16s{spec.Mul[int16, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int32x4) Mul(y Int32x4) (z Int32x4) {
	return Int32x4{spec.Mul[int32, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int32x8) Mul(y Int32x8) (z Int32x8) {
	return Int32x8{spec.Mul[int32, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int32x16) Mul(y Int32x16) (z Int32x16) {
	return Int32x16{spec.Mul[int32, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int32s) Mul(y Int32s) (z Int32s) {
	return Int32s{spec.Mul[int32, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int64x2) Mul(y Int64x2) (z Int64x2) {
	return Int64x2{spec.Mul[int64, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int64x4) Mul(y Int64x4) (z Int64x4) {
	return Int64x4{spec.Mul[int64, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int64x8) Mul(y Int64x8) (z Int64x8) {
	return Int64x8{spec.Mul[int64, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Int64s) Mul(y Int64s) (z Int64s) {
	return Int64s{spec.Mul[int64, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint8x16) Mul(y Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Mul[uint8, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint8x32) Mul(y Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Mul[uint8, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint8x64) Mul(y Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Mul[uint8, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint8s) Mul(y Uint8s) (z Uint8s) {
	return Uint8s{spec.Mul[uint8, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint16x8) Mul(y Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Mul[uint16, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint16x16) Mul(y Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Mul[uint16, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint16x32) Mul(y Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Mul[uint16, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint16s) Mul(y Uint16s) (z Uint16s) {
	return Uint16s{spec.Mul[uint16, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint32x4) Mul(y Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Mul[uint32, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint32x8) Mul(y Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Mul[uint32, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint32x16) Mul(y Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Mul[uint32, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint32s) Mul(y Uint32s) (z Uint32s) {
	return Uint32s{spec.Mul[uint32, spec.WidthScalable](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint64x2) Mul(y Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Mul[uint64, spec.Width128](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint64x4) Mul(y Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Mul[uint64, spec.Width256](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint64x8) Mul(y Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Mul[uint64, spec.Width512](x.v, y.v)}
}

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
func (x Uint64s) Mul(y Uint64s) (z Uint64s) {
	return Uint64s{spec.Mul[uint64, spec.WidthScalable](x.v, y.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float32x4) MulAdd(y Float32x4, z Float32x4) (w Float32x4) {
	return Float32x4{spec.MulAdd[float32, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float32x8) MulAdd(y Float32x8, z Float32x8) (w Float32x8) {
	return Float32x8{spec.MulAdd[float32, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float32x16) MulAdd(y Float32x16, z Float32x16) (w Float32x16) {
	return Float32x16{spec.MulAdd[float32, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float32s) MulAdd(y Float32s, z Float32s) (w Float32s) {
	return Float32s{spec.MulAdd[float32, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float64x2) MulAdd(y Float64x2, z Float64x2) (w Float64x2) {
	return Float64x2{spec.MulAdd[float64, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float64x4) MulAdd(y Float64x4, z Float64x4) (w Float64x4) {
	return Float64x4{spec.MulAdd[float64, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float64x8) MulAdd(y Float64x8, z Float64x8) (w Float64x8) {
	return Float64x8{spec.MulAdd[float64, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Float64s) MulAdd(y Float64s, z Float64s) (w Float64s) {
	return Float64s{spec.MulAdd[float64, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int8x16) MulAdd(y Int8x16, z Int8x16) (w Int8x16) {
	return Int8x16{spec.MulAdd[int8, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int8x32) MulAdd(y Int8x32, z Int8x32) (w Int8x32) {
	return Int8x32{spec.MulAdd[int8, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int8x64) MulAdd(y Int8x64, z Int8x64) (w Int8x64) {
	return Int8x64{spec.MulAdd[int8, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int8s) MulAdd(y Int8s, z Int8s) (w Int8s) {
	return Int8s{spec.MulAdd[int8, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int16x8) MulAdd(y Int16x8, z Int16x8) (w Int16x8) {
	return Int16x8{spec.MulAdd[int16, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int16x16) MulAdd(y Int16x16, z Int16x16) (w Int16x16) {
	return Int16x16{spec.MulAdd[int16, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int16x32) MulAdd(y Int16x32, z Int16x32) (w Int16x32) {
	return Int16x32{spec.MulAdd[int16, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int16s) MulAdd(y Int16s, z Int16s) (w Int16s) {
	return Int16s{spec.MulAdd[int16, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int32x4) MulAdd(y Int32x4, z Int32x4) (w Int32x4) {
	return Int32x4{spec.MulAdd[int32, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int32x8) MulAdd(y Int32x8, z Int32x8) (w Int32x8) {
	return Int32x8{spec.MulAdd[int32, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int32x16) MulAdd(y Int32x16, z Int32x16) (w Int32x16) {
	return Int32x16{spec.MulAdd[int32, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int32s) MulAdd(y Int32s, z Int32s) (w Int32s) {
	return Int32s{spec.MulAdd[int32, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int64x2) MulAdd(y Int64x2, z Int64x2) (w Int64x2) {
	return Int64x2{spec.MulAdd[int64, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int64x4) MulAdd(y Int64x4, z Int64x4) (w Int64x4) {
	return Int64x4{spec.MulAdd[int64, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int64x8) MulAdd(y Int64x8, z Int64x8) (w Int64x8) {
	return Int64x8{spec.MulAdd[int64, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Int64s) MulAdd(y Int64s, z Int64s) (w Int64s) {
	return Int64s{spec.MulAdd[int64, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint8x16) MulAdd(y Uint8x16, z Uint8x16) (w Uint8x16) {
	return Uint8x16{spec.MulAdd[uint8, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint8x32) MulAdd(y Uint8x32, z Uint8x32) (w Uint8x32) {
	return Uint8x32{spec.MulAdd[uint8, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint8x64) MulAdd(y Uint8x64, z Uint8x64) (w Uint8x64) {
	return Uint8x64{spec.MulAdd[uint8, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint8s) MulAdd(y Uint8s, z Uint8s) (w Uint8s) {
	return Uint8s{spec.MulAdd[uint8, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint16x8) MulAdd(y Uint16x8, z Uint16x8) (w Uint16x8) {
	return Uint16x8{spec.MulAdd[uint16, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint16x16) MulAdd(y Uint16x16, z Uint16x16) (w Uint16x16) {
	return Uint16x16{spec.MulAdd[uint16, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint16x32) MulAdd(y Uint16x32, z Uint16x32) (w Uint16x32) {
	return Uint16x32{spec.MulAdd[uint16, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint16s) MulAdd(y Uint16s, z Uint16s) (w Uint16s) {
	return Uint16s{spec.MulAdd[uint16, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint32x4) MulAdd(y Uint32x4, z Uint32x4) (w Uint32x4) {
	return Uint32x4{spec.MulAdd[uint32, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint32x8) MulAdd(y Uint32x8, z Uint32x8) (w Uint32x8) {
	return Uint32x8{spec.MulAdd[uint32, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint32x16) MulAdd(y Uint32x16, z Uint32x16) (w Uint32x16) {
	return Uint32x16{spec.MulAdd[uint32, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint32s) MulAdd(y Uint32s, z Uint32s) (w Uint32s) {
	return Uint32s{spec.MulAdd[uint32, spec.WidthScalable](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint64x2) MulAdd(y Uint64x2, z Uint64x2) (w Uint64x2) {
	return Uint64x2{spec.MulAdd[uint64, spec.Width128](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint64x4) MulAdd(y Uint64x4, z Uint64x4) (w Uint64x4) {
	return Uint64x4{spec.MulAdd[uint64, spec.Width256](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint64x8) MulAdd(y Uint64x8, z Uint64x8) (w Uint64x8) {
	return Uint64x8{spec.MulAdd[uint64, spec.Width512](x.v, y.v, z.v)}
}

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
func (x Uint64s) MulAdd(y Uint64s, z Uint64s) (w Uint64s) {
	return Uint64s{spec.MulAdd[uint64, spec.WidthScalable](x.v, y.v, z.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int8x16) Neg() (z Int8x16) {
	return Int8x16{spec.Neg[int8, spec.Width128](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int8x32) Neg() (z Int8x32) {
	return Int8x32{spec.Neg[int8, spec.Width256](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int8x64) Neg() (z Int8x64) {
	return Int8x64{spec.Neg[int8, spec.Width512](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int8s) Neg() (z Int8s) {
	return Int8s{spec.Neg[int8, spec.WidthScalable](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int16x8) Neg() (z Int16x8) {
	return Int16x8{spec.Neg[int16, spec.Width128](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int16x16) Neg() (z Int16x16) {
	return Int16x16{spec.Neg[int16, spec.Width256](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int16x32) Neg() (z Int16x32) {
	return Int16x32{spec.Neg[int16, spec.Width512](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int16s) Neg() (z Int16s) {
	return Int16s{spec.Neg[int16, spec.WidthScalable](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int32x4) Neg() (z Int32x4) {
	return Int32x4{spec.Neg[int32, spec.Width128](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int32x8) Neg() (z Int32x8) {
	return Int32x8{spec.Neg[int32, spec.Width256](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int32x16) Neg() (z Int32x16) {
	return Int32x16{spec.Neg[int32, spec.Width512](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int32s) Neg() (z Int32s) {
	return Int32s{spec.Neg[int32, spec.WidthScalable](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int64x2) Neg() (z Int64x2) {
	return Int64x2{spec.Neg[int64, spec.Width128](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int64x4) Neg() (z Int64x4) {
	return Int64x4{spec.Neg[int64, spec.Width256](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int64x8) Neg() (z Int64x8) {
	return Int64x8{spec.Neg[int64, spec.Width512](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Int64s) Neg() (z Int64s) {
	return Int64s{spec.Neg[int64, spec.WidthScalable](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float32x4) Neg() (z Float32x4) {
	return Float32x4{spec.Neg[float32, spec.Width128](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float32x8) Neg() (z Float32x8) {
	return Float32x8{spec.Neg[float32, spec.Width256](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float32x16) Neg() (z Float32x16) {
	return Float32x16{spec.Neg[float32, spec.Width512](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float32s) Neg() (z Float32s) {
	return Float32s{spec.Neg[float32, spec.WidthScalable](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float64x2) Neg() (z Float64x2) {
	return Float64x2{spec.Neg[float64, spec.Width128](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float64x4) Neg() (z Float64x4) {
	return Float64x4{spec.Neg[float64, spec.Width256](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float64x8) Neg() (z Float64x8) {
	return Float64x8{spec.Neg[float64, spec.Width512](x.v)}
}

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
func (x Float64s) Neg() (z Float64s) {
	return Float64s{spec.Neg[float64, spec.WidthScalable](x.v)}
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float32x4) ReduceSum() (z float32) {
	return spec.ReduceSum[float32, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float32x8) ReduceSum() (z float32) {
	return spec.ReduceSum[float32, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float32x16) ReduceSum() (z float32) {
	return spec.ReduceSum[float32, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float32s) ReduceSum() (z float32) {
	return spec.ReduceSum[float32, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float64x2) ReduceSum() (z float64) {
	return spec.ReduceSum[float64, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float64x4) ReduceSum() (z float64) {
	return spec.ReduceSum[float64, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float64x8) ReduceSum() (z float64) {
	return spec.ReduceSum[float64, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Float64s) ReduceSum() (z float64) {
	return spec.ReduceSum[float64, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int8x16) ReduceSum() (z int8) {
	return spec.ReduceSum[int8, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int8x32) ReduceSum() (z int8) {
	return spec.ReduceSum[int8, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int8x64) ReduceSum() (z int8) {
	return spec.ReduceSum[int8, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int8s) ReduceSum() (z int8) {
	return spec.ReduceSum[int8, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int16x8) ReduceSum() (z int16) {
	return spec.ReduceSum[int16, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int16x16) ReduceSum() (z int16) {
	return spec.ReduceSum[int16, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int16x32) ReduceSum() (z int16) {
	return spec.ReduceSum[int16, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int16s) ReduceSum() (z int16) {
	return spec.ReduceSum[int16, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int32x4) ReduceSum() (z int32) {
	return spec.ReduceSum[int32, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int32x8) ReduceSum() (z int32) {
	return spec.ReduceSum[int32, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int32x16) ReduceSum() (z int32) {
	return spec.ReduceSum[int32, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int32s) ReduceSum() (z int32) {
	return spec.ReduceSum[int32, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int64x2) ReduceSum() (z int64) {
	return spec.ReduceSum[int64, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int64x4) ReduceSum() (z int64) {
	return spec.ReduceSum[int64, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int64x8) ReduceSum() (z int64) {
	return spec.ReduceSum[int64, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Int64s) ReduceSum() (z int64) {
	return spec.ReduceSum[int64, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint8x16) ReduceSum() (z uint8) {
	return spec.ReduceSum[uint8, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint8x32) ReduceSum() (z uint8) {
	return spec.ReduceSum[uint8, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint8x64) ReduceSum() (z uint8) {
	return spec.ReduceSum[uint8, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint8s) ReduceSum() (z uint8) {
	return spec.ReduceSum[uint8, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint16x8) ReduceSum() (z uint16) {
	return spec.ReduceSum[uint16, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint16x16) ReduceSum() (z uint16) {
	return spec.ReduceSum[uint16, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint16x32) ReduceSum() (z uint16) {
	return spec.ReduceSum[uint16, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint16s) ReduceSum() (z uint16) {
	return spec.ReduceSum[uint16, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint32x4) ReduceSum() (z uint32) {
	return spec.ReduceSum[uint32, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint32x8) ReduceSum() (z uint32) {
	return spec.ReduceSum[uint32, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint32x16) ReduceSum() (z uint32) {
	return spec.ReduceSum[uint32, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint32s) ReduceSum() (z uint32) {
	return spec.ReduceSum[uint32, spec.WidthScalable](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint64x2) ReduceSum() (z uint64) {
	return spec.ReduceSum[uint64, spec.Width128](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint64x4) ReduceSum() (z uint64) {
	return spec.ReduceSum[uint64, spec.Width256](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint64x8) ReduceSum() (z uint64) {
	return spec.ReduceSum[uint64, spec.Width512](x.v)
}

// ReduceSum returns the scalar sum of the elements of x.
//
//	z = x[0] + x[1] + ...
func (x Uint64s) ReduceSum() (z uint64) {
	return spec.ReduceSum[uint64, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float32x4) ReduceMax() (z float32) {
	return spec.ReduceMax[float32, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float32x8) ReduceMax() (z float32) {
	return spec.ReduceMax[float32, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float32x16) ReduceMax() (z float32) {
	return spec.ReduceMax[float32, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float32s) ReduceMax() (z float32) {
	return spec.ReduceMax[float32, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float64x2) ReduceMax() (z float64) {
	return spec.ReduceMax[float64, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float64x4) ReduceMax() (z float64) {
	return spec.ReduceMax[float64, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float64x8) ReduceMax() (z float64) {
	return spec.ReduceMax[float64, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Float64s) ReduceMax() (z float64) {
	return spec.ReduceMax[float64, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int8x16) ReduceMax() (z int8) {
	return spec.ReduceMax[int8, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int8x32) ReduceMax() (z int8) {
	return spec.ReduceMax[int8, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int8x64) ReduceMax() (z int8) {
	return spec.ReduceMax[int8, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int8s) ReduceMax() (z int8) {
	return spec.ReduceMax[int8, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int16x8) ReduceMax() (z int16) {
	return spec.ReduceMax[int16, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int16x16) ReduceMax() (z int16) {
	return spec.ReduceMax[int16, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int16x32) ReduceMax() (z int16) {
	return spec.ReduceMax[int16, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int16s) ReduceMax() (z int16) {
	return spec.ReduceMax[int16, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int32x4) ReduceMax() (z int32) {
	return spec.ReduceMax[int32, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int32x8) ReduceMax() (z int32) {
	return spec.ReduceMax[int32, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int32x16) ReduceMax() (z int32) {
	return spec.ReduceMax[int32, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int32s) ReduceMax() (z int32) {
	return spec.ReduceMax[int32, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int64x2) ReduceMax() (z int64) {
	return spec.ReduceMax[int64, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int64x4) ReduceMax() (z int64) {
	return spec.ReduceMax[int64, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int64x8) ReduceMax() (z int64) {
	return spec.ReduceMax[int64, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Int64s) ReduceMax() (z int64) {
	return spec.ReduceMax[int64, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint8x16) ReduceMax() (z uint8) {
	return spec.ReduceMax[uint8, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint8x32) ReduceMax() (z uint8) {
	return spec.ReduceMax[uint8, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint8x64) ReduceMax() (z uint8) {
	return spec.ReduceMax[uint8, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint8s) ReduceMax() (z uint8) {
	return spec.ReduceMax[uint8, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint16x8) ReduceMax() (z uint16) {
	return spec.ReduceMax[uint16, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint16x16) ReduceMax() (z uint16) {
	return spec.ReduceMax[uint16, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint16x32) ReduceMax() (z uint16) {
	return spec.ReduceMax[uint16, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint16s) ReduceMax() (z uint16) {
	return spec.ReduceMax[uint16, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint32x4) ReduceMax() (z uint32) {
	return spec.ReduceMax[uint32, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint32x8) ReduceMax() (z uint32) {
	return spec.ReduceMax[uint32, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint32x16) ReduceMax() (z uint32) {
	return spec.ReduceMax[uint32, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint32s) ReduceMax() (z uint32) {
	return spec.ReduceMax[uint32, spec.WidthScalable](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint64x2) ReduceMax() (z uint64) {
	return spec.ReduceMax[uint64, spec.Width128](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint64x4) ReduceMax() (z uint64) {
	return spec.ReduceMax[uint64, spec.Width256](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint64x8) ReduceMax() (z uint64) {
	return spec.ReduceMax[uint64, spec.Width512](x.v)
}

// ReduceMax returns the largest element of x.
//
//	z = max(x[0], x[1], ...)
func (x Uint64s) ReduceMax() (z uint64) {
	return spec.ReduceMax[uint64, spec.WidthScalable](x.v)
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float32x4) Sqrt() (z Float32x4) {
	return Float32x4{spec.Sqrt[float32, spec.Width128](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float32x8) Sqrt() (z Float32x8) {
	return Float32x8{spec.Sqrt[float32, spec.Width256](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float32x16) Sqrt() (z Float32x16) {
	return Float32x16{spec.Sqrt[float32, spec.Width512](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float32s) Sqrt() (z Float32s) {
	return Float32s{spec.Sqrt[float32, spec.WidthScalable](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float64x2) Sqrt() (z Float64x2) {
	return Float64x2{spec.Sqrt[float64, spec.Width128](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float64x4) Sqrt() (z Float64x4) {
	return Float64x4{spec.Sqrt[float64, spec.Width256](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float64x8) Sqrt() (z Float64x8) {
	return Float64x8{spec.Sqrt[float64, spec.Width512](x.v)}
}

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
func (x Float64s) Sqrt() (z Float64s) {
	return Float64s{spec.Sqrt[float64, spec.WidthScalable](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint8.
func (x Int8x16) ToBits() (z Uint8x16) {
	return Uint8x16{spec.ToBits[int8, spec.Width128, uint8](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint8.
func (x Int8x32) ToBits() (z Uint8x32) {
	return Uint8x32{spec.ToBits[int8, spec.Width256, uint8](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint8.
func (x Int8x64) ToBits() (z Uint8x64) {
	return Uint8x64{spec.ToBits[int8, spec.Width512, uint8](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint8.
func (x Int8s) ToBits() (z Uint8s) {
	return Uint8s{spec.ToBits[int8, spec.WidthScalable, uint8](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint16.
func (x Int16x8) ToBits() (z Uint16x8) {
	return Uint16x8{spec.ToBits[int16, spec.Width128, uint16](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint16.
func (x Int16x16) ToBits() (z Uint16x16) {
	return Uint16x16{spec.ToBits[int16, spec.Width256, uint16](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint16.
func (x Int16x32) ToBits() (z Uint16x32) {
	return Uint16x32{spec.ToBits[int16, spec.Width512, uint16](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint16.
func (x Int16s) ToBits() (z Uint16s) {
	return Uint16s{spec.ToBits[int16, spec.WidthScalable, uint16](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint32.
func (x Int32x4) ToBits() (z Uint32x4) {
	return Uint32x4{spec.ToBits[int32, spec.Width128, uint32](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint32.
func (x Int32x8) ToBits() (z Uint32x8) {
	return Uint32x8{spec.ToBits[int32, spec.Width256, uint32](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint32.
func (x Int32x16) ToBits() (z Uint32x16) {
	return Uint32x16{spec.ToBits[int32, spec.Width512, uint32](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint32.
func (x Int32s) ToBits() (z Uint32s) {
	return Uint32s{spec.ToBits[int32, spec.WidthScalable, uint32](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint64.
func (x Int64x2) ToBits() (z Uint64x2) {
	return Uint64x2{spec.ToBits[int64, spec.Width128, uint64](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint64.
func (x Int64x4) ToBits() (z Uint64x4) {
	return Uint64x4{spec.ToBits[int64, spec.Width256, uint64](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint64.
func (x Int64x8) ToBits() (z Uint64x8) {
	return Uint64x8{spec.ToBits[int64, spec.Width512, uint64](x.v)}
}

// ToBits reinterprets the bits of each element of x as type uint64.
func (x Int64s) ToBits() (z Uint64s) {
	return Uint64s{spec.ToBits[int64, spec.WidthScalable, uint64](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float32x4) ToBits() (z Uint32x4) {
	return Uint32x4{spec.ToBitsFloat[float32, spec.Width128, uint32](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float32x8) ToBits() (z Uint32x8) {
	return Uint32x8{spec.ToBitsFloat[float32, spec.Width256, uint32](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float32x16) ToBits() (z Uint32x16) {
	return Uint32x16{spec.ToBitsFloat[float32, spec.Width512, uint32](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float32s) ToBits() (z Uint32s) {
	return Uint32s{spec.ToBitsFloat[float32, spec.WidthScalable, uint32](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float64x2) ToBits() (z Uint64x2) {
	return Uint64x2{spec.ToBitsFloat[float64, spec.Width128, uint64](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float64x4) ToBits() (z Uint64x4) {
	return Uint64x4{spec.ToBitsFloat[float64, spec.Width256, uint64](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float64x8) ToBits() (z Uint64x8) {
	return Uint64x8{spec.ToBitsFloat[float64, spec.Width512, uint64](x.v)}
}

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float64s) ToBits() (z Uint64s) {
	return Uint64s{spec.ToBitsFloat[float64, spec.WidthScalable, uint64](x.v)}
}

// BitsToInt8 reinterprets the bits of each element of x as type int8.
func (x Uint8x16) BitsToInt8() (z Int8x16) {
	return Int8x16{spec.BitsTo[uint8, spec.Width128, int8](x.v)}
}

// BitsToInt8 reinterprets the bits of each element of x as type int8.
func (x Uint8x32) BitsToInt8() (z Int8x32) {
	return Int8x32{spec.BitsTo[uint8, spec.Width256, int8](x.v)}
}

// BitsToInt8 reinterprets the bits of each element of x as type int8.
func (x Uint8x64) BitsToInt8() (z Int8x64) {
	return Int8x64{spec.BitsTo[uint8, spec.Width512, int8](x.v)}
}

// BitsToInt8 reinterprets the bits of each element of x as type int8.
func (x Uint8s) BitsToInt8() (z Int8s) {
	return Int8s{spec.BitsTo[uint8, spec.WidthScalable, int8](x.v)}
}

// BitsToInt16 reinterprets the bits of each element of x as type int16.
func (x Uint16x8) BitsToInt16() (z Int16x8) {
	return Int16x8{spec.BitsTo[uint16, spec.Width128, int16](x.v)}
}

// BitsToInt16 reinterprets the bits of each element of x as type int16.
func (x Uint16x16) BitsToInt16() (z Int16x16) {
	return Int16x16{spec.BitsTo[uint16, spec.Width256, int16](x.v)}
}

// BitsToInt16 reinterprets the bits of each element of x as type int16.
func (x Uint16x32) BitsToInt16() (z Int16x32) {
	return Int16x32{spec.BitsTo[uint16, spec.Width512, int16](x.v)}
}

// BitsToInt16 reinterprets the bits of each element of x as type int16.
func (x Uint16s) BitsToInt16() (z Int16s) {
	return Int16s{spec.BitsTo[uint16, spec.WidthScalable, int16](x.v)}
}

// BitsToInt32 reinterprets the bits of each element of x as type int32.
func (x Uint32x4) BitsToInt32() (z Int32x4) {
	return Int32x4{spec.BitsTo[uint32, spec.Width128, int32](x.v)}
}

// BitsToInt32 reinterprets the bits of each element of x as type int32.
func (x Uint32x8) BitsToInt32() (z Int32x8) {
	return Int32x8{spec.BitsTo[uint32, spec.Width256, int32](x.v)}
}

// BitsToInt32 reinterprets the bits of each element of x as type int32.
func (x Uint32x16) BitsToInt32() (z Int32x16) {
	return Int32x16{spec.BitsTo[uint32, spec.Width512, int32](x.v)}
}

// BitsToInt32 reinterprets the bits of each element of x as type int32.
func (x Uint32s) BitsToInt32() (z Int32s) {
	return Int32s{spec.BitsTo[uint32, spec.WidthScalable, int32](x.v)}
}

// BitsToInt64 reinterprets the bits of each element of x as type int64.
func (x Uint64x2) BitsToInt64() (z Int64x2) {
	return Int64x2{spec.BitsTo[uint64, spec.Width128, int64](x.v)}
}

// BitsToInt64 reinterprets the bits of each element of x as type int64.
func (x Uint64x4) BitsToInt64() (z Int64x4) {
	return Int64x4{spec.BitsTo[uint64, spec.Width256, int64](x.v)}
}

// BitsToInt64 reinterprets the bits of each element of x as type int64.
func (x Uint64x8) BitsToInt64() (z Int64x8) {
	return Int64x8{spec.BitsTo[uint64, spec.Width512, int64](x.v)}
}

// BitsToInt64 reinterprets the bits of each element of x as type int64.
func (x Uint64s) BitsToInt64() (z Int64s) {
	return Int64s{spec.BitsTo[uint64, spec.WidthScalable, int64](x.v)}
}

// BitsToFloat32 reinterprets the bits of each element of x as type float32.
func (x Uint32x4) BitsToFloat32() (z Float32x4) {
	return Float32x4{spec.BitsToFloat[uint32, spec.Width128, float32](x.v)}
}

// BitsToFloat32 reinterprets the bits of each element of x as type float32.
func (x Uint32x8) BitsToFloat32() (z Float32x8) {
	return Float32x8{spec.BitsToFloat[uint32, spec.Width256, float32](x.v)}
}

// BitsToFloat32 reinterprets the bits of each element of x as type float32.
func (x Uint32x16) BitsToFloat32() (z Float32x16) {
	return Float32x16{spec.BitsToFloat[uint32, spec.Width512, float32](x.v)}
}

// BitsToFloat32 reinterprets the bits of each element of x as type float32.
func (x Uint32s) BitsToFloat32() (z Float32s) {
	return Float32s{spec.BitsToFloat[uint32, spec.WidthScalable, float32](x.v)}
}

// BitsToFloat64 reinterprets the bits of each element of x as type float64.
func (x Uint64x2) BitsToFloat64() (z Float64x2) {
	return Float64x2{spec.BitsToFloat[uint64, spec.Width128, float64](x.v)}
}

// BitsToFloat64 reinterprets the bits of each element of x as type float64.
func (x Uint64x4) BitsToFloat64() (z Float64x4) {
	return Float64x4{spec.BitsToFloat[uint64, spec.Width256, float64](x.v)}
}

// BitsToFloat64 reinterprets the bits of each element of x as type float64.
func (x Uint64x8) BitsToFloat64() (z Float64x8) {
	return Float64x8{spec.BitsToFloat[uint64, spec.Width512, float64](x.v)}
}

// BitsToFloat64 reinterprets the bits of each element of x as type float64.
func (x Uint64s) BitsToFloat64() (z Float64s) {
	return Float64s{spec.BitsToFloat[uint64, spec.WidthScalable, float64](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	         z[7]         ⋯          z[0]
func (x Uint8x16) ReshapeToUint16s() (z Uint16x8) {
	return Uint16x8{spec.ReshapeToUints[uint8, spec.Width128, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]     x[13]     x[12]    ⋯     x[3]      x[2]      x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	                   z[3]                   ⋯                    z[0]
func (x Uint8x16) ReshapeToUint32s() (z Uint32x4) {
	return Uint32x4{spec.ReshapeToUints[uint8, spec.Width128, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x2 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]    ⋯     x[9]      x[8]      x[7]      x[6]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 63                 ....                 0 | 63                 ....                 0 |
//	                     z[1]                                        z[0]
func (x Uint8x16) ReshapeToUint64s() (z Uint64x2) {
	return Uint64x2{spec.ReshapeToUints[uint8, spec.Width128, uint64](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[31]     x[30]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	        z[15]         ⋯          z[0]
func (x Uint8x32) ReshapeToUint16s() (z Uint16x16) {
	return Uint16x16{spec.ReshapeToUints[uint8, spec.Width256, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[31]     x[30]     x[29]     x[28]    ⋯     x[3]      x[2]      x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	                   z[7]                   ⋯                    z[0]
func (x Uint8x32) ReshapeToUint32s() (z Uint32x8) {
	return Uint32x8{spec.ReshapeToUints[uint8, spec.Width256, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[31]     x[30]    ⋯    x[25]     x[24]    ⋯     x[7]      x[6]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 63                 ....                 0 | ⋯ | 63                 ....                 0 |
//	                     z[3]                     ⋯                      z[0]
func (x Uint8x32) ReshapeToUint64s() (z Uint64x4) {
	return Uint64x4{spec.ReshapeToUints[uint8, spec.Width256, uint64](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x32 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[63]     x[62]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	        z[31]         ⋯          z[0]
func (x Uint8x64) ReshapeToUint16s() (z Uint16x32) {
	return Uint16x32{spec.ReshapeToUints[uint8, spec.Width512, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[63]     x[62]     x[61]     x[60]    ⋯     x[3]      x[2]      x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	                  z[15]                   ⋯                    z[0]
func (x Uint8x64) ReshapeToUint32s() (z Uint32x16) {
	return Uint32x16{spec.ReshapeToUints[uint8, spec.Width512, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[63]     x[62]    ⋯    x[57]     x[56]    ⋯     x[7]      x[6]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 63                 ....                 0 | ⋯ | 63                 ....                 0 |
//	                     z[7]                     ⋯                      z[0]
func (x Uint8x64) ReshapeToUint64s() (z Uint64x8) {
	return Uint64x8{spec.ReshapeToUints[uint8, spec.Width512, uint64](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[3]      x[2]      x[1]      x[0]
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯ | 15     ....     0 | 15     ....     0 |
//	⋯          z[1]                z[0]
func (x Uint8s) ReshapeToUint16s() (z Uint16s) {
	return Uint16s{spec.ReshapeToUints[uint8, spec.WidthScalable, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[7]      x[6]      x[5]      x[4]      x[3]      x[2]      x[1]      x[0]
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯ | 31               ....               0 | 31               ....               0 |
//	⋯                    z[1]                                    z[0]
func (x Uint8s) ReshapeToUint32s() (z Uint32s) {
	return Uint32s{spec.ReshapeToUints[uint8, spec.WidthScalable, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯    x[15]     x[14]    ⋯     x[9]      x[8]      x[7]      x[6]    ⋯     x[1]      x[0]
//	⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	⋯ | 63                 ....                 0 | 63                 ....                 0 |
//	⋯                      z[1]                                        z[0]
func (x Uint8s) ReshapeToUint64s() (z Uint64s) {
	return Uint64s{spec.ReshapeToUints[uint8, spec.WidthScalable, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[7]         ⋯          x[0]
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[15]     z[14]    ⋯     z[1]      z[0]
func (x Uint16x8) ReshapeToUint8s() (z Uint8x16) {
	return Uint8x16{spec.ReshapeToUints[uint16, spec.Width128, uint8](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[7]      x[6]    ⋯     x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	         z[3]         ⋯          z[0]
func (x Uint16x8) ReshapeToUint32s() (z Uint32x4) {
	return Uint32x4{spec.ReshapeToUints[uint16, spec.Width128, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x2 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[7]      x[6]      x[5]      x[4]      x[3]      x[2]      x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	| 63               ....               0 | 63               ....               0 |
//	                   z[1]                                    z[0]
func (x Uint16x8) ReshapeToUint64s() (z Uint64x2) {
	return Uint64x2{spec.ReshapeToUints[uint16, spec.Width128, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x32 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	        x[15]         ⋯          x[0]
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[31]     z[30]    ⋯     z[1]      z[0]
func (x Uint16x16) ReshapeToUint8s() (z Uint8x32) {
	return Uint8x32{spec.ReshapeToUints[uint16, spec.Width256, uint8](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]    ⋯     x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	         z[7]         ⋯          z[0]
func (x Uint16x16) ReshapeToUint32s() (z Uint32x8) {
	return Uint32x8{spec.ReshapeToUints[uint16, spec.Width256, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]     x[13]     x[12]    ⋯     x[3]      x[2]      x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	| 63               ....               0 | ⋯ | 63               ....               0 |
//	                   z[3]                   ⋯                    z[0]
func (x Uint16x16) ReshapeToUint64s() (z Uint64x4) {
	return Uint64x4{spec.ReshapeToUints[uint16, spec.Width256, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x64 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	        x[31]         ⋯          x[0]
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[63]     z[62]    ⋯     z[1]      z[0]
func (x Uint16x32) ReshapeToUint8s() (z Uint8x64) {
	return Uint8x64{spec.ReshapeToUints[uint16, spec.Width512, uint8](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[31]     x[30]    ⋯     x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	        z[15]         ⋯          z[0]
func (x Uint16x32) ReshapeToUint32s() (z Uint32x16) {
	return Uint32x16{spec.ReshapeToUints[uint16, spec.Width512, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[31]     x[30]     x[29]     x[28]    ⋯     x[3]      x[2]      x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	| 63               ....               0 | ⋯ | 63               ....               0 |
//	                   z[7]                   ⋯                    z[0]
func (x Uint16x32) ReshapeToUint64s() (z Uint64x8) {
	return Uint64x8{spec.ReshapeToUints[uint16, spec.Width512, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯          x[1]                x[0]
//	⋯ | 15     ....     0 | 15     ....     0 |
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint16s) ReshapeToUint8s() (z Uint8s) {
	return Uint8s{spec.ReshapeToUints[uint16, spec.WidthScalable, uint8](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[3]      x[2]      x[1]      x[0]
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯ | 31     ....     0 | 31     ....     0 |
//	⋯          z[1]                z[0]
func (x Uint16s) ReshapeToUint32s() (z Uint32s) {
	return Uint32s{spec.ReshapeToUints[uint16, spec.WidthScalable, uint32](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[7]      x[6]      x[5]      x[4]      x[3]      x[2]      x[1]      x[0]
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯ | 63               ....               0 | 63               ....               0 |
//	⋯                    z[1]                                    z[0]
func (x Uint16s) ReshapeToUint64s() (z Uint64s) {
	return Uint64s{spec.ReshapeToUints[uint16, spec.WidthScalable, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[3]                   ⋯                    x[0]
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	   z[15]     z[14]     z[13]     z[12]    ⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint32x4) ReshapeToUint8s() (z Uint8x16) {
	return Uint8x16{spec.ReshapeToUints[uint32, spec.Width128, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[3]         ⋯          x[0]
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	    z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint32x4) ReshapeToUint16s() (z Uint16x8) {
	return Uint16x8{spec.ReshapeToUints[uint32, spec.Width128, uint16](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x2 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[3]      x[2]      x[1]      x[0]
//	| 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	| 63     ....     0 | 63     ....     0 |
//	         z[1]                z[0]
func (x Uint32x4) ReshapeToUint64s() (z Uint64x2) {
	return Uint64x2{spec.ReshapeToUints[uint32, spec.Width128, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x32 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[7]                   ⋯                    x[0]
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	   z[31]     z[30]     z[29]     z[28]    ⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint32x8) ReshapeToUint8s() (z Uint8x32) {
	return Uint8x32{spec.ReshapeToUints[uint32, spec.Width256, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[7]         ⋯          x[0]
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	   z[15]     z[14]    ⋯     z[1]      z[0]
func (x Uint32x8) ReshapeToUint16s() (z Uint16x16) {
	return Uint16x16{spec.ReshapeToUints[uint32, spec.Width256, uint16](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[7]      x[6]    ⋯     x[1]      x[0]
//	| 31 .. 0 | 31 .. 0 | ⋯ | 31 .. 0 | 31 .. 0 |
//	| 63     ....     0 | ⋯ | 63     ....     0 |
//	         z[3]         ⋯          z[0]
func (x Uint32x8) ReshapeToUint64s() (z Uint64x4) {
	return Uint64x4{spec.ReshapeToUints[uint32, spec.Width256, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x64 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                  x[15]                   ⋯                    x[0]
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	   z[63]     z[62]     z[61]     z[60]    ⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint32x16) ReshapeToUint8s() (z Uint8x64) {
	return Uint8x64{spec.ReshapeToUints[uint32, spec.Width512, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x32 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	        x[15]         ⋯          x[0]
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	   z[31]     z[30]    ⋯     z[1]      z[0]
func (x Uint32x16) ReshapeToUint16s() (z Uint16x32) {
	return Uint16x32{spec.ReshapeToUints[uint32, spec.Width512, uint16](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]    ⋯     x[1]      x[0]
//	| 31 .. 0 | 31 .. 0 | ⋯ | 31 .. 0 | 31 .. 0 |
//	| 63     ....     0 | ⋯ | 63     ....     0 |
//	         z[7]         ⋯          z[0]
func (x Uint32x16) ReshapeToUint64s() (z Uint64x8) {
	return Uint64x8{spec.ReshapeToUints[uint32, spec.Width512, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯                    x[1]                                    x[0]
//	⋯ | 31               ....               0 | 31               ....               0 |
//	⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	⋯     z[7]      z[6]      z[5]      z[4]      z[3]      z[2]      z[1]      z[0]
func (x Uint32s) ReshapeToUint8s() (z Uint8s) {
	return Uint8s{spec.ReshapeToUints[uint32, spec.WidthScalable, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯          x[1]                x[0]
//	⋯ | 31     ....     0 | 31     ....     0 |
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint32s) ReshapeToUint16s() (z Uint16s) {
	return Uint16s{spec.ReshapeToUints[uint32, spec.WidthScalable, uint16](x.v)}
}

// ReshapeToUint64s reinterprets the bits of x as a Uint64s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯     x[3]      x[2]      x[1]      x[0]
//	⋯ | 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	⋯ | 63     ....     0 | 63     ....     0 |
//	⋯          z[1]                z[0]
func (x Uint32s) ReshapeToUint64s() (z Uint64s) {
	return Uint64s{spec.ReshapeToUints[uint32, spec.WidthScalable, uint64](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                     x[1]                                        x[0]
//	| 63                 ....                 0 | 63                 ....                 0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[15]     z[14]    ⋯     z[9]      z[8]      z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64x2) ReshapeToUint8s() (z Uint8x16) {
	return Uint8x16{spec.ReshapeToUints[uint64, spec.Width128, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[1]                                    x[0]
//	| 63               ....               0 | 63               ....               0 |
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	    z[7]      z[6]      z[5]      z[4]      z[3]      z[2]      z[1]      z[0]
func (x Uint64x2) ReshapeToUint16s() (z Uint16x8) {
	return Uint16x8{spec.ReshapeToUints[uint64, spec.Width128, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[1]                x[0]
//	| 63     ....     0 | 63     ....     0 |
//	| 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	    z[3]      z[2]      z[1]      z[0]
func (x Uint64x2) ReshapeToUint32s() (z Uint32x4) {
	return Uint32x4{spec.ReshapeToUints[uint64, spec.Width128, uint32](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x32 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                     x[3]                     ⋯                      x[0]
//	| 63                 ....                 0 | ⋯ | 63                 ....                 0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[31]     z[30]    ⋯    z[25]     z[24]    ⋯     z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64x4) ReshapeToUint8s() (z Uint8x32) {
	return Uint8x32{spec.ReshapeToUints[uint64, spec.Width256, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[3]                   ⋯                    x[0]
//	| 63               ....               0 | ⋯ | 63               ....               0 |
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	   z[15]     z[14]     z[13]     z[12]    ⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint64x4) ReshapeToUint16s() (z Uint16x16) {
	return Uint16x16{spec.ReshapeToUints[uint64, spec.Width256, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[3]         ⋯          x[0]
//	| 63     ....     0 | ⋯ | 63     ....     0 |
//	| 31 .. 0 | 31 .. 0 | ⋯ | 31 .. 0 | 31 .. 0 |
//	    z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64x4) ReshapeToUint32s() (z Uint32x8) {
	return Uint32x8{spec.ReshapeToUints[uint64, spec.Width256, uint32](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8x64 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                     x[7]                     ⋯                      x[0]
//	| 63                 ....                 0 | ⋯ | 63                 ....                 0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[63]     z[62]    ⋯    z[57]     z[56]    ⋯     z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64x8) ReshapeToUint8s() (z Uint8x64) {
	return Uint8x64{spec.ReshapeToUints[uint64, spec.Width512, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x32 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[7]                   ⋯                    x[0]
//	| 63               ....               0 | ⋯ | 63               ....               0 |
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	   z[31]     z[30]     z[29]     z[28]    ⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint64x8) ReshapeToUint16s() (z Uint16x32) {
	return Uint16x32{spec.ReshapeToUints[uint64, spec.Width512, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[7]         ⋯          x[0]
//	| 63     ....     0 | ⋯ | 63     ....     0 |
//	| 31 .. 0 | 31 .. 0 | ⋯ | 31 .. 0 | 31 .. 0 |
//	   z[15]     z[14]    ⋯     z[1]      z[0]
func (x Uint64x8) ReshapeToUint32s() (z Uint32x16) {
	return Uint32x16{spec.ReshapeToUints[uint64, spec.Width512, uint32](x.v)}
}

// ReshapeToUint8s reinterprets the bits of x as a Uint8s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯                      x[1]                                        x[0]
//	⋯ | 63                 ....                 0 | 63                 ....                 0 |
//	⋯ | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	⋯    z[15]     z[14]    ⋯     z[9]      z[8]      z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64s) ReshapeToUint8s() (z Uint8s) {
	return Uint8s{spec.ReshapeToUints[uint64, spec.WidthScalable, uint8](x.v)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯                    x[1]                                    x[0]
//	⋯ | 63               ....               0 | 63               ....               0 |
//	⋯ | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	⋯     z[7]      z[6]      z[5]      z[4]      z[3]      z[2]      z[1]      z[0]
func (x Uint64s) ReshapeToUint16s() (z Uint16s) {
	return Uint16s{spec.ReshapeToUints[uint64, spec.WidthScalable, uint16](x.v)}
}

// ReshapeToUint32s reinterprets the bits of x as a Uint32s vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	⋯          x[1]                x[0]
//	⋯ | 63     ....     0 | 63     ....     0 |
//	⋯ | 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint64s) ReshapeToUint32s() (z Uint32s) {
	return Uint32s{spec.ReshapeToUints[uint64, spec.WidthScalable, uint32](x.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int8x16) ScaleSaturated(scale Int8x16) (z Int8x16) {
	return Int8x16{spec.ScaleSaturated[int8, spec.Width128, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int8x32) ScaleSaturated(scale Int8x32) (z Int8x32) {
	return Int8x32{spec.ScaleSaturated[int8, spec.Width256, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int8x64) ScaleSaturated(scale Int8x64) (z Int8x64) {
	return Int8x64{spec.ScaleSaturated[int8, spec.Width512, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int8s) ScaleSaturated(scale Int8s) (z Int8s) {
	return Int8s{spec.ScaleSaturated[int8, spec.WidthScalable, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int16x8) ScaleSaturated(scale Int16x8) (z Int16x8) {
	return Int16x8{spec.ScaleSaturated[int16, spec.Width128, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int16x16) ScaleSaturated(scale Int16x16) (z Int16x16) {
	return Int16x16{spec.ScaleSaturated[int16, spec.Width256, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int16x32) ScaleSaturated(scale Int16x32) (z Int16x32) {
	return Int16x32{spec.ScaleSaturated[int16, spec.Width512, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int16s) ScaleSaturated(scale Int16s) (z Int16s) {
	return Int16s{spec.ScaleSaturated[int16, spec.WidthScalable, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int32x4) ScaleSaturated(scale Int32x4) (z Int32x4) {
	return Int32x4{spec.ScaleSaturated[int32, spec.Width128, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int32x8) ScaleSaturated(scale Int32x8) (z Int32x8) {
	return Int32x8{spec.ScaleSaturated[int32, spec.Width256, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int32x16) ScaleSaturated(scale Int32x16) (z Int32x16) {
	return Int32x16{spec.ScaleSaturated[int32, spec.Width512, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int32s) ScaleSaturated(scale Int32s) (z Int32s) {
	return Int32s{spec.ScaleSaturated[int32, spec.WidthScalable, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int64x2) ScaleSaturated(scale Int64x2) (z Int64x2) {
	return Int64x2{spec.ScaleSaturated[int64, spec.Width128, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int64x4) ScaleSaturated(scale Int64x4) (z Int64x4) {
	return Int64x4{spec.ScaleSaturated[int64, spec.Width256, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int64x8) ScaleSaturated(scale Int64x8) (z Int64x8) {
	return Int64x8{spec.ScaleSaturated[int64, spec.Width512, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Int64s) ScaleSaturated(scale Int64s) (z Int64s) {
	return Int64s{spec.ScaleSaturated[int64, spec.WidthScalable, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint8x16) ScaleSaturated(scale Int8x16) (z Uint8x16) {
	return Uint8x16{spec.ScaleSaturated[uint8, spec.Width128, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint8x32) ScaleSaturated(scale Int8x32) (z Uint8x32) {
	return Uint8x32{spec.ScaleSaturated[uint8, spec.Width256, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint8x64) ScaleSaturated(scale Int8x64) (z Uint8x64) {
	return Uint8x64{spec.ScaleSaturated[uint8, spec.Width512, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint8s) ScaleSaturated(scale Int8s) (z Uint8s) {
	return Uint8s{spec.ScaleSaturated[uint8, spec.WidthScalable, int8](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint16x8) ScaleSaturated(scale Int16x8) (z Uint16x8) {
	return Uint16x8{spec.ScaleSaturated[uint16, spec.Width128, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint16x16) ScaleSaturated(scale Int16x16) (z Uint16x16) {
	return Uint16x16{spec.ScaleSaturated[uint16, spec.Width256, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint16x32) ScaleSaturated(scale Int16x32) (z Uint16x32) {
	return Uint16x32{spec.ScaleSaturated[uint16, spec.Width512, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint16s) ScaleSaturated(scale Int16s) (z Uint16s) {
	return Uint16s{spec.ScaleSaturated[uint16, spec.WidthScalable, int16](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint32x4) ScaleSaturated(scale Int32x4) (z Uint32x4) {
	return Uint32x4{spec.ScaleSaturated[uint32, spec.Width128, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint32x8) ScaleSaturated(scale Int32x8) (z Uint32x8) {
	return Uint32x8{spec.ScaleSaturated[uint32, spec.Width256, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint32x16) ScaleSaturated(scale Int32x16) (z Uint32x16) {
	return Uint32x16{spec.ScaleSaturated[uint32, spec.Width512, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint32s) ScaleSaturated(scale Int32s) (z Uint32s) {
	return Uint32s{spec.ScaleSaturated[uint32, spec.WidthScalable, int32](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint64x2) ScaleSaturated(scale Int64x2) (z Uint64x2) {
	return Uint64x2{spec.ScaleSaturated[uint64, spec.Width128, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint64x4) ScaleSaturated(scale Int64x4) (z Uint64x4) {
	return Uint64x4{spec.ScaleSaturated[uint64, spec.Width256, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint64x8) ScaleSaturated(scale Int64x8) (z Uint64x8) {
	return Uint64x8{spec.ScaleSaturated[uint64, spec.Width512, int64](x.v, scale.v)}
}

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
func (x Uint64s) ScaleSaturated(scale Int64s) (z Uint64s) {
	return Uint64s{spec.ScaleSaturated[uint64, spec.WidthScalable, int64](x.v, scale.v)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int8x16) ShiftAllRight(shift uint64) (z Int8x16) {
	return Int8x16{spec.ShiftAllRight[int8, spec.Width128](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int8x32) ShiftAllRight(shift uint64) (z Int8x32) {
	return Int8x32{spec.ShiftAllRight[int8, spec.Width256](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int8x64) ShiftAllRight(shift uint64) (z Int8x64) {
	return Int8x64{spec.ShiftAllRight[int8, spec.Width512](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int8s) ShiftAllRight(shift uint64) (z Int8s) {
	return Int8s{spec.ShiftAllRight[int8, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int16x8) ShiftAllRight(shift uint64) (z Int16x8) {
	return Int16x8{spec.ShiftAllRight[int16, spec.Width128](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int16x16) ShiftAllRight(shift uint64) (z Int16x16) {
	return Int16x16{spec.ShiftAllRight[int16, spec.Width256](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int16x32) ShiftAllRight(shift uint64) (z Int16x32) {
	return Int16x32{spec.ShiftAllRight[int16, spec.Width512](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int16s) ShiftAllRight(shift uint64) (z Int16s) {
	return Int16s{spec.ShiftAllRight[int16, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int32x4) ShiftAllRight(shift uint64) (z Int32x4) {
	return Int32x4{spec.ShiftAllRight[int32, spec.Width128](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int32x8) ShiftAllRight(shift uint64) (z Int32x8) {
	return Int32x8{spec.ShiftAllRight[int32, spec.Width256](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int32x16) ShiftAllRight(shift uint64) (z Int32x16) {
	return Int32x16{spec.ShiftAllRight[int32, spec.Width512](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int32s) ShiftAllRight(shift uint64) (z Int32s) {
	return Int32s{spec.ShiftAllRight[int32, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int64x2) ShiftAllRight(shift uint64) (z Int64x2) {
	return Int64x2{spec.ShiftAllRight[int64, spec.Width128](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int64x4) ShiftAllRight(shift uint64) (z Int64x4) {
	return Int64x4{spec.ShiftAllRight[int64, spec.Width256](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int64x8) ShiftAllRight(shift uint64) (z Int64x8) {
	return Int64x8{spec.ShiftAllRight[int64, spec.Width512](x.v, shift)}
}

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
func (x Int64s) ShiftAllRight(shift uint64) (z Int64s) {
	return Int64s{spec.ShiftAllRight[int64, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint8x16) ShiftAllRight(shift uint64) (z Uint8x16) {
	return Uint8x16{spec.ShiftAllRight[uint8, spec.Width128](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint8x32) ShiftAllRight(shift uint64) (z Uint8x32) {
	return Uint8x32{spec.ShiftAllRight[uint8, spec.Width256](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint8x64) ShiftAllRight(shift uint64) (z Uint8x64) {
	return Uint8x64{spec.ShiftAllRight[uint8, spec.Width512](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint8s) ShiftAllRight(shift uint64) (z Uint8s) {
	return Uint8s{spec.ShiftAllRight[uint8, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint16x8) ShiftAllRight(shift uint64) (z Uint16x8) {
	return Uint16x8{spec.ShiftAllRight[uint16, spec.Width128](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint16x16) ShiftAllRight(shift uint64) (z Uint16x16) {
	return Uint16x16{spec.ShiftAllRight[uint16, spec.Width256](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint16x32) ShiftAllRight(shift uint64) (z Uint16x32) {
	return Uint16x32{spec.ShiftAllRight[uint16, spec.Width512](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint16s) ShiftAllRight(shift uint64) (z Uint16s) {
	return Uint16s{spec.ShiftAllRight[uint16, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint32x4) ShiftAllRight(shift uint64) (z Uint32x4) {
	return Uint32x4{spec.ShiftAllRight[uint32, spec.Width128](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint32x8) ShiftAllRight(shift uint64) (z Uint32x8) {
	return Uint32x8{spec.ShiftAllRight[uint32, spec.Width256](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint32x16) ShiftAllRight(shift uint64) (z Uint32x16) {
	return Uint32x16{spec.ShiftAllRight[uint32, spec.Width512](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint32s) ShiftAllRight(shift uint64) (z Uint32s) {
	return Uint32s{spec.ShiftAllRight[uint32, spec.WidthScalable](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint64x2) ShiftAllRight(shift uint64) (z Uint64x2) {
	return Uint64x2{spec.ShiftAllRight[uint64, spec.Width128](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint64x4) ShiftAllRight(shift uint64) (z Uint64x4) {
	return Uint64x4{spec.ShiftAllRight[uint64, spec.Width256](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint64x8) ShiftAllRight(shift uint64) (z Uint64x8) {
	return Uint64x8{spec.ShiftAllRight[uint64, spec.Width512](x.v, shift)}
}

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
func (x Uint64s) ShiftAllRight(shift uint64) (z Uint64s) {
	return Uint64s{spec.ShiftAllRight[uint64, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int8x16) ShiftAllLeft(shift uint64) (z Int8x16) {
	return Int8x16{spec.ShiftAllLeft[int8, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int8x32) ShiftAllLeft(shift uint64) (z Int8x32) {
	return Int8x32{spec.ShiftAllLeft[int8, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int8x64) ShiftAllLeft(shift uint64) (z Int8x64) {
	return Int8x64{spec.ShiftAllLeft[int8, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int8s) ShiftAllLeft(shift uint64) (z Int8s) {
	return Int8s{spec.ShiftAllLeft[int8, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int16x8) ShiftAllLeft(shift uint64) (z Int16x8) {
	return Int16x8{spec.ShiftAllLeft[int16, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int16x16) ShiftAllLeft(shift uint64) (z Int16x16) {
	return Int16x16{spec.ShiftAllLeft[int16, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int16x32) ShiftAllLeft(shift uint64) (z Int16x32) {
	return Int16x32{spec.ShiftAllLeft[int16, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int16s) ShiftAllLeft(shift uint64) (z Int16s) {
	return Int16s{spec.ShiftAllLeft[int16, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int32x4) ShiftAllLeft(shift uint64) (z Int32x4) {
	return Int32x4{spec.ShiftAllLeft[int32, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int32x8) ShiftAllLeft(shift uint64) (z Int32x8) {
	return Int32x8{spec.ShiftAllLeft[int32, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int32x16) ShiftAllLeft(shift uint64) (z Int32x16) {
	return Int32x16{spec.ShiftAllLeft[int32, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int32s) ShiftAllLeft(shift uint64) (z Int32s) {
	return Int32s{spec.ShiftAllLeft[int32, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int64x2) ShiftAllLeft(shift uint64) (z Int64x2) {
	return Int64x2{spec.ShiftAllLeft[int64, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int64x4) ShiftAllLeft(shift uint64) (z Int64x4) {
	return Int64x4{spec.ShiftAllLeft[int64, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int64x8) ShiftAllLeft(shift uint64) (z Int64x8) {
	return Int64x8{spec.ShiftAllLeft[int64, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Int64s) ShiftAllLeft(shift uint64) (z Int64s) {
	return Int64s{spec.ShiftAllLeft[int64, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint8x16) ShiftAllLeft(shift uint64) (z Uint8x16) {
	return Uint8x16{spec.ShiftAllLeft[uint8, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint8x32) ShiftAllLeft(shift uint64) (z Uint8x32) {
	return Uint8x32{spec.ShiftAllLeft[uint8, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint8x64) ShiftAllLeft(shift uint64) (z Uint8x64) {
	return Uint8x64{spec.ShiftAllLeft[uint8, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint8s) ShiftAllLeft(shift uint64) (z Uint8s) {
	return Uint8s{spec.ShiftAllLeft[uint8, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint16x8) ShiftAllLeft(shift uint64) (z Uint16x8) {
	return Uint16x8{spec.ShiftAllLeft[uint16, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint16x16) ShiftAllLeft(shift uint64) (z Uint16x16) {
	return Uint16x16{spec.ShiftAllLeft[uint16, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint16x32) ShiftAllLeft(shift uint64) (z Uint16x32) {
	return Uint16x32{spec.ShiftAllLeft[uint16, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint16s) ShiftAllLeft(shift uint64) (z Uint16s) {
	return Uint16s{spec.ShiftAllLeft[uint16, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint32x4) ShiftAllLeft(shift uint64) (z Uint32x4) {
	return Uint32x4{spec.ShiftAllLeft[uint32, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint32x8) ShiftAllLeft(shift uint64) (z Uint32x8) {
	return Uint32x8{spec.ShiftAllLeft[uint32, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint32x16) ShiftAllLeft(shift uint64) (z Uint32x16) {
	return Uint32x16{spec.ShiftAllLeft[uint32, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint32s) ShiftAllLeft(shift uint64) (z Uint32s) {
	return Uint32s{spec.ShiftAllLeft[uint32, spec.WidthScalable](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint64x2) ShiftAllLeft(shift uint64) (z Uint64x2) {
	return Uint64x2{spec.ShiftAllLeft[uint64, spec.Width128](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint64x4) ShiftAllLeft(shift uint64) (z Uint64x4) {
	return Uint64x4{spec.ShiftAllLeft[uint64, spec.Width256](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint64x8) ShiftAllLeft(shift uint64) (z Uint64x8) {
	return Uint64x8{spec.ShiftAllLeft[uint64, spec.Width512](x.v, shift)}
}

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
func (x Uint64s) ShiftAllLeft(shift uint64) (z Uint64s) {
	return Uint64s{spec.ShiftAllLeft[uint64, spec.WidthScalable](x.v, shift)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int8x16) ShiftRight(shift Uint8x16) (z Int8x16) {
	return Int8x16{spec.ShiftRight[int8, spec.Width128, uint8](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int8x32) ShiftRight(shift Uint8x32) (z Int8x32) {
	return Int8x32{spec.ShiftRight[int8, spec.Width256, uint8](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int8x64) ShiftRight(shift Uint8x64) (z Int8x64) {
	return Int8x64{spec.ShiftRight[int8, spec.Width512, uint8](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int8s) ShiftRight(shift Uint8s) (z Int8s) {
	return Int8s{spec.ShiftRight[int8, spec.WidthScalable, uint8](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int16x8) ShiftRight(shift Uint16x8) (z Int16x8) {
	return Int16x8{spec.ShiftRight[int16, spec.Width128, uint16](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int16x16) ShiftRight(shift Uint16x16) (z Int16x16) {
	return Int16x16{spec.ShiftRight[int16, spec.Width256, uint16](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int16x32) ShiftRight(shift Uint16x32) (z Int16x32) {
	return Int16x32{spec.ShiftRight[int16, spec.Width512, uint16](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int16s) ShiftRight(shift Uint16s) (z Int16s) {
	return Int16s{spec.ShiftRight[int16, spec.WidthScalable, uint16](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int32x4) ShiftRight(shift Uint32x4) (z Int32x4) {
	return Int32x4{spec.ShiftRight[int32, spec.Width128, uint32](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int32x8) ShiftRight(shift Uint32x8) (z Int32x8) {
	return Int32x8{spec.ShiftRight[int32, spec.Width256, uint32](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int32x16) ShiftRight(shift Uint32x16) (z Int32x16) {
	return Int32x16{spec.ShiftRight[int32, spec.Width512, uint32](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int32s) ShiftRight(shift Uint32s) (z Int32s) {
	return Int32s{spec.ShiftRight[int32, spec.WidthScalable, uint32](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int64x2) ShiftRight(shift Uint64x2) (z Int64x2) {
	return Int64x2{spec.ShiftRight[int64, spec.Width128, uint64](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int64x4) ShiftRight(shift Uint64x4) (z Int64x4) {
	return Int64x4{spec.ShiftRight[int64, spec.Width256, uint64](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int64x8) ShiftRight(shift Uint64x8) (z Int64x8) {
	return Int64x8{spec.ShiftRight[int64, spec.Width512, uint64](x.v, shift.v)}
}

// ShiftRight arithmetically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift[i]
func (x Int64s) ShiftRight(shift Uint64s) (z Int64s) {
	return Int64s{spec.ShiftRight[int64, spec.WidthScalable, uint64](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint8x16) ShiftRight(shift Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ShiftRight[uint8, spec.Width128, uint8](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint8x32) ShiftRight(shift Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ShiftRight[uint8, spec.Width256, uint8](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint8x64) ShiftRight(shift Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ShiftRight[uint8, spec.Width512, uint8](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint8s) ShiftRight(shift Uint8s) (z Uint8s) {
	return Uint8s{spec.ShiftRight[uint8, spec.WidthScalable, uint8](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint16x8) ShiftRight(shift Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ShiftRight[uint16, spec.Width128, uint16](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint16x16) ShiftRight(shift Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ShiftRight[uint16, spec.Width256, uint16](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint16x32) ShiftRight(shift Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ShiftRight[uint16, spec.Width512, uint16](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint16s) ShiftRight(shift Uint16s) (z Uint16s) {
	return Uint16s{spec.ShiftRight[uint16, spec.WidthScalable, uint16](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint32x4) ShiftRight(shift Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ShiftRight[uint32, spec.Width128, uint32](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint32x8) ShiftRight(shift Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ShiftRight[uint32, spec.Width256, uint32](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint32x16) ShiftRight(shift Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ShiftRight[uint32, spec.Width512, uint32](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint32s) ShiftRight(shift Uint32s) (z Uint32s) {
	return Uint32s{spec.ShiftRight[uint32, spec.WidthScalable, uint32](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint64x2) ShiftRight(shift Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ShiftRight[uint64, spec.Width128, uint64](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint64x4) ShiftRight(shift Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ShiftRight[uint64, spec.Width256, uint64](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint64x8) ShiftRight(shift Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ShiftRight[uint64, spec.Width512, uint64](x.v, shift.v)}
}

// ShiftRight logically shifts x[i] right by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift[i]
func (x Uint64s) ShiftRight(shift Uint64s) (z Uint64s) {
	return Uint64s{spec.ShiftRight[uint64, spec.WidthScalable, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int8x16) ShiftLeft(shift Uint8x16) (z Int8x16) {
	return Int8x16{spec.ShiftLeft[int8, spec.Width128, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int8x32) ShiftLeft(shift Uint8x32) (z Int8x32) {
	return Int8x32{spec.ShiftLeft[int8, spec.Width256, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int8x64) ShiftLeft(shift Uint8x64) (z Int8x64) {
	return Int8x64{spec.ShiftLeft[int8, spec.Width512, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int8s) ShiftLeft(shift Uint8s) (z Int8s) {
	return Int8s{spec.ShiftLeft[int8, spec.WidthScalable, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int16x8) ShiftLeft(shift Uint16x8) (z Int16x8) {
	return Int16x8{spec.ShiftLeft[int16, spec.Width128, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int16x16) ShiftLeft(shift Uint16x16) (z Int16x16) {
	return Int16x16{spec.ShiftLeft[int16, spec.Width256, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int16x32) ShiftLeft(shift Uint16x32) (z Int16x32) {
	return Int16x32{spec.ShiftLeft[int16, spec.Width512, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int16s) ShiftLeft(shift Uint16s) (z Int16s) {
	return Int16s{spec.ShiftLeft[int16, spec.WidthScalable, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int32x4) ShiftLeft(shift Uint32x4) (z Int32x4) {
	return Int32x4{spec.ShiftLeft[int32, spec.Width128, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int32x8) ShiftLeft(shift Uint32x8) (z Int32x8) {
	return Int32x8{spec.ShiftLeft[int32, spec.Width256, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int32x16) ShiftLeft(shift Uint32x16) (z Int32x16) {
	return Int32x16{spec.ShiftLeft[int32, spec.Width512, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int32s) ShiftLeft(shift Uint32s) (z Int32s) {
	return Int32s{spec.ShiftLeft[int32, spec.WidthScalable, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int64x2) ShiftLeft(shift Uint64x2) (z Int64x2) {
	return Int64x2{spec.ShiftLeft[int64, spec.Width128, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int64x4) ShiftLeft(shift Uint64x4) (z Int64x4) {
	return Int64x4{spec.ShiftLeft[int64, spec.Width256, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int64x8) ShiftLeft(shift Uint64x8) (z Int64x8) {
	return Int64x8{spec.ShiftLeft[int64, spec.Width512, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Int64s) ShiftLeft(shift Uint64s) (z Int64s) {
	return Int64s{spec.ShiftLeft[int64, spec.WidthScalable, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint8x16) ShiftLeft(shift Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.ShiftLeft[uint8, spec.Width128, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint8x32) ShiftLeft(shift Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.ShiftLeft[uint8, spec.Width256, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint8x64) ShiftLeft(shift Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.ShiftLeft[uint8, spec.Width512, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint8s) ShiftLeft(shift Uint8s) (z Uint8s) {
	return Uint8s{spec.ShiftLeft[uint8, spec.WidthScalable, uint8](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint16x8) ShiftLeft(shift Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.ShiftLeft[uint16, spec.Width128, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint16x16) ShiftLeft(shift Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.ShiftLeft[uint16, spec.Width256, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint16x32) ShiftLeft(shift Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.ShiftLeft[uint16, spec.Width512, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint16s) ShiftLeft(shift Uint16s) (z Uint16s) {
	return Uint16s{spec.ShiftLeft[uint16, spec.WidthScalable, uint16](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint32x4) ShiftLeft(shift Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.ShiftLeft[uint32, spec.Width128, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint32x8) ShiftLeft(shift Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.ShiftLeft[uint32, spec.Width256, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint32x16) ShiftLeft(shift Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.ShiftLeft[uint32, spec.Width512, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint32s) ShiftLeft(shift Uint32s) (z Uint32s) {
	return Uint32s{spec.ShiftLeft[uint32, spec.WidthScalable, uint32](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint64x2) ShiftLeft(shift Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.ShiftLeft[uint64, spec.Width128, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint64x4) ShiftLeft(shift Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.ShiftLeft[uint64, spec.Width256, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint64x8) ShiftLeft(shift Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.ShiftLeft[uint64, spec.Width512, uint64](x.v, shift.v)}
}

// ShiftLeft shifts x[i] left by shift[i] bits.
// If shift[i] is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift[i]
func (x Uint64s) ShiftLeft(shift Uint64s) (z Uint64s) {
	return Uint64s{spec.ShiftLeft[uint64, spec.WidthScalable, uint64](x.v, shift.v)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint8x16) RotateAllLeft(shift uint64) (z Uint8x16) {
	return Uint8x16{spec.RotateAllLeft[uint8, spec.Width128](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint8x32) RotateAllLeft(shift uint64) (z Uint8x32) {
	return Uint8x32{spec.RotateAllLeft[uint8, spec.Width256](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint8x64) RotateAllLeft(shift uint64) (z Uint8x64) {
	return Uint8x64{spec.RotateAllLeft[uint8, spec.Width512](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint8s) RotateAllLeft(shift uint64) (z Uint8s) {
	return Uint8s{spec.RotateAllLeft[uint8, spec.WidthScalable](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint16x8) RotateAllLeft(shift uint64) (z Uint16x8) {
	return Uint16x8{spec.RotateAllLeft[uint16, spec.Width128](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint16x16) RotateAllLeft(shift uint64) (z Uint16x16) {
	return Uint16x16{spec.RotateAllLeft[uint16, spec.Width256](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint16x32) RotateAllLeft(shift uint64) (z Uint16x32) {
	return Uint16x32{spec.RotateAllLeft[uint16, spec.Width512](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint16s) RotateAllLeft(shift uint64) (z Uint16s) {
	return Uint16s{spec.RotateAllLeft[uint16, spec.WidthScalable](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint32x4) RotateAllLeft(shift uint64) (z Uint32x4) {
	return Uint32x4{spec.RotateAllLeft[uint32, spec.Width128](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint32x8) RotateAllLeft(shift uint64) (z Uint32x8) {
	return Uint32x8{spec.RotateAllLeft[uint32, spec.Width256](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint32x16) RotateAllLeft(shift uint64) (z Uint32x16) {
	return Uint32x16{spec.RotateAllLeft[uint32, spec.Width512](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint32s) RotateAllLeft(shift uint64) (z Uint32s) {
	return Uint32s{spec.RotateAllLeft[uint32, spec.WidthScalable](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint64x2) RotateAllLeft(shift uint64) (z Uint64x2) {
	return Uint64x2{spec.RotateAllLeft[uint64, spec.Width128](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint64x4) RotateAllLeft(shift uint64) (z Uint64x4) {
	return Uint64x4{spec.RotateAllLeft[uint64, spec.Width256](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint64x8) RotateAllLeft(shift uint64) (z Uint64x8) {
	return Uint64x8{spec.RotateAllLeft[uint64, spec.Width512](x.v, shift)}
}

// RotateAllLeft rotates each element of x left by shift bits.
//
//	z[i] = rotateLeft(x[i], shift)
func (x Uint64s) RotateAllLeft(shift uint64) (z Uint64s) {
	return Uint64s{spec.RotateAllLeft[uint64, spec.WidthScalable](x.v, shift)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint8x16) RotateLeft(shift Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.RotateLeft[uint8, spec.Width128](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint8x32) RotateLeft(shift Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.RotateLeft[uint8, spec.Width256](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint8x64) RotateLeft(shift Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.RotateLeft[uint8, spec.Width512](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint8s) RotateLeft(shift Uint8s) (z Uint8s) {
	return Uint8s{spec.RotateLeft[uint8, spec.WidthScalable](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint16x8) RotateLeft(shift Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.RotateLeft[uint16, spec.Width128](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint16x16) RotateLeft(shift Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.RotateLeft[uint16, spec.Width256](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint16x32) RotateLeft(shift Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.RotateLeft[uint16, spec.Width512](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint16s) RotateLeft(shift Uint16s) (z Uint16s) {
	return Uint16s{spec.RotateLeft[uint16, spec.WidthScalable](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint32x4) RotateLeft(shift Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.RotateLeft[uint32, spec.Width128](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint32x8) RotateLeft(shift Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.RotateLeft[uint32, spec.Width256](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint32x16) RotateLeft(shift Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.RotateLeft[uint32, spec.Width512](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint32s) RotateLeft(shift Uint32s) (z Uint32s) {
	return Uint32s{spec.RotateLeft[uint32, spec.WidthScalable](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint64x2) RotateLeft(shift Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.RotateLeft[uint64, spec.Width128](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint64x4) RotateLeft(shift Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.RotateLeft[uint64, spec.Width256](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint64x8) RotateLeft(shift Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.RotateLeft[uint64, spec.Width512](x.v, shift.v)}
}

// RotateLeft rotates x left by shift bits, elementwise.
//
//	z[i] = rotateLeft(x[i], shift[i])
func (x Uint64s) RotateLeft(shift Uint64s) (z Uint64s) {
	return Uint64s{spec.RotateLeft[uint64, spec.WidthScalable](x.v, shift.v)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint8x16) RotateAllRight(shift uint64) (z Uint8x16) {
	return Uint8x16{spec.RotateAllRight[uint8, spec.Width128](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint8x32) RotateAllRight(shift uint64) (z Uint8x32) {
	return Uint8x32{spec.RotateAllRight[uint8, spec.Width256](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint8x64) RotateAllRight(shift uint64) (z Uint8x64) {
	return Uint8x64{spec.RotateAllRight[uint8, spec.Width512](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint8s) RotateAllRight(shift uint64) (z Uint8s) {
	return Uint8s{spec.RotateAllRight[uint8, spec.WidthScalable](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint16x8) RotateAllRight(shift uint64) (z Uint16x8) {
	return Uint16x8{spec.RotateAllRight[uint16, spec.Width128](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint16x16) RotateAllRight(shift uint64) (z Uint16x16) {
	return Uint16x16{spec.RotateAllRight[uint16, spec.Width256](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint16x32) RotateAllRight(shift uint64) (z Uint16x32) {
	return Uint16x32{spec.RotateAllRight[uint16, spec.Width512](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint16s) RotateAllRight(shift uint64) (z Uint16s) {
	return Uint16s{spec.RotateAllRight[uint16, spec.WidthScalable](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint32x4) RotateAllRight(shift uint64) (z Uint32x4) {
	return Uint32x4{spec.RotateAllRight[uint32, spec.Width128](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint32x8) RotateAllRight(shift uint64) (z Uint32x8) {
	return Uint32x8{spec.RotateAllRight[uint32, spec.Width256](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint32x16) RotateAllRight(shift uint64) (z Uint32x16) {
	return Uint32x16{spec.RotateAllRight[uint32, spec.Width512](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint32s) RotateAllRight(shift uint64) (z Uint32s) {
	return Uint32s{spec.RotateAllRight[uint32, spec.WidthScalable](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint64x2) RotateAllRight(shift uint64) (z Uint64x2) {
	return Uint64x2{spec.RotateAllRight[uint64, spec.Width128](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint64x4) RotateAllRight(shift uint64) (z Uint64x4) {
	return Uint64x4{spec.RotateAllRight[uint64, spec.Width256](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint64x8) RotateAllRight(shift uint64) (z Uint64x8) {
	return Uint64x8{spec.RotateAllRight[uint64, spec.Width512](x.v, shift)}
}

// RotateAllRight rotates each element of x right by shift bits.
//
//	z[i] = rotateRight(x[i], shift)
func (x Uint64s) RotateAllRight(shift uint64) (z Uint64s) {
	return Uint64s{spec.RotateAllRight[uint64, spec.WidthScalable](x.v, shift)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint8x16) RotateRight(shift Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.RotateRight[uint8, spec.Width128](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint8x32) RotateRight(shift Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.RotateRight[uint8, spec.Width256](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint8x64) RotateRight(shift Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.RotateRight[uint8, spec.Width512](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint8s) RotateRight(shift Uint8s) (z Uint8s) {
	return Uint8s{spec.RotateRight[uint8, spec.WidthScalable](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint16x8) RotateRight(shift Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.RotateRight[uint16, spec.Width128](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint16x16) RotateRight(shift Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.RotateRight[uint16, spec.Width256](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint16x32) RotateRight(shift Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.RotateRight[uint16, spec.Width512](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint16s) RotateRight(shift Uint16s) (z Uint16s) {
	return Uint16s{spec.RotateRight[uint16, spec.WidthScalable](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint32x4) RotateRight(shift Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.RotateRight[uint32, spec.Width128](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint32x8) RotateRight(shift Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.RotateRight[uint32, spec.Width256](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint32x16) RotateRight(shift Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.RotateRight[uint32, spec.Width512](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint32s) RotateRight(shift Uint32s) (z Uint32s) {
	return Uint32s{spec.RotateRight[uint32, spec.WidthScalable](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint64x2) RotateRight(shift Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.RotateRight[uint64, spec.Width128](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint64x4) RotateRight(shift Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.RotateRight[uint64, spec.Width256](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint64x8) RotateRight(shift Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.RotateRight[uint64, spec.Width512](x.v, shift.v)}
}

// RotateRight rotates x right by shift bits, elementwise.
//
//	z[i] = rotateRight(x[i], shift[i])
func (x Uint64s) RotateRight(shift Uint64s) (z Uint64s) {
	return Uint64s{spec.RotateRight[uint64, spec.WidthScalable](x.v, shift.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float32x4) Permute(indices Uint32x4) (z Float32x4) {
	return Float32x4{spec.Permute[float32, spec.Width128, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float32x8) Permute(indices Uint32x8) (z Float32x8) {
	return Float32x8{spec.Permute[float32, spec.Width256, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float32x16) Permute(indices Uint32x16) (z Float32x16) {
	return Float32x16{spec.Permute[float32, spec.Width512, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float32s) Permute(indices Uint32s) (z Float32s) {
	return Float32s{spec.Permute[float32, spec.WidthScalable, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float64x2) Permute(indices Uint64x2) (z Float64x2) {
	return Float64x2{spec.Permute[float64, spec.Width128, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float64x4) Permute(indices Uint64x4) (z Float64x4) {
	return Float64x4{spec.Permute[float64, spec.Width256, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float64x8) Permute(indices Uint64x8) (z Float64x8) {
	return Float64x8{spec.Permute[float64, spec.Width512, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Float64s) Permute(indices Uint64s) (z Float64s) {
	return Float64s{spec.Permute[float64, spec.WidthScalable, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int8x16) Permute(indices Uint8x16) (z Int8x16) {
	return Int8x16{spec.Permute[int8, spec.Width128, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int8x32) Permute(indices Uint8x32) (z Int8x32) {
	return Int8x32{spec.Permute[int8, spec.Width256, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int8x64) Permute(indices Uint8x64) (z Int8x64) {
	return Int8x64{spec.Permute[int8, spec.Width512, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int8s) Permute(indices Uint8s) (z Int8s) {
	return Int8s{spec.Permute[int8, spec.WidthScalable, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int16x8) Permute(indices Uint16x8) (z Int16x8) {
	return Int16x8{spec.Permute[int16, spec.Width128, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int16x16) Permute(indices Uint16x16) (z Int16x16) {
	return Int16x16{spec.Permute[int16, spec.Width256, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int16x32) Permute(indices Uint16x32) (z Int16x32) {
	return Int16x32{spec.Permute[int16, spec.Width512, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int16s) Permute(indices Uint16s) (z Int16s) {
	return Int16s{spec.Permute[int16, spec.WidthScalable, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int32x4) Permute(indices Uint32x4) (z Int32x4) {
	return Int32x4{spec.Permute[int32, spec.Width128, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int32x8) Permute(indices Uint32x8) (z Int32x8) {
	return Int32x8{spec.Permute[int32, spec.Width256, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int32x16) Permute(indices Uint32x16) (z Int32x16) {
	return Int32x16{spec.Permute[int32, spec.Width512, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int32s) Permute(indices Uint32s) (z Int32s) {
	return Int32s{spec.Permute[int32, spec.WidthScalable, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int64x2) Permute(indices Uint64x2) (z Int64x2) {
	return Int64x2{spec.Permute[int64, spec.Width128, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int64x4) Permute(indices Uint64x4) (z Int64x4) {
	return Int64x4{spec.Permute[int64, spec.Width256, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int64x8) Permute(indices Uint64x8) (z Int64x8) {
	return Int64x8{spec.Permute[int64, spec.Width512, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Int64s) Permute(indices Uint64s) (z Int64s) {
	return Int64s{spec.Permute[int64, spec.WidthScalable, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint8x16) Permute(indices Uint8x16) (z Uint8x16) {
	return Uint8x16{spec.Permute[uint8, spec.Width128, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint8x32) Permute(indices Uint8x32) (z Uint8x32) {
	return Uint8x32{spec.Permute[uint8, spec.Width256, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint8x64) Permute(indices Uint8x64) (z Uint8x64) {
	return Uint8x64{spec.Permute[uint8, spec.Width512, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint8s) Permute(indices Uint8s) (z Uint8s) {
	return Uint8s{spec.Permute[uint8, spec.WidthScalable, uint8](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint16x8) Permute(indices Uint16x8) (z Uint16x8) {
	return Uint16x8{spec.Permute[uint16, spec.Width128, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint16x16) Permute(indices Uint16x16) (z Uint16x16) {
	return Uint16x16{spec.Permute[uint16, spec.Width256, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint16x32) Permute(indices Uint16x32) (z Uint16x32) {
	return Uint16x32{spec.Permute[uint16, spec.Width512, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint16s) Permute(indices Uint16s) (z Uint16s) {
	return Uint16s{spec.Permute[uint16, spec.WidthScalable, uint16](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint32x4) Permute(indices Uint32x4) (z Uint32x4) {
	return Uint32x4{spec.Permute[uint32, spec.Width128, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint32x8) Permute(indices Uint32x8) (z Uint32x8) {
	return Uint32x8{spec.Permute[uint32, spec.Width256, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint32x16) Permute(indices Uint32x16) (z Uint32x16) {
	return Uint32x16{spec.Permute[uint32, spec.Width512, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint32s) Permute(indices Uint32s) (z Uint32s) {
	return Uint32s{spec.Permute[uint32, spec.WidthScalable, uint32](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint64x2) Permute(indices Uint64x2) (z Uint64x2) {
	return Uint64x2{spec.Permute[uint64, spec.Width128, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint64x4) Permute(indices Uint64x4) (z Uint64x4) {
	return Uint64x4{spec.Permute[uint64, spec.Width256, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint64x8) Permute(indices Uint64x8) (z Uint64x8) {
	return Uint64x8{spec.Permute[uint64, spec.Width512, uint64](x.v, indices.v)}
}

// Permute permutes x.
//
//	z[i] = x[indices[i] % len(x)]
func (x Uint64s) Permute(indices Uint64s) (z Uint64s) {
	return Uint64s{spec.Permute[uint64, spec.WidthScalable, uint64](x.v, indices.v)}
}