@ttsc/win32-arm64 0.33.0 → 0.34.0

package/bin/go/src/simd/internal/bridge/simd_emulated.go

@@ -0,0 +1,3275 @@
+// Copyright 2026 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build goexperiment.simd && (amd64 || wasm || arm64)
+
+package bridge
+
+import (
+	"internal/strconv"
+	"math"
+	"math/bits"
+)
+
+// VectorSize returns the bit length of the emulated vector (fixed to 128).
+func VectorBitSize() int {
+	return 128
+}
+
+// Emulated returns whether simd is emulated.
+func Emulated() bool {
+	return true
+}
+
+// HasHardwareCarrylessMultiply returns whether this platform
+// has a hardware-implemented version of carryless multiply.
+// With default GODEBUG=simd settings, if this is false,
+// it is emulated and merely slow, but with non-default settings
+// this can indicate the possibility of a missing instruction
+// that will fail ("SIGILL") if it is executed.
+func HasHardwareCarrylessMultiply() bool {
+	return false
+}
+
+type number interface {
+	~int8 | ~int16 | ~int32 | ~int64 | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~float32 | ~float64
+}
+
+func sliceToString[T number](x []T) string {
+	s := ""
+	pfx := "{"
+	for _, y := range x {
+		s += pfx
+		pfx = ","
+		switch e := any(y).(type) {
+		case int8:
+			s += strconv.Itoa(int(e))
+		case int16:
+			s += strconv.Itoa(int(e))
+		case int32:
+			s += strconv.Itoa(int(e))
+		case int64:
+			s += strconv.FormatInt(int64(e), 10)
+		case uint8:
+			s += strconv.FormatUint(uint64(e), 10)
+		case uint16:
+			s += strconv.FormatUint(uint64(e), 10)
+		case uint32:
+			s += strconv.FormatUint(uint64(e), 10)
+		case uint64:
+			s += strconv.FormatUint(uint64(e), 10)
+		case float32:
+			s += strconv.FormatFloat(float64(e), 'g', -1, 32)
+		case float64:
+			s += strconv.FormatFloat(e, 'g', -1, 64)
+		}
+	}
+	s += "}"
+	return s
+}
+
+// LoadInt8s loads a slice of int8 into an Int8s vector.
+func LoadInt8s(s []int8) Int8s {
+	var a, b uint64
+	for i := 0; i < 16; i++ {
+		val := uint64(uint8(s[i]))
+		if i < 8 {
+			a |= val << (8 * i)
+		} else {
+			b |= val << (8 * (i - 8))
+		}
+	}
+	return Int8s{a: a, b: b}
+}
+
+// LoadInt8sPart loads a partial slice of int8 into an Int8s vector.
+func LoadInt8sPart(s []int8) (Int8s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 16 {
+		n = 16
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(uint8(s[i]))
+		if i < 8 {
+			a |= val << (8 * i)
+		} else {
+			b |= val << (8 * (i - 8))
+		}
+	}
+	return Int8s{a: a, b: b}, n
+}
+
+func (x Int8s) get(i int) int8 {
+	if i < 8 {
+		return int8(x.a >> (8 * i))
+	}
+	return int8(x.b >> (8 * (i - 8)))
+}
+
+func (x *Int8s) set(i int, v int8) {
+	val := uint64(uint8(v))
+	if i < 8 {
+		mask := uint64(0xff) << (8 * i)
+		x.a = (x.a &^ mask) | (val << (8 * i))
+	} else {
+		mask := uint64(0xff) << (8 * (i - 8))
+		x.b = (x.b &^ mask) | (val << (8 * (i - 8)))
+	}
+}
+
+// Abs returns the element-wise absolute value of x.
+func (x Int8s) Abs() Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		v := x.get(i)
+		if v < 0 {
+			res.set(i, -v)
+		} else {
+			res.set(i, v)
+		}
+	}
+	return res
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Int8s) Add(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		res.set(i, x.get(i)+y.get(i))
+	}
+	return res
+}
+
+// AddSaturated returns the element-wise saturated sum of x and y.
+func (x Int8s) AddSaturated(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		sum := int(x.get(i)) + int(y.get(i))
+		if sum > math.MaxInt8 {
+			res.set(i, math.MaxInt8)
+		} else if sum < math.MinInt8 {
+			res.set(i, math.MinInt8)
+		} else {
+			res.set(i, int8(sum))
+		}
+	}
+	return res
+}
+
+// And returns the bitwise AND of x and y.
+func (x Int8s) And(y Int8s) Int8s {
+	return Int8s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Int8s) AndNot(y Int8s) Int8s {
+	return Int8s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Int8s) Equal(y Int8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Int8s) Greater(y Int8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Int8s) GreaterEqual(y Int8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Int8s) Less(y Int8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Int8s) LessEqual(y Int8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Int8s) NotEqual(y Int8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Int8s) Len() int {
+	return 16
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Int8s) Masked(mask Mask8s) Int8s {
+	return Int8s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Int8s) Max(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Int8s) Mul(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		res.set(i, x.get(i)*y.get(i))
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Int8s) IfElse(mask Mask8s, y Int8s) Int8s {
+	return Int8s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Int8s) Min(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Neg returns the element-wise negation of x.
+func (x Int8s) Neg() Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		res.set(i, -x.get(i))
+	}
+	return res
+}
+
+// Not returns the bitwise NOT of x.
+func (x Int8s) Not() Int8s {
+	return Int8s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Int8s) Or(y Int8s) Int8s {
+	return Int8s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// Store stores the vector elements into the slice s.
+func (x Int8s) Store(s []int8) {
+	for i := 0; i < 16 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Int8s) StorePart(s []int8) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Int8s) String() string {
+	var parts [16]int8
+	for i := 0; i < 16; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Int8s) Sub(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// SubSaturated returns the element-wise saturated difference of x and y.
+func (x Int8s) SubSaturated(y Int8s) Int8s {
+	var res Int8s
+	for i := 0; i < 16; i++ {
+		diff := int(x.get(i)) - int(y.get(i))
+		if diff > math.MaxInt8 {
+			res.set(i, math.MaxInt8)
+		} else if diff < math.MinInt8 {
+			res.set(i, math.MinInt8)
+		} else {
+			res.set(i, int8(diff))
+		}
+	}
+	return res
+}
+
+// ToMask returns a mask representation of the vector.
+func (x Int8s) ToMask() Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) != 0 {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Int8s) Xor(y Int8s) Int8s {
+	return Int8s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// ConvertToUint8 converts the vector elements to uint8.
+func (x Int8s) ConvertToUint8() Uint8s {
+	return Uint8s{a: x.a, b: x.b}
+}
+
+// ToBits reinterprets the vector bits as a Uint8s vector.
+func (x Int8s) ToBits() Uint8s {
+	return Uint8s{a: x.a, b: x.b}
+}
+
+// LoadInt16s loads a slice of int16 into an Int16s vector.
+func LoadInt16s(s []int16) Int16s {
+	var a, b uint64
+	for i := 0; i < 8; i++ {
+		val := uint64(uint16(s[i]))
+		if i < 4 {
+			a |= val << (16 * i)
+		} else {
+			b |= val << (16 * (i - 4))
+		}
+	}
+	return Int16s{a: a, b: b}
+}
+
+// LoadInt16sPart loads a partial slice of int16 into an Int16s vector.
+func LoadInt16sPart(s []int16) (Int16s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 8 {
+		n = 8
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(uint16(s[i]))
+		if i < 4 {
+			a |= val << (16 * i)
+		} else {
+			b |= val << (16 * (i - 4))
+		}
+	}
+	return Int16s{a: a, b: b}, n
+}
+
+func (x Int16s) get(i int) int16 {
+	if i < 4 {
+		return int16(x.a >> (16 * i))
+	}
+	return int16(x.b >> (16 * (i - 4)))
+}
+
+func (x *Int16s) set(i int, v int16) {
+	val := uint64(uint16(v))
+	if i < 4 {
+		mask := uint64(0xffff) << (16 * i)
+		x.a = (x.a &^ mask) | (val << (16 * i))
+	} else {
+		mask := uint64(0xffff) << (16 * (i - 4))
+		x.b = (x.b &^ mask) | (val << (16 * (i - 4)))
+	}
+}
+
+// Abs returns the element-wise absolute value of x.
+func (x Int16s) Abs() Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		v := x.get(i)
+		if v < 0 {
+			res.set(i, -v)
+		} else {
+			res.set(i, v)
+		}
+	}
+	return res
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Int16s) Add(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)+y.get(i))
+	}
+	return res
+}
+
+// AddSaturated returns the element-wise saturated sum of x and y.
+func (x Int16s) AddSaturated(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		sum := int(x.get(i)) + int(y.get(i))
+		if sum > math.MaxInt16 {
+			res.set(i, math.MaxInt16)
+		} else if sum < math.MinInt16 {
+			res.set(i, math.MinInt16)
+		} else {
+			res.set(i, int16(sum))
+		}
+	}
+	return res
+}
+
+// And returns the bitwise AND of x and y.
+func (x Int16s) And(y Int16s) Int16s {
+	return Int16s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Int16s) AndNot(y Int16s) Int16s {
+	return Int16s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Int16s) Equal(y Int16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Int16s) Greater(y Int16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Int16s) GreaterEqual(y Int16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Int16s) Less(y Int16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Int16s) LessEqual(y Int16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Int16s) NotEqual(y Int16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Int16s) Len() int {
+	return 8
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Int16s) Masked(mask Mask16s) Int16s {
+	return Int16s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Int16s) Max(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Int16s) IfElse(mask Mask16s, y Int16s) Int16s {
+	return Int16s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Int16s) Min(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Int16s) Mul(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)*y.get(i))
+	}
+	return res
+}
+
+// Neg returns the element-wise negation of x.
+func (x Int16s) Neg() Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		res.set(i, -x.get(i))
+	}
+	return res
+}
+
+// Not returns the bitwise NOT of x.
+func (x Int16s) Not() Int16s {
+	return Int16s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Int16s) Or(y Int16s) Int16s {
+	return Int16s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// ShiftAllLeft shifts all elements left by y bits.
+func (x Int16s) ShiftAllLeft(y uint64) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)<<y)
+	}
+	return res
+}
+
+// ShiftAllRight shifts all elements right by y bits.
+func (x Int16s) ShiftAllRight(y uint64) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)>>y)
+	}
+	return res
+}
+
+// RotateAllLeft rotates all elements left by dist bits.
+func (x Int16s) RotateAllLeft(dist uint64) Int16s {
+	var res Int16s
+	d := dist & 15
+	for i := 0; i < 8; i++ {
+		u := uint16(x.get(i))
+		r := (u << d) | (u >> ((16 - d) & 15))
+		res.set(i, int16(r))
+	}
+	return res
+}
+
+// RotateAllRight rotates all elements right by dist bits.
+func (x Int16s) RotateAllRight(dist uint64) Int16s {
+	var res Int16s
+	d := dist & 15
+	for i := 0; i < 8; i++ {
+		u := uint16(x.get(i))
+		r := (u >> d) | (u << ((16 - d) & 15))
+		res.set(i, int16(r))
+	}
+	return res
+}
+
+// Store stores the vector elements into the slice s.
+func (x Int16s) Store(s []int16) {
+	for i := 0; i < 8 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Int16s) StorePart(s []int16) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Int16s) String() string {
+	var parts [8]int16
+	for i := 0; i < 8; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Int16s) Sub(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// SubSaturated returns the element-wise saturated difference of x and y.
+func (x Int16s) SubSaturated(y Int16s) Int16s {
+	var res Int16s
+	for i := 0; i < 8; i++ {
+		diff := int(x.get(i)) - int(y.get(i))
+		if diff > math.MaxInt16 {
+			res.set(i, math.MaxInt16)
+		} else if diff < math.MinInt16 {
+			res.set(i, math.MinInt16)
+		} else {
+			res.set(i, int16(diff))
+		}
+	}
+	return res
+}
+
+// ToMask returns a mask representation of the vector.
+func (x Int16s) ToMask() Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) != 0 {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Int16s) Xor(y Int16s) Int16s {
+	return Int16s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// ConvertToUint16 converts the vector elements to uint16.
+func (x Int16s) ConvertToUint16() Uint16s {
+	return Uint16s{a: x.a, b: x.b}
+}
+
+// ToBits reinterprets the vector bits as a Uint16s vector.
+func (x Int16s) ToBits() Uint16s {
+	return Uint16s{a: x.a, b: x.b}
+}
+
+// LoadInt32s loads a slice of int32 into an Int32s vector.
+func LoadInt32s(s []int32) Int32s {
+	var a, b uint64
+	for i := 0; i < 4; i++ {
+		val := uint64(uint32(s[i]))
+		if i < 2 {
+			a |= val << (32 * i)
+		} else {
+			b |= val << (32 * (i - 2))
+		}
+	}
+	return Int32s{a: a, b: b}
+}
+
+// LoadInt32sPart loads a partial slice of int32 into an Int32s vector.
+func LoadInt32sPart(s []int32) (Int32s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 4 {
+		n = 4
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(uint32(s[i]))
+		if i < 2 {
+			a |= val << (32 * i)
+		} else {
+			b |= val << (32 * (i - 2))
+		}
+	}
+	return Int32s{a: a, b: b}, n
+}
+
+func (x Int32s) get(i int) int32 {
+	if i < 2 {
+		return int32(x.a >> (32 * i))
+	}
+	return int32(x.b >> (32 * (i - 2)))
+}
+
+func (x *Int32s) set(i int, v int32) {
+	val := uint64(uint32(v))
+	if i < 2 {
+		mask := uint64(0xffffffff) << (32 * i)
+		x.a = (x.a &^ mask) | (val << (32 * i))
+	} else {
+		mask := uint64(0xffffffff) << (32 * (i - 2))
+		x.b = (x.b &^ mask) | (val << (32 * (i - 2)))
+	}
+}
+
+// Abs returns the element-wise absolute value of x.
+func (x Int32s) Abs() Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		v := x.get(i)
+		if v < 0 {
+			res.set(i, -v)
+		} else {
+			res.set(i, v)
+		}
+	}
+	return res
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Int32s) Add(y Int32s) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)+y.get(i))
+	}
+	return res
+}
+
+// And returns the bitwise AND of x and y.
+func (x Int32s) And(y Int32s) Int32s {
+	return Int32s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Int32s) AndNot(y Int32s) Int32s {
+	return Int32s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// ConvertToFloat32 converts the vector elements to float32.
+func (x Int32s) ConvertToFloat32() Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		res.set(i, float32(x.get(i)))
+	}
+	return res
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Int32s) Equal(y Int32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Int32s) Greater(y Int32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Int32s) GreaterEqual(y Int32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Int32s) Less(y Int32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Int32s) LessEqual(y Int32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Int32s) NotEqual(y Int32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Int32s) Len() int {
+	return 4
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Int32s) Masked(mask Mask32s) Int32s {
+	return Int32s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Int32s) Max(y Int32s) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Int32s) IfElse(mask Mask32s, y Int32s) Int32s {
+	return Int32s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Int32s) Min(y Int32s) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Int32s) Mul(y Int32s) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)*y.get(i))
+	}
+	return res
+}
+
+// Neg returns the element-wise negation of x.
+func (x Int32s) Neg() Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, -x.get(i))
+	}
+	return res
+}
+
+// Not returns the bitwise NOT of x.
+func (x Int32s) Not() Int32s {
+	return Int32s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Int32s) Or(y Int32s) Int32s {
+	return Int32s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// ShiftAllLeft shifts all elements left by y bits.
+func (x Int32s) ShiftAllLeft(y uint64) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)<<y)
+	}
+	return res
+}
+
+// ShiftAllRight shifts all elements right by y bits.
+func (x Int32s) ShiftAllRight(y uint64) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)>>y)
+	}
+	return res
+}
+
+// RotateAllLeft rotates all elements left by dist bits.
+func (x Int32s) RotateAllLeft(dist uint64) Int32s {
+	var res Int32s
+	d := dist & 31
+	for i := 0; i < 4; i++ {
+		u := uint32(x.get(i))
+		r := (u << d) | (u >> ((32 - d) & 31))
+		res.set(i, int32(r))
+	}
+	return res
+}
+
+// RotateAllRight rotates all elements right by dist bits.
+func (x Int32s) RotateAllRight(dist uint64) Int32s {
+	var res Int32s
+	d := dist & 31
+	for i := 0; i < 4; i++ {
+		u := uint32(x.get(i))
+		r := (u >> d) | (u << ((32 - d) & 31))
+		res.set(i, int32(r))
+	}
+	return res
+}
+
+// Store stores the vector elements into the slice s.
+func (x Int32s) Store(s []int32) {
+	for i := 0; i < 4 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Int32s) StorePart(s []int32) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Int32s) String() string {
+	var parts [4]int32
+	for i := 0; i < 4; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Int32s) Sub(y Int32s) Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// ToMask returns a mask representation of the vector.
+func (x Int32s) ToMask() Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) != 0 {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Int32s) Xor(y Int32s) Int32s {
+	return Int32s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// ConvertToUint32 converts the vector elements to uint32.
+func (x Int32s) ConvertToUint32() Uint32s {
+	return Uint32s{a: x.a, b: x.b}
+}
+
+// ToBits reinterprets the vector bits as a Uint32s vector.
+func (x Int32s) ToBits() Uint32s {
+	return Uint32s{a: x.a, b: x.b}
+}
+
+// LoadInt64s loads a slice of int64 into an Int64s vector.
+func LoadInt64s(s []int64) Int64s {
+	var a, b uint64
+	a = uint64(s[0])
+	b = uint64(s[1])
+	return Int64s{a: a, b: b}
+}
+
+// LoadInt64sPart loads a partial slice of int64 into an Int64s vector.
+func LoadInt64sPart(s []int64) (Int64s, int) {
+	var a, b uint64
+	if len(s) > 0 {
+		a = uint64(s[0])
+	}
+	if len(s) > 1 {
+		b = uint64(s[1])
+	}
+	return Int64s{a: a, b: b}, len(s)
+}
+
+func (x Int64s) get(i int) int64 {
+	if i == 0 {
+		return int64(x.a)
+	}
+	return int64(x.b)
+}
+
+func (x *Int64s) set(i int, v int64) {
+	if i == 0 {
+		x.a = uint64(v)
+	} else {
+		x.b = uint64(v)
+	}
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Int64s) Add(y Int64s) Int64s {
+	return Int64s{a: x.a + y.a, b: x.b + y.b}
+}
+
+// And returns the bitwise AND of x and y.
+func (x Int64s) And(y Int64s) Int64s {
+	return Int64s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Int64s) AndNot(y Int64s) Int64s {
+	return Int64s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Int64s) Equal(y Int64s) Mask64s {
+	var res Mask64s
+	if x.a == y.a {
+		res.a = ^uint64(0)
+	}
+	if x.b == y.b {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Int64s) Greater(y Int64s) Mask64s {
+	var res Mask64s
+	if int64(x.a) > int64(y.a) {
+		res.a = ^uint64(0)
+	}
+	if int64(x.b) > int64(y.b) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Int64s) GreaterEqual(y Int64s) Mask64s {
+	var res Mask64s
+	if int64(x.a) >= int64(y.a) {
+		res.a = ^uint64(0)
+	}
+	if int64(x.b) >= int64(y.b) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Int64s) Less(y Int64s) Mask64s {
+	var res Mask64s
+	if int64(x.a) < int64(y.a) {
+		res.a = ^uint64(0)
+	}
+	if int64(x.b) < int64(y.b) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Int64s) LessEqual(y Int64s) Mask64s {
+	var res Mask64s
+	if int64(x.a) <= int64(y.a) {
+		res.a = ^uint64(0)
+	}
+	if int64(x.b) <= int64(y.b) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Int64s) NotEqual(y Int64s) Mask64s {
+	var res Mask64s
+	if x.a != y.a {
+		res.a = ^uint64(0)
+	}
+	if x.b != y.b {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Int64s) Len() int {
+	return 2
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Int64s) Masked(mask Mask64s) Int64s {
+	return Int64s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Int64s) IfElse(mask Mask64s, y Int64s) Int64s {
+	return Int64s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Neg returns the element-wise negation of x.
+func (x Int64s) Neg() Int64s {
+	return Int64s{a: uint64(-int64(x.a)), b: uint64(-int64(x.b))}
+}
+
+// Not returns the bitwise NOT of x.
+func (x Int64s) Not() Int64s {
+	return Int64s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Int64s) Or(y Int64s) Int64s {
+	return Int64s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// ShiftAllLeft shifts all elements left by y bits.
+func (x Int64s) ShiftAllLeft(y uint64) Int64s {
+	return Int64s{a: x.a << y, b: x.b << y}
+}
+
+// RotateAllLeft rotates all elements left by dist bits.
+func (x Int64s) RotateAllLeft(dist uint64) Int64s {
+	d := dist & 63
+	return Int64s{
+		a: (x.a << d) | (x.a >> ((64 - d) & 63)),
+		b: (x.b << d) | (x.b >> ((64 - d) & 63)),
+	}
+}
+
+// RotateAllRight rotates all elements right by dist bits.
+func (x Int64s) RotateAllRight(dist uint64) Int64s {
+	d := dist & 63
+	return Int64s{
+		a: (x.a >> d) | (x.a << ((64 - d) & 63)),
+		b: (x.b >> d) | (x.b << ((64 - d) & 63)),
+	}
+}
+
+// Store stores the vector elements into the slice s.
+func (x Int64s) Store(s []int64) {
+	if len(s) > 0 {
+		s[0] = int64(x.a)
+	}
+	if len(s) > 1 {
+		s[1] = int64(x.b)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Int64s) StorePart(s []int64) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Int64s) String() string {
+	return sliceToString([]int64{int64(x.a), int64(x.b)})
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Int64s) Sub(y Int64s) Int64s {
+	return Int64s{a: x.a - y.a, b: x.b - y.b}
+}
+
+// ToMask returns a mask representation of the vector.
+func (x Int64s) ToMask() Mask64s {
+	var res Mask64s
+	if x.a != 0 {
+		res.a = ^uint64(0)
+	}
+	if x.b != 0 {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Int64s) Xor(y Int64s) Int64s {
+	return Int64s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// ConvertToUint64 converts the vector elements to uint64.
+func (x Int64s) ConvertToUint64() Uint64s {
+	return Uint64s{a: x.a, b: x.b}
+}
+
+// ToBits reinterprets the vector bits as a Uint64s vector.
+func (x Int64s) ToBits() Uint64s {
+	return Uint64s{a: x.a, b: x.b}
+}
+
+// LoadUint8s loads a slice of uint8 into an Uint8s vector.
+func LoadUint8s(s []uint8) Uint8s {
+	var a, b uint64
+	for i := 0; i < 16; i++ {
+		val := uint64(s[i])
+		if i < 8 {
+			a |= val << (8 * i)
+		} else {
+			b |= val << (8 * (i - 8))
+		}
+	}
+	return Uint8s{a: a, b: b}
+}
+
+// LoadUint8sPart loads a partial slice of uint8 into an Uint8s vector.
+func LoadUint8sPart(s []uint8) (Uint8s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 16 {
+		n = 16
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(s[i])
+		if i < 8 {
+			a |= val << (8 * i)
+		} else {
+			b |= val << (8 * (i - 8))
+		}
+	}
+	return Uint8s{a: a, b: b}, n
+}
+
+func (x Uint8s) get(i int) uint8 {
+	if i < 8 {
+		return uint8(x.a >> (8 * i))
+	}
+	return uint8(x.b >> (8 * (i - 8)))
+}
+
+func (x *Uint8s) set(i int, v uint8) {
+	val := uint64(v)
+	if i < 8 {
+		mask := uint64(0xff) << (8 * i)
+		x.a = (x.a &^ mask) | (val << (8 * i))
+	} else {
+		mask := uint64(0xff) << (8 * (i - 8))
+		x.b = (x.b &^ mask) | (val << (8 * (i - 8)))
+	}
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Uint8s) Add(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		res.set(i, x.get(i)+y.get(i))
+	}
+	return res
+}
+
+// AddSaturated returns the element-wise saturated sum of x and y.
+func (x Uint8s) AddSaturated(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		sum := int(x.get(i)) + int(y.get(i))
+		if sum > math.MaxUint8 {
+			res.set(i, math.MaxUint8)
+		} else {
+			res.set(i, uint8(sum))
+		}
+	}
+	return res
+}
+
+// And returns the bitwise AND of x and y.
+func (x Uint8s) And(y Uint8s) Uint8s {
+	return Uint8s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Uint8s) AndNot(y Uint8s) Uint8s {
+	return Uint8s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Average returns the element-wise average of x and y.
+func (x Uint8s) Average(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		res.set(i, uint8((int(x.get(i))+int(y.get(i))+1)>>1))
+	}
+	return res
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Uint8s) Equal(y Uint8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Uint8s) NotEqual(y Uint8s) Mask8s {
+	var res Mask8s
+	for i := 0; i < 16; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Uint8s) Len() int {
+	return 16
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Uint8s) Masked(mask Mask8s) Uint8s {
+	return Uint8s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Uint8s) Max(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Uint8s) IfElse(mask Mask8s, y Uint8s) Uint8s {
+	return Uint8s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Uint8s) Min(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Uint8s) Mul(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		res.set(i, x.get(i)*y.get(i))
+	}
+	return res
+}
+
+// Not returns the bitwise NOT of x.
+func (x Uint8s) Not() Uint8s {
+	return Uint8s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Uint8s) Or(y Uint8s) Uint8s {
+	return Uint8s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// Store stores the vector elements into the slice s.
+func (x Uint8s) Store(s []uint8) {
+	for i := 0; i < 16 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Uint8s) StorePart(s []uint8) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Uint8s) String() string {
+	var parts [16]uint8
+	for i := 0; i < 16; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Uint8s) Sub(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// SubSaturated returns the element-wise saturated difference of x and y.
+func (x Uint8s) SubSaturated(y Uint8s) Uint8s {
+	var res Uint8s
+	for i := 0; i < 16; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, 0)
+		} else {
+			res.set(i, vx-vy)
+		}
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Uint8s) Xor(y Uint8s) Uint8s {
+	return Uint8s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// BitsToInt8 reinterprets the vector bits as an Int8s vector.
+func (x Uint8s) BitsToInt8() Int8s {
+	return Int8s{a: x.a, b: x.b}
+}
+
+// ConvertToInt8 converts the vector elements to int8.
+func (x Uint8s) ConvertToInt8() Int8s {
+	return Int8s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint16s reinterprets the vector bits as a Uint16s vector.
+func (x Uint8s) ReshapeToUint16s() Uint16s {
+	return Uint16s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint32s reinterprets the vector bits as a Uint32s vector.
+func (x Uint8s) ReshapeToUint32s() Uint32s {
+	return Uint32s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint64s reinterprets the vector bits as a Uint64s vector.
+func (x Uint8s) ReshapeToUint64s() Uint64s {
+	return Uint64s{a: x.a, b: x.b}
+}
+
+// LoadUint16s loads a slice of uint16 into an Uint16s vector.
+func LoadUint16s(s []uint16) Uint16s {
+	var a, b uint64
+	for i := 0; i < 8; i++ {
+		val := uint64(s[i])
+		if i < 4 {
+			a |= val << (16 * i)
+		} else {
+			b |= val << (16 * (i - 4))
+		}
+	}
+	return Uint16s{a: a, b: b}
+}
+
+// LoadUint16sPart loads a partial slice of uint16 into an Uint16s vector.
+func LoadUint16sPart(s []uint16) (Uint16s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 8 {
+		n = 8
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(s[i])
+		if i < 4 {
+			a |= val << (16 * i)
+		} else {
+			b |= val << (16 * (i - 4))
+		}
+	}
+	return Uint16s{a: a, b: b}, n
+}
+
+func (x Uint16s) get(i int) uint16 {
+	if i < 4 {
+		return uint16(x.a >> (16 * i))
+	}
+	return uint16(x.b >> (16 * (i - 4)))
+}
+
+func (x *Uint16s) set(i int, v uint16) {
+	val := uint64(v)
+	if i < 4 {
+		mask := uint64(0xffff) << (16 * i)
+		x.a = (x.a &^ mask) | (val << (16 * i))
+	} else {
+		mask := uint64(0xffff) << (16 * (i - 4))
+		x.b = (x.b &^ mask) | (val << (16 * (i - 4)))
+	}
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Uint16s) Add(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)+y.get(i))
+	}
+	return res
+}
+
+// AddSaturated returns the element-wise saturated sum of x and y.
+func (x Uint16s) AddSaturated(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		sum := int(x.get(i)) + int(y.get(i))
+		if sum > math.MaxUint16 {
+			res.set(i, math.MaxUint16)
+		} else {
+			res.set(i, uint16(sum))
+		}
+	}
+	return res
+}
+
+// And returns the bitwise AND of x and y.
+func (x Uint16s) And(y Uint16s) Uint16s {
+	return Uint16s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Uint16s) AndNot(y Uint16s) Uint16s {
+	return Uint16s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Average returns the element-wise average of x and y.
+func (x Uint16s) Average(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		res.set(i, uint16((int(x.get(i))+int(y.get(i))+1)>>1))
+	}
+	return res
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Uint16s) Equal(y Uint16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Uint16s) Greater(y Uint16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Uint16s) GreaterEqual(y Uint16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Uint16s) Less(y Uint16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Uint16s) LessEqual(y Uint16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Uint16s) NotEqual(y Uint16s) Mask16s {
+	var res Mask16s
+	for i := 0; i < 8; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Uint16s) Len() int {
+	return 8
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Uint16s) Masked(mask Mask16s) Uint16s {
+	return Uint16s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Uint16s) Max(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Uint16s) IfElse(mask Mask16s, y Uint16s) Uint16s {
+	return Uint16s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Uint16s) Min(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Uint16s) Mul(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)*y.get(i))
+	}
+	return res
+}
+
+// Not returns the bitwise NOT of x.
+func (x Uint16s) Not() Uint16s {
+	return Uint16s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Uint16s) Or(y Uint16s) Uint16s {
+	return Uint16s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// ShiftAllLeft shifts all elements left by y bits.
+func (x Uint16s) ShiftAllLeft(y uint64) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)<<y)
+	}
+	return res
+}
+
+// ShiftAllRight shifts all elements right by y bits.
+func (x Uint16s) ShiftAllRight(y uint64) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)>>y)
+	}
+	return res
+}
+
+// RotateAllLeft rotates all elements left by dist bits.
+func (x Uint16s) RotateAllLeft(dist uint64) Uint16s {
+	var res Uint16s
+	d := dist & 15
+	for i := 0; i < 8; i++ {
+		u := x.get(i)
+		r := (u << d) | (u >> ((16 - d) & 15))
+		res.set(i, r)
+	}
+	return res
+}
+
+// RotateAllRight rotates all elements right by dist bits.
+func (x Uint16s) RotateAllRight(dist uint64) Uint16s {
+	var res Uint16s
+	d := dist & 15
+	for i := 0; i < 8; i++ {
+		u := x.get(i)
+		r := (u >> d) | (u << ((16 - d) & 15))
+		res.set(i, r)
+	}
+	return res
+}
+
+// Store stores the vector elements into the slice s.
+func (x Uint16s) Store(s []uint16) {
+	for i := 0; i < 8 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Uint16s) StorePart(s []uint16) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Uint16s) String() string {
+	var parts [8]uint16
+	for i := 0; i < 8; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Uint16s) Sub(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// SubSaturated returns the element-wise saturated difference of x and y.
+func (x Uint16s) SubSaturated(y Uint16s) Uint16s {
+	var res Uint16s
+	for i := 0; i < 8; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, 0)
+		} else {
+			res.set(i, vx-vy)
+		}
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Uint16s) Xor(y Uint16s) Uint16s {
+	return Uint16s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// BitsToInt16 reinterprets the vector bits as an Int16s vector.
+func (x Uint16s) BitsToInt16() Int16s {
+	return Int16s{a: x.a, b: x.b}
+}
+
+// ConvertToInt16 converts the vector elements to int16.
+func (x Uint16s) ConvertToInt16() Int16s {
+	return Int16s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint32s reinterprets the vector bits as a Uint32s vector.
+func (x Uint16s) ReshapeToUint32s() Uint32s {
+	return Uint32s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint64s reinterprets the vector bits as a Uint64s vector.
+func (x Uint16s) ReshapeToUint64s() Uint64s {
+	return Uint64s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint8s reinterprets the vector bits as a Uint8s vector.
+func (x Uint16s) ReshapeToUint8s() Uint8s {
+	return Uint8s{a: x.a, b: x.b}
+}
+
+// LoadUint32s loads a slice of uint32 into an Uint32s vector.
+func LoadUint32s(s []uint32) Uint32s {
+	var a, b uint64
+	for i := 0; i < 4; i++ {
+		val := uint64(s[i])
+		if i < 2 {
+			a |= val << (32 * i)
+		} else {
+			b |= val << (32 * (i - 2))
+		}
+	}
+	return Uint32s{a: a, b: b}
+}
+
+// LoadUint32sPart loads a partial slice of uint32 into an Uint32s vector.
+func LoadUint32sPart(s []uint32) (Uint32s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 4 {
+		n = 4
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(s[i])
+		if i < 2 {
+			a |= val << (32 * i)
+		} else {
+			b |= val << (32 * (i - 2))
+		}
+	}
+	return Uint32s{a: a, b: b}, n
+}
+
+func (x Uint32s) get(i int) uint32 {
+	if i < 2 {
+		return uint32(x.a >> (32 * i))
+	}
+	return uint32(x.b >> (32 * (i - 2)))
+}
+
+func (x *Uint32s) set(i int, v uint32) {
+	val := uint64(v)
+	if i < 2 {
+		mask := uint64(0xffffffff) << (32 * i)
+		x.a = (x.a &^ mask) | (val << (32 * i))
+	} else {
+		mask := uint64(0xffffffff) << (32 * (i - 2))
+		x.b = (x.b &^ mask) | (val << (32 * (i - 2)))
+	}
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Uint32s) Add(y Uint32s) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)+y.get(i))
+	}
+	return res
+}
+
+// And returns the bitwise AND of x and y.
+func (x Uint32s) And(y Uint32s) Uint32s {
+	return Uint32s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Uint32s) AndNot(y Uint32s) Uint32s {
+	return Uint32s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Uint32s) Equal(y Uint32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Uint32s) Greater(y Uint32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Uint32s) GreaterEqual(y Uint32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Uint32s) Less(y Uint32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Uint32s) LessEqual(y Uint32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Uint32s) NotEqual(y Uint32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Uint32s) Len() int {
+	return 4
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Uint32s) Masked(mask Mask32s) Uint32s {
+	return Uint32s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Uint32s) Max(y Uint32s) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Uint32s) IfElse(mask Mask32s, y Uint32s) Uint32s {
+	return Uint32s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Uint32s) Min(y Uint32s) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Uint32s) Mul(y Uint32s) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)*y.get(i))
+	}
+	return res
+}
+
+// Not returns the bitwise NOT of x.
+func (x Uint32s) Not() Uint32s {
+	return Uint32s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Uint32s) Or(y Uint32s) Uint32s {
+	return Uint32s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// ShiftAllLeft shifts all elements left by y bits.
+func (x Uint32s) ShiftAllLeft(y uint64) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)<<y)
+	}
+	return res
+}
+
+// ShiftAllRight shifts all elements right by y bits.
+func (x Uint32s) ShiftAllRight(y uint64) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)>>y)
+	}
+	return res
+}
+
+// RotateAllLeft rotates all elements left by dist bits.
+func (x Uint32s) RotateAllLeft(dist uint64) Uint32s {
+	var res Uint32s
+	d := dist & 31
+	for i := 0; i < 4; i++ {
+		u := x.get(i)
+		r := (u << d) | (u >> ((32 - d) & 31))
+		res.set(i, r)
+	}
+	return res
+}
+
+// RotateAllRight rotates all elements right by dist bits.
+func (x Uint32s) RotateAllRight(dist uint64) Uint32s {
+	var res Uint32s
+	d := dist & 31
+	for i := 0; i < 4; i++ {
+		u := x.get(i)
+		r := (u >> d) | (u << ((32 - d) & 31))
+		res.set(i, r)
+	}
+	return res
+}
+
+// Store stores the vector elements into the slice s.
+func (x Uint32s) Store(s []uint32) {
+	for i := 0; i < 4 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Uint32s) StorePart(s []uint32) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Uint32s) String() string {
+	var parts [4]uint32
+	for i := 0; i < 4; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Uint32s) Sub(y Uint32s) Uint32s {
+	var res Uint32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Uint32s) Xor(y Uint32s) Uint32s {
+	return Uint32s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// BitsToFloat32 reinterprets the vector bits as a Float32s vector.
+func (x Uint32s) BitsToFloat32() Float32s {
+	return Float32s{a: x.a, b: x.b}
+}
+
+// BitsToInt32 reinterprets the vector bits as an Int32s vector.
+func (x Uint32s) BitsToInt32() Int32s {
+	return Int32s{a: x.a, b: x.b}
+}
+
+// ConvertToInt32 converts the vector elements to int32.
+func (x Uint32s) ConvertToInt32() Int32s {
+	return Int32s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint16s reinterprets the vector bits as a Uint16s vector.
+func (x Uint32s) ReshapeToUint16s() Uint16s {
+	return Uint16s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint64s reinterprets the vector bits as a Uint64s vector.
+func (x Uint32s) ReshapeToUint64s() Uint64s {
+	return Uint64s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint8s reinterprets the vector bits as a Uint8s vector.
+func (x Uint32s) ReshapeToUint8s() Uint8s {
+	return Uint8s{a: x.a, b: x.b}
+}
+
+// LoadUint64s loads a slice of uint64 into an Uint64s vector.
+func LoadUint64s(s []uint64) Uint64s {
+	var a, b uint64
+	a = s[0]
+	b = s[1]
+	return Uint64s{a: a, b: b}
+}
+
+// LoadUint64sPart loads a partial slice of uint64 into an Uint64s vector.
+func LoadUint64sPart(s []uint64) (Uint64s, int) {
+	n := len(s)
+	var a, b uint64
+	if n > 0 {
+		a = s[0]
+	}
+	if n > 1 {
+		b = s[1]
+	}
+	return Uint64s{a: a, b: b}, n
+}
+
+func (x Uint64s) get(i int) uint64 {
+	if i == 0 {
+		return x.a
+	}
+	return x.b
+}
+
+func (x *Uint64s) set(i int, v uint64) {
+	if i == 0 {
+		x.a = v
+	} else {
+		x.b = v
+	}
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Uint64s) Add(y Uint64s) Uint64s {
+	return Uint64s{a: x.a + y.a, b: x.b + y.b}
+}
+
+// And returns the bitwise AND of x and y.
+func (x Uint64s) And(y Uint64s) Uint64s {
+	return Uint64s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// AndNot returns the bitwise AND NOT of x and y.
+func (x Uint64s) AndNot(y Uint64s) Uint64s {
+	return Uint64s{a: x.a &^ y.a, b: x.b &^ y.b}
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Uint64s) Equal(y Uint64s) Mask64s {
+	var res Mask64s
+	if x.a == y.a {
+		res.a = ^uint64(0)
+	}
+	if x.b == y.b {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Uint64s) Greater(y Uint64s) Mask64s {
+	var res Mask64s
+	for i := 0; i < 2; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Uint64s) GreaterEqual(y Uint64s) Mask64s {
+	var res Mask64s
+	for i := 0; i < 2; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Uint64s) Less(y Uint64s) Mask64s {
+	var res Mask64s
+	for i := 0; i < 2; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Uint64s) LessEqual(y Uint64s) Mask64s {
+	var res Mask64s
+	for i := 0; i < 2; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Uint64s) NotEqual(y Uint64s) Mask64s {
+	var res Mask64s
+	if x.a != y.a {
+		res.a = ^uint64(0)
+	}
+	if x.b != y.b {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Uint64s) Len() int {
+	return 2
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Uint64s) Masked(mask Mask64s) Uint64s {
+	return Uint64s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Uint64s) IfElse(mask Mask64s, y Uint64s) Uint64s {
+	return Uint64s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Not returns the bitwise NOT of x.
+func (x Uint64s) Not() Uint64s {
+	return Uint64s{a: ^x.a, b: ^x.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Uint64s) Or(y Uint64s) Uint64s {
+	return Uint64s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// ShiftAllLeft shifts all elements left by y bits.
+func (x Uint64s) ShiftAllLeft(y uint64) Uint64s {
+	return Uint64s{a: x.a << y, b: x.b << y}
+}
+
+// ShiftAllRight shifts all elements right by y bits.
+func (x Uint64s) ShiftAllRight(y uint64) Uint64s {
+	return Uint64s{a: x.a >> y, b: x.b >> y}
+}
+
+// RotateAllLeft rotates all elements left by dist bits.
+func (x Uint64s) RotateAllLeft(dist uint64) Uint64s {
+	d := dist & 63
+	return Uint64s{
+		a: (x.a << d) | (x.a >> ((64 - d) & 63)),
+		b: (x.b << d) | (x.b >> ((64 - d) & 63)),
+	}
+}
+
+// RotateAllRight rotates all elements right by dist bits.
+func (x Uint64s) RotateAllRight(dist uint64) Uint64s {
+	d := dist & 63
+	return Uint64s{
+		a: (x.a >> d) | (x.a << ((64 - d) & 63)),
+		b: (x.b >> d) | (x.b << ((64 - d) & 63)),
+	}
+}
+
+// Store stores the vector elements into the slice s.
+func (x Uint64s) Store(s []uint64) {
+	if len(s) > 0 {
+		s[0] = x.a
+	}
+	if len(s) > 1 {
+		s[1] = x.b
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Uint64s) StorePart(s []uint64) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Uint64s) String() string {
+	return sliceToString([]uint64{x.a, x.b})
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Uint64s) Sub(y Uint64s) Uint64s {
+	return Uint64s{a: x.a - y.a, b: x.b - y.b}
+}
+
+// Xor returns the bitwise XOR of x and y.
+func (x Uint64s) Xor(y Uint64s) Uint64s {
+	return Uint64s{a: x.a ^ y.a, b: x.b ^ y.b}
+}
+
+// BitsToFloat64 reinterprets the vector bits as a Float64s vector.
+func (x Uint64s) BitsToFloat64() Float64s {
+	return Float64s{a: x.a, b: x.b}
+}
+
+// BitsToInt64 reinterprets the vector bits as an Int64s vector.
+func (x Uint64s) BitsToInt64() Int64s {
+	return Int64s{a: x.a, b: x.b}
+}
+
+// ConvertToInt64 converts the vector elements to int64.
+func (x Uint64s) ConvertToInt64() Int64s {
+	return Int64s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint16s reinterprets the vector bits as a Uint16s vector.
+func (x Uint64s) ReshapeToUint16s() Uint16s {
+	return Uint16s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint32s reinterprets the vector bits as a Uint32s vector.
+func (x Uint64s) ReshapeToUint32s() Uint32s {
+	return Uint32s{a: x.a, b: x.b}
+}
+
+// ReshapeToUint8s reinterprets the vector bits as a Uint8s vector.
+func (x Uint64s) ReshapeToUint8s() Uint8s {
+	return Uint8s{a: x.a, b: x.b}
+}
+
+// LoadFloat32s loads a slice of float32 into an Float32s vector.
+func LoadFloat32s(s []float32) Float32s {
+	var a, b uint64
+	for i := 0; i < 4; i++ {
+		val := uint64(math.Float32bits(s[i]))
+		if i < 2 {
+			a |= val << (32 * i)
+		} else {
+			b |= val << (32 * (i - 2))
+		}
+	}
+	return Float32s{a: a, b: b}
+}
+
+// LoadFloat32sPart loads a partial slice of float32 into an Float32s vector.
+func LoadFloat32sPart(s []float32) (Float32s, int) {
+	var a, b uint64
+	n := len(s)
+	if n > 4 {
+		n = 4
+	}
+	for i := 0; i < n; i++ {
+		val := uint64(math.Float32bits(s[i]))
+		if i < 2 {
+			a |= val << (32 * i)
+		} else {
+			b |= val << (32 * (i - 2))
+		}
+	}
+	return Float32s{a: a, b: b}, n
+}
+
+func (x Float32s) get(i int) float32 {
+	if i < 2 {
+		return math.Float32frombits(uint32(x.a >> (32 * i)))
+	}
+	return math.Float32frombits(uint32(x.b >> (32 * (i - 2))))
+}
+
+func (x *Float32s) set(i int, v float32) {
+	val := uint64(math.Float32bits(v))
+	if i < 2 {
+		mask := uint64(0xffffffff) << (32 * i)
+		x.a = (x.a &^ mask) | (val << (32 * i))
+	} else {
+		mask := uint64(0xffffffff) << (32 * (i - 2))
+		x.b = (x.b &^ mask) | (val << (32 * (i - 2)))
+	}
+}
+
+// Abs returns the element-wise absolute value of x.
+func (x Float32s) Abs() Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		v := x.get(i)
+		if v < 0 {
+			res.set(i, -v)
+		} else {
+			res.set(i, v)
+		}
+	}
+	return res
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Float32s) Add(y Float32s) Float32s {
+	var res Float32s
+	res.set(0, x.get(0)+y.get(0))
+	res.set(1, x.get(1)+y.get(1))
+	res.set(2, x.get(2)+y.get(2))
+	res.set(3, x.get(3)+y.get(3))
+	return res
+}
+
+// ConvertToInt32 converts the vector elements to int32.
+func (x Float32s) ConvertToInt32() Int32s {
+	var res Int32s
+	for i := 0; i < 4; i++ {
+		res.set(i, int32(x.get(i)))
+	}
+	return res
+}
+
+// Div returns the element-wise quotient of x and y.
+func (x Float32s) Div(y Float32s) Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)/y.get(i))
+	}
+	return res
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Float32s) Equal(y Float32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) == y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Float32s) Greater(y Float32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) > y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Float32s) GreaterEqual(y Float32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) >= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Float32s) Len() int {
+	return 4
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Float32s) Less(y Float32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) < y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Float32s) LessEqual(y Float32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) <= y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Float32s) Masked(mask Mask32s) Float32s {
+	return Float32s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Float32s) Max(y Float32s) Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx > vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Float32s) IfElse(mask Mask32s, y Float32s) Float32s {
+	return Float32s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Float32s) Min(y Float32s) Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		vx := x.get(i)
+		vy := y.get(i)
+		if vx < vy {
+			res.set(i, vx)
+		} else {
+			res.set(i, vy)
+		}
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Float32s) Mul(y Float32s) Float32s {
+	var res Float32s
+	res.set(0, x.get(0)*y.get(0))
+	res.set(1, x.get(1)*y.get(1))
+	res.set(2, x.get(2)*y.get(2))
+	res.set(3, x.get(3)*y.get(3))
+	return res
+}
+
+// MulAdd returns x * y + z element-wise.
+func (x Float32s) MulAdd(y, z Float32s) Float32s {
+	var res Float32s
+
+	res.set(0, x.get(0)*y.get(0)+z.get(0))
+	res.set(1, x.get(1)*y.get(1)+z.get(1))
+	res.set(2, x.get(2)*y.get(2)+z.get(2))
+	res.set(3, x.get(3)*y.get(3)+z.get(3))
+	return res
+}
+
+// Neg returns the element-wise negation of x.
+func (x Float32s) Neg() Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		res.set(i, -(x.get(i)))
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Float32s) NotEqual(y Float32s) Mask32s {
+	var res Mask32s
+	for i := 0; i < 4; i++ {
+		if x.get(i) != y.get(i) {
+			res.set(i, true)
+		}
+	}
+	return res
+}
+
+// Sqrt returns the element-wise square root of x.
+func (x Float32s) Sqrt() Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		res.set(i, float32(math.Sqrt(float64(x.get(i)))))
+	}
+	return res
+}
+
+// Store stores the vector elements into the slice s.
+func (x Float32s) Store(s []float32) {
+	for i := 0; i < 4 && i < len(s); i++ {
+		s[i] = x.get(i)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Float32s) StorePart(s []float32) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Float32s) String() string {
+	var parts [4]float32
+	for i := 0; i < 4; i++ {
+		parts[i] = x.get(i)
+	}
+	return sliceToString(parts[:])
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Float32s) Sub(y Float32s) Float32s {
+	var res Float32s
+	for i := 0; i < 4; i++ {
+		res.set(i, x.get(i)-y.get(i))
+	}
+	return res
+}
+
+// ToBits reinterprets the vector bits as a Uint32s vector.
+func (x Float32s) ToBits() Uint32s {
+	return Uint32s{a: x.a, b: x.b}
+}
+
+// LoadFloat64s loads a slice of float64 into an Float64s vector.
+func LoadFloat64s(s []float64) Float64s {
+	var a, b uint64
+	a = math.Float64bits(s[0])
+	b = math.Float64bits(s[1])
+	return Float64s{a: a, b: b}
+}
+
+// LoadFloat64sPart loads a partial slice of float64 into an Float64s vector.
+func LoadFloat64sPart(s []float64) (Float64s, int) {
+	n := len(s)
+	var a, b uint64
+	if n > 0 {
+		a = math.Float64bits(s[0])
+	}
+	if n > 1 {
+		b = math.Float64bits(s[1])
+	}
+	return Float64s{a: a, b: b}, n
+}
+
+func (x Float64s) get(i int) float64 {
+	if i == 0 {
+		return math.Float64frombits(x.a)
+	}
+	return math.Float64frombits(x.b)
+}
+
+func (x *Float64s) set(i int, v float64) {
+	if i == 0 {
+		x.a = math.Float64bits(v)
+	} else {
+		x.b = math.Float64bits(v)
+	}
+}
+
+// Abs returns the element-wise absolute value of x.
+func (x Float64s) Abs() Float64s {
+	var res Float64s
+	for i := 0; i < 4; i++ {
+		v := x.get(i)
+		if v < 0 {
+			res.set(i, -v)
+		} else {
+			res.set(i, v)
+		}
+	}
+	return res
+}
+
+// Add returns the element-wise sum of x and y.
+func (x Float64s) Add(y Float64s) Float64s {
+	var res Float64s
+	res.set(0, x.get(0)+y.get(0))
+	res.set(1, x.get(1)+y.get(1))
+	return res
+}
+
+// Div returns the element-wise quotient of x and y.
+func (x Float64s) Div(y Float64s) Float64s {
+	var res Float64s
+	res.set(0, x.get(0)/y.get(0))
+	res.set(1, x.get(1)/y.get(1))
+	return res
+}
+
+// Equal returns a mask indicating where x and y are equal.
+func (x Float64s) Equal(y Float64s) Mask64s {
+	var res Mask64s
+	if x.get(0) == y.get(0) {
+		res.a = ^uint64(0)
+	}
+	if x.get(1) == y.get(1) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Greater returns a mask indicating where x is greater than y.
+func (x Float64s) Greater(y Float64s) Mask64s {
+	var res Mask64s
+	if x.get(0) > y.get(0) {
+		res.a = ^uint64(0)
+	}
+	if x.get(1) > y.get(1) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// GreaterEqual returns a mask indicating where x is greater than or equal to y.
+func (x Float64s) GreaterEqual(y Float64s) Mask64s {
+	var res Mask64s
+	if x.get(0) >= y.get(0) {
+		res.a = ^uint64(0)
+	}
+	if x.get(1) >= y.get(1) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Len returns the number of elements in the vector.
+func (x Float64s) Len() int {
+	return 2
+}
+
+// Less returns a mask indicating where x is less than y.
+func (x Float64s) Less(y Float64s) Mask64s {
+	var res Mask64s
+	if x.get(0) < y.get(0) {
+		res.a = ^uint64(0)
+	}
+	if x.get(1) < y.get(1) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// LessEqual returns a mask indicating where x is less than or equal to y.
+func (x Float64s) LessEqual(y Float64s) Mask64s {
+	var res Mask64s
+	if x.get(0) <= y.get(0) {
+		res.a = ^uint64(0)
+	}
+	if x.get(1) <= y.get(1) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Masked returns a new vector with elements from x where mask is true, and zero elsewhere.
+func (x Float64s) Masked(mask Mask64s) Float64s {
+	return Float64s{a: x.a & mask.a, b: x.b & mask.b}
+}
+
+// Max returns the element-wise maximum of x and y.
+func (x Float64s) Max(y Float64s) Float64s {
+	var res Float64s
+	vx := x.get(0)
+	vy := y.get(0)
+	if vx > vy {
+		res.set(0, vx)
+	} else {
+		res.set(0, vy)
+	}
+	vx = x.get(1)
+	vy = y.get(1)
+	if vx > vy {
+		res.set(1, vx)
+	} else {
+		res.set(1, vy)
+	}
+	return res
+}
+
+// IfElse returns a new vector with elements from x where mask is true, and y where mask is false.
+func (x Float64s) IfElse(mask Mask64s, y Float64s) Float64s {
+	return Float64s{
+		a: (x.a & mask.a) | (y.a &^ mask.a),
+		b: (x.b & mask.b) | (y.b &^ mask.b),
+	}
+}
+
+// Min returns the element-wise minimum of x and y.
+func (x Float64s) Min(y Float64s) Float64s {
+	var res Float64s
+	vx := x.get(0)
+	vy := y.get(0)
+	if vx < vy {
+		res.set(0, vx)
+	} else {
+		res.set(0, vy)
+	}
+	vx = x.get(1)
+	vy = y.get(1)
+	if vx < vy {
+		res.set(1, vx)
+	} else {
+		res.set(1, vy)
+	}
+	return res
+}
+
+// Mul returns the element-wise product of x and y.
+func (x Float64s) Mul(y Float64s) Float64s {
+	var res Float64s
+	res.set(0, x.get(0)*y.get(0))
+	res.set(1, x.get(1)*y.get(1))
+	return res
+}
+
+// MulAdd returns x * y + z element-wise.
+func (x Float64s) MulAdd(y, z Float64s) Float64s {
+	var res Float64s
+	res.set(0, x.get(0)*y.get(0)+z.get(0))
+	res.set(1, x.get(1)*y.get(1)+z.get(1))
+	return res
+}
+
+// Neg returns the element-wise negation of x.
+func (x Float64s) Neg() Float64s {
+	var res Float64s
+	for i := 0; i < 4; i++ {
+		res.set(i, -(x.get(i)))
+	}
+	return res
+}
+
+// NotEqual returns a mask indicating where x and y are not equal.
+func (x Float64s) NotEqual(y Float64s) Mask64s {
+	var res Mask64s
+	if x.get(0) != y.get(0) {
+		res.a = ^uint64(0)
+	}
+	if x.get(1) != y.get(1) {
+		res.b = ^uint64(0)
+	}
+	return res
+}
+
+// Sqrt returns the element-wise square root of x.
+func (x Float64s) Sqrt() Float64s {
+	var res Float64s
+	res.set(0, math.Sqrt(x.get(0)))
+	res.set(1, math.Sqrt(x.get(1)))
+	return res
+}
+
+// Store stores the vector elements into the slice s.
+func (x Float64s) Store(s []float64) {
+	if len(s) > 0 {
+		s[0] = x.get(0)
+	}
+	if len(s) > 1 {
+		s[1] = x.get(1)
+	}
+}
+
+// StorePart stores a partial vector into the slice s.
+func (x Float64s) StorePart(s []float64) int {
+	x.Store(s)
+	return min(len(s), x.Len())
+}
+
+// String returns a string representation of the vector.
+func (x Float64s) String() string {
+	return sliceToString([]float64{x.get(0), x.get(1)})
+}
+
+// Sub returns the element-wise difference of x and y.
+func (x Float64s) Sub(y Float64s) Float64s {
+	var res Float64s
+	res.set(0, x.get(0)-y.get(0))
+	res.set(1, x.get(1)-y.get(1))
+	return res
+}
+
+// ToBits reinterprets the vector bits as a Uint64s vector.
+func (x Float64s) ToBits() Uint64s {
+	return Uint64s{a: x.a, b: x.b}
+}
+
+func (x *Mask8s) set(i int, v bool) {
+	if v {
+		if i < 8 {
+			mask := uint64(0xff) << (8 * i)
+			x.a |= mask
+		} else {
+			mask := uint64(0xff) << (8 * (i - 8))
+			x.b |= mask
+		}
+	}
+}
+
+// And returns the bitwise AND of x and y.
+func (x Mask8s) And(y Mask8s) Mask8s {
+	return Mask8s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Mask8s) Or(y Mask8s) Mask8s {
+	return Mask8s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// String returns a string representation of the vector.
+func (x Mask8s) String() string {
+	var s [16]int8
+	x.ToInt8s().Neg().Store(s[:])
+	return sliceToString(s[:])
+}
+
+// ToInt8s converts the mask to an Int8s vector.
+func (x Mask8s) ToInt8s() Int8s {
+	return Int8s{a: x.a, b: x.b}
+}
+
+func (x *Mask16s) set(i int, v bool) {
+	if v {
+		if i < 4 {
+			mask := uint64(0xffff) << (16 * i)
+			x.a |= mask
+		} else {
+			mask := uint64(0xffff) << (16 * (i - 4))
+			x.b |= mask
+		}
+	}
+}
+
+// And returns the bitwise AND of x and y.
+func (x Mask16s) And(y Mask16s) Mask16s {
+	return Mask16s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Mask16s) Or(y Mask16s) Mask16s {
+	return Mask16s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// String returns a string representation of the vector.
+func (x Mask16s) String() string {
+	var s [8]int16
+	x.ToInt16s().Neg().Store(s[:])
+	return sliceToString(s[:])
+}
+
+// ToInt16s converts the mask to an Int16s vector.
+func (x Mask16s) ToInt16s() Int16s {
+	return Int16s{a: x.a, b: x.b}
+}
+
+func (x *Mask32s) set(i int, v bool) {
+	if v {
+		if i < 2 {
+			mask := uint64(0xffffffff) << (32 * i)
+			x.a |= mask
+		} else {
+			mask := uint64(0xffffffff) << (32 * (i - 2))
+			x.b |= mask
+		}
+	}
+}
+
+// And returns the bitwise AND of x and y.
+func (x Mask32s) And(y Mask32s) Mask32s {
+	return Mask32s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Mask32s) Or(y Mask32s) Mask32s {
+	return Mask32s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// String returns a string representation of the vector.
+func (x Mask32s) String() string {
+	var s [4]int32
+	x.ToInt32s().Neg().Store(s[:])
+	return sliceToString(s[:])
+}
+
+// ToInt32s converts the mask to an Int32s vector.
+func (x Mask32s) ToInt32s() Int32s {
+	return Int32s{a: x.a, b: x.b}
+}
+
+func (x *Mask64s) set(i int, v bool) {
+	if v {
+		if i == 0 {
+			x.a = ^uint64(0)
+		} else {
+			x.b = ^uint64(0)
+		}
+	}
+}
+
+// And returns the bitwise AND of x and y.
+func (x Mask64s) And(y Mask64s) Mask64s {
+	return Mask64s{a: x.a & y.a, b: x.b & y.b}
+}
+
+// Or returns the bitwise OR of x and y.
+func (x Mask64s) Or(y Mask64s) Mask64s {
+	return Mask64s{a: x.a | y.a, b: x.b | y.b}
+}
+
+// String returns a string representation of the vector.
+func (x Mask64s) String() string {
+	var s [2]int64
+	x.ToInt64s().Neg().Store(s[:])
+	return sliceToString(s[:])
+}
+
+// ToInt64s converts the mask to an Int64s vector.
+func (x Mask64s) ToInt64s() Int64s {
+	return Int64s{a: x.a, b: x.b}
+}
+
+func newT(lo, hi uint64) Uint64s {
+	return Uint64s{a: lo, b: hi}
+}
+
+// mwl returns the 128-bit product of the lower halves of x and y
+func (x Uint64s) mwl(y Uint64s) Uint64s {
+	hi, lo := bits.Mul64(x.a, y.a)
+	return Uint64s{a: lo, b: hi}
+}
+
+var (
+	// For mK, bits J such that J mod 5 == K are set
+	m0 = newT(0x1084210842108421, 0x2108421084210842)
+	m1 = newT(0x2108421084210842, 0x4210842108421084)
+	m2 = newT(0x4210842108421084, 0x8421084210842108)
+	m3 = newT(0x8421084210842108, 0x0842108421084210)
+	m4 = newT(0x0842108421084210, 0x1084210842108421)
+)
+
+func (x Uint64s) clmul(y Uint64s) Uint64s {
+	x0 := x.And(m0)
+	x1 := x.And(m1)
+	x2 := x.And(m2)
+	x3 := x.And(m3)
+	x4 := x.And(m4)
+
+	y0 := y.And(m0)
+	y1 := y.And(m1)
+	y2 := y.And(m2)
+	y3 := y.And(m3)
+	y4 := y.And(m4)
+
+	// sum of x, y indices == K mod 5; mask index = K
+	z := (x0.mwl(y0)).Xor(x1.mwl(y4)).Xor(x4.mwl(y1)).Xor(x2.mwl(y3)).Xor(x3.mwl(y2)).And(m0)
+	z = (x3.mwl(y3)).Xor(x2.mwl(y4)).Xor(x4.mwl(y2)).Xor(x0.mwl(y1)).Xor(x1.mwl(y0)).And(m1).Or(z)
+	z = (x1.mwl(y1)).Xor(x3.mwl(y4)).Xor(x4.mwl(y3)).Xor(x0.mwl(y2)).Xor(x2.mwl(y0)).And(m2).Or(z)
+	z = (x4.mwl(y4)).Xor(x0.mwl(y3)).Xor(x3.mwl(y0)).Xor(x1.mwl(y2)).Xor(x2.mwl(y1)).And(m3).Or(z)
+	z = (x2.mwl(y2)).Xor(x0.mwl(y4)).Xor(x4.mwl(y0)).Xor(x1.mwl(y3)).Xor(x3.mwl(y1)).And(m4).Or(z)
+
+	return z
+}
+
+// CarrylessMultiplyEven computes the carryless
+// multiplications of selected even halves of the elements of x and y.
+// The result fills the 128 bits of each even-odd pair.
+//
+// A carryless multiplication uses bitwise XOR instead of
+// add-with-carry, for example (in base two):
+//
+//	11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101
+//
+// This also models multiplication of polynomials with coefficients
+// from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 =
+// x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
+// polynomial terms, but coefficients "add" with XOR.)
+func (x Uint64s) CarrylessMultiplyEven(y Uint64s) Uint64s {
+	return x.clmul(y)
+}
+
+// CarrylessMultiplyOdd computes the carryless
+// multiplications of selected odd halves of the elements of x and y.
+// The result fills the 128 bits of each even-odd pair.
+//
+// A carryless multiplication uses bitwise XOR instead of
+// add-with-carry, for example (in base two):
+//
+//	11 * 11 = 11 * (10 ^ 1) = (11 * 10) ^ (11 * 1) = 110 ^ 11 = 101
+//
+// This also models multiplication of polynomials with coefficients
+// from GF(2) -- 11 * 11 models (x+1)*(x+1) = x**2 + (1^1)x + 1 =
+// x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
+// polynomial terms, but coefficients "add" with XOR.)
+func (x Uint64s) CarrylessMultiplyOdd(y Uint64s) Uint64s {
+	x.a = x.b
+	y.a = y.b
+	return x.clmul(y)
+}
+
+const (
+	by8  = 0x0101010101010101
+	by16 = 0x0001000100010001
+)
+
+// BroadcastInt8 fills the elements of a slice with its argument value.
+func BroadcastInt8s(x int8) Int8s {
+	v := (255 & uint64(x)) * by8
+	return Int8s{a: v, b: v}
+}
+
+// BroadcastInt16 fills the elements of a slice with its argument value.
+func BroadcastInt16s(x int16) Int16s {
+	v := (65535 & uint64(x)) * by16
+	return Int16s{a: v, b: v}
+}
+
+// BroadcastInt32 fills the elements of a slice with its argument value.
+func BroadcastInt32s(x int32) Int32s {
+	v := uint64(x) & 0xffffffff
+	v = v<<32 | v
+	return Int32s{a: v, b: v}
+}
+
+// BroadcastInt64 fills the elements of a slice with its argument value.
+func BroadcastInt64s(x int64) Int64s {
+	v := uint64(x)
+	return Int64s{a: v, b: v}
+}
+
+// BroadcastUint8 fills the elements of a slice with its argument value.
+func BroadcastUint8s(x uint8) Uint8s {
+	v := uint64(x) * by8
+	return Uint8s{a: v, b: v}
+
+}
+
+// BroadcastUint16 fills the elements of a slice with its argument value.
+func BroadcastUint16s(x uint16) Uint16s {
+	v := uint64(x) * by16
+	return Uint16s{a: v, b: v}
+
+}
+
+// BroadcastUint32 fills the elements of a slice with its argument value.
+func BroadcastUint32s(x uint32) Uint32s {
+	v := uint64(x)
+	v = v<<32 | v
+	return Uint32s{a: v, b: v}
+}
+
+// BroadcastUint64 fills the elements of a slice with its argument value.
+func BroadcastUint64s(x uint64) Uint64s {
+	return Uint64s{a: x, b: x}
+}
+
+// BroadcastFloat32 fills the elements of a slice with its argument value.
+func BroadcastFloat32s(x float32) Float32s {
+	v := uint64(math.Float32bits(x))
+	v = v<<32 | v
+	return Float32s{a: v, b: v}
+}
+
+// BroadcastFloat64 fills the elements of a slice with its argument value.
+func BroadcastFloat64s(x float64) Float64s {
+	v := math.Float64bits(x)
+	return Float64s{a: v, b: v}
+}