// Code generated by 'simdgen -o godefs -goroot $GOROOT -arch arm64 -arm64Path $ARM64_ISA_PATH go_arm64.yaml types.yaml categories.yaml'; DO NOT EDIT.

//go:build goexperiment.simd

package archsimd

/* Abs */

// Abs computes the absolute value of each element.
//
// Asm: VFABS, CPU Feature: NEON
func (x Float32x4) Abs() Float32x4

// Abs computes the absolute value of each element.
//
// Asm: VFABS, CPU Feature: NEON
func (x Float64x2) Abs() Float64x2

// Abs computes the absolute value of each element.
//
// Asm: VABS, CPU Feature: NEON
func (x Int8x16) Abs() Int8x16

// Abs computes the absolute value of each element.
//
// Asm: VABS, CPU Feature: NEON
func (x Int16x8) Abs() Int16x8

// Abs computes the absolute value of each element.
//
// Asm: VABS, CPU Feature: NEON
func (x Int32x4) Abs() Int32x4

// Abs computes the absolute value of each element.
//
// Asm: VABS, CPU Feature: NEON
func (x Int64x2) Abs() Int64x2

/* Add */

// Add adds corresponding elements of two vectors.
//
// Asm: VFADD, CPU Feature: NEON
func (x Float32x4) Add(y Float32x4) Float32x4

// Add adds corresponding elements of two vectors.
//
// Asm: VFADD, CPU Feature: NEON
func (x Float64x2) Add(y Float64x2) Float64x2

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Int8x16) Add(y Int8x16) Int8x16

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Int16x8) Add(y Int16x8) Int16x8

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Int32x4) Add(y Int32x4) Int32x4

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Int64x2) Add(y Int64x2) Int64x2

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Uint8x16) Add(y Uint8x16) Uint8x16

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Uint16x8) Add(y Uint16x8) Uint16x8

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Uint32x4) Add(y Uint32x4) Uint32x4

// Add adds corresponding elements of two vectors.
//
// Asm: VADD, CPU Feature: NEON
func (x Uint64x2) Add(y Uint64x2) Uint64x2

/* AddSaturated */

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VSQADD, CPU Feature: NEON
func (x Int8x16) AddSaturated(y Int8x16) Int8x16

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VSQADD, CPU Feature: NEON
func (x Int16x8) AddSaturated(y Int16x8) Int16x8

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VSQADD, CPU Feature: NEON
func (x Int32x4) AddSaturated(y Int32x4) Int32x4

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VSQADD, CPU Feature: NEON
func (x Int64x2) AddSaturated(y Int64x2) Int64x2

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VUQADD, CPU Feature: NEON
func (x Uint8x16) AddSaturated(y Uint8x16) Uint8x16

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VUQADD, CPU Feature: NEON
func (x Uint16x8) AddSaturated(y Uint16x8) Uint16x8

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VUQADD, CPU Feature: NEON
func (x Uint32x4) AddSaturated(y Uint32x4) Uint32x4

// AddSaturated adds corresponding elements of two vectors with saturation.
//
// Asm: VUQADD, CPU Feature: NEON
func (x Uint64x2) AddSaturated(y Uint64x2) Uint64x2

/* And */

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Int8x16) And(y Int8x16) Int8x16

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Int16x8) And(y Int16x8) Int16x8

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Int32x4) And(y Int32x4) Int32x4

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Int64x2) And(y Int64x2) Int64x2

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Uint8x16) And(y Uint8x16) Uint8x16

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Uint16x8) And(y Uint16x8) Uint16x8

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Uint32x4) And(y Uint32x4) Uint32x4

// And performs a bitwise x & y.
//
// Asm: VAND, CPU Feature: NEON
func (x Uint64x2) And(y Uint64x2) Uint64x2

/* AndNot */

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Int8x16) AndNot(y Int8x16) Int8x16

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Int16x8) AndNot(y Int16x8) Int16x8

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Int32x4) AndNot(y Int32x4) Int32x4

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Int64x2) AndNot(y Int64x2) Int64x2

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Uint8x16) AndNot(y Uint8x16) Uint8x16

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Uint16x8) AndNot(y Uint16x8) Uint16x8

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Uint32x4) AndNot(y Uint32x4) Uint32x4

// AndNot performs a bitwise x &^ y.
//
// Asm: VBIC, CPU Feature: NEON
func (x Uint64x2) AndNot(y Uint64x2) Uint64x2

/* Average */

// Average computes the rounded average of corresponding elements.
//
// Asm: VSRHADD, CPU Feature: NEON
func (x Int8x16) Average(y Int8x16) Int8x16

// Average computes the rounded average of corresponding elements.
//
// Asm: VSRHADD, CPU Feature: NEON
func (x Int16x8) Average(y Int16x8) Int16x8

// Average computes the rounded average of corresponding elements.
//
// Asm: VSRHADD, CPU Feature: NEON
func (x Int32x4) Average(y Int32x4) Int32x4

// Average computes the rounded average of corresponding elements.
//
// Asm: VURHADD, CPU Feature: NEON
func (x Uint8x16) Average(y Uint8x16) Uint8x16

// Average computes the rounded average of corresponding elements.
//
// Asm: VURHADD, CPU Feature: NEON
func (x Uint16x8) Average(y Uint16x8) Uint16x8

// Average computes the rounded average of corresponding elements.
//
// Asm: VURHADD, CPU Feature: NEON
func (x Uint32x4) Average(y Uint32x4) Uint32x4

/* Ceil */

// Ceil rounds elements up to the nearest integer.
//
// Asm: VFRINTP, CPU Feature: NEON
func (x Float32x4) Ceil() Float32x4

// Ceil rounds elements up to the nearest integer.
//
// Asm: VFRINTP, CPU Feature: NEON
func (x Float64x2) Ceil() Float64x2

/* ConcatAddPairs */

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].
//
// Asm: VFADDP, CPU Feature: NEON
func (x Float32x4) ConcatAddPairs(y Float32x4) Float32x4

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1].
//
// Asm: VFADDP, CPU Feature: NEON
func (x Float64x2) ConcatAddPairs(y Float64x2) Float64x2

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].
//
// Asm: VADDP, CPU Feature: NEON
func (x Int16x8) ConcatAddPairs(y Int16x8) Int16x8

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].
//
// Asm: VADDP, CPU Feature: NEON
func (x Int32x4) ConcatAddPairs(y Int32x4) Int32x4

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1].
//
// Asm: VADDP, CPU Feature: NEON
func (x Int64x2) ConcatAddPairs(y Int64x2) Int64x2

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].
//
// Asm: VADDP, CPU Feature: NEON
func (x Uint16x8) ConcatAddPairs(y Uint16x8) Uint16x8

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [x0+x1, x2+x3, ..., y0+y1, y2+y3, ...].
//
// Asm: VADDP, CPU Feature: NEON
func (x Uint32x4) ConcatAddPairs(y Uint32x4) Uint32x4

// ConcatAddPairs horizontally adds adjacent pairs of elements.
// For x = [x0, x1] and y = [y0, y1], the result is [x0+x1, y0+y1].
//
// Asm: VADDP, CPU Feature: NEON
func (x Uint64x2) ConcatAddPairs(y Uint64x2) Uint64x2

/* ConcatEven */

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Int8x16) ConcatEven(y Int8x16) Int8x16

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Int16x8) ConcatEven(y Int16x8) Int16x8

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Int32x4) ConcatEven(y Int32x4) Int32x4

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Int64x2) ConcatEven(y Int64x2) Int64x2

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Uint8x16) ConcatEven(y Uint8x16) Uint8x16

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Uint16x8) ConcatEven(y Uint16x8) Uint16x8

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Uint32x4) ConcatEven(y Uint32x4) Uint32x4

// ConcatEven concatenates even-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x0,x2,y0,y2].
//
// Asm: VUZP1, CPU Feature: NEON
func (x Uint64x2) ConcatEven(y Uint64x2) Uint64x2

/* ConcatOdd */

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Int8x16) ConcatOdd(y Int8x16) Int8x16

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Int16x8) ConcatOdd(y Int16x8) Int16x8

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Int32x4) ConcatOdd(y Int32x4) Int32x4

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Int64x2) ConcatOdd(y Int64x2) Int64x2

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Uint8x16) ConcatOdd(y Uint8x16) Uint8x16

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Uint16x8) ConcatOdd(y Uint16x8) Uint16x8

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Uint32x4) ConcatOdd(y Uint32x4) Uint32x4

// ConcatOdd concatenates odd-indexed elements from the concatenation of x and y.
// For x = [x0,x1,x2,x3] and y = [y0,y1,y2,y3], result = [x1,x3,y1,y3].
//
// Asm: VUZP2, CPU Feature: NEON
func (x Uint64x2) ConcatOdd(y Uint64x2) Uint64x2

/* ConcatShiftBytesRight */

// ConcatShiftBytesRight concatenates x and y and shifts it right by shift bytes.
// The result vector will be the lower half of the concatenated vector.
//
// A non-constant value of shift may result in significantly worse performance for this operation.
//
// Asm: VEXT, CPU Feature: NEON
func (x Uint8x16) ConcatShiftBytesRight(y Uint8x16, shift uint64) Uint8x16

/* ConvertLo2ToFloat64 */

// ConvertLo2ToFloat64 converts low-indexed float32 element values to float64.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ConvertLo2ToFloat64(...)
//
// Asm: VFCVTL, CPU Feature: NEON
func (x Float32x4) ConvertLo2ToFloat64() Float64x2

/* ConvertToFloat32 */

// ConvertToFloat32 converts element values to float32.
//
// Asm: VFCVTN, CPU Feature: NEON
func (x Float64x2) ConvertToFloat32() Float32x4

// ConvertToFloat32 converts element values to float32.
//
// Asm: VSCVTF, CPU Feature: NEON
func (x Int32x4) ConvertToFloat32() Float32x4

// ConvertToFloat32 converts element values to float32.
//
// Asm: VUCVTF, CPU Feature: NEON
func (x Uint32x4) ConvertToFloat32() Float32x4

/* ConvertToFloat64 */

// ConvertToFloat64 converts element values to float64.
//
// Asm: VSCVTF, CPU Feature: NEON
func (x Int64x2) ConvertToFloat64() Float64x2

// ConvertToFloat64 converts element values to float64.
//
// Asm: VUCVTF, CPU Feature: NEON
func (x Uint64x2) ConvertToFloat64() Float64x2

/* ConvertToInt32 */

// ConvertToInt32 converts element values to int32.
// When a conversion is inexact, a truncated (round toward zero) value is returned.
// If a converted result cannot be represented in int32, an implementation-defined
// architecture-specific value is returned.
//
// Asm: VFCVTZS, CPU Feature: NEON
func (x Float32x4) ConvertToInt32() Int32x4

/* ConvertToInt64 */

// ConvertToInt64 converts element values to int64.
// When a conversion is inexact, a truncated (round toward zero) value is returned.
// If a converted result cannot be represented in int64, an implementation-defined
// architecture-specific value is returned.
//
// Asm: VFCVTZS, CPU Feature: NEON
func (x Float64x2) ConvertToInt64() Int64x2

/* ConvertToUint32 */

// ConvertToUint32 converts element values to uint32.
// When a conversion is inexact, a truncated (round toward zero) value is returned.
// If a converted result cannot be represented in uint32, an implementation-defined
// architecture-specific value is returned.
//
// Asm: VFCVTZU, CPU Feature: NEON
func (x Float32x4) ConvertToUint32() Uint32x4

/* ConvertToUint64 */

// ConvertToUint64 converts element values to uint64.
// When a conversion is inexact, a truncated (round toward zero) value is returned.
// If a converted result cannot be represented in uint64, an implementation-defined
// architecture-specific value is returned.
//
// Asm: VFCVTZU, CPU Feature: NEON
func (x Float64x2) ConvertToUint64() Uint64x2

/* Div */

// Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.
//
// Asm: VFDIV, CPU Feature: NEON
func (x Float32x4) Div(y Float32x4) Float32x4

// Div divides elements of two vectors. Division by zero follows IEEE 754 and does not panic.
//
// Asm: VFDIV, CPU Feature: NEON
func (x Float64x2) Div(y Float64x2) Float64x2

/* Equal */

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VFCMEQ, CPU Feature: NEON
func (x Float32x4) Equal(y Float32x4) Mask32x4

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VFCMEQ, CPU Feature: NEON
func (x Float64x2) Equal(y Float64x2) Mask64x2

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Int8x16) Equal(y Int8x16) Mask8x16

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Int16x8) Equal(y Int16x8) Mask16x8

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Int32x4) Equal(y Int32x4) Mask32x4

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Int64x2) Equal(y Int64x2) Mask64x2

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Uint8x16) Equal(y Uint8x16) Mask8x16

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Uint16x8) Equal(y Uint16x8) Mask16x8

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Uint32x4) Equal(y Uint32x4) Mask32x4

// Equal returns a mask whose elements indicate whether x == y.
//
// Asm: VCMEQ, CPU Feature: NEON
func (x Uint64x2) Equal(y Uint64x2) Mask64x2

/* ExtendLo2ToInt64 */

// ExtendLo2ToInt64 sign-extends 2 lowest vector element values to int64.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ExtendLo2ToInt64(...)
//
// Asm: VSXTL, CPU Feature: NEON
func (x Int32x4) ExtendLo2ToInt64() Int64x2

/* ExtendLo2ToUint64 */

// ExtendLo2ToUint64 zero-extends 2 lowest vector element values to uint64.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ExtendLo2ToUint64(...)
//
// Asm: VUXTL, CPU Feature: NEON
func (x Uint32x4) ExtendLo2ToUint64() Uint64x2

/* ExtendLo4ToInt32 */

// ExtendLo4ToInt32 sign-extends 4 lowest vector element values to int32.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ExtendLo4ToInt32(...)
//
// Asm: VSXTL, CPU Feature: NEON
func (x Int16x8) ExtendLo4ToInt32() Int32x4

/* ExtendLo4ToUint32 */

// ExtendLo4ToUint32 zero-extends 4 lowest vector element values to uint32.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ExtendLo4ToUint32(...)
//
// Asm: VUXTL, CPU Feature: NEON
func (x Uint16x8) ExtendLo4ToUint32() Uint32x4

/* ExtendLo8ToInt16 */

// ExtendLo8ToInt16 sign-extends 8 lowest vector element values to int16.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ExtendLo8ToInt16(...)
//
// Asm: VSXTL, CPU Feature: NEON
func (x Int8x16) ExtendLo8ToInt16() Int16x8

/* ExtendLo8ToUint16 */

// ExtendLo8ToUint16 zero-extends 8 lowest vector element values to uint16.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().ExtendLo8ToUint16(...)
//
// Asm: VUXTL, CPU Feature: NEON
func (x Uint8x16) ExtendLo8ToUint16() Uint16x8

/* Floor */

// Floor rounds elements down to the nearest integer.
//
// Asm: VFRINTM, CPU Feature: NEON
func (x Float32x4) Floor() Float32x4

// Floor rounds elements down to the nearest integer.
//
// Asm: VFRINTM, CPU Feature: NEON
func (x Float64x2) Floor() Float64x2

/* GetElem */

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VDUP, CPU Feature: NEON
func (x Float32x4) GetElem(index uint8) float32

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VDUP, CPU Feature: NEON
func (x Float64x2) GetElem(index uint8) float64

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int8x16) GetElem(index uint8) int8

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int16x8) GetElem(index uint8) int16

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int32x4) GetElem(index uint8) int32

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int64x2) GetElem(index uint8) int64

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint8x16) GetElem(index uint8) uint8

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint16x8) GetElem(index uint8) uint16

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint32x4) GetElem(index uint8) uint32

// GetElem returns the index'th element of x.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint64x2) GetElem(index uint8) uint64

/* Greater */

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VFCMGT, CPU Feature: NEON
func (x Float32x4) Greater(y Float32x4) Mask32x4

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VFCMGT, CPU Feature: NEON
func (x Float64x2) Greater(y Float64x2) Mask64x2

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMGT, CPU Feature: NEON
func (x Int8x16) Greater(y Int8x16) Mask8x16

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMGT, CPU Feature: NEON
func (x Int16x8) Greater(y Int16x8) Mask16x8

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMGT, CPU Feature: NEON
func (x Int32x4) Greater(y Int32x4) Mask32x4

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMGT, CPU Feature: NEON
func (x Int64x2) Greater(y Int64x2) Mask64x2

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMHI, CPU Feature: NEON
func (x Uint8x16) Greater(y Uint8x16) Mask8x16

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMHI, CPU Feature: NEON
func (x Uint16x8) Greater(y Uint16x8) Mask16x8

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMHI, CPU Feature: NEON
func (x Uint32x4) Greater(y Uint32x4) Mask32x4

// Greater returns a mask whose elements indicate whether x > y.
//
// Asm: VCMHI, CPU Feature: NEON
func (x Uint64x2) Greater(y Uint64x2) Mask64x2

/* GreaterEqual */

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VFCMGE, CPU Feature: NEON
func (x Float32x4) GreaterEqual(y Float32x4) Mask32x4

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VFCMGE, CPU Feature: NEON
func (x Float64x2) GreaterEqual(y Float64x2) Mask64x2

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMGE, CPU Feature: NEON
func (x Int8x16) GreaterEqual(y Int8x16) Mask8x16

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMGE, CPU Feature: NEON
func (x Int16x8) GreaterEqual(y Int16x8) Mask16x8

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMGE, CPU Feature: NEON
func (x Int32x4) GreaterEqual(y Int32x4) Mask32x4

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMGE, CPU Feature: NEON
func (x Int64x2) GreaterEqual(y Int64x2) Mask64x2

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMHS, CPU Feature: NEON
func (x Uint8x16) GreaterEqual(y Uint8x16) Mask8x16

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMHS, CPU Feature: NEON
func (x Uint16x8) GreaterEqual(y Uint16x8) Mask16x8

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMHS, CPU Feature: NEON
func (x Uint32x4) GreaterEqual(y Uint32x4) Mask32x4

// GreaterEqual returns a mask whose elements indicate whether x >= y.
//
// Asm: VCMHS, CPU Feature: NEON
func (x Uint64x2) GreaterEqual(y Uint64x2) Mask64x2

/* InterleaveEven */

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Int8x16) InterleaveEven(y Int8x16) Int8x16

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Int16x8) InterleaveEven(y Int16x8) Int16x8

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Int32x4) InterleaveEven(y Int32x4) Int32x4

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Int64x2) InterleaveEven(y Int64x2) Int64x2

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Uint8x16) InterleaveEven(y Uint8x16) Uint8x16

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Uint16x8) InterleaveEven(y Uint16x8) Uint16x8

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Uint32x4) InterleaveEven(y Uint32x4) Uint32x4

// InterleaveEven interleaves even elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a0,b0,a2,b2].
//
// Asm: VTRN1, CPU Feature: NEON
func (x Uint64x2) InterleaveEven(y Uint64x2) Uint64x2

/* InterleaveHi */

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Int8x16) InterleaveHi(y Int8x16) Int8x16

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Int16x8) InterleaveHi(y Int16x8) Int16x8

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Int32x4) InterleaveHi(y Int32x4) Int32x4

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Int64x2) InterleaveHi(y Int64x2) Int64x2

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Uint8x16) InterleaveHi(y Uint8x16) Uint8x16

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Uint16x8) InterleaveHi(y Uint16x8) Uint16x8

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Uint32x4) InterleaveHi(y Uint32x4) Uint32x4

// InterleaveHi interleaves the elements of the high halves of x and y.
//
// Asm: VZIP2, CPU Feature: NEON
func (x Uint64x2) InterleaveHi(y Uint64x2) Uint64x2

/* InterleaveLo */

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Int8x16) InterleaveLo(y Int8x16) Int8x16

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Int16x8) InterleaveLo(y Int16x8) Int16x8

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Int32x4) InterleaveLo(y Int32x4) Int32x4

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Int64x2) InterleaveLo(y Int64x2) Int64x2

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Uint8x16) InterleaveLo(y Uint8x16) Uint8x16

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Uint16x8) InterleaveLo(y Uint16x8) Uint16x8

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Uint32x4) InterleaveLo(y Uint32x4) Uint32x4

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1, CPU Feature: NEON
func (x Uint64x2) InterleaveLo(y Uint64x2) Uint64x2

/* InterleaveOdd */

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Int8x16) InterleaveOdd(y Int8x16) Int8x16

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Int16x8) InterleaveOdd(y Int16x8) Int16x8

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Int32x4) InterleaveOdd(y Int32x4) Int32x4

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Int64x2) InterleaveOdd(y Int64x2) Int64x2

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Uint8x16) InterleaveOdd(y Uint8x16) Uint8x16

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Uint16x8) InterleaveOdd(y Uint16x8) Uint16x8

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Uint32x4) InterleaveOdd(y Uint32x4) Uint32x4

// InterleaveOdd interleaves odd elements from x and y.
// For x = [a0,a1,a2,a3] and y = [b0,b1,b2,b3], result = [a1,b1,a3,b3].
//
// Asm: VTRN2, CPU Feature: NEON
func (x Uint64x2) InterleaveOdd(y Uint64x2) Uint64x2

/* LeadingSignBits */

// LeadingSignBits counts the leading sign bits of each element in x.
//
// Asm: VCLS, CPU Feature: NEON
func (x Int8x16) LeadingSignBits() Int8x16

// LeadingSignBits counts the leading sign bits of each element in x.
//
// Asm: VCLS, CPU Feature: NEON
func (x Int16x8) LeadingSignBits() Int16x8

// LeadingSignBits counts the leading sign bits of each element in x.
//
// Asm: VCLS, CPU Feature: NEON
func (x Int32x4) LeadingSignBits() Int32x4

// LeadingSignBits counts the leading sign bits of each element in x.
//
// Asm: VCLS, CPU Feature: NEON
func (x Uint8x16) LeadingSignBits() Uint8x16

// LeadingSignBits counts the leading sign bits of each element in x.
//
// Asm: VCLS, CPU Feature: NEON
func (x Uint16x8) LeadingSignBits() Uint16x8

// LeadingSignBits counts the leading sign bits of each element in x.
//
// Asm: VCLS, CPU Feature: NEON
func (x Uint32x4) LeadingSignBits() Uint32x4

/* LeadingZeros */

// LeadingZeros counts the leading zeros of each element in x.
//
// Asm: VCLZ, CPU Feature: NEON
func (x Int8x16) LeadingZeros() Int8x16

// LeadingZeros counts the leading zeros of each element in x.
//
// Asm: VCLZ, CPU Feature: NEON
func (x Int16x8) LeadingZeros() Int16x8

// LeadingZeros counts the leading zeros of each element in x.
//
// Asm: VCLZ, CPU Feature: NEON
func (x Int32x4) LeadingZeros() Int32x4

// LeadingZeros counts the leading zeros of each element in x.
//
// Asm: VCLZ, CPU Feature: NEON
func (x Uint8x16) LeadingZeros() Uint8x16

// LeadingZeros counts the leading zeros of each element in x.
//
// Asm: VCLZ, CPU Feature: NEON
func (x Uint16x8) LeadingZeros() Uint16x8

// LeadingZeros counts the leading zeros of each element in x.
//
// Asm: VCLZ, CPU Feature: NEON
func (x Uint32x4) LeadingZeros() Uint32x4

/* LookupOrZero */

// LookupOrZero looks up table. If an index is out of range, the result is 0.
//
//	if 0 <= indices[i] && indices[i] < len(table) {
//	    result[i] = table[indices[i]]
//	} else {
//	    result[i] = 0
//	}
//
// Asm: VTBL, CPU Feature: NEON
func (table Int8x16) LookupOrZero(indices Int8x16) Int8x16

// LookupOrZero looks up table. If an index is out of range, the result is 0.
//
//	if 0 <= indices[i] && indices[i] < len(table) {
//	    result[i] = table[indices[i]]
//	} else {
//	    result[i] = 0
//	}
//
// Asm: VTBL, CPU Feature: NEON
func (table Uint8x16) LookupOrZero(indices Uint8x16) Uint8x16

/* Max */

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VFMAX, CPU Feature: NEON
func (x Float32x4) Max(y Float32x4) Float32x4

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VFMAX, CPU Feature: NEON
func (x Float64x2) Max(y Float64x2) Float64x2

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VSMAX, CPU Feature: NEON
func (x Int8x16) Max(y Int8x16) Int8x16

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VSMAX, CPU Feature: NEON
func (x Int16x8) Max(y Int16x8) Int16x8

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VSMAX, CPU Feature: NEON
func (x Int32x4) Max(y Int32x4) Int32x4

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VUMAX, CPU Feature: NEON
func (x Uint8x16) Max(y Uint8x16) Uint8x16

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VUMAX, CPU Feature: NEON
func (x Uint16x8) Max(y Uint16x8) Uint16x8

// Max computes the maximum of each pair of corresponding elements in x and y.
//
// Asm: VUMAX, CPU Feature: NEON
func (x Uint32x4) Max(y Uint32x4) Uint32x4

/* Min */

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VFMIN, CPU Feature: NEON
func (x Float32x4) Min(y Float32x4) Float32x4

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VFMIN, CPU Feature: NEON
func (x Float64x2) Min(y Float64x2) Float64x2

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VSMIN, CPU Feature: NEON
func (x Int8x16) Min(y Int8x16) Int8x16

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VSMIN, CPU Feature: NEON
func (x Int16x8) Min(y Int16x8) Int16x8

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VSMIN, CPU Feature: NEON
func (x Int32x4) Min(y Int32x4) Int32x4

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VUMIN, CPU Feature: NEON
func (x Uint8x16) Min(y Uint8x16) Uint8x16

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VUMIN, CPU Feature: NEON
func (x Uint16x8) Min(y Uint16x8) Uint16x8

// Min computes the minimum of each pair of corresponding elements in x and y.
//
// Asm: VUMIN, CPU Feature: NEON
func (x Uint32x4) Min(y Uint32x4) Uint32x4

/* Mul */

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VFMUL, CPU Feature: NEON
func (x Float32x4) Mul(y Float32x4) Float32x4

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VFMUL, CPU Feature: NEON
func (x Float64x2) Mul(y Float64x2) Float64x2

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VMUL, CPU Feature: NEON
func (x Int8x16) Mul(y Int8x16) Int8x16

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VMUL, CPU Feature: NEON
func (x Int16x8) Mul(y Int16x8) Int16x8

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VMUL, CPU Feature: NEON
func (x Int32x4) Mul(y Int32x4) Int32x4

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VMUL, CPU Feature: NEON
func (x Uint8x16) Mul(y Uint8x16) Uint8x16

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VMUL, CPU Feature: NEON
func (x Uint16x8) Mul(y Uint16x8) Uint16x8

// Mul multiplies corresponding elements of two vectors, modulo 2ⁿ.
//
// Asm: VMUL, CPU Feature: NEON
func (x Uint32x4) Mul(y Uint32x4) Uint32x4

/* MulAdd */

// MulAdd performs a fused (x * y) + z.
//
// Asm: VFMLA, CPU Feature: NEON
func (x Float32x4) MulAdd(y Float32x4, z Float32x4) Float32x4

// MulAdd performs a fused (x * y) + z.
//
// Asm: VFMLA, CPU Feature: NEON
func (x Float64x2) MulAdd(y Float64x2, z Float64x2) Float64x2

// MulAdd computes (x * y) + z.
//
// Asm: VMLA, CPU Feature: NEON
func (x Int8x16) MulAdd(y Int8x16, z Int8x16) Int8x16

// MulAdd computes (x * y) + z.
//
// Asm: VMLA, CPU Feature: NEON
func (x Int16x8) MulAdd(y Int16x8, z Int16x8) Int16x8

// MulAdd computes (x * y) + z.
//
// Asm: VMLA, CPU Feature: NEON
func (x Int32x4) MulAdd(y Int32x4, z Int32x4) Int32x4

// MulAdd computes (x * y) + z.
//
// Asm: VMLA, CPU Feature: NEON
func (x Uint8x16) MulAdd(y Uint8x16, z Uint8x16) Uint8x16

// MulAdd computes (x * y) + z.
//
// Asm: VMLA, CPU Feature: NEON
func (x Uint16x8) MulAdd(y Uint16x8, z Uint16x8) Uint16x8

// MulAdd computes (x * y) + z.
//
// Asm: VMLA, CPU Feature: NEON
func (x Uint32x4) MulAdd(y Uint32x4, z Uint32x4) Uint32x4

/* MulWidenLo */

// MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().MulWidenLo(y.HiToLo())
//
// Asm: VSMULL, CPU Feature: NEON
func (x Int8x16) MulWidenLo(y Int8x16) Int16x8

// MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().MulWidenLo(y.HiToLo())
//
// Asm: VSMULL, CPU Feature: NEON
func (x Int16x8) MulWidenLo(y Int16x8) Int32x4

// MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().MulWidenLo(y.HiToLo())
//
// Asm: VSMULL, CPU Feature: NEON
func (x Int32x4) MulWidenLo(y Int32x4) Int64x2

// MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().MulWidenLo(y.HiToLo())
//
// Asm: VUMULL, CPU Feature: NEON
func (x Uint8x16) MulWidenLo(y Uint8x16) Uint16x8

// MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().MulWidenLo(y.HiToLo())
//
// Asm: VUMULL, CPU Feature: NEON
func (x Uint16x8) MulWidenLo(y Uint16x8) Uint32x4

// MulWidenLo multiplies corresponding low-indexed elements and produces a result with double the element width.
// For the high-indexed elements, use HiToLo:
//
//	x.HiToLo().MulWidenLo(y.HiToLo())
//
// Asm: VUMULL, CPU Feature: NEON
func (x Uint32x4) MulWidenLo(y Uint32x4) Uint64x2

/* Neg */

// Neg returns the elementwise negation of x.
//
// Asm: VFNEG, CPU Feature: NEON
func (x Float32x4) Neg() Float32x4

// Neg returns the elementwise negation of x.
//
// Asm: VFNEG, CPU Feature: NEON
func (x Float64x2) Neg() Float64x2

// Neg returns the elementwise negation of x.
//
// Asm: VNEG, CPU Feature: NEON
func (x Int8x16) Neg() Int8x16

// Neg returns the elementwise negation of x.
//
// Asm: VNEG, CPU Feature: NEON
func (x Int16x8) Neg() Int16x8

// Neg returns the elementwise negation of x.
//
// Asm: VNEG, CPU Feature: NEON
func (x Int32x4) Neg() Int32x4

// Neg returns the elementwise negation of x.
//
// Asm: VNEG, CPU Feature: NEON
func (x Int64x2) Neg() Int64x2

/* Not */

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Int8x16) Not() Int8x16

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Int16x8) Not() Int16x8

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Int32x4) Not() Int32x4

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Int64x2) Not() Int64x2

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Uint8x16) Not() Uint8x16

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Uint16x8) Not() Uint16x8

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Uint32x4) Not() Uint32x4

// Not returns the bitwise complement of x.
//
// Asm: VNOT, CPU Feature: NEON
func (x Uint64x2) Not() Uint64x2

/* OnesCount */

// OnesCount counts the number of set bits in each element.
//
// Asm: VCNT, CPU Feature: NEON
func (x Int8x16) OnesCount() Int8x16

// OnesCount counts the number of set bits in each element.
//
// Asm: VCNT, CPU Feature: NEON
func (x Uint8x16) OnesCount() Uint8x16

/* Or */

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Int8x16) Or(y Int8x16) Int8x16

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Int16x8) Or(y Int16x8) Int16x8

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Int32x4) Or(y Int32x4) Int32x4

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Int64x2) Or(y Int64x2) Int64x2

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Uint8x16) Or(y Uint8x16) Uint8x16

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Uint16x8) Or(y Uint16x8) Uint16x8

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Uint32x4) Or(y Uint32x4) Uint32x4

// Or performs a bitwise x | y.
//
// Asm: VORR, CPU Feature: NEON
func (x Uint64x2) Or(y Uint64x2) Uint64x2

/* OrNot */

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Int8x16) OrNot(y Int8x16) Int8x16

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Int16x8) OrNot(y Int16x8) Int16x8

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Int32x4) OrNot(y Int32x4) Int32x4

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Int64x2) OrNot(y Int64x2) Int64x2

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Uint8x16) OrNot(y Uint8x16) Uint8x16

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Uint16x8) OrNot(y Uint16x8) Uint16x8

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Uint32x4) OrNot(y Uint32x4) Uint32x4

// OrNot performs a bitwise x | ^y.
//
// Asm: VORN, CPU Feature: NEON
func (x Uint64x2) OrNot(y Uint64x2) Uint64x2

/* Round */

// Round rounds elements to the nearest integer, rounding ties to even.
//
// Asm: VFRINTN, CPU Feature: NEON
func (x Float32x4) Round() Float32x4

// Round rounds elements to the nearest integer, rounding ties to even.
//
// Asm: VFRINTN, CPU Feature: NEON
func (x Float64x2) Round() Float64x2

/* SaturateToInt8 */

// SaturateToInt8 converts element values to int8 with signed saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VSQXTN, CPU Feature: NEON
func (x Int16x8) SaturateToInt8() Int8x16

/* SaturateToInt16 */

// SaturateToInt16 converts element values to int16 with signed saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VSQXTN, CPU Feature: NEON
func (x Int32x4) SaturateToInt16() Int16x8

/* SaturateToInt32 */

// SaturateToInt32 converts element values to int32 with signed saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VSQXTN, CPU Feature: NEON
func (x Int64x2) SaturateToInt32() Int32x4

/* SaturateToUint8 */

// SaturateToUint8 converts element values to uint8 with unsigned saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VSQXTUN, CPU Feature: NEON
func (x Int16x8) SaturateToUint8() Uint8x16

// SaturateToUint8 converts element values to uint8 with unsigned saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VUQXTN, CPU Feature: NEON
func (x Uint16x8) SaturateToUint8() Uint8x16

/* SaturateToUint16 */

// SaturateToUint16 converts element values to uint16 with unsigned saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VSQXTUN, CPU Feature: NEON
func (x Int32x4) SaturateToUint16() Uint16x8

// SaturateToUint16 converts element values to uint16 with unsigned saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VUQXTN, CPU Feature: NEON
func (x Uint32x4) SaturateToUint16() Uint16x8

/* SaturateToUint32 */

// SaturateToUint32 converts element values to uint32 with unsigned saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VSQXTUN, CPU Feature: NEON
func (x Int64x2) SaturateToUint32() Uint32x4

// SaturateToUint32 converts element values to uint32 with unsigned saturation.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VUQXTN, CPU Feature: NEON
func (x Uint64x2) SaturateToUint32() Uint32x4

/* SetElem */

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int8x16) SetElem(index uint8, y int8) Int8x16

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int16x8) SetElem(index uint8, y int16) Int16x8

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int32x4) SetElem(index uint8, y int32) Int32x4

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Int64x2) SetElem(index uint8, y int64) Int64x2

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint8x16) SetElem(index uint8, y uint8) Uint8x16

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint16x8) SetElem(index uint8, y uint16) Uint16x8

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint32x4) SetElem(index uint8, y uint32) Uint32x4

// SetElem returns x with the index'th element set to y.
//
// A non-constant value of index may result in significantly worse performance for this operation.
//
// Asm: VMOV, CPU Feature: NEON
func (x Uint64x2) SetElem(index uint8, y uint64) Uint64x2

// SetElem returns x with the index'th element set to y.
//
// index results in better performance when it's a constant, a non-constant value will be translated into a jump table.
// Asm: VMOV, CPU Feature: NEON
func (x Float32x4) SetElem(index uint8, v float32) Float32x4

// SetElem returns x with the index'th element set to y.
//
// index results in better performance when it's a constant, a non-constant value will be translated into a jump table.
// Asm: VMOV, CPU Feature: NEON
func (x Float64x2) SetElem(index uint8, v float64) Float64x2

/* Shift */

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int8x16) Shift(y Int8x16) Int8x16

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int16x8) Shift(y Int16x8) Int16x8

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int32x4) Shift(y Int32x4) Int32x4

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int64x2) Shift(y Int64x2) Int64x2

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint8x16) Shift(y Int8x16) Uint8x16

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint16x8) Shift(y Int16x8) Uint16x8

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint32x4) Shift(y Int32x4) Uint32x4

// Shift shifts each element in x by the signed value of the least significant byte
// of y's corresponding element: positive values shift left, negative values shift right.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint64x2) Shift(y Int64x2) Uint64x2

/* ShiftAllLeft */

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int8x16) ShiftAllLeft(y uint64) Int8x16

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int16x8) ShiftAllLeft(y uint64) Int16x8

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int32x4) ShiftAllLeft(y uint64) Int32x4

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int64x2) ShiftAllLeft(y uint64) Int64x2

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint8x16) ShiftAllLeft(y uint64) Uint8x16

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint16x8) ShiftAllLeft(y uint64) Uint16x8

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint32x4) ShiftAllLeft(y uint64) Uint32x4

// ShiftAllLeft shifts each element of x left by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint64x2) ShiftAllLeft(y uint64) Uint64x2

/* ShiftAllRight */

// ShiftAllRight arithmetically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0 or -1.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int8x16) ShiftAllRight(y uint64) Int8x16

// ShiftAllRight arithmetically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0 or -1.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int16x8) ShiftAllRight(y uint64) Int16x8

// ShiftAllRight arithmetically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0 or -1.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int32x4) ShiftAllRight(y uint64) Int32x4

// ShiftAllRight arithmetically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0 or -1.
//
// Asm: VSSHL, CPU Feature: NEON
func (x Int64x2) ShiftAllRight(y uint64) Int64x2

// ShiftAllRight logically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint8x16) ShiftAllRight(y uint64) Uint8x16

// ShiftAllRight logically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint16x8) ShiftAllRight(y uint64) Uint16x8

// ShiftAllRight logically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint32x4) ShiftAllRight(y uint64) Uint32x4

// ShiftAllRight logically shifts each element of x right by y bits.
// If y is greater than the element width, the result is 0.
//
// Asm: VUSHL, CPU Feature: NEON
func (x Uint64x2) ShiftAllRight(y uint64) Uint64x2

/* ShiftSaturated */

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the signed range on overflow.
//
// Asm: VSQSHL, CPU Feature: NEON
func (x Int8x16) ShiftSaturated(y Int8x16) Int8x16

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the signed range on overflow.
//
// Asm: VSQSHL, CPU Feature: NEON
func (x Int16x8) ShiftSaturated(y Int16x8) Int16x8

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the signed range on overflow.
//
// Asm: VSQSHL, CPU Feature: NEON
func (x Int32x4) ShiftSaturated(y Int32x4) Int32x4

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the signed range on overflow.
//
// Asm: VSQSHL, CPU Feature: NEON
func (x Int64x2) ShiftSaturated(y Int64x2) Int64x2

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the unsigned range on overflow.
//
// Asm: VUQSHL, CPU Feature: NEON
func (x Uint8x16) ShiftSaturated(y Int8x16) Uint8x16

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the unsigned range on overflow.
//
// Asm: VUQSHL, CPU Feature: NEON
func (x Uint16x8) ShiftSaturated(y Int16x8) Uint16x8

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the unsigned range on overflow.
//
// Asm: VUQSHL, CPU Feature: NEON
func (x Uint32x4) ShiftSaturated(y Int32x4) Uint32x4

// ShiftSaturated shifts each element in x by the signed value of the least significant byte
// of y's corresponding element (positive shifts left, negative shifts right).
// Results are saturated to the unsigned range on overflow.
//
// Asm: VUQSHL, CPU Feature: NEON
func (x Uint64x2) ShiftSaturated(y Int64x2) Uint64x2

/* Sqrt */

// Sqrt computes the square root of each element.
//
// Asm: VFSQRT, CPU Feature: NEON
func (x Float32x4) Sqrt() Float32x4

// Sqrt computes the square root of each element.
//
// Asm: VFSQRT, CPU Feature: NEON
func (x Float64x2) Sqrt() Float64x2

/* Sub */

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VFSUB, CPU Feature: NEON
func (x Float32x4) Sub(y Float32x4) Float32x4

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VFSUB, CPU Feature: NEON
func (x Float64x2) Sub(y Float64x2) Float64x2

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Int8x16) Sub(y Int8x16) Int8x16

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Int16x8) Sub(y Int16x8) Int16x8

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Int32x4) Sub(y Int32x4) Int32x4

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Int64x2) Sub(y Int64x2) Int64x2

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Uint8x16) Sub(y Uint8x16) Uint8x16

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Uint16x8) Sub(y Uint16x8) Uint16x8

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Uint32x4) Sub(y Uint32x4) Uint32x4

// Sub subtracts corresponding elements of two vectors.
//
// Asm: VSUB, CPU Feature: NEON
func (x Uint64x2) Sub(y Uint64x2) Uint64x2

/* SubSaturated */

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VSQSUB, CPU Feature: NEON
func (x Int8x16) SubSaturated(y Int8x16) Int8x16

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VSQSUB, CPU Feature: NEON
func (x Int16x8) SubSaturated(y Int16x8) Int16x8

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VSQSUB, CPU Feature: NEON
func (x Int32x4) SubSaturated(y Int32x4) Int32x4

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VSQSUB, CPU Feature: NEON
func (x Int64x2) SubSaturated(y Int64x2) Int64x2

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VUQSUB, CPU Feature: NEON
func (x Uint8x16) SubSaturated(y Uint8x16) Uint8x16

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VUQSUB, CPU Feature: NEON
func (x Uint16x8) SubSaturated(y Uint16x8) Uint16x8

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VUQSUB, CPU Feature: NEON
func (x Uint32x4) SubSaturated(y Uint32x4) Uint32x4

// SubSaturated subtracts corresponding elements of two vectors with saturation.
//
// Asm: VUQSUB, CPU Feature: NEON
func (x Uint64x2) SubSaturated(y Uint64x2) Uint64x2

/* Trunc */

// Trunc truncates elements towards zero.
//
// Asm: VFRINTZ, CPU Feature: NEON
func (x Float32x4) Trunc() Float32x4

// Trunc truncates elements towards zero.
//
// Asm: VFRINTZ, CPU Feature: NEON
func (x Float64x2) Trunc() Float64x2

/* TruncToInt8 */

// TruncToInt8 truncates element values to int8.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VXTN, CPU Feature: NEON
func (x Int16x8) TruncToInt8() Int8x16

/* TruncToInt16 */

// TruncToInt16 truncates element values to int16.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VXTN, CPU Feature: NEON
func (x Int32x4) TruncToInt16() Int16x8

/* TruncToInt32 */

// TruncToInt32 truncates element values to int32.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VXTN, CPU Feature: NEON
func (x Int64x2) TruncToInt32() Int32x4

/* TruncToUint8 */

// TruncToUint8 truncates element values to uint8.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VXTN, CPU Feature: NEON
func (x Uint16x8) TruncToUint8() Uint8x16

/* TruncToUint16 */

// TruncToUint16 truncates element values to uint16.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VXTN, CPU Feature: NEON
func (x Uint32x4) TruncToUint16() Uint16x8

/* TruncToUint32 */

// TruncToUint32 truncates element values to uint32.
// Results are packed to low elements in the returned vector, its upper elements are zeroed.
//
// Asm: VXTN, CPU Feature: NEON
func (x Uint64x2) TruncToUint32() Uint32x4

/* Xor */

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Int8x16) Xor(y Int8x16) Int8x16

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Int16x8) Xor(y Int16x8) Int16x8

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Int32x4) Xor(y Int32x4) Int32x4

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Int64x2) Xor(y Int64x2) Int64x2

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Uint8x16) Xor(y Uint8x16) Uint8x16

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Uint16x8) Xor(y Uint16x8) Uint16x8

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Uint32x4) Xor(y Uint32x4) Uint32x4

// Xor performs a bitwise x ^ y.
//
// Asm: VEOR, CPU Feature: NEON
func (x Uint64x2) Xor(y Uint64x2) Uint64x2

// BitsToInt8 reinterprets the bits of a Uint8x16 vector as a Int8x16 vector
func (x Uint8x16) BitsToInt8() Int8x16

// ConvertToInt8 converts a Uint8x16 vector to a Int8x16 vector
func (x Uint8x16) ConvertToInt8() Int8x16

// ConvertToUint8 converts a Int8x16 vector to a Uint8x16 vector
func (x Int8x16) ConvertToUint8() Uint8x16

// ToBits reinterprets the bits of a Int8x16 vector as a Uint8x16 vector
func (x Int8x16) ToBits() Uint8x16

// ReshapeToUint16s reinterprets the bits of a Uint8x16 vector as a Uint16x8 vector
func (x Uint8x16) ReshapeToUint16s() Uint16x8

// ReshapeToUint32s reinterprets the bits of a Uint8x16 vector as a Uint32x4 vector
func (x Uint8x16) ReshapeToUint32s() Uint32x4

// ReshapeToUint64s reinterprets the bits of a Uint8x16 vector as a Uint64x2 vector
func (x Uint8x16) ReshapeToUint64s() Uint64x2

// BitsToInt16 reinterprets the bits of a Uint16x8 vector as a Int16x8 vector
func (x Uint16x8) BitsToInt16() Int16x8

// ConvertToInt16 converts a Uint16x8 vector to a Int16x8 vector
func (x Uint16x8) ConvertToInt16() Int16x8

// ConvertToUint16 converts a Int16x8 vector to a Uint16x8 vector
func (x Int16x8) ConvertToUint16() Uint16x8

// ToBits reinterprets the bits of a Int16x8 vector as a Uint16x8 vector
func (x Int16x8) ToBits() Uint16x8

// ReshapeToUint8s reinterprets the bits of a Uint16x8 vector as a Uint8x16 vector
func (x Uint16x8) ReshapeToUint8s() Uint8x16

// ReshapeToUint32s reinterprets the bits of a Uint16x8 vector as a Uint32x4 vector
func (x Uint16x8) ReshapeToUint32s() Uint32x4

// ReshapeToUint64s reinterprets the bits of a Uint16x8 vector as a Uint64x2 vector
func (x Uint16x8) ReshapeToUint64s() Uint64x2

// BitsToFloat32 reinterprets the bits of a Uint32x4 vector as a Float32x4 vector
func (x Uint32x4) BitsToFloat32() Float32x4

// ToBits reinterprets the bits of a Float32x4 vector as a Uint32x4 vector
func (x Float32x4) ToBits() Uint32x4

// BitsToInt32 reinterprets the bits of a Uint32x4 vector as a Int32x4 vector
func (x Uint32x4) BitsToInt32() Int32x4

// ConvertToInt32 converts a Uint32x4 vector to a Int32x4 vector
func (x Uint32x4) ConvertToInt32() Int32x4

// ConvertToUint32 converts a Int32x4 vector to a Uint32x4 vector
func (x Int32x4) ConvertToUint32() Uint32x4

// ToBits reinterprets the bits of a Int32x4 vector as a Uint32x4 vector
func (x Int32x4) ToBits() Uint32x4

// ReshapeToUint8s reinterprets the bits of a Uint32x4 vector as a Uint8x16 vector
func (x Uint32x4) ReshapeToUint8s() Uint8x16

// ReshapeToUint16s reinterprets the bits of a Uint32x4 vector as a Uint16x8 vector
func (x Uint32x4) ReshapeToUint16s() Uint16x8

// ReshapeToUint64s reinterprets the bits of a Uint32x4 vector as a Uint64x2 vector
func (x Uint32x4) ReshapeToUint64s() Uint64x2

// BitsToFloat64 reinterprets the bits of a Uint64x2 vector as a Float64x2 vector
func (x Uint64x2) BitsToFloat64() Float64x2

// ToBits reinterprets the bits of a Float64x2 vector as a Uint64x2 vector
func (x Float64x2) ToBits() Uint64x2

// BitsToInt64 reinterprets the bits of a Uint64x2 vector as a Int64x2 vector
func (x Uint64x2) BitsToInt64() Int64x2

// ConvertToInt64 converts a Uint64x2 vector to a Int64x2 vector
func (x Uint64x2) ConvertToInt64() Int64x2

// ConvertToUint64 converts a Int64x2 vector to a Uint64x2 vector
func (x Int64x2) ConvertToUint64() Uint64x2

// ToBits reinterprets the bits of a Int64x2 vector as a Uint64x2 vector
func (x Int64x2) ToBits() Uint64x2

// ReshapeToUint8s reinterprets the bits of a Uint64x2 vector as a Uint8x16 vector
func (x Uint64x2) ReshapeToUint8s() Uint8x16

// ReshapeToUint16s reinterprets the bits of a Uint64x2 vector as a Uint16x8 vector
func (x Uint64x2) ReshapeToUint16s() Uint16x8

// ReshapeToUint32s reinterprets the bits of a Uint64x2 vector as a Uint32x4 vector
func (x Uint64x2) ReshapeToUint32s() Uint32x4

// ToInt8x16 converts from Mask8x16 to Int8x16.
// If element i in the mask is "true", all bits in element i of the resulting
// vector will be set.
func (from Mask8x16) ToInt8x16() (to Int8x16)

// asMask converts from Int8x16 to Mask8x16.
func (from Int8x16) asMask() (to Mask8x16)

func (x Mask8x16) And(y Mask8x16) Mask8x16

func (x Mask8x16) Or(y Mask8x16) Mask8x16

func (x Mask8x16) Not() Mask8x16

// ToInt16x8 converts from Mask16x8 to Int16x8.
// If element i in the mask is "true", all bits in element i of the resulting
// vector will be set.
func (from Mask16x8) ToInt16x8() (to Int16x8)

// asMask converts from Int16x8 to Mask16x8.
func (from Int16x8) asMask() (to Mask16x8)

func (x Mask16x8) And(y Mask16x8) Mask16x8

func (x Mask16x8) Or(y Mask16x8) Mask16x8

func (x Mask16x8) Not() Mask16x8

// ToInt32x4 converts from Mask32x4 to Int32x4.
// If element i in the mask is "true", all bits in element i of the resulting
// vector will be set.
func (from Mask32x4) ToInt32x4() (to Int32x4)

// asMask converts from Int32x4 to Mask32x4.
func (from Int32x4) asMask() (to Mask32x4)

func (x Mask32x4) And(y Mask32x4) Mask32x4

func (x Mask32x4) Or(y Mask32x4) Mask32x4

func (x Mask32x4) Not() Mask32x4

// ToInt64x2 converts from Mask64x2 to Int64x2.
// If element i in the mask is "true", all bits in element i of the resulting
// vector will be set.
func (from Mask64x2) ToInt64x2() (to Int64x2)

// asMask converts from Int64x2 to Mask64x2.
func (from Int64x2) asMask() (to Mask64x2)

func (x Mask64x2) And(y Mask64x2) Mask64x2

func (x Mask64x2) Or(y Mask64x2) Mask64x2

func (x Mask64x2) Not() Mask64x2