src/simd/archsimd/ops_arm64.go

// 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 returns the elementwise absolute value of x.
//
// Asm: VFABS
func (x Float32x4) Abs() (z Float32x4)

// Abs returns the elementwise absolute value of x.
//
// Asm: VFABS
func (x Float64x2) Abs() (z Float64x2)

// Abs returns the elementwise absolute value of x.
//
// Asm: VABS
func (x Int8x16) Abs() (z Uint8x16)

// Abs returns the elementwise absolute value of x.
//
// Asm: VABS
func (x Int16x8) Abs() (z Uint16x8)

// Abs returns the elementwise absolute value of x.
//
// Asm: VABS
func (x Int32x4) Abs() (z Uint32x4)

// Abs returns the elementwise absolute value of x.
//
// Asm: VABS
func (x Int64x2) Abs() (z Uint64x2)

/* Add */

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VFADD
func (x Float32x4) Add(y Float32x4) (z Float32x4)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VFADD
func (x Float64x2) Add(y Float64x2) (z Float64x2)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Int8x16) Add(y Int8x16) (z Int8x16)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Int16x8) Add(y Int16x8) (z Int16x8)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Int32x4) Add(y Int32x4) (z Int32x4)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Int64x2) Add(y Int64x2) (z Int64x2)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Uint8x16) Add(y Uint8x16) (z Uint8x16)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Uint16x8) Add(y Uint16x8) (z Uint16x8)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Uint32x4) Add(y Uint32x4) (z Uint32x4)

// Add adds x and y elementwise.
//
//	z[i] = x[i] + y[i]
//
// Asm: VADD
func (x Uint64x2) Add(y Uint64x2) (z Uint64x2)

/* AddSaturated */

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VSQADD
func (x Int8x16) AddSaturated(y Int8x16) (z Int8x16)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VSQADD
func (x Int16x8) AddSaturated(y Int16x8) (z Int16x8)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VSQADD
func (x Int32x4) AddSaturated(y Int32x4) (z Int32x4)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VSQADD
func (x Int64x2) AddSaturated(y Int64x2) (z Int64x2)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VUQADD
func (x Uint8x16) AddSaturated(y Uint8x16) (z Uint8x16)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VUQADD
func (x Uint16x8) AddSaturated(y Uint16x8) (z Uint16x8)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VUQADD
func (x Uint32x4) AddSaturated(y Uint32x4) (z Uint32x4)

// AddSaturated adds x and y elementwise with saturation.
//
//	z[i] = sat(x[i] + y[i])
//
// Asm: VUQADD
func (x Uint64x2) AddSaturated(y Uint64x2) (z Uint64x2)

/* And */

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Int8x16) And(y Int8x16) (z Int8x16)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Int16x8) And(y Int16x8) (z Int16x8)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Int32x4) And(y Int32x4) (z Int32x4)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Int64x2) And(y Int64x2) (z Int64x2)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Uint8x16) And(y Uint8x16) (z Uint8x16)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Uint16x8) And(y Uint16x8) (z Uint16x8)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Uint32x4) And(y Uint32x4) (z Uint32x4)

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
//
// Asm: VAND
func (x Uint64x2) And(y Uint64x2) (z Uint64x2)

/* AndNot */

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Int8x16) AndNot(y Int8x16) (z Int8x16)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Int16x8) AndNot(y Int16x8) (z Int16x8)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Int32x4) AndNot(y Int32x4) (z Int32x4)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Int64x2) AndNot(y Int64x2) (z Int64x2)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Uint8x16) AndNot(y Uint8x16) (z Uint8x16)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Uint16x8) AndNot(y Uint16x8) (z Uint16x8)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Uint32x4) AndNot(y Uint32x4) (z Uint32x4)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
//
// Asm: VBIC
func (x Uint64x2) AndNot(y Uint64x2) (z Uint64x2)

/* Average */

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
//
// Asm: VSRHADD
func (x Int8x16) Average(y Int8x16) (z Int8x16)

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
//
// Asm: VSRHADD
func (x Int16x8) Average(y Int16x8) (z Int16x8)

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
//
// Asm: VSRHADD
func (x Int32x4) Average(y Int32x4) (z Int32x4)

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
//
// Asm: VURHADD
func (x Uint8x16) Average(y Uint8x16) (z Uint8x16)

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
//
// Asm: VURHADD
func (x Uint16x8) Average(y Uint16x8) (z Uint16x8)

// Average returns the elementwise average of x and y, rounded toward +∞.
//
//	z[i] = (x[i] + y[i] + 1) / 2
//
// Asm: VURHADD
func (x Uint32x4) Average(y Uint32x4) (z Uint32x4)

/* Ceil */

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

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

/* ConcatAddPairs */

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
//
// Asm: VFADDP
func (x Float32x4) ConcatAddPairs(y Float32x4) (z Float32x4)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], y[0]+y[1]}
//
// Asm: VFADDP
func (x Float64x2) ConcatAddPairs(y Float64x2) (z Float64x2)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
//
// Asm: VADDP
func (x Int8x16) ConcatAddPairs(y Int8x16) (z Int8x16)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
//
// Asm: VADDP
func (x Int16x8) ConcatAddPairs(y Int16x8) (z Int16x8)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
//
// Asm: VADDP
func (x Int32x4) ConcatAddPairs(y Int32x4) (z Int32x4)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], y[0]+y[1]}
//
// Asm: VADDP
func (x Int64x2) ConcatAddPairs(y Int64x2) (z Int64x2)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
//
// Asm: VADDP
func (x Uint8x16) ConcatAddPairs(y Uint8x16) (z Uint8x16)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], ..., y[0]+y[1], y[2]+y[3], ...}
//
// Asm: VADDP
func (x Uint16x8) ConcatAddPairs(y Uint16x8) (z Uint16x8)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], x[2]+x[3], y[0]+y[1], y[2]+y[3]}
//
// Asm: VADDP
func (x Uint32x4) ConcatAddPairs(y Uint32x4) (z Uint32x4)

// ConcatAddPairs horizontally adds adjacent pairs of elements in x and y and
// returns the concatenated result.
//
//	z = {x[0]+x[1], y[0]+y[1]}
//
// Asm: VADDP
func (x Uint64x2) ConcatAddPairs(y Uint64x2) (z 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
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
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
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
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
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
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
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
func (x Uint64x2) ConcatEven(y Uint64x2) Uint64x2

/* ConcatMaxPairs */

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3] and y = [y0, y1, y2, y3], the result is [max(x0,x1), max(x2,x3), max(y0,y1), max(y2,y3)].
//
// Asm: VFMAXP
func (x Float32x4) ConcatMaxPairs(y Float32x4) Float32x4

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1] and y = [y0, y1], the result is [max(x0,x1), max(y0,y1)].
//
// Asm: VFMAXP
func (x Float64x2) ConcatMaxPairs(y Float64x2) Float64x2

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [max(x0,x1), max(x2,x3), ..., max(y0,y1), max(y2,y3), ...].
//
// Asm: VSMAXP
func (x Int8x16) ConcatMaxPairs(y Int8x16) Int8x16

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [max(x0,x1), max(x2,x3), ..., max(y0,y1), max(y2,y3), ...].
//
// Asm: VSMAXP
func (x Int16x8) ConcatMaxPairs(y Int16x8) Int16x8

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3] and y = [y0, y1, y2, y3], the result is [max(x0,x1), max(x2,x3), max(y0,y1), max(y2,y3)].
//
// Asm: VSMAXP
func (x Int32x4) ConcatMaxPairs(y Int32x4) Int32x4

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [max(x0,x1), max(x2,x3), ..., max(y0,y1), max(y2,y3), ...].
//
// Asm: VUMAXP
func (x Uint8x16) ConcatMaxPairs(y Uint8x16) Uint8x16

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [max(x0,x1), max(x2,x3), ..., max(y0,y1), max(y2,y3), ...].
//
// Asm: VUMAXP
func (x Uint16x8) ConcatMaxPairs(y Uint16x8) Uint16x8

// ConcatMaxPairs horizontally computes the maximum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3] and y = [y0, y1, y2, y3], the result is [max(x0,x1), max(x2,x3), max(y0,y1), max(y2,y3)].
//
// Asm: VUMAXP
func (x Uint32x4) ConcatMaxPairs(y Uint32x4) Uint32x4

/* ConcatMinPairs */

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3] and y = [y0, y1, y2, y3], the result is [min(x0,x1), min(x2,x3), min(y0,y1), min(y2,y3)].
//
// Asm: VFMINP
func (x Float32x4) ConcatMinPairs(y Float32x4) Float32x4

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1] and y = [y0, y1], the result is [min(x0,x1), min(y0,y1)].
//
// Asm: VFMINP
func (x Float64x2) ConcatMinPairs(y Float64x2) Float64x2

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [min(x0,x1), min(x2,x3), ..., min(y0,y1), min(y2,y3), ...].
//
// Asm: VSMINP
func (x Int8x16) ConcatMinPairs(y Int8x16) Int8x16

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [min(x0,x1), min(x2,x3), ..., min(y0,y1), min(y2,y3), ...].
//
// Asm: VSMINP
func (x Int16x8) ConcatMinPairs(y Int16x8) Int16x8

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3] and y = [y0, y1, y2, y3], the result is [min(x0,x1), min(x2,x3), min(y0,y1), min(y2,y3)].
//
// Asm: VSMINP
func (x Int32x4) ConcatMinPairs(y Int32x4) Int32x4

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [min(x0,x1), min(x2,x3), ..., min(y0,y1), min(y2,y3), ...].
//
// Asm: VUMINP
func (x Uint8x16) ConcatMinPairs(y Uint8x16) Uint8x16

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3, ...] and y = [y0, y1, y2, y3, ...], the result is [min(x0,x1), min(x2,x3), ..., min(y0,y1), min(y2,y3), ...].
//
// Asm: VUMINP
func (x Uint16x8) ConcatMinPairs(y Uint16x8) Uint16x8

// ConcatMinPairs horizontally computes the minimum of adjacent pairs of elements.
// For x = [x0, x1, x2, x3] and y = [y0, y1, y2, y3], the result is [min(x0,x1), min(x2,x3), min(y0,y1), min(y2,y3)].
//
// Asm: VUMINP
func (x Uint32x4) ConcatMinPairs(y Uint32x4) Uint32x4

/* 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
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
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
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
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
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
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
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
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.
//
// Performance: A non-constant value of shift may result in significantly worse performance for this operation.
//
// Asm: VEXT
func (x Uint8x16) ConcatShiftBytesRight(y Uint8x16, shift uint64) Uint8x16

/* ConvertLo2ToFloat64 */

// ConvertLo2ToFloat64 converts the low-indexed 2 elements of x to float64.
//
//	z[i] = float64(x[i])
//
// Asm: VFCVTL
func (x Float32x4) ConvertLo2ToFloat64() (z Float64x2)

/* ConvertToFloat32 */

// ConvertToFloat32 converts each element of x to float32.
//
// The results are rounded to the nearest representable value, or ±inf if they
// cannot be represented.
//
// The low 2 elements of the result are set. The rest are zero.
//
// Asm: VFCVTN
func (x Float64x2) ConvertToFloat32() (z Float32x4)

// ConvertToFloat32 converts each element of x to float32.
//
// Asm: VSCVTF
func (x Int32x4) ConvertToFloat32() (z Float32x4)

// ConvertToFloat32 converts each element of x to float32.
//
// Asm: VUCVTF
func (x Uint32x4) ConvertToFloat32() (z Float32x4)

/* ConvertToFloat64 */

// ConvertToFloat64 converts each element of x to float64.
//
// Asm: VSCVTF
func (x Int64x2) ConvertToFloat64() (z Float64x2)

// ConvertToFloat64 converts each element of x to float64.
//
// Asm: VUCVTF
func (x Uint64x2) ConvertToFloat64() (z Float64x2)

/* ConvertToInt32 */

// ConvertToInt32 converts each element of x to int32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// Asm: VFCVTZS
func (x Float32x4) ConvertToInt32() (z Int32x4)

/* ConvertToInt64 */

// ConvertToInt64 converts each element of x to int64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// Asm: VFCVTZS
func (x Float64x2) ConvertToInt64() (z Int64x2)

/* ConvertToUint32 */

// ConvertToUint32 converts each element of x to uint32.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// Asm: VFCVTZU
func (x Float32x4) ConvertToUint32() (z Uint32x4)

/* ConvertToUint64 */

// ConvertToUint64 converts each element of x to uint64.
//
// When a conversion is inexact, this truncates the result (rounds toward zero).
// If the converted result would be outside the representable range, the result
// is architecture-dependent.
//
// Asm: VFCVTZU
func (x Float64x2) ConvertToUint64() (z Uint64x2)

/* Div */

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
//
// Asm: VFDIV
func (x Float32x4) Div(y Float32x4) (z Float32x4)

// Div divides x by y elementwise.
//
//	z[i] = x[i] / y[i]
//
// Division by zero does not panic, and the result follows IEEE 754. That is,
// dividing a non-zero value by zero results in +/- infinity, and dividing zero
// by zero results in NaN.
//
// Asm: VFDIV
func (x Float64x2) Div(y Float64x2) (z Float64x2)

/* Equal */

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VFCMEQ
func (x Float32x4) Equal(y Float32x4) (z Mask32x4)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VFCMEQ
func (x Float64x2) Equal(y Float64x2) (z Mask64x2)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Int8x16) Equal(y Int8x16) (z Mask8x16)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Int16x8) Equal(y Int16x8) (z Mask16x8)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Int32x4) Equal(y Int32x4) (z Mask32x4)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Int64x2) Equal(y Int64x2) (z Mask64x2)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Uint8x16) Equal(y Uint8x16) (z Mask8x16)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Uint16x8) Equal(y Uint16x8) (z Mask16x8)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Uint32x4) Equal(y Uint32x4) (z Mask32x4)

// Equal returns a mask indicating which elements of x and y are equal.
//
// Asm: VCMEQ
func (x Uint64x2) Equal(y Uint64x2) (z Mask64x2)

/* ExtendLo2ToInt64 */

// ExtendLo2ToInt64 sign-extends
// the lowest 2 vector elements to int64.
//
// Asm: VSXTL
func (x Int32x4) ExtendLo2ToInt64() (z Int64x2)

/* ExtendLo2ToUint64 */

// ExtendLo2ToUint64 zero-extends
// the lowest 2 vector elements to uint64.
//
// Asm: VUXTL
func (x Uint32x4) ExtendLo2ToUint64() (z Uint64x2)

/* ExtendLo4ToInt32 */

// ExtendLo4ToInt32 sign-extends
// the lowest 4 vector elements to int32.
//
// Asm: VSXTL
func (x Int16x8) ExtendLo4ToInt32() (z Int32x4)

/* ExtendLo4ToUint32 */

// ExtendLo4ToUint32 zero-extends
// the lowest 4 vector elements to uint32.
//
// Asm: VUXTL
func (x Uint16x8) ExtendLo4ToUint32() (z Uint32x4)

/* ExtendLo8ToInt16 */

// ExtendLo8ToInt16 sign-extends
// the lowest 8 vector elements to int16.
//
// Asm: VSXTL
func (x Int8x16) ExtendLo8ToInt16() (z Int16x8)

/* ExtendLo8ToUint16 */

// ExtendLo8ToUint16 zero-extends
// the lowest 8 vector elements to uint16.
//
// Asm: VUXTL
func (x Uint8x16) ExtendLo8ToUint16() (z Uint16x8)

/* Floor */

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

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

/* GetElem */

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

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

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

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

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

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

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

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

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

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

/* Greater */

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VFCMGT
func (x Float32x4) Greater(y Float32x4) (z Mask32x4)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VFCMGT
func (x Float64x2) Greater(y Float64x2) (z Mask64x2)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMGT
func (x Int8x16) Greater(y Int8x16) (z Mask8x16)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMGT
func (x Int16x8) Greater(y Int16x8) (z Mask16x8)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMGT
func (x Int32x4) Greater(y Int32x4) (z Mask32x4)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMGT
func (x Int64x2) Greater(y Int64x2) (z Mask64x2)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMHI
func (x Uint8x16) Greater(y Uint8x16) (z Mask8x16)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMHI
func (x Uint16x8) Greater(y Uint16x8) (z Mask16x8)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMHI
func (x Uint32x4) Greater(y Uint32x4) (z Mask32x4)

// Greater returns a mask indicating which elements of x are greater than y.
//
//	z[i] = x[i] > y[i]
//
// Asm: VCMHI
func (x Uint64x2) Greater(y Uint64x2) (z Mask64x2)

/* GreaterEqual */

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VFCMGE
func (x Float32x4) GreaterEqual(y Float32x4) (z Mask32x4)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VFCMGE
func (x Float64x2) GreaterEqual(y Float64x2) (z Mask64x2)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMGE
func (x Int8x16) GreaterEqual(y Int8x16) (z Mask8x16)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMGE
func (x Int16x8) GreaterEqual(y Int16x8) (z Mask16x8)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMGE
func (x Int32x4) GreaterEqual(y Int32x4) (z Mask32x4)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMGE
func (x Int64x2) GreaterEqual(y Int64x2) (z Mask64x2)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMHS
func (x Uint8x16) GreaterEqual(y Uint8x16) (z Mask8x16)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMHS
func (x Uint16x8) GreaterEqual(y Uint16x8) (z Mask16x8)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMHS
func (x Uint32x4) GreaterEqual(y Uint32x4) (z Mask32x4)

// GreaterEqual returns a mask indicating which elements of x are greater than
// or equal to y.
//
//	z[i] = x[i] >= y[i]
//
// Asm: VCMHS
func (x Uint64x2) GreaterEqual(y Uint64x2) (z 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
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
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
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
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
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
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
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
func (x Uint64x2) InterleaveEven(y Uint64x2) Uint64x2

/* InterleaveHi */

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

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

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

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

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

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

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

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

/* InterleaveLo */

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

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

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

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

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

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

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

// InterleaveLo interleaves the elements of the low halves of x and y.
//
// Asm: VZIP1
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
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
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
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
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
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
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
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
func (x Uint64x2) InterleaveOdd(y Uint64x2) Uint64x2

/* LeadingSignBits */

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

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

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

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

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

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

/* LeadingZeros */

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
//
// Asm: VCLZ
func (x Int8x16) LeadingZeros() (z Int8x16)

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
//
// Asm: VCLZ
func (x Int16x8) LeadingZeros() (z Int16x8)

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
//
// Asm: VCLZ
func (x Int32x4) LeadingZeros() (z Int32x4)

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 8.
//
//	z[i] = bits.LeadingZeros(x[i])
//
// Asm: VCLZ
func (x Uint8x16) LeadingZeros() (z Uint8x16)

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 16.
//
//	z[i] = bits.LeadingZeros(x[i])
//
// Asm: VCLZ
func (x Uint16x8) LeadingZeros() (z Uint16x8)

// LeadingZeros counts the leading zero bits of each element in x,
// starting from the most significant bit.
// If an element is 0, the result is 32.
//
//	z[i] = bits.LeadingZeros(x[i])
//
// Asm: VCLZ
func (x Uint32x4) LeadingZeros() (z 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
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
func (table Uint8x16) LookupOrZero(indices Uint8x16) Uint8x16

/* Max */

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VFMAX
func (x Float32x4) Max(y Float32x4) (z Float32x4)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VFMAX
func (x Float64x2) Max(y Float64x2) (z Float64x2)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VSMAX
func (x Int8x16) Max(y Int8x16) (z Int8x16)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VSMAX
func (x Int16x8) Max(y Int16x8) (z Int16x8)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VSMAX
func (x Int32x4) Max(y Int32x4) (z Int32x4)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VUMAX
func (x Uint8x16) Max(y Uint8x16) (z Uint8x16)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VUMAX
func (x Uint16x8) Max(y Uint16x8) (z Uint16x8)

// Max returns the elementwise maximum of x and y.
//
//	z[i] = max(x[i], y[i])
//
// Asm: VUMAX
func (x Uint32x4) Max(y Uint32x4) (z Uint32x4)

/* Min */

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VFMIN
func (x Float32x4) Min(y Float32x4) (z Float32x4)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VFMIN
func (x Float64x2) Min(y Float64x2) (z Float64x2)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VSMIN
func (x Int8x16) Min(y Int8x16) (z Int8x16)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VSMIN
func (x Int16x8) Min(y Int16x8) (z Int16x8)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VSMIN
func (x Int32x4) Min(y Int32x4) (z Int32x4)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VUMIN
func (x Uint8x16) Min(y Uint8x16) (z Uint8x16)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VUMIN
func (x Uint16x8) Min(y Uint16x8) (z Uint16x8)

// Min returns the elementwise minimum of x and y.
//
//	z[i] = min(x[i], y[i])
//
// Asm: VUMIN
func (x Uint32x4) Min(y Uint32x4) (z Uint32x4)

/* Mul */

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VFMUL
func (x Float32x4) Mul(y Float32x4) (z Float32x4)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VFMUL
func (x Float64x2) Mul(y Float64x2) (z Float64x2)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VMUL
func (x Int8x16) Mul(y Int8x16) (z Int8x16)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VMUL
func (x Int16x8) Mul(y Int16x8) (z Int16x8)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VMUL
func (x Int32x4) Mul(y Int32x4) (z Int32x4)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VMUL
func (x Uint8x16) Mul(y Uint8x16) (z Uint8x16)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VMUL
func (x Uint16x8) Mul(y Uint16x8) (z Uint16x8)

// Mul returns the elementwise product of x and y.
//
//	z[i] = x[i] * y[i]
//
// Asm: VMUL
func (x Uint32x4) Mul(y Uint32x4) (z Uint32x4)

/* MulAdd */

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VFMLA
func (x Float32x4) MulAdd(y Float32x4, z Float32x4) (w Float32x4)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VFMLA
func (x Float64x2) MulAdd(y Float64x2, z Float64x2) (w Float64x2)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VMLA
func (x Int8x16) MulAdd(y Int8x16, z Int8x16) (w Int8x16)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VMLA
func (x Int16x8) MulAdd(y Int16x8, z Int16x8) (w Int16x8)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VMLA
func (x Int32x4) MulAdd(y Int32x4, z Int32x4) (w Int32x4)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VMLA
func (x Uint8x16) MulAdd(y Uint8x16, z Uint8x16) (w Uint8x16)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VMLA
func (x Uint16x8) MulAdd(y Uint16x8, z Uint16x8) (w Uint16x8)

// MulAdd returns x * y + z elementwise.
//
//	w[i] = x[i] * y[i] + z[i]
//
// Asm: VMLA
func (x Uint32x4) MulAdd(y Uint32x4, z Uint32x4) (w 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
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
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
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
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
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
func (x Uint32x4) MulWidenLo(y Uint32x4) Uint64x2

/* Neg */

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: VFNEG
func (x Float32x4) Neg() (z Float32x4)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: VFNEG
func (x Float64x2) Neg() (z Float64x2)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: VNEG
func (x Int8x16) Neg() (z Int8x16)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: VNEG
func (x Int16x8) Neg() (z Int16x8)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: VNEG
func (x Int32x4) Neg() (z Int32x4)

// Neg returns the elementwise negation of x.
//
//	z[i] = -x[i]
//
// Asm: VNEG
func (x Int64x2) Neg() (z Int64x2)

/* Not */

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Int8x16) Not() (z Int8x16)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Int16x8) Not() (z Int16x8)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Int32x4) Not() (z Int32x4)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Int64x2) Not() (z Int64x2)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Uint8x16) Not() (z Uint8x16)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Uint16x8) Not() (z Uint16x8)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Uint32x4) Not() (z Uint32x4)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
//
// Asm: VNOT
func (x Uint64x2) Not() (z Uint64x2)

/* OnesCount */

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
//
// Asm: VCNT
func (x Int8x16) OnesCount() (z Int8x16)

// OnesCount counts the number of one bits ("population count") in
// each element.
//
//	z[i] = bits.OnesCount(x[i])
//
// Asm: VCNT
func (x Uint8x16) OnesCount() (z Uint8x16)

/* Or */

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Int8x16) Or(y Int8x16) (z Int8x16)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Int16x8) Or(y Int16x8) (z Int16x8)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Int32x4) Or(y Int32x4) (z Int32x4)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Int64x2) Or(y Int64x2) (z Int64x2)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Uint8x16) Or(y Uint8x16) (z Uint8x16)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Uint16x8) Or(y Uint16x8) (z Uint16x8)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Uint32x4) Or(y Uint32x4) (z Uint32x4)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
//
// Asm: VORR
func (x Uint64x2) Or(y Uint64x2) (z Uint64x2)

/* OrNot */

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

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

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

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

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

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

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

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

/* Round */

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

// Round rounds elements to the nearest integer, rounding ties to even.
//
// Asm: VFRINTN
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
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
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
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
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
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
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
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
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
func (x Uint64x2) SaturateToUint32() Uint32x4

/* ScaleSaturated */

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VSQSHL
func (x Int8x16) ScaleSaturated(scale Int8x16) (z Int8x16)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VSQSHL
func (x Int16x8) ScaleSaturated(scale Int16x8) (z Int16x8)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VSQSHL
func (x Int32x4) ScaleSaturated(scale Int32x4) (z Int32x4)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (arithmetic shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VSQSHL
func (x Int64x2) ScaleSaturated(scale Int64x2) (z Int64x2)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VUQSHL
func (x Uint8x16) ScaleSaturated(scale Int8x16) (z Uint8x16)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VUQSHL
func (x Uint16x8) ScaleSaturated(scale Int16x8) (z Uint16x8)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VUQSHL
func (x Uint32x4) ScaleSaturated(scale Int32x4) (z Uint32x4)

// ScaleSaturated multiplies x[i] by 2^scale[i], with saturation.
//
// Positive exponents scale up (shift left with saturation). Negative exponents
// scale down (logical shift right).
//
//	z[i] = sat(x[i] * 2^scale[i])
//
// Asm: VUQSHL
func (x Uint64x2) ScaleSaturated(scale Int64x2) (z Uint64x2)

/* SetElem */

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

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

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

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

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

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

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

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

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

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

/* Shift */

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

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

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

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

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

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

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

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

/* ShiftAllLeft */

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VSSHL
func (x Int8x16) ShiftAllLeft(shift uint64) (z Int8x16)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VSSHL
func (x Int16x8) ShiftAllLeft(shift uint64) (z Int16x8)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VSSHL
func (x Int32x4) ShiftAllLeft(shift uint64) (z Int32x4)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VSSHL
func (x Int64x2) ShiftAllLeft(shift uint64) (z Int64x2)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VUSHL
func (x Uint8x16) ShiftAllLeft(shift uint64) (z Uint8x16)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VUSHL
func (x Uint16x8) ShiftAllLeft(shift uint64) (z Uint16x8)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VUSHL
func (x Uint32x4) ShiftAllLeft(shift uint64) (z Uint32x4)

// ShiftAllLeft shifts each element of x left by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] << shift
//
// Asm: VUSHL
func (x Uint64x2) ShiftAllLeft(shift uint64) (z Uint64x2)

/* ShiftAllRight */

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
//
// Asm: VSSHL
func (x Int8x16) ShiftAllRight(shift uint64) (z Int8x16)

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
//
// Asm: VSSHL
func (x Int16x8) ShiftAllRight(shift uint64) (z Int16x8)

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
//
// Asm: VSSHL
func (x Int32x4) ShiftAllRight(shift uint64) (z Int32x4)

// ShiftAllRight arithmetically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0 or -1.
//
//	z[i] = x[i] >> shift
//
// Asm: VSSHL
func (x Int64x2) ShiftAllRight(shift uint64) (z Int64x2)

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
//
// Asm: VUSHL
func (x Uint8x16) ShiftAllRight(shift uint64) (z Uint8x16)

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
//
// Asm: VUSHL
func (x Uint16x8) ShiftAllRight(shift uint64) (z Uint16x8)

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
//
// Asm: VUSHL
func (x Uint32x4) ShiftAllRight(shift uint64) (z Uint32x4)

// ShiftAllRight logically shifts each element of x right by shift bits.
// If shift is greater than the element width, the result is 0.
//
//	z[i] = x[i] >> shift
//
// Asm: VUSHL
func (x Uint64x2) ShiftAllRight(shift uint64) (z Uint64x2)

/* Sqrt */

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
//
// Asm: VFSQRT
func (x Float32x4) Sqrt() (z Float32x4)

// Sqrt returns the elementwise square root of x.
//
//	z[i] = sqrt(x[i])
//
// Asm: VFSQRT
func (x Float64x2) Sqrt() (z Float64x2)

/* Sub */

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VFSUB
func (x Float32x4) Sub(y Float32x4) (z Float32x4)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VFSUB
func (x Float64x2) Sub(y Float64x2) (z Float64x2)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Int8x16) Sub(y Int8x16) (z Int8x16)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Int16x8) Sub(y Int16x8) (z Int16x8)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Int32x4) Sub(y Int32x4) (z Int32x4)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Int64x2) Sub(y Int64x2) (z Int64x2)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Uint8x16) Sub(y Uint8x16) (z Uint8x16)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Uint16x8) Sub(y Uint16x8) (z Uint16x8)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Uint32x4) Sub(y Uint32x4) (z Uint32x4)

// Sub subtracts y from x elementwise.
//
//	z[i] = x[i] - y[i]
//
// Asm: VSUB
func (x Uint64x2) Sub(y Uint64x2) (z Uint64x2)

/* SubSaturated */

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VSQSUB
func (x Int8x16) SubSaturated(y Int8x16) (z Int8x16)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VSQSUB
func (x Int16x8) SubSaturated(y Int16x8) (z Int16x8)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VSQSUB
func (x Int32x4) SubSaturated(y Int32x4) (z Int32x4)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VSQSUB
func (x Int64x2) SubSaturated(y Int64x2) (z Int64x2)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VUQSUB
func (x Uint8x16) SubSaturated(y Uint8x16) (z Uint8x16)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VUQSUB
func (x Uint16x8) SubSaturated(y Uint16x8) (z Uint16x8)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VUQSUB
func (x Uint32x4) SubSaturated(y Uint32x4) (z Uint32x4)

// SubSaturated subtracts y from x elementwise with saturation.
//
//	z[i] = sat(x[i] - y[i])
//
// Asm: VUQSUB
func (x Uint64x2) SubSaturated(y Uint64x2) (z Uint64x2)

/* Trunc */

// Trunc truncates elements towards zero.
//
// Asm: VFRINTZ
func (x Float32x4) Trunc() Float32x4

// Trunc truncates elements towards zero.
//
// Asm: VFRINTZ
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
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
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
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
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
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
func (x Uint64x2) TruncToUint32() Uint32x4

/* Xor */

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Int8x16) Xor(y Int8x16) (z Int8x16)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Int16x8) Xor(y Int16x8) (z Int16x8)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Int32x4) Xor(y Int32x4) (z Int32x4)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Int64x2) Xor(y Int64x2) (z Int64x2)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Uint8x16) Xor(y Uint8x16) (z Uint8x16)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Uint16x8) Xor(y Uint16x8) (z Uint16x8)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Uint32x4) Xor(y Uint32x4) (z Uint32x4)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
//
// Asm: VEOR
func (x Uint64x2) Xor(y Uint64x2) (z Uint64x2)

// BitsToInt8 reinterprets the bits of each element of x as type int8.
func (x Uint8x16) BitsToInt8() (z Int8x16)

// ConvertToInt8 converts each element of x to int8.
func (x Uint8x16) ConvertToInt8() (z Int8x16)

// ConvertToUint8 converts each element of x to uint8.
func (x Int8x16) ConvertToUint8() (z Uint8x16)

// ToBits reinterprets the bits of each element of x as type uint8.
func (x Int8x16) ToBits() (z Uint8x16)

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	         z[7]         ⋯          z[0]
func (x Uint8x16) ReshapeToUint16s() (z Uint16x8)

// ReshapeToUint32s reinterprets the bits of x as a Uint32x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]     x[13]     x[12]    ⋯     x[3]      x[2]      x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	                   z[3]                   ⋯                    z[0]
func (x Uint8x16) ReshapeToUint32s() (z Uint32x4)

// ReshapeToUint64s reinterprets the bits of x as a Uint64x2 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	   x[15]     x[14]    ⋯     x[9]      x[8]      x[7]      x[6]    ⋯     x[1]      x[0]
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	| 63                 ....                 0 | 63                 ....                 0 |
//	                     z[1]                                        z[0]
func (x Uint8x16) ReshapeToUint64s() (z Uint64x2)

// BitsToInt16 reinterprets the bits of each element of x as type int16.
func (x Uint16x8) BitsToInt16() (z Int16x8)

// ConvertToInt16 converts each element of x to int16.
func (x Uint16x8) ConvertToInt16() (z Int16x8)

// ConvertToUint16 converts each element of x to uint16.
func (x Int16x8) ConvertToUint16() (z Uint16x8)

// ToBits reinterprets the bits of each element of x as type uint16.
func (x Int16x8) ToBits() (z Uint16x8)

// ReshapeToUint8s reinterprets the bits of x as a Uint8x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[7]         ⋯          x[0]
//	| 15     ....     0 | ⋯ | 15     ....     0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[15]     z[14]    ⋯     z[1]      z[0]
func (x Uint16x8) ReshapeToUint8s() (z Uint8x16)

// ReshapeToUint32s reinterprets the bits of x as a Uint32x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[7]      x[6]    ⋯     x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	         z[3]         ⋯          z[0]
func (x Uint16x8) ReshapeToUint32s() (z Uint32x4)

// ReshapeToUint64s reinterprets the bits of x as a Uint64x2 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[7]      x[6]      x[5]      x[4]      x[3]      x[2]      x[1]      x[0]
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	| 63               ....               0 | 63               ....               0 |
//	                   z[1]                                    z[0]
func (x Uint16x8) ReshapeToUint64s() (z Uint64x2)

// BitsToFloat32 reinterprets the bits of each element of x as type float32.
func (x Uint32x4) BitsToFloat32() (z Float32x4)

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float32x4) ToBits() (z Uint32x4)

// BitsToInt32 reinterprets the bits of each element of x as type int32.
func (x Uint32x4) BitsToInt32() (z Int32x4)

// ConvertToInt32 converts each element of x to int32.
func (x Uint32x4) ConvertToInt32() (z Int32x4)

// ConvertToUint32 converts each element of x to uint32.
func (x Int32x4) ConvertToUint32() (z Uint32x4)

// ToBits reinterprets the bits of each element of x as type uint32.
func (x Int32x4) ToBits() (z Uint32x4)

// ReshapeToUint8s reinterprets the bits of x as a Uint8x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[3]                   ⋯                    x[0]
//	| 31               ....               0 | ⋯ | 31               ....               0 |
//	| 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 |
//	   z[15]     z[14]     z[13]     z[12]    ⋯     z[3]      z[2]      z[1]      z[0]
func (x Uint32x4) ReshapeToUint8s() (z Uint8x16)

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[3]         ⋯          x[0]
//	| 31     ....     0 | ⋯ | 31     ....     0 |
//	| 15 .. 0 | 15 .. 0 | ⋯ | 15 .. 0 | 15 .. 0 |
//	    z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint32x4) ReshapeToUint16s() (z Uint16x8)

// ReshapeToUint64s reinterprets the bits of x as a Uint64x2 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	    x[3]      x[2]      x[1]      x[0]
//	| 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	| 63     ....     0 | 63     ....     0 |
//	         z[1]                z[0]
func (x Uint32x4) ReshapeToUint64s() (z Uint64x2)

// BitsToFloat64 reinterprets the bits of each element of x as type float64.
func (x Uint64x2) BitsToFloat64() (z Float64x2)

// ToBits returns the IEEE 754 binary representation of each element of x.
func (x Float64x2) ToBits() (z Uint64x2)

// BitsToInt64 reinterprets the bits of each element of x as type int64.
func (x Uint64x2) BitsToInt64() (z Int64x2)

// ConvertToInt64 converts each element of x to int64.
func (x Uint64x2) ConvertToInt64() (z Int64x2)

// ConvertToUint64 converts each element of x to uint64.
func (x Int64x2) ConvertToUint64() (z Uint64x2)

// ToBits reinterprets the bits of each element of x as type uint64.
func (x Int64x2) ToBits() (z Uint64x2)

// ReshapeToUint8s reinterprets the bits of x as a Uint8x16 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                     x[1]                                        x[0]
//	| 63                 ....                 0 | 63                 ....                 0 |
//	| 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 | 7  .. 0 | 7  .. 0 | ⋯ | 7  .. 0 | 7  .. 0 |
//	   z[15]     z[14]    ⋯     z[9]      z[8]      z[7]      z[6]    ⋯     z[1]      z[0]
func (x Uint64x2) ReshapeToUint8s() (z Uint8x16)

// ReshapeToUint16s reinterprets the bits of x as a Uint16x8 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	                   x[1]                                    x[0]
//	| 63               ....               0 | 63               ....               0 |
//	| 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 | 15 .. 0 |
//	    z[7]      z[6]      z[5]      z[4]      z[3]      z[2]      z[1]      z[0]
func (x Uint64x2) ReshapeToUint16s() (z Uint16x8)

// ReshapeToUint32s reinterprets the bits of x as a Uint32x4 vector.
//
// Both the vector elements and the bits of each element are interpreted in
// little endian order.
//
//	         x[1]                x[0]
//	| 63     ....     0 | 63     ....     0 |
//	| 31 .. 0 | 31 .. 0 | 31 .. 0 | 31 .. 0 |
//	    z[3]      z[2]      z[1]      z[0]
func (x Uint64x2) ReshapeToUint32s() (z Uint32x4)

// ToInt8x16 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask8x16) ToInt8x16() (z Int8x16)

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

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask8x16) And(y Mask8x16) (z Mask8x16)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask8x16) AndNot(y Mask8x16) (z Mask8x16)

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask8x16) Equal(y Mask8x16) (z Mask8x16)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask8x16) Or(y Mask8x16) (z Mask8x16)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask8x16) Xor(y Mask8x16) (z Mask8x16)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask8x16) Not() (z Mask8x16)

// ToInt16x8 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask16x8) ToInt16x8() (z Int16x8)

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

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask16x8) And(y Mask16x8) (z Mask16x8)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask16x8) AndNot(y Mask16x8) (z Mask16x8)

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask16x8) Equal(y Mask16x8) (z Mask16x8)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask16x8) Or(y Mask16x8) (z Mask16x8)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask16x8) Xor(y Mask16x8) (z Mask16x8)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask16x8) Not() (z Mask16x8)

// ToInt32x4 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask32x4) ToInt32x4() (z Int32x4)

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

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask32x4) And(y Mask32x4) (z Mask32x4)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask32x4) AndNot(y Mask32x4) (z Mask32x4)

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask32x4) Equal(y Mask32x4) (z Mask32x4)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask32x4) Or(y Mask32x4) (z Mask32x4)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask32x4) Xor(y Mask32x4) (z Mask32x4)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask32x4) Not() (z Mask32x4)

// ToInt64x2 converts the mask to a vector, where element i is set to ^0 (all bits
// set, e.g., -1) if mask element i is "true", and 0 otherwise.
func (x Mask64x2) ToInt64x2() (z Int64x2)

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

// And returns the bitwise AND of x and y.
//
//	z[i] = x[i] & y[i]
func (x Mask64x2) And(y Mask64x2) (z Mask64x2)

// AndNot returns the bitwise AND NOT of x and y.
//
//	z[i] = x[i] &^ y[i]
func (x Mask64x2) AndNot(y Mask64x2) (z Mask64x2)

// Equal returns a mask indicating which elements of x and y are equal.
func (x Mask64x2) Equal(y Mask64x2) (z Mask64x2)

// Or returns the bitwise OR of x and y.
//
//	z[i] = x[i] | y[i]
func (x Mask64x2) Or(y Mask64x2) (z Mask64x2)

// Xor returns the bitwise XOR of x and y.
//
//	z[i] = x[i] ^ y[i]
func (x Mask64x2) Xor(y Mask64x2) (z Mask64x2)

// Not returns the bitwise negation of x.
//
//	z[i] = ^x[i]
func (x Mask64x2) Not() (z Mask64x2)