@ttsc/win32-arm64 0.33.1 → 0.34.0

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

@@ -1,4 +1,4 @@
-// Code generated by 'simdgen -o godefs -goroot $GOROOT -xedPath $XED_PATH go.yaml types.yaml categories.yaml'; DO NOT EDIT.
+// 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
 
@@ -18,31 +18,23 @@ type Float32x4 struct {
 // Len returns the number of elements in a Float32x4.
 func (x Float32x4) Len() int { return 4 }
 
-// LoadFloat32x4 loads a Float32x4 from an array.
+// LoadFloat32x4Array loads a Float32x4 from an array.
 //
 //go:noescape
-func LoadFloat32x4(y *[4]float32) Float32x4
+func LoadFloat32x4Array(y *[4]float32) Float32x4
 
-// Store stores a Float32x4 to an array.
+// StoreArray stores a Float32x4 to an array.
 //
 //go:noescape
-func (x Float32x4) Store(y *[4]float32)
+func (x Float32x4) StoreArray(y *[4]float32)
 
-// LoadMaskedFloat32x4 loads a Float32x4 from an array,
+// StoreArrayMasked stores a Float32x4 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVD, CPU Feature: AVX2
 //
 //go:noescape
-func LoadMaskedFloat32x4(y *[4]float32, mask Mask32x4) Float32x4
-
-// StoreMasked stores a Float32x4 to an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVD, CPU Feature: AVX2
-//
-//go:noescape
-func (x Float32x4) StoreMasked(y *[4]float32, mask Mask32x4)
+func (x Float32x4) StoreArrayMasked(y *[4]float32, mask Mask32x4)
 
 // Float64x2 is a 128-bit SIMD vector of 2 float64s.
 type Float64x2 struct {
@@ -53,31 +45,23 @@ type Float64x2 struct {
 // Len returns the number of elements in a Float64x2.
 func (x Float64x2) Len() int { return 2 }
 
-// LoadFloat64x2 loads a Float64x2 from an array.
-//
-//go:noescape
-func LoadFloat64x2(y *[2]float64) Float64x2
-
-// Store stores a Float64x2 to an array.
+// LoadFloat64x2Array loads a Float64x2 from an array.
 //
 //go:noescape
-func (x Float64x2) Store(y *[2]float64)
+func LoadFloat64x2Array(y *[2]float64) Float64x2
 
-// LoadMaskedFloat64x2 loads a Float64x2 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVQ, CPU Feature: AVX2
+// StoreArray stores a Float64x2 to an array.
 //
 //go:noescape
-func LoadMaskedFloat64x2(y *[2]float64, mask Mask64x2) Float64x2
+func (x Float64x2) StoreArray(y *[2]float64)
 
-// StoreMasked stores a Float64x2 to an array,
+// StoreArrayMasked stores a Float64x2 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVQ, CPU Feature: AVX2
 //
 //go:noescape
-func (x Float64x2) StoreMasked(y *[2]float64, mask Mask64x2)
+func (x Float64x2) StoreArrayMasked(y *[2]float64, mask Mask64x2)
 
 // Int8x16 is a 128-bit SIMD vector of 16 int8s.
 type Int8x16 struct {
@@ -88,15 +72,15 @@ type Int8x16 struct {
 // Len returns the number of elements in an Int8x16.
 func (x Int8x16) Len() int { return 16 }
 
-// LoadInt8x16 loads an Int8x16 from an array.
+// LoadInt8x16Array loads an Int8x16 from an array.
 //
 //go:noescape
-func LoadInt8x16(y *[16]int8) Int8x16
+func LoadInt8x16Array(y *[16]int8) Int8x16
 
-// Store stores an Int8x16 to an array.
+// StoreArray stores an Int8x16 to an array.
 //
 //go:noescape
-func (x Int8x16) Store(y *[16]int8)
+func (x Int8x16) StoreArray(y *[16]int8)
 
 // Int16x8 is a 128-bit SIMD vector of 8 int16s.
 type Int16x8 struct {
@@ -107,15 +91,15 @@ type Int16x8 struct {
 // Len returns the number of elements in an Int16x8.
 func (x Int16x8) Len() int { return 8 }
 
-// LoadInt16x8 loads an Int16x8 from an array.
+// LoadInt16x8Array loads an Int16x8 from an array.
 //
 //go:noescape
-func LoadInt16x8(y *[8]int16) Int16x8
+func LoadInt16x8Array(y *[8]int16) Int16x8
 
-// Store stores an Int16x8 to an array.
+// StoreArray stores an Int16x8 to an array.
 //
 //go:noescape
-func (x Int16x8) Store(y *[8]int16)
+func (x Int16x8) StoreArray(y *[8]int16)
 
 // Int32x4 is a 128-bit SIMD vector of 4 int32s.
 type Int32x4 struct {
@@ -126,31 +110,23 @@ type Int32x4 struct {
 // Len returns the number of elements in an Int32x4.
 func (x Int32x4) Len() int { return 4 }
 
-// LoadInt32x4 loads an Int32x4 from an array.
+// LoadInt32x4Array loads an Int32x4 from an array.
 //
 //go:noescape
-func LoadInt32x4(y *[4]int32) Int32x4
+func LoadInt32x4Array(y *[4]int32) Int32x4
 
-// Store stores an Int32x4 to an array.
+// StoreArray stores an Int32x4 to an array.
 //
 //go:noescape
-func (x Int32x4) Store(y *[4]int32)
+func (x Int32x4) StoreArray(y *[4]int32)
 
-// LoadMaskedInt32x4 loads an Int32x4 from an array,
+// StoreArrayMasked stores an Int32x4 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVD, CPU Feature: AVX2
 //
 //go:noescape
-func LoadMaskedInt32x4(y *[4]int32, mask Mask32x4) Int32x4
-
-// StoreMasked stores an Int32x4 to an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVD, CPU Feature: AVX2
-//
-//go:noescape
-func (x Int32x4) StoreMasked(y *[4]int32, mask Mask32x4)
+func (x Int32x4) StoreArrayMasked(y *[4]int32, mask Mask32x4)
 
 // Int64x2 is a 128-bit SIMD vector of 2 int64s.
 type Int64x2 struct {
@@ -161,31 +137,23 @@ type Int64x2 struct {
 // Len returns the number of elements in an Int64x2.
 func (x Int64x2) Len() int { return 2 }
 
-// LoadInt64x2 loads an Int64x2 from an array.
-//
-//go:noescape
-func LoadInt64x2(y *[2]int64) Int64x2
-
-// Store stores an Int64x2 to an array.
+// LoadInt64x2Array loads an Int64x2 from an array.
 //
 //go:noescape
-func (x Int64x2) Store(y *[2]int64)
+func LoadInt64x2Array(y *[2]int64) Int64x2
 
-// LoadMaskedInt64x2 loads an Int64x2 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVQ, CPU Feature: AVX2
+// StoreArray stores an Int64x2 to an array.
 //
 //go:noescape
-func LoadMaskedInt64x2(y *[2]int64, mask Mask64x2) Int64x2
+func (x Int64x2) StoreArray(y *[2]int64)
 
-// StoreMasked stores an Int64x2 to an array,
+// StoreArrayMasked stores an Int64x2 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVQ, CPU Feature: AVX2
 //
 //go:noescape
-func (x Int64x2) StoreMasked(y *[2]int64, mask Mask64x2)
+func (x Int64x2) StoreArrayMasked(y *[2]int64, mask Mask64x2)
 
 // Uint8x16 is a 128-bit SIMD vector of 16 uint8s.
 type Uint8x16 struct {
@@ -196,15 +164,15 @@ type Uint8x16 struct {
 // Len returns the number of elements in a Uint8x16.
 func (x Uint8x16) Len() int { return 16 }
 
-// LoadUint8x16 loads a Uint8x16 from an array.
+// LoadUint8x16Array loads a Uint8x16 from an array.
 //
 //go:noescape
-func LoadUint8x16(y *[16]uint8) Uint8x16
+func LoadUint8x16Array(y *[16]uint8) Uint8x16
 
-// Store stores a Uint8x16 to an array.
+// StoreArray stores a Uint8x16 to an array.
 //
 //go:noescape
-func (x Uint8x16) Store(y *[16]uint8)
+func (x Uint8x16) StoreArray(y *[16]uint8)
 
 // Uint16x8 is a 128-bit SIMD vector of 8 uint16s.
 type Uint16x8 struct {
@@ -215,15 +183,15 @@ type Uint16x8 struct {
 // Len returns the number of elements in a Uint16x8.
 func (x Uint16x8) Len() int { return 8 }
 
-// LoadUint16x8 loads a Uint16x8 from an array.
+// LoadUint16x8Array loads a Uint16x8 from an array.
 //
 //go:noescape
-func LoadUint16x8(y *[8]uint16) Uint16x8
+func LoadUint16x8Array(y *[8]uint16) Uint16x8
 
-// Store stores a Uint16x8 to an array.
+// StoreArray stores a Uint16x8 to an array.
 //
 //go:noescape
-func (x Uint16x8) Store(y *[8]uint16)
+func (x Uint16x8) StoreArray(y *[8]uint16)
 
 // Uint32x4 is a 128-bit SIMD vector of 4 uint32s.
 type Uint32x4 struct {
@@ -234,31 +202,23 @@ type Uint32x4 struct {
 // Len returns the number of elements in a Uint32x4.
 func (x Uint32x4) Len() int { return 4 }
 
-// LoadUint32x4 loads a Uint32x4 from an array.
+// LoadUint32x4Array loads a Uint32x4 from an array.
 //
 //go:noescape
-func LoadUint32x4(y *[4]uint32) Uint32x4
+func LoadUint32x4Array(y *[4]uint32) Uint32x4
 
-// Store stores a Uint32x4 to an array.
+// StoreArray stores a Uint32x4 to an array.
 //
 //go:noescape
-func (x Uint32x4) Store(y *[4]uint32)
+func (x Uint32x4) StoreArray(y *[4]uint32)
 
-// LoadMaskedUint32x4 loads a Uint32x4 from an array,
+// StoreArrayMasked stores a Uint32x4 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVD, CPU Feature: AVX2
 //
 //go:noescape
-func LoadMaskedUint32x4(y *[4]uint32, mask Mask32x4) Uint32x4
-
-// StoreMasked stores a Uint32x4 to an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVD, CPU Feature: AVX2
-//
-//go:noescape
-func (x Uint32x4) StoreMasked(y *[4]uint32, mask Mask32x4)
+func (x Uint32x4) StoreArrayMasked(y *[4]uint32, mask Mask32x4)
 
 // Uint64x2 is a 128-bit SIMD vector of 2 uint64s.
 type Uint64x2 struct {
@@ -269,31 +229,23 @@ type Uint64x2 struct {
 // Len returns the number of elements in a Uint64x2.
 func (x Uint64x2) Len() int { return 2 }
 
-// LoadUint64x2 loads a Uint64x2 from an array.
+// LoadUint64x2Array loads a Uint64x2 from an array.
 //
 //go:noescape
-func LoadUint64x2(y *[2]uint64) Uint64x2
+func LoadUint64x2Array(y *[2]uint64) Uint64x2
 
-// Store stores a Uint64x2 to an array.
+// StoreArray stores a Uint64x2 to an array.
 //
 //go:noescape
-func (x Uint64x2) Store(y *[2]uint64)
+func (x Uint64x2) StoreArray(y *[2]uint64)
 
-// LoadMaskedUint64x2 loads a Uint64x2 from an array,
+// StoreArrayMasked stores a Uint64x2 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVQ, CPU Feature: AVX2
 //
 //go:noescape
-func LoadMaskedUint64x2(y *[2]uint64, mask Mask64x2) Uint64x2
-
-// StoreMasked stores a Uint64x2 to an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVQ, CPU Feature: AVX2
-//
-//go:noescape
-func (x Uint64x2) StoreMasked(y *[2]uint64, mask Mask64x2)
+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 {
@@ -377,31 +329,23 @@ type Float32x8 struct {
 // Len returns the number of elements in a Float32x8.
 func (x Float32x8) Len() int { return 8 }
 
-// LoadFloat32x8 loads a Float32x8 from an array.
+// LoadFloat32x8Array loads a Float32x8 from an array.
 //
 //go:noescape
-func LoadFloat32x8(y *[8]float32) Float32x8
+func LoadFloat32x8Array(y *[8]float32) Float32x8
 
-// Store stores a Float32x8 to an array.
+// StoreArray stores a Float32x8 to an array.
 //
 //go:noescape
-func (x Float32x8) Store(y *[8]float32)
+func (x Float32x8) StoreArray(y *[8]float32)
 
-// LoadMaskedFloat32x8 loads a Float32x8 from an array,
+// StoreArrayMasked stores a Float32x8 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVD, CPU Feature: AVX2
 //
 //go:noescape
-func LoadMaskedFloat32x8(y *[8]float32, mask Mask32x8) Float32x8
-
-// StoreMasked stores a Float32x8 to an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVD, CPU Feature: AVX2
-//
-//go:noescape
-func (x Float32x8) StoreMasked(y *[8]float32, mask Mask32x8)
+func (x Float32x8) StoreArrayMasked(y *[8]float32, mask Mask32x8)
 
 // Float64x4 is a 256-bit SIMD vector of 4 float64s.
 type Float64x4 struct {
@@ -412,31 +356,23 @@ type Float64x4 struct {
 // Len returns the number of elements in a Float64x4.
 func (x Float64x4) Len() int { return 4 }
 
-// LoadFloat64x4 loads a Float64x4 from an array.
+// LoadFloat64x4Array loads a Float64x4 from an array.
 //
 //go:noescape
-func LoadFloat64x4(y *[4]float64) Float64x4
+func LoadFloat64x4Array(y *[4]float64) Float64x4
 
-// Store stores a Float64x4 to an array.
-//
-//go:noescape
-func (x Float64x4) Store(y *[4]float64)
-
-// LoadMaskedFloat64x4 loads a Float64x4 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVQ, CPU Feature: AVX2
+// StoreArray stores a Float64x4 to an array.
 //
 //go:noescape
-func LoadMaskedFloat64x4(y *[4]float64, mask Mask64x4) Float64x4
+func (x Float64x4) StoreArray(y *[4]float64)
 
-// StoreMasked stores a Float64x4 to an array,
+// StoreArrayMasked stores a Float64x4 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVQ, CPU Feature: AVX2
 //
 //go:noescape
-func (x Float64x4) StoreMasked(y *[4]float64, mask Mask64x4)
+func (x Float64x4) StoreArrayMasked(y *[4]float64, mask Mask64x4)
 
 // Int8x32 is a 256-bit SIMD vector of 32 int8s.
 type Int8x32 struct {
@@ -447,15 +383,15 @@ type Int8x32 struct {
 // Len returns the number of elements in an Int8x32.
 func (x Int8x32) Len() int { return 32 }
 
-// LoadInt8x32 loads an Int8x32 from an array.
+// LoadInt8x32Array loads an Int8x32 from an array.
 //
 //go:noescape
-func LoadInt8x32(y *[32]int8) Int8x32
+func LoadInt8x32Array(y *[32]int8) Int8x32
 
-// Store stores an Int8x32 to an array.
+// StoreArray stores an Int8x32 to an array.
 //
 //go:noescape
-func (x Int8x32) Store(y *[32]int8)
+func (x Int8x32) StoreArray(y *[32]int8)
 
 // Int16x16 is a 256-bit SIMD vector of 16 int16s.
 type Int16x16 struct {
@@ -466,15 +402,15 @@ type Int16x16 struct {
 // Len returns the number of elements in an Int16x16.
 func (x Int16x16) Len() int { return 16 }
 
-// LoadInt16x16 loads an Int16x16 from an array.
+// LoadInt16x16Array loads an Int16x16 from an array.
 //
 //go:noescape
-func LoadInt16x16(y *[16]int16) Int16x16
+func LoadInt16x16Array(y *[16]int16) Int16x16
 
-// Store stores an Int16x16 to an array.
+// StoreArray stores an Int16x16 to an array.
 //
 //go:noescape
-func (x Int16x16) Store(y *[16]int16)
+func (x Int16x16) StoreArray(y *[16]int16)
 
 // Int32x8 is a 256-bit SIMD vector of 8 int32s.
 type Int32x8 struct {
@@ -485,31 +421,23 @@ type Int32x8 struct {
 // Len returns the number of elements in an Int32x8.
 func (x Int32x8) Len() int { return 8 }
 
-// LoadInt32x8 loads an Int32x8 from an array.
-//
-//go:noescape
-func LoadInt32x8(y *[8]int32) Int32x8
-
-// Store stores an Int32x8 to an array.
+// LoadInt32x8Array loads an Int32x8 from an array.
 //
 //go:noescape
-func (x Int32x8) Store(y *[8]int32)
+func LoadInt32x8Array(y *[8]int32) Int32x8
 
-// LoadMaskedInt32x8 loads an Int32x8 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVD, CPU Feature: AVX2
+// StoreArray stores an Int32x8 to an array.
 //
 //go:noescape
-func LoadMaskedInt32x8(y *[8]int32, mask Mask32x8) Int32x8
+func (x Int32x8) StoreArray(y *[8]int32)
 
-// StoreMasked stores an Int32x8 to an array,
+// StoreArrayMasked stores an Int32x8 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVD, CPU Feature: AVX2
 //
 //go:noescape
-func (x Int32x8) StoreMasked(y *[8]int32, mask Mask32x8)
+func (x Int32x8) StoreArrayMasked(y *[8]int32, mask Mask32x8)
 
 // Int64x4 is a 256-bit SIMD vector of 4 int64s.
 type Int64x4 struct {
@@ -520,31 +448,23 @@ type Int64x4 struct {
 // Len returns the number of elements in an Int64x4.
 func (x Int64x4) Len() int { return 4 }
 
-// LoadInt64x4 loads an Int64x4 from an array.
+// LoadInt64x4Array loads an Int64x4 from an array.
 //
 //go:noescape
-func LoadInt64x4(y *[4]int64) Int64x4
+func LoadInt64x4Array(y *[4]int64) Int64x4
 
-// Store stores an Int64x4 to an array.
+// StoreArray stores an Int64x4 to an array.
 //
 //go:noescape
-func (x Int64x4) Store(y *[4]int64)
+func (x Int64x4) StoreArray(y *[4]int64)
 
-// LoadMaskedInt64x4 loads an Int64x4 from an array,
+// StoreArrayMasked stores an Int64x4 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVQ, CPU Feature: AVX2
 //
 //go:noescape
-func LoadMaskedInt64x4(y *[4]int64, mask Mask64x4) Int64x4
-
-// StoreMasked stores an Int64x4 to an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVQ, CPU Feature: AVX2
-//
-//go:noescape
-func (x Int64x4) StoreMasked(y *[4]int64, mask Mask64x4)
+func (x Int64x4) StoreArrayMasked(y *[4]int64, mask Mask64x4)
 
 // Uint8x32 is a 256-bit SIMD vector of 32 uint8s.
 type Uint8x32 struct {
@@ -555,15 +475,15 @@ type Uint8x32 struct {
 // Len returns the number of elements in a Uint8x32.
 func (x Uint8x32) Len() int { return 32 }
 
-// LoadUint8x32 loads a Uint8x32 from an array.
+// LoadUint8x32Array loads a Uint8x32 from an array.
 //
 //go:noescape
-func LoadUint8x32(y *[32]uint8) Uint8x32
+func LoadUint8x32Array(y *[32]uint8) Uint8x32
 
-// Store stores a Uint8x32 to an array.
+// StoreArray stores a Uint8x32 to an array.
 //
 //go:noescape
-func (x Uint8x32) Store(y *[32]uint8)
+func (x Uint8x32) StoreArray(y *[32]uint8)
 
 // Uint16x16 is a 256-bit SIMD vector of 16 uint16s.
 type Uint16x16 struct {
@@ -574,15 +494,15 @@ type Uint16x16 struct {
 // Len returns the number of elements in a Uint16x16.
 func (x Uint16x16) Len() int { return 16 }
 
-// LoadUint16x16 loads a Uint16x16 from an array.
+// LoadUint16x16Array loads a Uint16x16 from an array.
 //
 //go:noescape
-func LoadUint16x16(y *[16]uint16) Uint16x16
+func LoadUint16x16Array(y *[16]uint16) Uint16x16
 
-// Store stores a Uint16x16 to an array.
+// StoreArray stores a Uint16x16 to an array.
 //
 //go:noescape
-func (x Uint16x16) Store(y *[16]uint16)
+func (x Uint16x16) StoreArray(y *[16]uint16)
 
 // Uint32x8 is a 256-bit SIMD vector of 8 uint32s.
 type Uint32x8 struct {
@@ -593,31 +513,23 @@ type Uint32x8 struct {
 // Len returns the number of elements in a Uint32x8.
 func (x Uint32x8) Len() int { return 8 }
 
-// LoadUint32x8 loads a Uint32x8 from an array.
-//
-//go:noescape
-func LoadUint32x8(y *[8]uint32) Uint32x8
-
-// Store stores a Uint32x8 to an array.
+// LoadUint32x8Array loads a Uint32x8 from an array.
 //
 //go:noescape
-func (x Uint32x8) Store(y *[8]uint32)
+func LoadUint32x8Array(y *[8]uint32) Uint32x8
 
-// LoadMaskedUint32x8 loads a Uint32x8 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVD, CPU Feature: AVX2
+// StoreArray stores a Uint32x8 to an array.
 //
 //go:noescape
-func LoadMaskedUint32x8(y *[8]uint32, mask Mask32x8) Uint32x8
+func (x Uint32x8) StoreArray(y *[8]uint32)
 
-// StoreMasked stores a Uint32x8 to an array,
+// StoreArrayMasked stores a Uint32x8 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVD, CPU Feature: AVX2
 //
 //go:noescape
-func (x Uint32x8) StoreMasked(y *[8]uint32, mask Mask32x8)
+func (x Uint32x8) StoreArrayMasked(y *[8]uint32, mask Mask32x8)
 
 // Uint64x4 is a 256-bit SIMD vector of 4 uint64s.
 type Uint64x4 struct {
@@ -628,31 +540,23 @@ type Uint64x4 struct {
 // Len returns the number of elements in a Uint64x4.
 func (x Uint64x4) Len() int { return 4 }
 
-// LoadUint64x4 loads a Uint64x4 from an array.
-//
-//go:noescape
-func LoadUint64x4(y *[4]uint64) Uint64x4
-
-// Store stores a Uint64x4 to an array.
+// LoadUint64x4Array loads a Uint64x4 from an array.
 //
 //go:noescape
-func (x Uint64x4) Store(y *[4]uint64)
+func LoadUint64x4Array(y *[4]uint64) Uint64x4
 
-// LoadMaskedUint64x4 loads a Uint64x4 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMASKMOVQ, CPU Feature: AVX2
+// StoreArray stores a Uint64x4 to an array.
 //
 //go:noescape
-func LoadMaskedUint64x4(y *[4]uint64, mask Mask64x4) Uint64x4
+func (x Uint64x4) StoreArray(y *[4]uint64)
 
-// StoreMasked stores a Uint64x4 to an array,
+// StoreArrayMasked stores a Uint64x4 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMASKMOVQ, CPU Feature: AVX2
 //
 //go:noescape
-func (x Uint64x4) StoreMasked(y *[4]uint64, mask Mask64x4)
+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 {
@@ -734,31 +638,23 @@ type Float32x16 struct {
 // Len returns the number of elements in a Float32x16.
 func (x Float32x16) Len() int { return 16 }
 
-// LoadFloat32x16 loads a Float32x16 from an array.
-//
-//go:noescape
-func LoadFloat32x16(y *[16]float32) Float32x16
-
-// Store stores a Float32x16 to an array.
+// LoadFloat32x16Array loads a Float32x16 from an array.
 //
 //go:noescape
-func (x Float32x16) Store(y *[16]float32)
+func LoadFloat32x16Array(y *[16]float32) Float32x16
 
-// LoadMaskedFloat32x16 loads a Float32x16 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU32.Z, CPU Feature: AVX512
+// StoreArray stores a Float32x16 to an array.
 //
 //go:noescape
-func LoadMaskedFloat32x16(y *[16]float32, mask Mask32x16) Float32x16
+func (x Float32x16) StoreArray(y *[16]float32)
 
-// StoreMasked stores a Float32x16 to an array,
+// StoreArrayMasked stores a Float32x16 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU32, CPU Feature: AVX512
 //
 //go:noescape
-func (x Float32x16) StoreMasked(y *[16]float32, mask Mask32x16)
+func (x Float32x16) StoreArrayMasked(y *[16]float32, mask Mask32x16)
 
 // Float64x8 is a 512-bit SIMD vector of 8 float64s.
 type Float64x8 struct {
@@ -769,31 +665,23 @@ type Float64x8 struct {
 // Len returns the number of elements in a Float64x8.
 func (x Float64x8) Len() int { return 8 }
 
-// LoadFloat64x8 loads a Float64x8 from an array.
+// LoadFloat64x8Array loads a Float64x8 from an array.
 //
 //go:noescape
-func LoadFloat64x8(y *[8]float64) Float64x8
+func LoadFloat64x8Array(y *[8]float64) Float64x8
 
-// Store stores a Float64x8 to an array.
+// StoreArray stores a Float64x8 to an array.
 //
 //go:noescape
-func (x Float64x8) Store(y *[8]float64)
+func (x Float64x8) StoreArray(y *[8]float64)
 
-// LoadMaskedFloat64x8 loads a Float64x8 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU64.Z, CPU Feature: AVX512
-//
-//go:noescape
-func LoadMaskedFloat64x8(y *[8]float64, mask Mask64x8) Float64x8
-
-// StoreMasked stores a Float64x8 to an array,
+// StoreArrayMasked stores a Float64x8 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU64, CPU Feature: AVX512
 //
 //go:noescape
-func (x Float64x8) StoreMasked(y *[8]float64, mask Mask64x8)
+func (x Float64x8) StoreArrayMasked(y *[8]float64, mask Mask64x8)
 
 // Int8x64 is a 512-bit SIMD vector of 64 int8s.
 type Int8x64 struct {
@@ -804,31 +692,23 @@ type Int8x64 struct {
 // Len returns the number of elements in an Int8x64.
 func (x Int8x64) Len() int { return 64 }
 
-// LoadInt8x64 loads an Int8x64 from an array.
+// LoadInt8x64Array loads an Int8x64 from an array.
 //
 //go:noescape
-func LoadInt8x64(y *[64]int8) Int8x64
+func LoadInt8x64Array(y *[64]int8) Int8x64
 
-// Store stores an Int8x64 to an array.
+// StoreArray stores an Int8x64 to an array.
 //
 //go:noescape
-func (x Int8x64) Store(y *[64]int8)
+func (x Int8x64) StoreArray(y *[64]int8)
 
-// LoadMaskedInt8x64 loads an Int8x64 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU8.Z, CPU Feature: AVX512
-//
-//go:noescape
-func LoadMaskedInt8x64(y *[64]int8, mask Mask8x64) Int8x64
-
-// StoreMasked stores an Int8x64 to an array,
+// StoreArrayMasked stores an Int8x64 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU8, CPU Feature: AVX512
 //
 //go:noescape
-func (x Int8x64) StoreMasked(y *[64]int8, mask Mask8x64)
+func (x Int8x64) StoreArrayMasked(y *[64]int8, mask Mask8x64)
 
 // Int16x32 is a 512-bit SIMD vector of 32 int16s.
 type Int16x32 struct {
@@ -839,31 +719,23 @@ type Int16x32 struct {
 // Len returns the number of elements in an Int16x32.
 func (x Int16x32) Len() int { return 32 }
 
-// LoadInt16x32 loads an Int16x32 from an array.
+// LoadInt16x32Array loads an Int16x32 from an array.
 //
 //go:noescape
-func LoadInt16x32(y *[32]int16) Int16x32
+func LoadInt16x32Array(y *[32]int16) Int16x32
 
-// Store stores an Int16x32 to an array.
-//
-//go:noescape
-func (x Int16x32) Store(y *[32]int16)
-
-// LoadMaskedInt16x32 loads an Int16x32 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU16.Z, CPU Feature: AVX512
+// StoreArray stores an Int16x32 to an array.
 //
 //go:noescape
-func LoadMaskedInt16x32(y *[32]int16, mask Mask16x32) Int16x32
+func (x Int16x32) StoreArray(y *[32]int16)
 
-// StoreMasked stores an Int16x32 to an array,
+// StoreArrayMasked stores an Int16x32 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU16, CPU Feature: AVX512
 //
 //go:noescape
-func (x Int16x32) StoreMasked(y *[32]int16, mask Mask16x32)
+func (x Int16x32) StoreArrayMasked(y *[32]int16, mask Mask16x32)
 
 // Int32x16 is a 512-bit SIMD vector of 16 int32s.
 type Int32x16 struct {
@@ -874,31 +746,23 @@ type Int32x16 struct {
 // Len returns the number of elements in an Int32x16.
 func (x Int32x16) Len() int { return 16 }
 
-// LoadInt32x16 loads an Int32x16 from an array.
+// LoadInt32x16Array loads an Int32x16 from an array.
 //
 //go:noescape
-func LoadInt32x16(y *[16]int32) Int32x16
+func LoadInt32x16Array(y *[16]int32) Int32x16
 
-// Store stores an Int32x16 to an array.
+// StoreArray stores an Int32x16 to an array.
 //
 //go:noescape
-func (x Int32x16) Store(y *[16]int32)
+func (x Int32x16) StoreArray(y *[16]int32)
 
-// LoadMaskedInt32x16 loads an Int32x16 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU32.Z, CPU Feature: AVX512
-//
-//go:noescape
-func LoadMaskedInt32x16(y *[16]int32, mask Mask32x16) Int32x16
-
-// StoreMasked stores an Int32x16 to an array,
+// StoreArrayMasked stores an Int32x16 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU32, CPU Feature: AVX512
 //
 //go:noescape
-func (x Int32x16) StoreMasked(y *[16]int32, mask Mask32x16)
+func (x Int32x16) StoreArrayMasked(y *[16]int32, mask Mask32x16)
 
 // Int64x8 is a 512-bit SIMD vector of 8 int64s.
 type Int64x8 struct {
@@ -909,31 +773,23 @@ type Int64x8 struct {
 // Len returns the number of elements in an Int64x8.
 func (x Int64x8) Len() int { return 8 }
 
-// LoadInt64x8 loads an Int64x8 from an array.
+// LoadInt64x8Array loads an Int64x8 from an array.
 //
 //go:noescape
-func LoadInt64x8(y *[8]int64) Int64x8
+func LoadInt64x8Array(y *[8]int64) Int64x8
 
-// Store stores an Int64x8 to an array.
+// StoreArray stores an Int64x8 to an array.
 //
 //go:noescape
-func (x Int64x8) Store(y *[8]int64)
+func (x Int64x8) StoreArray(y *[8]int64)
 
-// LoadMaskedInt64x8 loads an Int64x8 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU64.Z, CPU Feature: AVX512
-//
-//go:noescape
-func LoadMaskedInt64x8(y *[8]int64, mask Mask64x8) Int64x8
-
-// StoreMasked stores an Int64x8 to an array,
+// StoreArrayMasked stores an Int64x8 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU64, CPU Feature: AVX512
 //
 //go:noescape
-func (x Int64x8) StoreMasked(y *[8]int64, mask Mask64x8)
+func (x Int64x8) StoreArrayMasked(y *[8]int64, mask Mask64x8)
 
 // Uint8x64 is a 512-bit SIMD vector of 64 uint8s.
 type Uint8x64 struct {
@@ -944,31 +800,23 @@ type Uint8x64 struct {
 // Len returns the number of elements in a Uint8x64.
 func (x Uint8x64) Len() int { return 64 }
 
-// LoadUint8x64 loads a Uint8x64 from an array.
+// LoadUint8x64Array loads a Uint8x64 from an array.
 //
 //go:noescape
-func LoadUint8x64(y *[64]uint8) Uint8x64
+func LoadUint8x64Array(y *[64]uint8) Uint8x64
 
-// Store stores a Uint8x64 to an array.
-//
-//go:noescape
-func (x Uint8x64) Store(y *[64]uint8)
-
-// LoadMaskedUint8x64 loads a Uint8x64 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU8.Z, CPU Feature: AVX512
+// StoreArray stores a Uint8x64 to an array.
 //
 //go:noescape
-func LoadMaskedUint8x64(y *[64]uint8, mask Mask8x64) Uint8x64
+func (x Uint8x64) StoreArray(y *[64]uint8)
 
-// StoreMasked stores a Uint8x64 to an array,
+// StoreArrayMasked stores a Uint8x64 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU8, CPU Feature: AVX512
 //
 //go:noescape
-func (x Uint8x64) StoreMasked(y *[64]uint8, mask Mask8x64)
+func (x Uint8x64) StoreArrayMasked(y *[64]uint8, mask Mask8x64)
 
 // Uint16x32 is a 512-bit SIMD vector of 32 uint16s.
 type Uint16x32 struct {
@@ -979,31 +827,23 @@ type Uint16x32 struct {
 // Len returns the number of elements in a Uint16x32.
 func (x Uint16x32) Len() int { return 32 }
 
-// LoadUint16x32 loads a Uint16x32 from an array.
+// LoadUint16x32Array loads a Uint16x32 from an array.
 //
 //go:noescape
-func LoadUint16x32(y *[32]uint16) Uint16x32
+func LoadUint16x32Array(y *[32]uint16) Uint16x32
 
-// Store stores a Uint16x32 to an array.
+// StoreArray stores a Uint16x32 to an array.
 //
 //go:noescape
-func (x Uint16x32) Store(y *[32]uint16)
+func (x Uint16x32) StoreArray(y *[32]uint16)
 
-// LoadMaskedUint16x32 loads a Uint16x32 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU16.Z, CPU Feature: AVX512
-//
-//go:noescape
-func LoadMaskedUint16x32(y *[32]uint16, mask Mask16x32) Uint16x32
-
-// StoreMasked stores a Uint16x32 to an array,
+// StoreArrayMasked stores a Uint16x32 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU16, CPU Feature: AVX512
 //
 //go:noescape
-func (x Uint16x32) StoreMasked(y *[32]uint16, mask Mask16x32)
+func (x Uint16x32) StoreArrayMasked(y *[32]uint16, mask Mask16x32)
 
 // Uint32x16 is a 512-bit SIMD vector of 16 uint32s.
 type Uint32x16 struct {
@@ -1014,31 +854,23 @@ type Uint32x16 struct {
 // Len returns the number of elements in a Uint32x16.
 func (x Uint32x16) Len() int { return 16 }
 
-// LoadUint32x16 loads a Uint32x16 from an array.
+// LoadUint32x16Array loads a Uint32x16 from an array.
 //
 //go:noescape
-func LoadUint32x16(y *[16]uint32) Uint32x16
+func LoadUint32x16Array(y *[16]uint32) Uint32x16
 
-// Store stores a Uint32x16 to an array.
+// StoreArray stores a Uint32x16 to an array.
 //
 //go:noescape
-func (x Uint32x16) Store(y *[16]uint32)
+func (x Uint32x16) StoreArray(y *[16]uint32)
 
-// LoadMaskedUint32x16 loads a Uint32x16 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU32.Z, CPU Feature: AVX512
-//
-//go:noescape
-func LoadMaskedUint32x16(y *[16]uint32, mask Mask32x16) Uint32x16
-
-// StoreMasked stores a Uint32x16 to an array,
+// StoreArrayMasked stores a Uint32x16 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU32, CPU Feature: AVX512
 //
 //go:noescape
-func (x Uint32x16) StoreMasked(y *[16]uint32, mask Mask32x16)
+func (x Uint32x16) StoreArrayMasked(y *[16]uint32, mask Mask32x16)
 
 // Uint64x8 is a 512-bit SIMD vector of 8 uint64s.
 type Uint64x8 struct {
@@ -1049,31 +881,23 @@ type Uint64x8 struct {
 // Len returns the number of elements in a Uint64x8.
 func (x Uint64x8) Len() int { return 8 }
 
-// LoadUint64x8 loads a Uint64x8 from an array.
+// LoadUint64x8Array loads a Uint64x8 from an array.
 //
 //go:noescape
-func LoadUint64x8(y *[8]uint64) Uint64x8
+func LoadUint64x8Array(y *[8]uint64) Uint64x8
 
-// Store stores a Uint64x8 to an array.
-//
-//go:noescape
-func (x Uint64x8) Store(y *[8]uint64)
-
-// LoadMaskedUint64x8 loads a Uint64x8 from an array,
-// at those elements enabled by mask.
-//
-// Asm: VMOVDQU64.Z, CPU Feature: AVX512
+// StoreArray stores a Uint64x8 to an array.
 //
 //go:noescape
-func LoadMaskedUint64x8(y *[8]uint64, mask Mask64x8) Uint64x8
+func (x Uint64x8) StoreArray(y *[8]uint64)
 
-// StoreMasked stores a Uint64x8 to an array,
+// StoreArrayMasked stores a Uint64x8 to an array,
 // at those elements enabled by mask.
 //
 // Asm: VMOVDQU64, CPU Feature: AVX512
 //
 //go:noescape
-func (x Uint64x8) StoreMasked(y *[8]uint64, mask Mask64x8)
+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 {