@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/simd/archsimd/ops_arm64.go

@@ -0,0 +1,2186 @@
+// 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