// Code generated by 'wasmgen'; DO NOT EDIT.

//go:build goexperiment.simd && wasm

package archsimd

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

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

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

// Abs returns the elementwise absolute value of x.
//
// Asm: F32x4Abs
func (x Float32x4) Abs() Float32x4

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

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

// Add returns the result of adding x and y, elementwise.
//
// Asm: I8x16Add
func (x Int8x16) Add(y Int8x16) Int8x16

// Add returns the result of adding x and y, elementwise.
//
// Asm: I8x16Add
func (x Uint8x16) Add(y Uint8x16) Uint8x16

// Add returns the result of adding x and y, elementwise.
//
// Asm: I16x8Add
func (x Int16x8) Add(y Int16x8) Int16x8

// Add returns the result of adding x and y, elementwise.
//
// Asm: I16x8Add
func (x Uint16x8) Add(y Uint16x8) Uint16x8

// Add returns the result of adding x and y, elementwise.
//
// Asm: I32x4Add
func (x Int32x4) Add(y Int32x4) Int32x4

// Add returns the result of adding x and y, elementwise.
//
// Asm: I32x4Add
func (x Uint32x4) Add(y Uint32x4) Uint32x4

// Add returns the result of adding x and y, elementwise.
//
// Asm: F32x4Add
func (x Float32x4) Add(y Float32x4) Float32x4

// Add returns the result of adding x and y, elementwise.
//
// Asm: I64x2Add
func (x Int64x2) Add(y Int64x2) Int64x2

// Add returns the result of adding x and y, elementwise.
//
// Asm: I64x2Add
func (x Uint64x2) Add(y Uint64x2) Uint64x2

// Add returns the result of adding x and y, elementwise.
//
// Asm: F64x2Add
func (x Float64x2) Add(y Float64x2) Float64x2

// AddSaturated returns the result of adding x and y, saturating instead of overflowing, elementwise.
//
// Asm: I8x16AddSatS
func (x Int8x16) AddSaturated(y Int8x16) Int8x16

// AddSaturated returns the result of adding x and y, saturating instead of overflowing, elementwise.
//
// Asm: I8x16AddSatU
func (x Uint8x16) AddSaturated(y Uint8x16) Uint8x16

// AddSaturated returns the result of adding x and y, saturating instead of overflowing, elementwise.
//
// Asm: I16x8AddSatS
func (x Int16x8) AddSaturated(y Int16x8) Int16x8

// AddSaturated returns the result of adding x and y, saturating instead of overflowing, elementwise.
//
// Asm: I16x8AddSatU
func (x Uint16x8) AddSaturated(y Uint16x8) Uint16x8

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Int8x16) And(y Int8x16) Int8x16

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Uint8x16) And(y Uint8x16) Uint8x16

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Mask8x16) And(y Mask8x16) Mask8x16

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Int16x8) And(y Int16x8) Int16x8

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Uint16x8) And(y Uint16x8) Uint16x8

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Mask16x8) And(y Mask16x8) Mask16x8

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Int32x4) And(y Int32x4) Int32x4

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Uint32x4) And(y Uint32x4) Uint32x4

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Mask32x4) And(y Mask32x4) Mask32x4

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Int64x2) And(y Int64x2) Int64x2

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Uint64x2) And(y Uint64x2) Uint64x2

// And returns the bitwise AND of x and y.
//
// Asm: V128And
func (x Mask64x2) And(y Mask64x2) Mask64x2

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Int8x16) AndNot(y Int8x16) Int8x16

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Uint8x16) AndNot(y Uint8x16) Uint8x16

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Mask8x16) AndNot(y Mask8x16) Mask8x16

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Int16x8) AndNot(y Int16x8) Int16x8

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Uint16x8) AndNot(y Uint16x8) Uint16x8

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Mask16x8) AndNot(y Mask16x8) Mask16x8

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Int32x4) AndNot(y Int32x4) Int32x4

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Uint32x4) AndNot(y Uint32x4) Uint32x4

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Mask32x4) AndNot(y Mask32x4) Mask32x4

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Int64x2) AndNot(y Int64x2) Int64x2

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Uint64x2) AndNot(y Uint64x2) Uint64x2

// AndNot returns the bitwise AND NOT of x and y (x & ^y).
//
// Asm: V128Andnot
func (x Mask64x2) AndNot(y Mask64x2) Mask64x2

// Average returns the elementwise average of unsigned integers in x and y.
//
// Asm: I8x16AvgrU
func (x Uint8x16) Average(y Uint8x16) Uint8x16

// Average returns the elementwise average of unsigned integers in x and y.
//
// Asm: I16x8AvgrU
func (x Uint16x8) Average(y Uint16x8) Uint16x8

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Int8x16) BitSelect(y Int8x16, cond Int8x16) Int8x16

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Uint8x16) BitSelect(y Uint8x16, cond Uint8x16) Uint8x16

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Int16x8) BitSelect(y Int16x8, cond Int16x8) Int16x8

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Uint16x8) BitSelect(y Uint16x8, cond Uint16x8) Uint16x8

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Int32x4) BitSelect(y Int32x4, cond Int32x4) Int32x4

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Uint32x4) BitSelect(y Uint32x4, cond Uint32x4) Uint32x4

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Int64x2) BitSelect(y Int64x2, cond Int64x2) Int64x2

// BitSelect returns the bitwise selection if mask[i] then x[i] else y[i]
//
// Asm: V128Bitselect
func (x Uint64x2) BitSelect(y Uint64x2, cond Uint64x2) Uint64x2

// Ceil returns the elementwise ceiling of x.
//
// Asm: F32x4Ceil
func (x Float32x4) Ceil() Float32x4

// Ceil returns the elementwise ceiling of x.
//
// Asm: F64x2Ceil
func (x Float64x2) Ceil() Float64x2

// ConvertLo2ToFloat64 converts the first two elements of x to Float64x2.
//
// Asm: F64x2ConvertLowI32x4S
func (x Int32x4) ConvertLo2ToFloat64() Float64x2

// ConvertLo2ToFloat64 converts the first two elements of x to Float64x2.
//
// Asm: F64x2ConvertLowI32x4U
func (x Uint32x4) ConvertLo2ToFloat64() Float64x2

// ConvertToFloat32 converts elements of x to Float32x4.
//
// Asm: F32x4ConvertI32x4S
func (x Int32x4) ConvertToFloat32() Float32x4

// ConvertToFloat32 converts elements of x to Float32x4.
//
// Asm: F32x4ConvertI32x4U
func (x Uint32x4) ConvertToFloat32() Float32x4

// ConvertToInt32 converts elements of x to Int32x4.
//
// Asm: I32x4TruncSatF32x4S
func (x Float32x4) ConvertToInt32() Int32x4

// ConvertToUint32 converts elements of x to Uint32x4.
//
// Asm: I32x4TruncSatF32x4U
func (x Float32x4) ConvertToUint32() Uint32x4

// Div returns the result of dividing x by y, elementwise.
//
// Asm: F32x4Div
func (x Float32x4) Div(y Float32x4) Float32x4

// Div returns the result of dividing x by y, elementwise.
//
// Asm: F64x2Div
func (x Float64x2) Div(y Float64x2) Float64x2

// Equal returns true if x equals y, elementwise.
//
// Asm: I8x16Eq
func (x Int8x16) Equal(y Int8x16) Mask8x16

// Equal returns true if x equals y, elementwise.
//
// Asm: I8x16Eq
func (x Uint8x16) Equal(y Uint8x16) Mask8x16

// Equal returns true if x equals y, elementwise.
//
// Asm: I16x8Eq
func (x Int16x8) Equal(y Int16x8) Mask16x8

// Equal returns true if x equals y, elementwise.
//
// Asm: I16x8Eq
func (x Uint16x8) Equal(y Uint16x8) Mask16x8

// Equal returns true if x equals y, elementwise.
//
// Asm: I32x4Eq
func (x Int32x4) Equal(y Int32x4) Mask32x4

// Equal returns true if x equals y, elementwise.
//
// Asm: I32x4Eq
func (x Uint32x4) Equal(y Uint32x4) Mask32x4

// Equal returns true if x equals y, elementwise.
//
// Asm: F32x4Eq
func (x Float32x4) Equal(y Float32x4) Mask32x4

// Equal returns true if x equals y, elementwise.
//
// Asm: I64x2Eq
func (x Int64x2) Equal(y Int64x2) Mask64x2

// Equal returns true if x equals y, elementwise.
//
// Asm: I64x2Eq
func (x Uint64x2) Equal(y Uint64x2) Mask64x2

// Equal returns true if x equals y, elementwise.
//
// Asm: F64x2Eq
func (x Float64x2) Equal(y Float64x2) Mask64x2

// ExtendHi2ToInt64
//
// Asm: I64x2ExtendHighI32x4S
func (x Int32x4) ExtendHi2ToInt64() Int64x2

// ExtendHi2ToUint64
//
// Asm: I64x2ExtendHighI32x4U
func (x Uint32x4) ExtendHi2ToUint64() Uint64x2

// ExtendHi4ToInt32
//
// Asm: I32x4ExtendHighI16x8S
func (x Int16x8) ExtendHi4ToInt32() Int32x4

// ExtendHi4ToUint32
//
// Asm: I32x4ExtendHighI16x8U
func (x Uint16x8) ExtendHi4ToUint32() Uint32x4

// ExtendHi8ToInt16 extends the higher 8 elements of x to 16-bit integers.
//
// Asm: I16x8ExtendHighI8x16S
func (x Int8x16) ExtendHi8ToInt16() Int16x8

// ExtendHi8ToUint16 extends the higher 8 elements of x to 16-bit unsigned integers.
//
// Asm: I16x8ExtendHighI8x16U
func (x Uint8x16) ExtendHi8ToUint16() Uint16x8

// ExtendLo2ToInt64
//
// Asm: I64x2ExtendLowI32x4S
func (x Int32x4) ExtendLo2ToInt64() Int64x2

// ExtendLo2ToUint64
//
// Asm: I64x2ExtendLowI32x4U
func (x Uint32x4) ExtendLo2ToUint64() Uint64x2

// ExtendLo4ToInt32
//
// Asm: I32x4ExtendLowI16x8S
func (x Int16x8) ExtendLo4ToInt32() Int32x4

// ExtendLo4ToUint32
//
// Asm: I32x4ExtendLowI16x8U
func (x Uint16x8) ExtendLo4ToUint32() Uint32x4

// ExtendLo8ToInt16 extends the lower 8 elements of x to 16-bit integers.
//
// Asm: I16x8ExtendLowI8x16S
func (x Int8x16) ExtendLo8ToInt16() Int16x8

// ExtendLo8ToUint16 extends the lower 8 elements of x to 16-bit unsigned integers.
//
// Asm: I16x8ExtendLowI8x16U
func (x Uint8x16) ExtendLo8ToUint16() Uint16x8

// Floor returns the elementwise floor of x.
//
// Asm: F32x4Floor
func (x Float32x4) Floor() Float32x4

// Floor returns the elementwise floor of x.
//
// Asm: F64x2Floor
func (x Float64x2) Floor() Float64x2

// GetElem gets the lane value at the given index.
//
// Asm: I8x16ExtractLaneS
func (x Int8x16) GetElem(index uint8) int8

// GetElem gets the lane value at the given index.
//
// Asm: I8x16ExtractLaneU
func (x Uint8x16) GetElem(index uint8) uint8

// GetElem gets the lane value at the given index.
//
// Asm: I16x8ExtractLaneS
func (x Int16x8) GetElem(index uint8) int16

// GetElem gets the lane value at the given index.
//
// Asm: I16x8ExtractLaneU
func (x Uint16x8) GetElem(index uint8) uint16

// GetElem gets the lane value at the given index.
//
// Asm: I32x4ExtractLane
func (x Int32x4) GetElem(index uint8) int32

// GetElem gets the lane value at the given index.
//
// Asm: I32x4ExtractLane
func (x Uint32x4) GetElem(index uint8) uint32

// GetElem gets the lane value at the given index.
//
// Asm: F32x4ExtractLane
func (x Float32x4) GetElem(index uint8) float32

// GetElem gets the lane value at the given index.
//
// Asm: I64x2ExtractLane
func (x Int64x2) GetElem(index uint8) int64

// GetElem gets the lane value at the given index.
//
// Asm: I64x2ExtractLane
func (x Uint64x2) GetElem(index uint8) uint64

// GetElem gets the lane value at the given index.
//
// Asm: F64x2ExtractLane
func (x Float64x2) GetElem(index uint8) float64

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I8x16GtS
func (x Int8x16) Greater(y Int8x16) Mask8x16

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I8x16GtU
func (x Uint8x16) Greater(y Uint8x16) Mask8x16

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I16x8GtS
func (x Int16x8) Greater(y Int16x8) Mask16x8

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I16x8GtU
func (x Uint16x8) Greater(y Uint16x8) Mask16x8

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I32x4GtS
func (x Int32x4) Greater(y Int32x4) Mask32x4

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I32x4GtU
func (x Uint32x4) Greater(y Uint32x4) Mask32x4

// Greater returns true if x is greater than y, elementwise.
//
// Asm: F32x4Gt
func (x Float32x4) Greater(y Float32x4) Mask32x4

// Greater returns true if x is greater than y, elementwise.
//
// Asm: I64x2GtS
func (x Int64x2) Greater(y Int64x2) Mask64x2

// Greater returns true if x is greater than y, elementwise.
//
// Asm: F64x2Gt
func (x Float64x2) Greater(y Float64x2) Mask64x2

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I8x16GeS
func (x Int8x16) GreaterEqual(y Int8x16) Mask8x16

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I8x16GeU
func (x Uint8x16) GreaterEqual(y Uint8x16) Mask8x16

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I16x8GeS
func (x Int16x8) GreaterEqual(y Int16x8) Mask16x8

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I16x8GeU
func (x Uint16x8) GreaterEqual(y Uint16x8) Mask16x8

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I32x4GeS
func (x Int32x4) GreaterEqual(y Int32x4) Mask32x4

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I32x4GeU
func (x Uint32x4) GreaterEqual(y Uint32x4) Mask32x4

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: F32x4Ge
func (x Float32x4) GreaterEqual(y Float32x4) Mask32x4

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: I64x2GeS
func (x Int64x2) GreaterEqual(y Int64x2) Mask64x2

// GreaterEqual returns true if x is greater than or equal to y, elementwise.
//
// Asm: F64x2Ge
func (x Float64x2) GreaterEqual(y Float64x2) Mask64x2

// Less returns true if x is less than y, elementwise.
//
// Asm: I8x16LtS
func (x Int8x16) Less(y Int8x16) Mask8x16

// Less returns true if x is less than y, elementwise.
//
// Asm: I8x16LtU
func (x Uint8x16) Less(y Uint8x16) Mask8x16

// Less returns true if x is less than y, elementwise.
//
// Asm: I16x8LtS
func (x Int16x8) Less(y Int16x8) Mask16x8

// Less returns true if x is less than y, elementwise.
//
// Asm: I16x8LtU
func (x Uint16x8) Less(y Uint16x8) Mask16x8

// Less returns true if x is less than y, elementwise.
//
// Asm: I32x4LtS
func (x Int32x4) Less(y Int32x4) Mask32x4

// Less returns true if x is less than y, elementwise.
//
// Asm: I32x4LtU
func (x Uint32x4) Less(y Uint32x4) Mask32x4

// Less returns true if x is less than y, elementwise.
//
// Asm: F32x4Lt
func (x Float32x4) Less(y Float32x4) Mask32x4

// Less returns true if x is less than y, elementwise.
//
// Asm: I64x2LtS
func (x Int64x2) Less(y Int64x2) Mask64x2

// Less returns true if x is less than y, elementwise.
//
// Asm: F64x2Lt
func (x Float64x2) Less(y Float64x2) Mask64x2

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I8x16LeS
func (x Int8x16) LessEqual(y Int8x16) Mask8x16

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I8x16LeU
func (x Uint8x16) LessEqual(y Uint8x16) Mask8x16

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I16x8LeS
func (x Int16x8) LessEqual(y Int16x8) Mask16x8

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I16x8LeU
func (x Uint16x8) LessEqual(y Uint16x8) Mask16x8

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I32x4LeS
func (x Int32x4) LessEqual(y Int32x4) Mask32x4

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I32x4LeU
func (x Uint32x4) LessEqual(y Uint32x4) Mask32x4

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: F32x4Le
func (x Float32x4) LessEqual(y Float32x4) Mask32x4

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: I64x2LeS
func (x Int64x2) LessEqual(y Int64x2) Mask64x2

// LessEqual returns true if x is less than or equal to y, elementwise.
//
// Asm: F64x2Le
func (x Float64x2) LessEqual(y Float64x2) Mask64x2

// LookupOrZero returns the elements of x as indexed by the elements of i. If an index is out of range, its result is 0.
//
//	if 0 <= indices[i] && indices[i] < len(table) {
//	    result[i] = table[indices[i]]
//	} else {
//	    result[i] = 0
//	}
//
// Asm: I8x16Swizzle
func (x Int8x16) LookupOrZero(i Int8x16) Int8x16

// Max returns the elementwise maximum of x and y.
//
// Asm: I8x16MaxS
func (x Int8x16) Max(y Int8x16) Int8x16

// Max returns the elementwise maximum of x and y.
//
// Asm: I8x16MaxU
func (x Uint8x16) Max(y Uint8x16) Uint8x16

// Max returns the elementwise maximum of x and y.
//
// Asm: I16x8MaxS
func (x Int16x8) Max(y Int16x8) Int16x8

// Max returns the elementwise maximum of x and y.
//
// Asm: I16x8MaxU
func (x Uint16x8) Max(y Uint16x8) Uint16x8

// Max returns the elementwise maximum of x and y.
//
// Asm: I32x4MaxS
func (x Int32x4) Max(y Int32x4) Int32x4

// Max returns the elementwise maximum of x and y.
//
// Asm: I32x4MaxU
func (x Uint32x4) Max(y Uint32x4) Uint32x4

// Max returns the elementwise maximum of x and y.
//
// Asm: F32x4Max
func (x Float32x4) Max(y Float32x4) Float32x4

// Max returns the elementwise maximum of x and y.
//
// Asm: F64x2Max
func (x Float64x2) Max(y Float64x2) Float64x2

// Min returns the elementwise minimum of x and y.
//
// Asm: I8x16MinS
func (x Int8x16) Min(y Int8x16) Int8x16

// Min returns the elementwise minimum of x and y.
//
// Asm: I8x16MinU
func (x Uint8x16) Min(y Uint8x16) Uint8x16

// Min returns the elementwise minimum of x and y.
//
// Asm: I16x8MinS
func (x Int16x8) Min(y Int16x8) Int16x8

// Min returns the elementwise minimum of x and y.
//
// Asm: I16x8MinU
func (x Uint16x8) Min(y Uint16x8) Uint16x8

// Min returns the elementwise minimum of x and y.
//
// Asm: I32x4MinS
func (x Int32x4) Min(y Int32x4) Int32x4

// Min returns the elementwise minimum of x and y.
//
// Asm: I32x4MinU
func (x Uint32x4) Min(y Uint32x4) Uint32x4

// Min returns the elementwise minimum of x and y.
//
// Asm: F32x4Min
func (x Float32x4) Min(y Float32x4) Float32x4

// Min returns the elementwise minimum of x and y.
//
// Asm: F64x2Min
func (x Float64x2) Min(y Float64x2) Float64x2

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: I16x8Mul
func (x Int16x8) Mul(y Int16x8) Int16x8

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: I16x8Mul
func (x Uint16x8) Mul(y Uint16x8) Uint16x8

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: I32x4Mul
func (x Int32x4) Mul(y Int32x4) Int32x4

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: I32x4Mul
func (x Uint32x4) Mul(y Uint32x4) Uint32x4

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: F32x4Mul
func (x Float32x4) Mul(y Float32x4) Float32x4

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: I64x2Mul
func (x Int64x2) Mul(y Int64x2) Int64x2

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: I64x2Mul
func (x Uint64x2) Mul(y Uint64x2) Uint64x2

// Mul returns the result of multiplying x and y, elementwise.
//
// Asm: F64x2Mul
func (x Float64x2) Mul(y Float64x2) Float64x2

// MulAdd returns the elementwise multiply-add of x, y, and z.
//
// Asm: F32x4RelaxedMadd
func (x Float32x4) MulAdd(y Float32x4, z Float32x4) Float32x4

// MulAdd returns the elementwise multiply-add of x, y, and z.
//
// Asm: F64x2RelaxedMadd
func (x Float64x2) MulAdd(y Float64x2, z Float64x2) Float64x2

// MulWidenHi returns the doubled-width product of respective elements of the upper halves of x and y.
//
//	Result[i] = x[i+8] * y[i+8], for 0 <= i < 8 == |x|/2.
//
// Asm: I16x8ExtmulHighI8x16S
func (x Int8x16) MulWidenHi(y Int8x16) Int16x8

// MulWidenHi returns the doubled-width product of respective elements of the upper halves of x and y.
//
//	Result[i] = x[i+8] * y[i+8], for 0 <= i < 8 == |x|/2.
//
// Asm: I16x8ExtmulHighI8x16U
func (x Uint8x16) MulWidenHi(y Uint8x16) Uint16x8

// MulWidenHi returns the doubled-width product of respective elements of the upper halves of x and y.
//
//	Result[i] = x[i+4] * y[i+4], for 0 <= i < 4 == |x|/2.
//
// Asm: I32x4ExtmulHighI16x8S
func (x Int16x8) MulWidenHi(y Int16x8) Int32x4

// MulWidenHi returns the doubled-width product of respective elements of the upper halves of x and y.
//
//	Result[i] = x[i+4] * y[i+4], for 0 <= i < 4 == |x|/2.
//
// Asm: I32x4ExtmulHighI16x8U
func (x Uint16x8) MulWidenHi(y Uint16x8) Uint32x4

// MulWidenHi returns the doubled-width product of respective elements of the upper halves of x and y.
//
//	Result[i] = x[i+2] * y[i+2], for 0 <= i < 2 == |x|/2.
//
// Asm: I64x2ExtmulHighI32x4S
func (x Int32x4) MulWidenHi(y Int32x4) Int64x2

// MulWidenHi returns the doubled-width product of respective elements of the upper halves of x and y.
//
//	Result[i] = x[i+2] * y[i+2], for 0 <= i < 2 == |x|/2.
//
// Asm: I64x2ExtmulHighI32x4U
func (x Uint32x4) MulWidenHi(y Uint32x4) Uint64x2

// MulWidenLo returns the doubled-width product of respective elements of the lower halves of x and y.
//
//	Result[i] = x[i] * y[i], for 0 <= i < 8 == |x|/2.
//
// Asm: I16x8ExtmulLowI8x16S
func (x Int8x16) MulWidenLo(y Int8x16) Int16x8

// MulWidenLo returns the doubled-width product of respective elements of the lower halves of x and y.
//
//	Result[i] = x[i] * y[i], for 0 <= i < 8 == |x|/2.
//
// Asm: I16x8ExtmulLowI8x16U
func (x Uint8x16) MulWidenLo(y Uint8x16) Uint16x8

// MulWidenLo returns the doubled-width product of respective elements of the lower halves of x and y.
//
//	Result[i] = x[i] * y[i], for 0 <= i < 4 == |x|/2.
//
// Asm: I32x4ExtmulLowI16x8S
func (x Int16x8) MulWidenLo(y Int16x8) Int32x4

// MulWidenLo returns the doubled-width product of respective elements of the lower halves of x and y.
//
//	Result[i] = x[i] * y[i], for 0 <= i < 4 == |x|/2.
//
// Asm: I32x4ExtmulLowI16x8U
func (x Uint16x8) MulWidenLo(y Uint16x8) Uint32x4

// MulWidenLo returns the doubled-width product of respective elements of the lower halves of x and y.
//
//	Result[i] = x[i] * y[i], for 0 <= i < 2 == |x|/2.
//
// Asm: I64x2ExtmulLowI32x4S
func (x Int32x4) MulWidenLo(y Int32x4) Int64x2

// MulWidenLo returns the doubled-width product of respective elements of the lower halves of x and y.
//
//	Result[i] = x[i] * y[i], for 0 <= i < 2 == |x|/2.
//
// Asm: I64x2ExtmulLowI32x4U
func (x Uint32x4) MulWidenLo(y Uint32x4) Uint64x2

// Neg returns the elementwise negation of x.
//
// Asm: I8x16Neg
func (x Int8x16) Neg() Int8x16

// Neg returns the elementwise negation of x.
//
// Asm: I16x8Neg
func (x Int16x8) Neg() Int16x8

// Neg returns the elementwise negation of x.
//
// Asm: I32x4Neg
func (x Int32x4) Neg() Int32x4

// Neg returns the elementwise negation of x.
//
// Asm: F32x4Neg
func (x Float32x4) Neg() Float32x4

// Neg returns the elementwise negation of x.
//
// Asm: I64x2Neg
func (x Int64x2) Neg() Int64x2

// Neg returns the elementwise negation of x.
//
// Asm: F64x2Neg
func (x Float64x2) Neg() Float64x2

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Int8x16) Not() Int8x16

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Uint8x16) Not() Uint8x16

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Int16x8) Not() Int16x8

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Uint16x8) Not() Uint16x8

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Int32x4) Not() Int32x4

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Uint32x4) Not() Uint32x4

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Int64x2) Not() Int64x2

// Not returns the bitwise NOT of x.
//
// Asm: V128Not
func (x Uint64x2) Not() Uint64x2

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I8x16Ne
func (x Int8x16) NotEqual(y Int8x16) Mask8x16

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I8x16Ne
func (x Uint8x16) NotEqual(y Uint8x16) Mask8x16

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I16x8Ne
func (x Int16x8) NotEqual(y Int16x8) Mask16x8

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I16x8Ne
func (x Uint16x8) NotEqual(y Uint16x8) Mask16x8

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I32x4Ne
func (x Int32x4) NotEqual(y Int32x4) Mask32x4

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I32x4Ne
func (x Uint32x4) NotEqual(y Uint32x4) Mask32x4

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: F32x4Ne
func (x Float32x4) NotEqual(y Float32x4) Mask32x4

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I64x2Ne
func (x Int64x2) NotEqual(y Int64x2) Mask64x2

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: I64x2Ne
func (x Uint64x2) NotEqual(y Uint64x2) Mask64x2

// NotEqual returns true if x does not equal y, elementwise.
//
// Asm: F64x2Ne
func (x Float64x2) NotEqual(y Float64x2) Mask64x2

// OnesCount returns the elementwise population count (number of bits set).
//
// Asm: I8x16Popcnt
func (x Int8x16) OnesCount() Int8x16

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Int8x16) Or(y Int8x16) Int8x16

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Uint8x16) Or(y Uint8x16) Uint8x16

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Mask8x16) Or(y Mask8x16) Mask8x16

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Int16x8) Or(y Int16x8) Int16x8

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Uint16x8) Or(y Uint16x8) Uint16x8

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Mask16x8) Or(y Mask16x8) Mask16x8

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Int32x4) Or(y Int32x4) Int32x4

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Uint32x4) Or(y Uint32x4) Uint32x4

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Mask32x4) Or(y Mask32x4) Mask32x4

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Int64x2) Or(y Int64x2) Int64x2

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Uint64x2) Or(y Uint64x2) Uint64x2

// Or returns the bitwise OR of x and y.
//
// Asm: V128Or
func (x Mask64x2) Or(y Mask64x2) Mask64x2

// RotateAllLeft
//
// Asm: I8x16RotateAllLeft
func (x Int8x16) RotateAllLeft(shift uint64) Int8x16

// RotateAllLeft
//
// Asm: I8x16RotateAllLeft
func (x Uint8x16) RotateAllLeft(shift uint64) Uint8x16

// RotateAllLeft
//
// Asm: I16x8RotateAllLeft
func (x Int16x8) RotateAllLeft(shift uint64) Int16x8

// RotateAllLeft
//
// Asm: I16x8RotateAllLeft
func (x Uint16x8) RotateAllLeft(shift uint64) Uint16x8

// RotateAllLeft
//
// Asm: I32x4RotateAllLeft
func (x Int32x4) RotateAllLeft(shift uint64) Int32x4

// RotateAllLeft
//
// Asm: I32x4RotateAllLeft
func (x Uint32x4) RotateAllLeft(shift uint64) Uint32x4

// RotateAllLeft
//
// Asm: I64x2RotateAllLeft
func (x Int64x2) RotateAllLeft(shift uint64) Int64x2

// RotateAllLeft
//
// Asm: I64x2RotateAllLeft
func (x Uint64x2) RotateAllLeft(shift uint64) Uint64x2

// RotateAllRight
//
// Asm: I8x16RotateAllRight
func (x Int8x16) RotateAllRight(shift uint64) Int8x16

// RotateAllRight
//
// Asm: I8x16RotateAllRight
func (x Uint8x16) RotateAllRight(shift uint64) Uint8x16

// RotateAllRight
//
// Asm: I16x8RotateAllRight
func (x Int16x8) RotateAllRight(shift uint64) Int16x8

// RotateAllRight
//
// Asm: I16x8RotateAllRight
func (x Uint16x8) RotateAllRight(shift uint64) Uint16x8

// RotateAllRight
//
// Asm: I32x4RotateAllRight
func (x Int32x4) RotateAllRight(shift uint64) Int32x4

// RotateAllRight
//
// Asm: I32x4RotateAllRight
func (x Uint32x4) RotateAllRight(shift uint64) Uint32x4

// RotateAllRight
//
// Asm: I64x2RotateAllRight
func (x Int64x2) RotateAllRight(shift uint64) Int64x2

// RotateAllRight
//
// Asm: I64x2RotateAllRight
func (x Uint64x2) RotateAllRight(shift uint64) Uint64x2

// Round returns the elementwise nearest integer, rounding ties to even.
//
// Asm: F32x4Nearest
func (x Float32x4) Round() Float32x4

// Round returns the elementwise nearest integer, rounding ties to even.
//
// Asm: F64x2Nearest
func (x Float64x2) Round() Float64x2

// SetElem sets the lane at the given index to y.
//
// Asm: I8x16ReplaceLane
func (x Int8x16) SetElem(index uint8, y int8) Int8x16

// SetElem sets the lane at the given index to y.
//
// Asm: I8x16ReplaceLane
func (x Uint8x16) SetElem(index uint8, y uint8) Uint8x16

// SetElem sets the lane at the given index to y.
//
// Asm: I16x8ReplaceLane
func (x Int16x8) SetElem(index uint8, y int16) Int16x8

// SetElem sets the lane at the given index to y.
//
// Asm: I16x8ReplaceLane
func (x Uint16x8) SetElem(index uint8, y uint16) Uint16x8

// SetElem sets the lane at the given index to y.
//
// Asm: I32x4ReplaceLane
func (x Int32x4) SetElem(index uint8, y int32) Int32x4

// SetElem sets the lane at the given index to y.
//
// Asm: I32x4ReplaceLane
func (x Uint32x4) SetElem(index uint8, y uint32) Uint32x4

// SetElem sets the lane at the given index to y.
//
// Asm: F32x4ReplaceLane
func (x Float32x4) SetElem(index uint8, y float32) Float32x4

// SetElem sets the lane at the given index to y.
//
// Asm: I64x2ReplaceLane
func (x Int64x2) SetElem(index uint8, y int64) Int64x2

// SetElem sets the lane at the given index to y.
//
// Asm: I64x2ReplaceLane
func (x Uint64x2) SetElem(index uint8, y uint64) Uint64x2

// SetElem sets the lane at the given index to y.
//
// Asm: F64x2ReplaceLane
func (x Float64x2) SetElem(index uint8, y float64) Float64x2

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I8x16Shl
func (x Int8x16) ShiftAllLeft(y uint64) Int8x16

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I8x16Shl
func (x Uint8x16) ShiftAllLeft(y uint64) Uint8x16

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I16x8Shl
func (x Int16x8) ShiftAllLeft(y uint64) Int16x8

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I16x8Shl
func (x Uint16x8) ShiftAllLeft(y uint64) Uint16x8

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I32x4Shl
func (x Int32x4) ShiftAllLeft(y uint64) Int32x4

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I32x4Shl
func (x Uint32x4) ShiftAllLeft(y uint64) Uint32x4

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I64x2Shl
func (x Int64x2) ShiftAllLeft(y uint64) Int64x2

// ShiftAllLeft returns the elementwise left shift of x by y bits.
//
// Asm: I64x2Shl
func (x Uint64x2) ShiftAllLeft(y uint64) Uint64x2

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I8x16ShrS
func (x Int8x16) ShiftAllRight(y uint64) Int8x16

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I8x16ShrU
func (x Uint8x16) ShiftAllRight(y uint64) Uint8x16

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I16x8ShrS
func (x Int16x8) ShiftAllRight(y uint64) Int16x8

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I16x8ShrU
func (x Uint16x8) ShiftAllRight(y uint64) Uint16x8

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I32x4ShrS
func (x Int32x4) ShiftAllRight(y uint64) Int32x4

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I32x4ShrU
func (x Uint32x4) ShiftAllRight(y uint64) Uint32x4

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I64x2ShrS
func (x Int64x2) ShiftAllRight(y uint64) Int64x2

// ShiftAllRight returns the elementwise right shift of x by y bits.
//
// Asm: I64x2ShrU
func (x Uint64x2) ShiftAllRight(y uint64) Uint64x2

// Sqrt returns the elementwise square root of x.
//
// Asm: F32x4Sqrt
func (x Float32x4) Sqrt() Float32x4

// Sqrt returns the elementwise square root of x.
//
// Asm: F64x2Sqrt
func (x Float64x2) Sqrt() Float64x2

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I8x16Sub
func (x Int8x16) Sub(y Int8x16) Int8x16

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I8x16Sub
func (x Uint8x16) Sub(y Uint8x16) Uint8x16

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I16x8Sub
func (x Int16x8) Sub(y Int16x8) Int16x8

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I16x8Sub
func (x Uint16x8) Sub(y Uint16x8) Uint16x8

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I32x4Sub
func (x Int32x4) Sub(y Int32x4) Int32x4

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I32x4Sub
func (x Uint32x4) Sub(y Uint32x4) Uint32x4

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: F32x4Sub
func (x Float32x4) Sub(y Float32x4) Float32x4

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I64x2Sub
func (x Int64x2) Sub(y Int64x2) Int64x2

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: I64x2Sub
func (x Uint64x2) Sub(y Uint64x2) Uint64x2

// Sub returns the result of subtracting y from x, elementwise.
//
// Asm: F64x2Sub
func (x Float64x2) Sub(y Float64x2) Float64x2

// SubSaturated returns the result of subtracting x and y, saturating instead of overflowing, elementwise.
//
// Asm: I8x16SubSatS
func (x Int8x16) SubSaturated(y Int8x16) Int8x16

// SubSaturated returns the result of subtracting x and y, saturating instead of overflowing, elementwise.
//
// Asm: I8x16SubSatU
func (x Uint8x16) SubSaturated(y Uint8x16) Uint8x16

// SubSaturated returns the result of subtracting x and y, saturating instead of overflowing, elementwise.
//
// Asm: I16x8SubSatS
func (x Int16x8) SubSaturated(y Int16x8) Int16x8

// SubSaturated returns the result of subtracting x and y, saturating instead of overflowing, elementwise.
//
// Asm: I16x8SubSatU
func (x Uint16x8) SubSaturated(y Uint16x8) Uint16x8

// Trunc returns the elementwise truncation of x.
//
// Asm: F32x4Trunc
func (x Float32x4) Trunc() Float32x4

// Trunc returns the elementwise truncation of x.
//
// Asm: F64x2Trunc
func (x Float64x2) Trunc() Float64x2

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Int8x16) Xor(y Int8x16) Int8x16

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Uint8x16) Xor(y Uint8x16) Uint8x16

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Mask8x16) Xor(y Mask8x16) Mask8x16

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Int16x8) Xor(y Int16x8) Int16x8

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Uint16x8) Xor(y Uint16x8) Uint16x8

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Mask16x8) Xor(y Mask16x8) Mask16x8

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Int32x4) Xor(y Int32x4) Int32x4

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Uint32x4) Xor(y Uint32x4) Uint32x4

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Mask32x4) Xor(y Mask32x4) Mask32x4

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Int64x2) Xor(y Int64x2) Int64x2

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Uint64x2) Xor(y Uint64x2) Uint64x2

// Xor returns the bitwise XOR of x and y.
//
// Asm: V128Xor
func (x Mask64x2) Xor(y Mask64x2) Mask64x2

// ToMask translates an Int8x16 vector to a Mask8x16 mask vector
// zero becomes false, not-zero becomes true
func (x Int8x16) ToMask() Mask8x16

// ToInt8x16 translates a Mask8x16 mask vector to an Int8x16 int vector
// false becomes zero, true becomes -1
func (x Mask8x16) ToInt8x16() Int8x16

// ToMask translates an Int16x8 vector to a Mask16x8 mask vector
// zero becomes false, not-zero becomes true
func (x Int16x8) ToMask() Mask16x8

// ToInt16x8 translates a Mask16x8 mask vector to an Int16x8 int vector
// false becomes zero, true becomes -1
func (x Mask16x8) ToInt16x8() Int16x8

// ToMask translates an Int32x4 vector to a Mask32x4 mask vector
// zero becomes false, not-zero becomes true
func (x Int32x4) ToMask() Mask32x4

// ToInt32x4 translates a Mask32x4 mask vector to an Int32x4 int vector
// false becomes zero, true becomes -1
func (x Mask32x4) ToInt32x4() Int32x4

// ToMask translates an Int64x2 vector to a Mask64x2 mask vector
// zero becomes false, not-zero becomes true
func (x Int64x2) ToMask() Mask64x2

// ToInt64x2 translates a Mask64x2 mask vector to an Int64x2 int vector
// false becomes zero, true becomes -1
func (x Mask64x2) ToInt64x2() Int64x2

// Masked returns x but with elements zeroed where mask is false.
func (x Int8x16) Masked(mask Mask8x16) Int8x16 {
	im := mask.ToInt8x16()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Int8x16) IfElse(mask Mask8x16, y Int8x16) Int8x16 {
	im := mask.ToInt8x16()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Int16x8) Masked(mask Mask16x8) Int16x8 {
	im := mask.ToInt16x8()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Int16x8) IfElse(mask Mask16x8, y Int16x8) Int16x8 {
	im := mask.ToInt16x8()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Int32x4) Masked(mask Mask32x4) Int32x4 {
	im := mask.ToInt32x4()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Int32x4) IfElse(mask Mask32x4, y Int32x4) Int32x4 {
	im := mask.ToInt32x4()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Int64x2) Masked(mask Mask64x2) Int64x2 {
	im := mask.ToInt64x2()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Int64x2) IfElse(mask Mask64x2, y Int64x2) Int64x2 {
	im := mask.ToInt64x2()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Uint8x16) Masked(mask Mask8x16) Uint8x16 {
	im := mask.ToInt8x16().ToBits()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Uint8x16) IfElse(mask Mask8x16, y Uint8x16) Uint8x16 {
	im := mask.ToInt8x16().ToBits()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Uint16x8) Masked(mask Mask16x8) Uint16x8 {
	im := mask.ToInt16x8().ToBits()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Uint16x8) IfElse(mask Mask16x8, y Uint16x8) Uint16x8 {
	im := mask.ToInt16x8().ToBits()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Uint32x4) Masked(mask Mask32x4) Uint32x4 {
	im := mask.ToInt32x4().ToBits()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Uint32x4) IfElse(mask Mask32x4, y Uint32x4) Uint32x4 {
	im := mask.ToInt32x4().ToBits()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Uint64x2) Masked(mask Mask64x2) Uint64x2 {
	im := mask.ToInt64x2().ToBits()
	return im.And(x)
}

// IfElse returns x but with elements set to y where mask is false.
func (x Uint64x2) IfElse(mask Mask64x2, y Uint64x2) Uint64x2 {
	im := mask.ToInt64x2().ToBits()
	return x.BitSelect(y, im)
}

// Masked returns x but with elements zeroed where mask is false.
func (x Float32x4) Masked(mask Mask32x4) Float32x4 {
	im := mask.ToInt32x4().ToBits()
	return im.And(x.ToBits()).BitsToFloat32()
}

// IfElse returns x but with elements set to y where mask is false.
func (x Float32x4) IfElse(mask Mask32x4, y Float32x4) Float32x4 {
	im := mask.ToInt32x4().ToBits()
	ix := x.ToBits()
	iy := y.ToBits()
	return ix.BitSelect(iy, im).BitsToFloat32()
}

// Masked returns x but with elements zeroed where mask is false.
func (x Float64x2) Masked(mask Mask64x2) Float64x2 {
	im := mask.ToInt64x2().ToBits()
	return im.And(x.ToBits()).BitsToFloat64()
}

// IfElse returns x but with elements set to y where mask is false.
func (x Float64x2) IfElse(mask Mask64x2, y Float64x2) Float64x2 {
	im := mask.ToInt64x2().ToBits()
	ix := x.ToBits()
	iy := y.ToBits()
	return ix.BitSelect(iy, im).BitsToFloat64()
}

// String returns a string representation of SIMD vector x.
func (x Int8x16) String() string {
	var s [16]int8
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Int16x8) String() string {
	var s [8]int16
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Int32x4) String() string {
	var s [4]int32
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Int64x2) String() string {
	var s [2]int64
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Uint8x16) String() string {
	var s [16]uint8
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Uint16x8) String() string {
	var s [8]uint16
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Uint32x4) String() string {
	var s [4]uint32
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Uint64x2) String() string {
	var s [2]uint64
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Float32x4) String() string {
	var s [4]float32
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD vector x.
func (x Float64x2) String() string {
	var s [2]float64
	x.StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD mask x.
func (x Mask8x16) String() string {
	var s [16]int8
	x.ToInt8x16().Neg().StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD mask x.
func (x Mask16x8) String() string {
	var s [8]int16
	x.ToInt16x8().Neg().StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD mask x.
func (x Mask32x4) String() string {
	var s [4]int32
	x.ToInt32x4().Neg().StoreArray(&s)
	return sliceToString(s[:])
}

// String returns a string representation of SIMD mask x.
func (x Mask64x2) String() string {
	var s [2]int64
	x.ToInt64x2().Neg().StoreArray(&s)
	return sliceToString(s[:])
}

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

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

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

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

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

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

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

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

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

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