// 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 }
)

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

// ConvertToInt8 converts element values to int8.
//
// 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 element values to int16.
//
// 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 element values to int32.
func (x Float32x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[float32, spec.Width128, int32, spec.Width128](x.v)}
}

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

// ConvertToUint8 converts element values to uint8.
//
// 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 element values to uint16.
//
// 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 element values to uint32.
func (x Float32x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[float32, spec.Width128, uint32, spec.Width128](x.v)}
}

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

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

// ConvertToInt8 converts element values to int8.
//
// 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 element values to int16.
func (x Float32x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float32, spec.Width256, int16, spec.Width128](x.v)}
}

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

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

// ConvertToUint8 converts element values to uint8.
//
// 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 element values to uint16.
func (x Float32x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float32, spec.Width256, uint16, spec.Width128](x.v)}
}

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

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

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

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

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

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

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

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

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

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

// ConvertToFloat32 converts element values to float32.
//
// 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 element values to int8.
//
// 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 element values to int16.
//
// 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 element values to int32.
//
// 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 element values to int64.
func (x Float64x2) ConvertToInt64() (z Int64x2) {
	return Int64x2{spec.ConvertToZ[float64, spec.Width128, int64, spec.Width128](x.v)}
}

// ConvertToUint8 converts element values to uint8.
//
// 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 element values to uint16.
//
// 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 element values to uint32.
//
// 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 element values to uint64.
func (x Float64x2) ConvertToUint64() (z Uint64x2) {
	return Uint64x2{spec.ConvertToZ[float64, spec.Width128, uint64, spec.Width128](x.v)}
}

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

// ConvertToInt8 converts element values to int8.
//
// 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 element values to int16.
//
// 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 element values to int32.
func (x Float64x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[float64, spec.Width256, int32, spec.Width128](x.v)}
}

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

// ConvertToUint8 converts element values to uint8.
//
// 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 element values to uint16.
//
// 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 element values to uint32.
func (x Float64x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[float64, spec.Width256, uint32, spec.Width128](x.v)}
}

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

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

// ConvertToInt8 converts element values to int8.
//
// 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 element values to int16.
func (x Float64x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[float64, spec.Width512, int16, spec.Width128](x.v)}
}

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

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

// ConvertToUint8 converts element values to uint8.
//
// 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 element values to uint16.
func (x Float64x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[float64, spec.Width512, uint16, spec.Width128](x.v)}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ConvertToInt8 converts element values 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 element values to int32.
func (x Int16x8) ConvertToInt32() (z Int32x8) {
	return Int32x8{spec.ConvertToZ[int16, spec.Width128, int32, spec.Width256](x.v)}
}

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

// ConvertToUint8 converts element values 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 element values to uint16.
func (x Int16x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int16, spec.Width128, uint16, spec.Width128](x.v)}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ConvertToInt8 converts element values 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 element values 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 element values to int64.
func (x Int32x4) ConvertToInt64() (z Int64x4) {
	return Int64x4{spec.ConvertToZ[int32, spec.Width128, int64, spec.Width256](x.v)}
}

// ConvertToUint8 converts element values 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 element values 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 element values to uint32.
func (x Int32x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[int32, spec.Width128, uint32, spec.Width128](x.v)}
}

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

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

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

// ConvertToInt8 converts element values 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 element values to int16.
func (x Int32x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int32, spec.Width256, int16, spec.Width128](x.v)}
}

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

// ConvertToUint8 converts element values 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 element values to uint16.
func (x Int32x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int32, spec.Width256, uint16, spec.Width128](x.v)}
}

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

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

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

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

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

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

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

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

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

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

// ConvertToFloat32 converts element values 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 element values to float64.
func (x Int64x2) ConvertToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertToZ[int64, spec.Width128, float64, spec.Width128](x.v)}
}

// ConvertToInt8 converts element values 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 element values 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 element values 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 element values 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 element values 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 element values 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 element values to uint64.
func (x Int64x2) ConvertToUint64() (z Uint64x2) {
	return Uint64x2{spec.ConvertToZ[int64, spec.Width128, uint64, spec.Width128](x.v)}
}

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

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

// ConvertToInt8 converts element values 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 element values 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 element values to int32.
func (x Int64x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[int64, spec.Width256, int32, spec.Width128](x.v)}
}

// ConvertToUint8 converts element values 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 element values 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 element values to uint32.
func (x Int64x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[int64, spec.Width256, uint32, spec.Width128](x.v)}
}

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

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

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

// ConvertToInt8 converts element values 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 element values to int16.
func (x Int64x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[int64, spec.Width512, int16, spec.Width128](x.v)}
}

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

// ConvertToUint8 converts element values 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 element values to uint16.
func (x Int64x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[int64, spec.Width512, uint16, spec.Width128](x.v)}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ConvertToInt8 converts element values 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 element values to int16.
func (x Uint16x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint16, spec.Width128, int16, spec.Width128](x.v)}
}

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

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

// ConvertToUint8 converts element values 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 element values to uint32.
func (x Uint16x8) ConvertToUint32() (z Uint32x8) {
	return Uint32x8{spec.ConvertToZ[uint16, spec.Width128, uint32, spec.Width256](x.v)}
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ConvertToInt8 converts element values 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 element values 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 element values to int32.
func (x Uint32x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[uint32, spec.Width128, int32, spec.Width128](x.v)}
}

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

// ConvertToUint8 converts element values 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 element values 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 element values to uint64.
func (x Uint32x4) ConvertToUint64() (z Uint64x4) {
	return Uint64x4{spec.ConvertToZ[uint32, spec.Width128, uint64, spec.Width256](x.v)}
}

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

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

// ConvertToInt8 converts element values 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 element values to int16.
func (x Uint32x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint32, spec.Width256, int16, spec.Width128](x.v)}
}

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

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

// ConvertToUint8 converts element values 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 element values to uint16.
func (x Uint32x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint32, spec.Width256, uint16, spec.Width128](x.v)}
}

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

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

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

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

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

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

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

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

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

// ConvertToFloat32 converts element values 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 element values to float64.
func (x Uint64x2) ConvertToFloat64() (z Float64x2) {
	return Float64x2{spec.ConvertToZ[uint64, spec.Width128, float64, spec.Width128](x.v)}
}

// ConvertToInt8 converts element values 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 element values 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 element values 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 element values to int64.
func (x Uint64x2) ConvertToInt64() (z Int64x2) {
	return Int64x2{spec.ConvertToZ[uint64, spec.Width128, int64, spec.Width128](x.v)}
}

// ConvertToUint8 converts element values 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 element values 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 element values 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 element values to float32.
func (x Uint64x4) ConvertToFloat32() (z Float32x4) {
	return Float32x4{spec.ConvertToZ[uint64, spec.Width256, float32, spec.Width128](x.v)}
}

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

// ConvertToInt8 converts element values 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 element values 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 element values to int32.
func (x Uint64x4) ConvertToInt32() (z Int32x4) {
	return Int32x4{spec.ConvertToZ[uint64, spec.Width256, int32, spec.Width128](x.v)}
}

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

// ConvertToUint8 converts element values 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 element values 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 element values to uint32.
func (x Uint64x4) ConvertToUint32() (z Uint32x4) {
	return Uint32x4{spec.ConvertToZ[uint64, spec.Width256, uint32, spec.Width128](x.v)}
}

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

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

// ConvertToInt8 converts element values 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 element values to int16.
func (x Uint64x8) ConvertToInt16() (z Int16x8) {
	return Int16x8{spec.ConvertToZ[uint64, spec.Width512, int16, spec.Width128](x.v)}
}

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

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

// ConvertToUint8 converts element values 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 element values to uint16.
func (x Uint64x8) ConvertToUint16() (z Uint16x8) {
	return Uint16x8{spec.ConvertToZ[uint64, spec.Width512, uint16, spec.Width128](x.v)}
}

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

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

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

// ExtendLo8ToInt16 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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) is less than the number of
// elements in the vector, 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 a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat32x4Part(s []float32) (z Float32x4, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.Width128](s)
	return Float32x4{r1}, r2
}

// LoadFloat32x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat32x8Part(s []float32) (z Float32x8, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.Width256](s)
	return Float32x8{r1}, r2
}

// LoadFloat32x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat32x16Part(s []float32) (z Float32x16, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.Width512](s)
	return Float32x16{r1}, r2
}

// LoadFloat32sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat32sPart(s []float32) (z Float32s, n int) {
	r1, r2 := spec.LoadZPart[float32, spec.WidthScalable](s)
	return Float32s{r1}, r2
}

// LoadFloat64x2Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat64x2Part(s []float64) (z Float64x2, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.Width128](s)
	return Float64x2{r1}, r2
}

// LoadFloat64x4Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat64x4Part(s []float64) (z Float64x4, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.Width256](s)
	return Float64x4{r1}, r2
}

// LoadFloat64x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat64x8Part(s []float64) (z Float64x8, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.Width512](s)
	return Float64x8{r1}, r2
}

// LoadFloat64sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadFloat64sPart(s []float64) (z Float64s, n int) {
	r1, r2 := spec.LoadZPart[float64, spec.WidthScalable](s)
	return Float64s{r1}, r2
}

// LoadInt8x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt8x16Part(s []int8) (z Int8x16, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.Width128](s)
	return Int8x16{r1}, r2
}

// LoadInt8x32Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt8x32Part(s []int8) (z Int8x32, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.Width256](s)
	return Int8x32{r1}, r2
}

// LoadInt8x64Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt8x64Part(s []int8) (z Int8x64, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.Width512](s)
	return Int8x64{r1}, r2
}

// LoadInt8sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt8sPart(s []int8) (z Int8s, n int) {
	r1, r2 := spec.LoadZPart[int8, spec.WidthScalable](s)
	return Int8s{r1}, r2
}

// LoadInt16x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt16x8Part(s []int16) (z Int16x8, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.Width128](s)
	return Int16x8{r1}, r2
}

// LoadInt16x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt16x16Part(s []int16) (z Int16x16, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.Width256](s)
	return Int16x16{r1}, r2
}

// LoadInt16x32Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt16x32Part(s []int16) (z Int16x32, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.Width512](s)
	return Int16x32{r1}, r2
}

// LoadInt16sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt16sPart(s []int16) (z Int16s, n int) {
	r1, r2 := spec.LoadZPart[int16, spec.WidthScalable](s)
	return Int16s{r1}, r2
}

// LoadInt32x4Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt32x4Part(s []int32) (z Int32x4, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.Width128](s)
	return Int32x4{r1}, r2
}

// LoadInt32x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt32x8Part(s []int32) (z Int32x8, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.Width256](s)
	return Int32x8{r1}, r2
}

// LoadInt32x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt32x16Part(s []int32) (z Int32x16, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.Width512](s)
	return Int32x16{r1}, r2
}

// LoadInt32sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt32sPart(s []int32) (z Int32s, n int) {
	r1, r2 := spec.LoadZPart[int32, spec.WidthScalable](s)
	return Int32s{r1}, r2
}

// LoadInt64x2Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt64x2Part(s []int64) (z Int64x2, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.Width128](s)
	return Int64x2{r1}, r2
}

// LoadInt64x4Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt64x4Part(s []int64) (z Int64x4, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.Width256](s)
	return Int64x4{r1}, r2
}

// LoadInt64x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt64x8Part(s []int64) (z Int64x8, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.Width512](s)
	return Int64x8{r1}, r2
}

// LoadInt64sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadInt64sPart(s []int64) (z Int64s, n int) {
	r1, r2 := spec.LoadZPart[int64, spec.WidthScalable](s)
	return Int64s{r1}, r2
}

// LoadUint8x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint8x16Part(s []uint8) (z Uint8x16, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.Width128](s)
	return Uint8x16{r1}, r2
}

// LoadUint8x32Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint8x32Part(s []uint8) (z Uint8x32, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.Width256](s)
	return Uint8x32{r1}, r2
}

// LoadUint8x64Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint8x64Part(s []uint8) (z Uint8x64, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.Width512](s)
	return Uint8x64{r1}, r2
}

// LoadUint8sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint8sPart(s []uint8) (z Uint8s, n int) {
	r1, r2 := spec.LoadZPart[uint8, spec.WidthScalable](s)
	return Uint8s{r1}, r2
}

// LoadUint16x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint16x8Part(s []uint16) (z Uint16x8, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.Width128](s)
	return Uint16x8{r1}, r2
}

// LoadUint16x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint16x16Part(s []uint16) (z Uint16x16, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.Width256](s)
	return Uint16x16{r1}, r2
}

// LoadUint16x32Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint16x32Part(s []uint16) (z Uint16x32, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.Width512](s)
	return Uint16x32{r1}, r2
}

// LoadUint16sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint16sPart(s []uint16) (z Uint16s, n int) {
	r1, r2 := spec.LoadZPart[uint16, spec.WidthScalable](s)
	return Uint16s{r1}, r2
}

// LoadUint32x4Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint32x4Part(s []uint32) (z Uint32x4, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.Width128](s)
	return Uint32x4{r1}, r2
}

// LoadUint32x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint32x8Part(s []uint32) (z Uint32x8, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.Width256](s)
	return Uint32x8{r1}, r2
}

// LoadUint32x16Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint32x16Part(s []uint32) (z Uint32x16, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.Width512](s)
	return Uint32x16{r1}, r2
}

// LoadUint32sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint32sPart(s []uint32) (z Uint32s, n int) {
	r1, r2 := spec.LoadZPart[uint32, spec.WidthScalable](s)
	return Uint32s{r1}, r2
}

// LoadUint64x2Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint64x2Part(s []uint64) (z Uint64x2, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.Width128](s)
	return Uint64x2{r1}, r2
}

// LoadUint64x4Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint64x4Part(s []uint64) (z Uint64x4, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.Width256](s)
	return Uint64x4{r1}, r2
}

// LoadUint64x8Part loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
func LoadUint64x8Part(s []uint64) (z Uint64x8, n int) {
	r1, r2 := spec.LoadZPart[uint64, spec.Width512](s)
	return Uint64x8{r1}, r2
}

// LoadUint64sPart loads a slice into a vector and returns the vector and the number
// of elements loaded from s. If len(s) is less than the number of elements in
// the vector, the remaining vector elements will be zero-filled.
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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than x.Len(),
// 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) is less than 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 at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float32x4) StorePart(s []float32) int {
	return spec.StorePart[float32, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float32x8) StorePart(s []float32) int {
	return spec.StorePart[float32, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float32x16) StorePart(s []float32) int {
	return spec.StorePart[float32, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float32s) StorePart(s []float32) int {
	return spec.StorePart[float32, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float64x2) StorePart(s []float64) int {
	return spec.StorePart[float64, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float64x4) StorePart(s []float64) int {
	return spec.StorePart[float64, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float64x8) StorePart(s []float64) int {
	return spec.StorePart[float64, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Float64s) StorePart(s []float64) int {
	return spec.StorePart[float64, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int8x16) StorePart(s []int8) int {
	return spec.StorePart[int8, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int8x32) StorePart(s []int8) int {
	return spec.StorePart[int8, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int8x64) StorePart(s []int8) int {
	return spec.StorePart[int8, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int8s) StorePart(s []int8) int {
	return spec.StorePart[int8, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int16x8) StorePart(s []int16) int {
	return spec.StorePart[int16, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int16x16) StorePart(s []int16) int {
	return spec.StorePart[int16, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int16x32) StorePart(s []int16) int {
	return spec.StorePart[int16, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int16s) StorePart(s []int16) int {
	return spec.StorePart[int16, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int32x4) StorePart(s []int32) int {
	return spec.StorePart[int32, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int32x8) StorePart(s []int32) int {
	return spec.StorePart[int32, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int32x16) StorePart(s []int32) int {
	return spec.StorePart[int32, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int32s) StorePart(s []int32) int {
	return spec.StorePart[int32, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int64x2) StorePart(s []int64) int {
	return spec.StorePart[int64, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int64x4) StorePart(s []int64) int {
	return spec.StorePart[int64, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int64x8) StorePart(s []int64) int {
	return spec.StorePart[int64, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Int64s) StorePart(s []int64) int {
	return spec.StorePart[int64, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint8x16) StorePart(s []uint8) int {
	return spec.StorePart[uint8, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint8x32) StorePart(s []uint8) int {
	return spec.StorePart[uint8, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint8x64) StorePart(s []uint8) int {
	return spec.StorePart[uint8, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint8s) StorePart(s []uint8) int {
	return spec.StorePart[uint8, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint16x8) StorePart(s []uint16) int {
	return spec.StorePart[uint16, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint16x16) StorePart(s []uint16) int {
	return spec.StorePart[uint16, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint16x32) StorePart(s []uint16) int {
	return spec.StorePart[uint16, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint16s) StorePart(s []uint16) int {
	return spec.StorePart[uint16, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint32x4) StorePart(s []uint32) int {
	return spec.StorePart[uint32, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint32x8) StorePart(s []uint32) int {
	return spec.StorePart[uint32, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint32x16) StorePart(s []uint32) int {
	return spec.StorePart[uint32, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint32s) StorePart(s []uint32) int {
	return spec.StorePart[uint32, spec.WidthScalable](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint64x2) StorePart(s []uint64) int {
	return spec.StorePart[uint64, spec.Width128](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint64x4) StorePart(s []uint64) int {
	return spec.StorePart[uint64, spec.Width256](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint64x8) StorePart(s []uint64) int {
	return spec.StorePart[uint64, spec.Width512](x.v, s)
}

// StorePart stores at most len(s) elements of x into s and returns the number
// of elements stored.
func (x Uint64s) StorePart(s []uint64) int {
	return spec.StorePart[uint64, spec.WidthScalable](x.v, s)
}

// Mask8x16FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask8x16FromBits(x uint16) (z Mask8x16) {
	return Mask8x16{spec.MaskFromBits[spec.Mask8, spec.Width128](spec.UintN(x))}
}

// Mask8x32FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask8x32FromBits(x uint32) (z Mask8x32) {
	return Mask8x32{spec.MaskFromBits[spec.Mask8, spec.Width256](spec.UintN(x))}
}

// Mask8x64FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask8x64FromBits(x uint64) (z Mask8x64) {
	return Mask8x64{spec.MaskFromBits[spec.Mask8, spec.Width512](spec.UintN(x))}
}

// Mask16x8FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask16x8FromBits(x uint8) (z Mask16x8) {
	return Mask16x8{spec.MaskFromBits[spec.Mask16, spec.Width128](spec.UintN(x))}
}

// Mask16x16FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask16x16FromBits(x uint16) (z Mask16x16) {
	return Mask16x16{spec.MaskFromBits[spec.Mask16, spec.Width256](spec.UintN(x))}
}

// Mask16x32FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask16x32FromBits(x uint32) (z Mask16x32) {
	return Mask16x32{spec.MaskFromBits[spec.Mask16, spec.Width512](spec.UintN(x))}
}

// Mask32x4FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask32x4FromBits(x uint8) (z Mask32x4) {
	return Mask32x4{spec.MaskFromBits[spec.Mask32, spec.Width128](spec.UintN(x))}
}

// Mask32x8FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask32x8FromBits(x uint8) (z Mask32x8) {
	return Mask32x8{spec.MaskFromBits[spec.Mask32, spec.Width256](spec.UintN(x))}
}

// Mask32x16FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask32x16FromBits(x uint16) (z Mask32x16) {
	return Mask32x16{spec.MaskFromBits[spec.Mask32, spec.Width512](spec.UintN(x))}
}

// Mask64x2FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask64x2FromBits(x uint8) (z Mask64x2) {
	return Mask64x2{spec.MaskFromBits[spec.Mask64, spec.Width128](spec.UintN(x))}
}

// Mask64x4FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask64x4FromBits(x uint8) (z Mask64x4) {
	return Mask64x4{spec.MaskFromBits[spec.Mask64, spec.Width256](spec.UintN(x))}
}

// Mask64x8FromBits constructs a mask from a bitmap value. If bit i of y is set,
// then mask element i of the result is set.
func Mask64x8FromBits(x uint8) (z Mask64x8) {
	return Mask64x8{spec.MaskFromBits[spec.Mask64, spec.Width512](spec.UintN(x))}
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask8x16) ToBits() (z uint16) {
	return uint16(spec.MaskToBits[spec.Mask8, spec.Width128](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask8x32) ToBits() (z uint32) {
	return uint32(spec.MaskToBits[spec.Mask8, spec.Width256](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask8x64) ToBits() (z uint64) {
	return uint64(spec.MaskToBits[spec.Mask8, spec.Width512](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask16x8) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask16, spec.Width128](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask16x16) ToBits() (z uint16) {
	return uint16(spec.MaskToBits[spec.Mask16, spec.Width256](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask16x32) ToBits() (z uint32) {
	return uint32(spec.MaskToBits[spec.Mask16, spec.Width512](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask32x4) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask32, spec.Width128](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask32x8) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask32, spec.Width256](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask32x16) ToBits() (z uint16) {
	return uint16(spec.MaskToBits[spec.Mask32, spec.Width512](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask64x2) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask64, spec.Width128](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
func (x Mask64x4) ToBits() (z uint8) {
	return uint8(spec.MaskToBits[spec.Mask64, spec.Width256](x.v))
}

// ToBits constructs a bitmap from mask x, where bit i is set if mask
// element i is set.
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
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".
func (x Mask64s) ToInt64s() (z Int64s) {
	return Int64s{spec.MaskToZ[spec.Mask64, spec.WidthScalable, int64](x.v)}
}

// Add adds corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors.
//
//	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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 corresponding elements of two vectors with saturation.
//
//	z[i] = saturated(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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], 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 = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], 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 = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], 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 = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], 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 = {x[0]-x[1], x[2]-x[3], ..., y[0]-y[1], 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)}
}

// DotProductPairs multiplies corresponding elements of x and y, and sums
// adjacent pairs, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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, yielding a vector of half as many elements with twice the
// input element size.
//
//	w[i] = x[i] * y[i]        // Double width
//	z[i] = w[2*i] + w[2*i+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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
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 yields a vector of half as many
// elements with twice the input element size.
//
//	w[i] = x[i] * y[i]        // Double width, saturated
//	z[i] = w[2*i] + w[2*i+1]  // Saturated
func (x Uint32s) DotProductPairsSaturated(y Int32s) (z Int64s) {
	return Int64s{spec.DotProductPairsSaturated[uint32, spec.WidthScalable, int32, int64](x.v, y.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)}
}

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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. The least
// significant bit of element 0 is bit 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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 (shift right; arithmetic for signed types, logical for unsigned types).
//
//	z[i] = saturated(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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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 y 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)}
}

// 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)}
}