// Code generated by 'simdgen -o godefs -goroot $GOROOT -arch amd64 -xedPath $XED_PATH go_amd64.yaml types.yaml categories.yaml'; DO NOT EDIT.

//go:build goexperiment.simd

package archsimd

// v128 is a tag type that tells the compiler that this is really 128-bit SIMD
type v128 struct {
	_128 [0]func() // uncomparable
}

// Float32x4 is a 128-bit SIMD vector of 4 float32s.
type Float32x4 struct {
	float32x4 v128
	vals      [4]float32
}

// Len returns the number of elements in a Float32x4.
func (x Float32x4) Len() int { return 4 }

// LoadFloat32x4Array loads a Float32x4 from an array.
//
//go:noescape
func LoadFloat32x4Array(y *[4]float32) Float32x4

// StoreArray stores a Float32x4 to an array.
//
//go:noescape
func (x Float32x4) StoreArray(y *[4]float32)

// StoreArrayMasked stores a Float32x4 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVD, CPU Feature: AVX2
//
//go:noescape
func (x Float32x4) StoreArrayMasked(y *[4]float32, mask Mask32x4)

// Float64x2 is a 128-bit SIMD vector of 2 float64s.
type Float64x2 struct {
	float64x2 v128
	vals      [2]float64
}

// Len returns the number of elements in a Float64x2.
func (x Float64x2) Len() int { return 2 }

// LoadFloat64x2Array loads a Float64x2 from an array.
//
//go:noescape
func LoadFloat64x2Array(y *[2]float64) Float64x2

// StoreArray stores a Float64x2 to an array.
//
//go:noescape
func (x Float64x2) StoreArray(y *[2]float64)

// StoreArrayMasked stores a Float64x2 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVQ, CPU Feature: AVX2
//
//go:noescape
func (x Float64x2) StoreArrayMasked(y *[2]float64, mask Mask64x2)

// Int8x16 is a 128-bit SIMD vector of 16 int8s.
type Int8x16 struct {
	int8x16 v128
	vals    [16]int8
}

// Len returns the number of elements in an Int8x16.
func (x Int8x16) Len() int { return 16 }

// LoadInt8x16Array loads an Int8x16 from an array.
//
//go:noescape
func LoadInt8x16Array(y *[16]int8) Int8x16

// StoreArray stores an Int8x16 to an array.
//
//go:noescape
func (x Int8x16) StoreArray(y *[16]int8)

// Int16x8 is a 128-bit SIMD vector of 8 int16s.
type Int16x8 struct {
	int16x8 v128
	vals    [8]int16
}

// Len returns the number of elements in an Int16x8.
func (x Int16x8) Len() int { return 8 }

// LoadInt16x8Array loads an Int16x8 from an array.
//
//go:noescape
func LoadInt16x8Array(y *[8]int16) Int16x8

// StoreArray stores an Int16x8 to an array.
//
//go:noescape
func (x Int16x8) StoreArray(y *[8]int16)

// Int32x4 is a 128-bit SIMD vector of 4 int32s.
type Int32x4 struct {
	int32x4 v128
	vals    [4]int32
}

// Len returns the number of elements in an Int32x4.
func (x Int32x4) Len() int { return 4 }

// LoadInt32x4Array loads an Int32x4 from an array.
//
//go:noescape
func LoadInt32x4Array(y *[4]int32) Int32x4

// StoreArray stores an Int32x4 to an array.
//
//go:noescape
func (x Int32x4) StoreArray(y *[4]int32)

// StoreArrayMasked stores an Int32x4 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVD, CPU Feature: AVX2
//
//go:noescape
func (x Int32x4) StoreArrayMasked(y *[4]int32, mask Mask32x4)

// Int64x2 is a 128-bit SIMD vector of 2 int64s.
type Int64x2 struct {
	int64x2 v128
	vals    [2]int64
}

// Len returns the number of elements in an Int64x2.
func (x Int64x2) Len() int { return 2 }

// LoadInt64x2Array loads an Int64x2 from an array.
//
//go:noescape
func LoadInt64x2Array(y *[2]int64) Int64x2

// StoreArray stores an Int64x2 to an array.
//
//go:noescape
func (x Int64x2) StoreArray(y *[2]int64)

// StoreArrayMasked stores an Int64x2 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVQ, CPU Feature: AVX2
//
//go:noescape
func (x Int64x2) StoreArrayMasked(y *[2]int64, mask Mask64x2)

// Uint8x16 is a 128-bit SIMD vector of 16 uint8s.
type Uint8x16 struct {
	uint8x16 v128
	vals     [16]uint8
}

// Len returns the number of elements in a Uint8x16.
func (x Uint8x16) Len() int { return 16 }

// LoadUint8x16Array loads a Uint8x16 from an array.
//
//go:noescape
func LoadUint8x16Array(y *[16]uint8) Uint8x16

// StoreArray stores a Uint8x16 to an array.
//
//go:noescape
func (x Uint8x16) StoreArray(y *[16]uint8)

// Uint16x8 is a 128-bit SIMD vector of 8 uint16s.
type Uint16x8 struct {
	uint16x8 v128
	vals     [8]uint16
}

// Len returns the number of elements in a Uint16x8.
func (x Uint16x8) Len() int { return 8 }

// LoadUint16x8Array loads a Uint16x8 from an array.
//
//go:noescape
func LoadUint16x8Array(y *[8]uint16) Uint16x8

// StoreArray stores a Uint16x8 to an array.
//
//go:noescape
func (x Uint16x8) StoreArray(y *[8]uint16)

// Uint32x4 is a 128-bit SIMD vector of 4 uint32s.
type Uint32x4 struct {
	uint32x4 v128
	vals     [4]uint32
}

// Len returns the number of elements in a Uint32x4.
func (x Uint32x4) Len() int { return 4 }

// LoadUint32x4Array loads a Uint32x4 from an array.
//
//go:noescape
func LoadUint32x4Array(y *[4]uint32) Uint32x4

// StoreArray stores a Uint32x4 to an array.
//
//go:noescape
func (x Uint32x4) StoreArray(y *[4]uint32)

// StoreArrayMasked stores a Uint32x4 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVD, CPU Feature: AVX2
//
//go:noescape
func (x Uint32x4) StoreArrayMasked(y *[4]uint32, mask Mask32x4)

// Uint64x2 is a 128-bit SIMD vector of 2 uint64s.
type Uint64x2 struct {
	uint64x2 v128
	vals     [2]uint64
}

// Len returns the number of elements in a Uint64x2.
func (x Uint64x2) Len() int { return 2 }

// LoadUint64x2Array loads a Uint64x2 from an array.
//
//go:noescape
func LoadUint64x2Array(y *[2]uint64) Uint64x2

// StoreArray stores a Uint64x2 to an array.
//
//go:noescape
func (x Uint64x2) StoreArray(y *[2]uint64)

// StoreArrayMasked stores a Uint64x2 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVQ, CPU Feature: AVX2
//
//go:noescape
func (x Uint64x2) StoreArrayMasked(y *[2]uint64, mask Mask64x2)

// Mask8x16 is a mask for a SIMD vector of 16 8-bit elements.
type Mask8x16 struct {
	int8x16 v128
	vals    [16]int8
}

// Mask8x16FromBits constructs a Mask8x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVB, CPU Feature: AVX512
func Mask8x16FromBits(y uint16) Mask8x16

// ToBits constructs a bitmap from a Mask8x16, where 1 means set for the indexed element, 0 means unset.
//
// Asm: VPMOVMSKB, CPU Features: AVX
func (x Mask8x16) ToBits() uint16

// Mask16x8 is a mask for a SIMD vector of 8 16-bit elements.
type Mask16x8 struct {
	int16x8 v128
	vals    [8]int16
}

// Mask16x8FromBits constructs a Mask16x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVW, CPU Feature: AVX512
func Mask16x8FromBits(y uint8) Mask16x8

// ToBits constructs a bitmap from a Mask16x8, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVW, CPU Features: AVX512
func (x Mask16x8) ToBits() uint8

// Mask32x4 is a mask for a SIMD vector of 4 32-bit elements.
type Mask32x4 struct {
	int32x4 v128
	vals    [4]int32
}

// Mask32x4FromBits constructs a Mask32x4 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
// Only the lower 4 bits of y are used.
//
// Asm: KMOVD, CPU Feature: AVX512
func Mask32x4FromBits(y uint8) Mask32x4

// ToBits constructs a bitmap from a Mask32x4, where 1 means set for the indexed element, 0 means unset.
// Only the lower 4 bits of y are used.
//
// Asm: VMOVMSKPS, CPU Features: AVX
func (x Mask32x4) ToBits() uint8

// Mask64x2 is a mask for a SIMD vector of 2 64-bit elements.
type Mask64x2 struct {
	int64x2 v128
	vals    [2]int64
}

// Mask64x2FromBits constructs a Mask64x2 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
// Only the lower 2 bits of y are used.
//
// Asm: KMOVQ, CPU Feature: AVX512
func Mask64x2FromBits(y uint8) Mask64x2

// ToBits constructs a bitmap from a Mask64x2, where 1 means set for the indexed element, 0 means unset.
// Only the lower 2 bits of y are used.
//
// Asm: VMOVMSKPD, CPU Features: AVX
func (x Mask64x2) ToBits() uint8

// v256 is a tag type that tells the compiler that this is really 256-bit SIMD
type v256 struct {
	_256 [0]func() // uncomparable
}

// Float32x8 is a 256-bit SIMD vector of 8 float32s.
type Float32x8 struct {
	float32x8 v256
	vals      [8]float32
}

// Len returns the number of elements in a Float32x8.
func (x Float32x8) Len() int { return 8 }

// LoadFloat32x8Array loads a Float32x8 from an array.
//
//go:noescape
func LoadFloat32x8Array(y *[8]float32) Float32x8

// StoreArray stores a Float32x8 to an array.
//
//go:noescape
func (x Float32x8) StoreArray(y *[8]float32)

// StoreArrayMasked stores a Float32x8 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVD, CPU Feature: AVX2
//
//go:noescape
func (x Float32x8) StoreArrayMasked(y *[8]float32, mask Mask32x8)

// Float64x4 is a 256-bit SIMD vector of 4 float64s.
type Float64x4 struct {
	float64x4 v256
	vals      [4]float64
}

// Len returns the number of elements in a Float64x4.
func (x Float64x4) Len() int { return 4 }

// LoadFloat64x4Array loads a Float64x4 from an array.
//
//go:noescape
func LoadFloat64x4Array(y *[4]float64) Float64x4

// StoreArray stores a Float64x4 to an array.
//
//go:noescape
func (x Float64x4) StoreArray(y *[4]float64)

// StoreArrayMasked stores a Float64x4 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVQ, CPU Feature: AVX2
//
//go:noescape
func (x Float64x4) StoreArrayMasked(y *[4]float64, mask Mask64x4)

// Int8x32 is a 256-bit SIMD vector of 32 int8s.
type Int8x32 struct {
	int8x32 v256
	vals    [32]int8
}

// Len returns the number of elements in an Int8x32.
func (x Int8x32) Len() int { return 32 }

// LoadInt8x32Array loads an Int8x32 from an array.
//
//go:noescape
func LoadInt8x32Array(y *[32]int8) Int8x32

// StoreArray stores an Int8x32 to an array.
//
//go:noescape
func (x Int8x32) StoreArray(y *[32]int8)

// Int16x16 is a 256-bit SIMD vector of 16 int16s.
type Int16x16 struct {
	int16x16 v256
	vals     [16]int16
}

// Len returns the number of elements in an Int16x16.
func (x Int16x16) Len() int { return 16 }

// LoadInt16x16Array loads an Int16x16 from an array.
//
//go:noescape
func LoadInt16x16Array(y *[16]int16) Int16x16

// StoreArray stores an Int16x16 to an array.
//
//go:noescape
func (x Int16x16) StoreArray(y *[16]int16)

// Int32x8 is a 256-bit SIMD vector of 8 int32s.
type Int32x8 struct {
	int32x8 v256
	vals    [8]int32
}

// Len returns the number of elements in an Int32x8.
func (x Int32x8) Len() int { return 8 }

// LoadInt32x8Array loads an Int32x8 from an array.
//
//go:noescape
func LoadInt32x8Array(y *[8]int32) Int32x8

// StoreArray stores an Int32x8 to an array.
//
//go:noescape
func (x Int32x8) StoreArray(y *[8]int32)

// StoreArrayMasked stores an Int32x8 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVD, CPU Feature: AVX2
//
//go:noescape
func (x Int32x8) StoreArrayMasked(y *[8]int32, mask Mask32x8)

// Int64x4 is a 256-bit SIMD vector of 4 int64s.
type Int64x4 struct {
	int64x4 v256
	vals    [4]int64
}

// Len returns the number of elements in an Int64x4.
func (x Int64x4) Len() int { return 4 }

// LoadInt64x4Array loads an Int64x4 from an array.
//
//go:noescape
func LoadInt64x4Array(y *[4]int64) Int64x4

// StoreArray stores an Int64x4 to an array.
//
//go:noescape
func (x Int64x4) StoreArray(y *[4]int64)

// StoreArrayMasked stores an Int64x4 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVQ, CPU Feature: AVX2
//
//go:noescape
func (x Int64x4) StoreArrayMasked(y *[4]int64, mask Mask64x4)

// Uint8x32 is a 256-bit SIMD vector of 32 uint8s.
type Uint8x32 struct {
	uint8x32 v256
	vals     [32]uint8
}

// Len returns the number of elements in a Uint8x32.
func (x Uint8x32) Len() int { return 32 }

// LoadUint8x32Array loads a Uint8x32 from an array.
//
//go:noescape
func LoadUint8x32Array(y *[32]uint8) Uint8x32

// StoreArray stores a Uint8x32 to an array.
//
//go:noescape
func (x Uint8x32) StoreArray(y *[32]uint8)

// Uint16x16 is a 256-bit SIMD vector of 16 uint16s.
type Uint16x16 struct {
	uint16x16 v256
	vals      [16]uint16
}

// Len returns the number of elements in a Uint16x16.
func (x Uint16x16) Len() int { return 16 }

// LoadUint16x16Array loads a Uint16x16 from an array.
//
//go:noescape
func LoadUint16x16Array(y *[16]uint16) Uint16x16

// StoreArray stores a Uint16x16 to an array.
//
//go:noescape
func (x Uint16x16) StoreArray(y *[16]uint16)

// Uint32x8 is a 256-bit SIMD vector of 8 uint32s.
type Uint32x8 struct {
	uint32x8 v256
	vals     [8]uint32
}

// Len returns the number of elements in a Uint32x8.
func (x Uint32x8) Len() int { return 8 }

// LoadUint32x8Array loads a Uint32x8 from an array.
//
//go:noescape
func LoadUint32x8Array(y *[8]uint32) Uint32x8

// StoreArray stores a Uint32x8 to an array.
//
//go:noescape
func (x Uint32x8) StoreArray(y *[8]uint32)

// StoreArrayMasked stores a Uint32x8 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVD, CPU Feature: AVX2
//
//go:noescape
func (x Uint32x8) StoreArrayMasked(y *[8]uint32, mask Mask32x8)

// Uint64x4 is a 256-bit SIMD vector of 4 uint64s.
type Uint64x4 struct {
	uint64x4 v256
	vals     [4]uint64
}

// Len returns the number of elements in a Uint64x4.
func (x Uint64x4) Len() int { return 4 }

// LoadUint64x4Array loads a Uint64x4 from an array.
//
//go:noescape
func LoadUint64x4Array(y *[4]uint64) Uint64x4

// StoreArray stores a Uint64x4 to an array.
//
//go:noescape
func (x Uint64x4) StoreArray(y *[4]uint64)

// StoreArrayMasked stores a Uint64x4 to an array,
// at those elements enabled by mask.
//
// Asm: VMASKMOVQ, CPU Feature: AVX2
//
//go:noescape
func (x Uint64x4) StoreArrayMasked(y *[4]uint64, mask Mask64x4)

// Mask8x32 is a mask for a SIMD vector of 32 8-bit elements.
type Mask8x32 struct {
	int8x32 v256
	vals    [32]int8
}

// Mask8x32FromBits constructs a Mask8x32 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVB, CPU Feature: AVX512
func Mask8x32FromBits(y uint32) Mask8x32

// ToBits constructs a bitmap from a Mask8x32, where 1 means set for the indexed element, 0 means unset.
//
// Asm: VPMOVMSKB, CPU Features: AVX2
func (x Mask8x32) ToBits() uint32

// Mask16x16 is a mask for a SIMD vector of 16 16-bit elements.
type Mask16x16 struct {
	int16x16 v256
	vals     [16]int16
}

// Mask16x16FromBits constructs a Mask16x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVW, CPU Feature: AVX512
func Mask16x16FromBits(y uint16) Mask16x16

// ToBits constructs a bitmap from a Mask16x16, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVW, CPU Features: AVX512
func (x Mask16x16) ToBits() uint16

// Mask32x8 is a mask for a SIMD vector of 8 32-bit elements.
type Mask32x8 struct {
	int32x8 v256
	vals    [8]int32
}

// Mask32x8FromBits constructs a Mask32x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVD, CPU Feature: AVX512
func Mask32x8FromBits(y uint8) Mask32x8

// ToBits constructs a bitmap from a Mask32x8, where 1 means set for the indexed element, 0 means unset.
//
// Asm: VMOVMSKPS, CPU Features: AVX
func (x Mask32x8) ToBits() uint8

// Mask64x4 is a mask for a SIMD vector of 4 64-bit elements.
type Mask64x4 struct {
	int64x4 v256
	vals    [4]int64
}

// Mask64x4FromBits constructs a Mask64x4 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
// Only the lower 4 bits of y are used.
//
// Asm: KMOVQ, CPU Feature: AVX512
func Mask64x4FromBits(y uint8) Mask64x4

// ToBits constructs a bitmap from a Mask64x4, where 1 means set for the indexed element, 0 means unset.
// Only the lower 4 bits of y are used.
//
// Asm: VMOVMSKPD, CPU Features: AVX
func (x Mask64x4) ToBits() uint8

// v512 is a tag type that tells the compiler that this is really 512-bit SIMD
type v512 struct {
	_512 [0]func() // uncomparable
}

// Float32x16 is a 512-bit SIMD vector of 16 float32s.
type Float32x16 struct {
	float32x16 v512
	vals       [16]float32
}

// Len returns the number of elements in a Float32x16.
func (x Float32x16) Len() int { return 16 }

// LoadFloat32x16Array loads a Float32x16 from an array.
//
//go:noescape
func LoadFloat32x16Array(y *[16]float32) Float32x16

// StoreArray stores a Float32x16 to an array.
//
//go:noescape
func (x Float32x16) StoreArray(y *[16]float32)

// StoreArrayMasked stores a Float32x16 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU32, CPU Feature: AVX512
//
//go:noescape
func (x Float32x16) StoreArrayMasked(y *[16]float32, mask Mask32x16)

// Float64x8 is a 512-bit SIMD vector of 8 float64s.
type Float64x8 struct {
	float64x8 v512
	vals      [8]float64
}

// Len returns the number of elements in a Float64x8.
func (x Float64x8) Len() int { return 8 }

// LoadFloat64x8Array loads a Float64x8 from an array.
//
//go:noescape
func LoadFloat64x8Array(y *[8]float64) Float64x8

// StoreArray stores a Float64x8 to an array.
//
//go:noescape
func (x Float64x8) StoreArray(y *[8]float64)

// StoreArrayMasked stores a Float64x8 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU64, CPU Feature: AVX512
//
//go:noescape
func (x Float64x8) StoreArrayMasked(y *[8]float64, mask Mask64x8)

// Int8x64 is a 512-bit SIMD vector of 64 int8s.
type Int8x64 struct {
	int8x64 v512
	vals    [64]int8
}

// Len returns the number of elements in an Int8x64.
func (x Int8x64) Len() int { return 64 }

// LoadInt8x64Array loads an Int8x64 from an array.
//
//go:noescape
func LoadInt8x64Array(y *[64]int8) Int8x64

// StoreArray stores an Int8x64 to an array.
//
//go:noescape
func (x Int8x64) StoreArray(y *[64]int8)

// StoreArrayMasked stores an Int8x64 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU8, CPU Feature: AVX512
//
//go:noescape
func (x Int8x64) StoreArrayMasked(y *[64]int8, mask Mask8x64)

// Int16x32 is a 512-bit SIMD vector of 32 int16s.
type Int16x32 struct {
	int16x32 v512
	vals     [32]int16
}

// Len returns the number of elements in an Int16x32.
func (x Int16x32) Len() int { return 32 }

// LoadInt16x32Array loads an Int16x32 from an array.
//
//go:noescape
func LoadInt16x32Array(y *[32]int16) Int16x32

// StoreArray stores an Int16x32 to an array.
//
//go:noescape
func (x Int16x32) StoreArray(y *[32]int16)

// StoreArrayMasked stores an Int16x32 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU16, CPU Feature: AVX512
//
//go:noescape
func (x Int16x32) StoreArrayMasked(y *[32]int16, mask Mask16x32)

// Int32x16 is a 512-bit SIMD vector of 16 int32s.
type Int32x16 struct {
	int32x16 v512
	vals     [16]int32
}

// Len returns the number of elements in an Int32x16.
func (x Int32x16) Len() int { return 16 }

// LoadInt32x16Array loads an Int32x16 from an array.
//
//go:noescape
func LoadInt32x16Array(y *[16]int32) Int32x16

// StoreArray stores an Int32x16 to an array.
//
//go:noescape
func (x Int32x16) StoreArray(y *[16]int32)

// StoreArrayMasked stores an Int32x16 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU32, CPU Feature: AVX512
//
//go:noescape
func (x Int32x16) StoreArrayMasked(y *[16]int32, mask Mask32x16)

// Int64x8 is a 512-bit SIMD vector of 8 int64s.
type Int64x8 struct {
	int64x8 v512
	vals    [8]int64
}

// Len returns the number of elements in an Int64x8.
func (x Int64x8) Len() int { return 8 }

// LoadInt64x8Array loads an Int64x8 from an array.
//
//go:noescape
func LoadInt64x8Array(y *[8]int64) Int64x8

// StoreArray stores an Int64x8 to an array.
//
//go:noescape
func (x Int64x8) StoreArray(y *[8]int64)

// StoreArrayMasked stores an Int64x8 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU64, CPU Feature: AVX512
//
//go:noescape
func (x Int64x8) StoreArrayMasked(y *[8]int64, mask Mask64x8)

// Uint8x64 is a 512-bit SIMD vector of 64 uint8s.
type Uint8x64 struct {
	uint8x64 v512
	vals     [64]uint8
}

// Len returns the number of elements in a Uint8x64.
func (x Uint8x64) Len() int { return 64 }

// LoadUint8x64Array loads a Uint8x64 from an array.
//
//go:noescape
func LoadUint8x64Array(y *[64]uint8) Uint8x64

// StoreArray stores a Uint8x64 to an array.
//
//go:noescape
func (x Uint8x64) StoreArray(y *[64]uint8)

// StoreArrayMasked stores a Uint8x64 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU8, CPU Feature: AVX512
//
//go:noescape
func (x Uint8x64) StoreArrayMasked(y *[64]uint8, mask Mask8x64)

// Uint16x32 is a 512-bit SIMD vector of 32 uint16s.
type Uint16x32 struct {
	uint16x32 v512
	vals      [32]uint16
}

// Len returns the number of elements in a Uint16x32.
func (x Uint16x32) Len() int { return 32 }

// LoadUint16x32Array loads a Uint16x32 from an array.
//
//go:noescape
func LoadUint16x32Array(y *[32]uint16) Uint16x32

// StoreArray stores a Uint16x32 to an array.
//
//go:noescape
func (x Uint16x32) StoreArray(y *[32]uint16)

// StoreArrayMasked stores a Uint16x32 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU16, CPU Feature: AVX512
//
//go:noescape
func (x Uint16x32) StoreArrayMasked(y *[32]uint16, mask Mask16x32)

// Uint32x16 is a 512-bit SIMD vector of 16 uint32s.
type Uint32x16 struct {
	uint32x16 v512
	vals      [16]uint32
}

// Len returns the number of elements in a Uint32x16.
func (x Uint32x16) Len() int { return 16 }

// LoadUint32x16Array loads a Uint32x16 from an array.
//
//go:noescape
func LoadUint32x16Array(y *[16]uint32) Uint32x16

// StoreArray stores a Uint32x16 to an array.
//
//go:noescape
func (x Uint32x16) StoreArray(y *[16]uint32)

// StoreArrayMasked stores a Uint32x16 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU32, CPU Feature: AVX512
//
//go:noescape
func (x Uint32x16) StoreArrayMasked(y *[16]uint32, mask Mask32x16)

// Uint64x8 is a 512-bit SIMD vector of 8 uint64s.
type Uint64x8 struct {
	uint64x8 v512
	vals     [8]uint64
}

// Len returns the number of elements in a Uint64x8.
func (x Uint64x8) Len() int { return 8 }

// LoadUint64x8Array loads a Uint64x8 from an array.
//
//go:noescape
func LoadUint64x8Array(y *[8]uint64) Uint64x8

// StoreArray stores a Uint64x8 to an array.
//
//go:noescape
func (x Uint64x8) StoreArray(y *[8]uint64)

// StoreArrayMasked stores a Uint64x8 to an array,
// at those elements enabled by mask.
//
// Asm: VMOVDQU64, CPU Feature: AVX512
//
//go:noescape
func (x Uint64x8) StoreArrayMasked(y *[8]uint64, mask Mask64x8)

// Mask8x64 is a mask for a SIMD vector of 64 8-bit elements.
type Mask8x64 struct {
	int8x64 v512
	vals    [64]int8
}

// Mask8x64FromBits constructs a Mask8x64 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVB, CPU Feature: AVX512
func Mask8x64FromBits(y uint64) Mask8x64

// ToBits constructs a bitmap from a Mask8x64, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVB, CPU Features: AVX512
func (x Mask8x64) ToBits() uint64

// Mask16x32 is a mask for a SIMD vector of 32 16-bit elements.
type Mask16x32 struct {
	int16x32 v512
	vals     [32]int16
}

// Mask16x32FromBits constructs a Mask16x32 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVW, CPU Feature: AVX512
func Mask16x32FromBits(y uint32) Mask16x32

// ToBits constructs a bitmap from a Mask16x32, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVW, CPU Features: AVX512
func (x Mask16x32) ToBits() uint32

// Mask32x16 is a mask for a SIMD vector of 16 32-bit elements.
type Mask32x16 struct {
	int32x16 v512
	vals     [16]int32
}

// Mask32x16FromBits constructs a Mask32x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVD, CPU Feature: AVX512
func Mask32x16FromBits(y uint16) Mask32x16

// ToBits constructs a bitmap from a Mask32x16, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVD, CPU Features: AVX512
func (x Mask32x16) ToBits() uint16

// Mask64x8 is a mask for a SIMD vector of 8 64-bit elements.
type Mask64x8 struct {
	int64x8 v512
	vals    [8]int64
}

// Mask64x8FromBits constructs a Mask64x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVQ, CPU Feature: AVX512
func Mask64x8FromBits(y uint8) Mask64x8

// ToBits constructs a bitmap from a Mask64x8, where 1 means set for the indexed element, 0 means unset.
//
// Asm: KMOVQ, CPU Features: AVX512
func (x Mask64x8) ToBits() uint8
