@ttsc/win32-arm64 0.33.1 → 0.34.0

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

@@ -7,7 +7,7 @@
 package archsimd
 
 // These constants represent the source pattern for the four parameters
-// (a, b, c, d) passed to SelectFromPair and SelectFromPairGrouped.
+// (a, b, c, d) passed to ConcatPermuteScalars and ConcatPermuteScalarsGrouped.
 // L means the element comes from the 'x' vector (Low), and
 // H means it comes from the 'y' vector (High).
 // The order of the letters corresponds to elements a, b, c, d.
@@ -37,7 +37,7 @@ const (
 )
 
 // These constants represent the source pattern for the four parameters
-// (a, b, c, d) passed to SelectFromPair and SelectFromPairGrouped for
+// (a, b, c, d) passed to ConcatPermuteScalars and ConcatPermuteScalarsGrouped for
 // two-element vectors.
 const (
 	_LL = iota
@@ -46,7 +46,7 @@ const (
 	_HH
 )
 
-// SelectFromPair returns the selection of four elements from the two
+// ConcatPermuteScalars returns the selection of four elements from the two
 // vectors x and y, where selector values in the range 0-3 specify
 // elements from x and values in the range 4-7 specify the 0-3 elements
 // of y.  When the selectors are constants and the selection can be
@@ -55,7 +55,7 @@ const (
 // output, and b, c, and d are the indices of the 2nd, 3rd, and 4th
 // elements in the output.  For example,
 //
-//	{1,2,4,8}.SelectFromPair(2,3,5,7,{9,25,49,81})
+//	{1,2,4,8}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81})
 //
 // returns {4,8,25,81}.
 //
@@ -63,7 +63,7 @@ const (
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX
-func (x Int32x4) SelectFromPair(a, b, c, d uint8, y Int32x4) Int32x4 {
+func (x Int32x4) ConcatPermuteScalars(a, b, c, d uint8, y Int32x4) Int32x4 {
 	// pattern gets the concatenation of "x or y?" bits
 	// (0 == x, 1 == y)
 	// This will determine operand choice/order and whether a second
@@ -128,7 +128,7 @@ func (x Int32x4) SelectFromPair(a, b, c, d uint8, y Int32x4) Int32x4 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPair returns the selection of four elements from the two
+// ConcatPermuteScalars returns the selection of four elements from the two
 // vectors x and y, where selector values in the range 0-3 specify
 // elements from x and values in the range 4-7 specify the 0-3 elements
 // of y.  When the selectors are constants and can be the selection
@@ -137,7 +137,7 @@ func (x Int32x4) SelectFromPair(a, b, c, d uint8, y Int32x4) Int32x4 {
 // output, and b, c, and d are the indices of the 2nd, 3rd, and 4th
 // elements in the output.  For example,
 //
-//	{1,2,4,8}.SelectFromPair(2,3,5,7,{9,25,49,81})
+//	{1,2,4,8}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81})
 //
 // returns {4,8,25,81}.
 //
@@ -145,7 +145,7 @@ func (x Int32x4) SelectFromPair(a, b, c, d uint8, y Int32x4) Int32x4 {
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX
-func (x Uint32x4) SelectFromPair(a, b, c, d uint8, y Uint32x4) Uint32x4 {
+func (x Uint32x4) ConcatPermuteScalars(a, b, c, d uint8, y Uint32x4) Uint32x4 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -203,7 +203,7 @@ func (x Uint32x4) SelectFromPair(a, b, c, d uint8, y Uint32x4) Uint32x4 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPair returns the selection of four elements from the two
+// ConcatPermuteScalars returns the selection of four elements from the two
 // vectors x and y, where selector values in the range 0-3 specify
 // elements from x and values in the range 4-7 specify the 0-3 elements
 // of y.  When the selectors are constants and can be the selection
@@ -212,7 +212,7 @@ func (x Uint32x4) SelectFromPair(a, b, c, d uint8, y Uint32x4) Uint32x4 {
 // output, and b, c, and d are the indices of the 2nd, 3rd, and 4th
 // elements in the output.  For example,
 //
-//	{1,2,4,8}.SelectFromPair(2,3,5,7,{9,25,49,81})
+//	{1,2,4,8}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81})
 //
 // returns {4,8,25,81}.
 //
@@ -220,7 +220,7 @@ func (x Uint32x4) SelectFromPair(a, b, c, d uint8, y Uint32x4) Uint32x4 {
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX
-func (x Float32x4) SelectFromPair(a, b, c, d uint8, y Float32x4) Float32x4 {
+func (x Float32x4) ConcatPermuteScalars(a, b, c, d uint8, y Float32x4) Float32x4 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -278,7 +278,7 @@ func (x Float32x4) SelectFromPair(a, b, c, d uint8, y Float32x4) Float32x4 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the two 128-bit halves of
+// ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of
 // the vectors x and y, the selection of four elements from  x and y,
 // where selector values in the range 0-3 specify elements from x and
 // values in the range 4-7 specify the 0-3 elements of y.
@@ -288,7 +288,7 @@ func (x Float32x4) SelectFromPair(a, b, c, d uint8, y Float32x4) Float32x4 {
 // output, and b, c, and d are the indices of the 2nd, 3rd, and 4th
 // elements in the output.  For example,
 //
-//	{1,2,4,8,16,32,64,128}.SelectFromPair(2,3,5,7,{9,25,49,81,121,169,225,289})
+//	{1,2,4,8,16,32,64,128}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81,121,169,225,289})
 //
 // returns {4,8,25,81,64,128,169,289}.
 //
@@ -296,7 +296,7 @@ func (x Float32x4) SelectFromPair(a, b, c, d uint8, y Float32x4) Float32x4 {
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX
-func (x Int32x8) SelectFromPairGrouped(a, b, c, d uint8, y Int32x8) Int32x8 {
+func (x Int32x8) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Int32x8) Int32x8 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -354,7 +354,7 @@ func (x Int32x8) SelectFromPairGrouped(a, b, c, d uint8, y Int32x8) Int32x8 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the two 128-bit halves of
+// ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of
 // the vectors x and y, the selection of four elements from  x and y,
 // where selector values in the range 0-3 specify elements from x and
 // values in the range 4-7 specify the 0-3 elements of y.
@@ -364,7 +364,7 @@ func (x Int32x8) SelectFromPairGrouped(a, b, c, d uint8, y Int32x8) Int32x8 {
 // output, and b, c, and d are the indices of the 2nd, 3rd, and 4th
 // elements in the output.  For example,
 //
-//	{1,2,4,8,16,32,64,128}.SelectFromPair(2,3,5,7,{9,25,49,81,121,169,225,289})
+//	{1,2,4,8,16,32,64,128}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81,121,169,225,289})
 //
 // returns {4,8,25,81,64,128,169,289}.
 //
@@ -372,7 +372,7 @@ func (x Int32x8) SelectFromPairGrouped(a, b, c, d uint8, y Int32x8) Int32x8 {
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX
-func (x Uint32x8) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x8) Uint32x8 {
+func (x Uint32x8) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Uint32x8) Uint32x8 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -430,7 +430,7 @@ func (x Uint32x8) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x8) Uint32x8 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the two 128-bit halves of
+// ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of
 // the vectors x and y, the selection of four elements from  x and y,
 // where selector values in the range 0-3 specify elements from x and
 // values in the range 4-7 specify the 0-3 elements of y.
@@ -440,7 +440,7 @@ func (x Uint32x8) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x8) Uint32x8 {
 // output, and b, c, and d are the indices of the 2nd, 3rd, and 4th
 // elements in the output.  For example,
 //
-//	{1,2,4,8,16,32,64,128}.SelectFromPair(2,3,5,7,{9,25,49,81,121,169,225,289})
+//	{1,2,4,8,16,32,64,128}.ConcatPermuteScalars(2,3,5,7,{9,25,49,81,121,169,225,289})
 //
 // returns {4,8,25,81,64,128,169,289}.
 //
@@ -448,7 +448,7 @@ func (x Uint32x8) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x8) Uint32x8 {
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX
-func (x Float32x8) SelectFromPairGrouped(a, b, c, d uint8, y Float32x8) Float32x8 {
+func (x Float32x8) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Float32x8) Float32x8 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -506,7 +506,7 @@ func (x Float32x8) SelectFromPairGrouped(a, b, c, d uint8, y Float32x8) Float32x
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the four 128-bit subvectors
+// ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors
 // of the vectors x and y, the selection of four elements from  x and y,
 // where selector values in the range 0-3 specify elements from x and
 // values in the range 4-7 specify the 0-3 elements of y.
@@ -518,7 +518,7 @@ func (x Float32x8) SelectFromPairGrouped(a, b, c, d uint8, y Float32x8) Float32x
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX512
-func (x Int32x16) SelectFromPairGrouped(a, b, c, d uint8, y Int32x16) Int32x16 {
+func (x Int32x16) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Int32x16) Int32x16 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -576,7 +576,7 @@ func (x Int32x16) SelectFromPairGrouped(a, b, c, d uint8, y Int32x16) Int32x16 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the four 128-bit subvectors
+// ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors
 // of the vectors x and y, the selection of four elements from  x and y,
 // where selector values in the range 0-3 specify elements from x and
 // values in the range 4-7 specify the 0-3 elements of y.
@@ -588,7 +588,7 @@ func (x Int32x16) SelectFromPairGrouped(a, b, c, d uint8, y Int32x16) Int32x16 {
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX512
-func (x Uint32x16) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x16) Uint32x16 {
+func (x Uint32x16) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Uint32x16) Uint32x16 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -646,7 +646,7 @@ func (x Uint32x16) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x16) Uint32x1
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the four 128-bit subvectors
+// ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors
 // of the vectors x and y, the selection of four elements from  x and y,
 // where selector values in the range 0-3 specify elements from x and
 // values in the range 4-7 specify the 0-3 elements of y.
@@ -658,7 +658,7 @@ func (x Uint32x16) SelectFromPairGrouped(a, b, c, d uint8, y Uint32x16) Uint32x1
 // call.
 //
 // Asm: VSHUFPS, CPU Feature: AVX512
-func (x Float32x16) SelectFromPairGrouped(a, b, c, d uint8, y Float32x16) Float32x16 {
+func (x Float32x16) ConcatPermuteScalarsGrouped(a, b, c, d uint8, y Float32x16) Float32x16 {
 	pattern := a>>2 + (b&4)>>1 + (c & 4) + (d&4)<<1
 
 	a, b, c, d = a&3, b&3, c&3, d&3
@@ -744,7 +744,7 @@ func cscimm2g4(a, b uint8) uint8 {
 	return g + g<<4
 }
 
-// SelectFromPair returns the selection of two elements from the two
+// ConcatPermuteScalars returns the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
 // of y.  When the selectors are constants the selection can be
@@ -754,7 +754,7 @@ func cscimm2g4(a, b uint8) uint8 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX
-func (x Uint64x2) SelectFromPair(a, b uint8, y Uint64x2) Uint64x2 {
+func (x Uint64x2) ConcatPermuteScalars(a, b uint8, y Uint64x2) Uint64x2 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -772,7 +772,7 @@ func (x Uint64x2) SelectFromPair(a, b uint8, y Uint64x2) Uint64x2 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the two 128-bit halves of
+// ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of
 // the vectors x and y, the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
@@ -783,7 +783,7 @@ func (x Uint64x2) SelectFromPair(a, b uint8, y Uint64x2) Uint64x2 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX
-func (x Uint64x4) SelectFromPairGrouped(a, b uint8, y Uint64x4) Uint64x4 {
+func (x Uint64x4) ConcatPermuteScalarsGrouped(a, b uint8, y Uint64x4) Uint64x4 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -801,7 +801,7 @@ func (x Uint64x4) SelectFromPairGrouped(a, b uint8, y Uint64x4) Uint64x4 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the four 128-bit subvectors
+// ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors
 // of the vectors x and y, the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
@@ -812,7 +812,7 @@ func (x Uint64x4) SelectFromPairGrouped(a, b uint8, y Uint64x4) Uint64x4 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX512
-func (x Uint64x8) SelectFromPairGrouped(a, b uint8, y Uint64x8) Uint64x8 {
+func (x Uint64x8) ConcatPermuteScalarsGrouped(a, b uint8, y Uint64x8) Uint64x8 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -830,7 +830,7 @@ func (x Uint64x8) SelectFromPairGrouped(a, b uint8, y Uint64x8) Uint64x8 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPair returns the selection of two elements from the two
+// ConcatPermuteScalars returns the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
 // of y.  When the selectors are constants the selection can be
@@ -840,7 +840,7 @@ func (x Uint64x8) SelectFromPairGrouped(a, b uint8, y Uint64x8) Uint64x8 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX
-func (x Float64x2) SelectFromPair(a, b uint8, y Float64x2) Float64x2 {
+func (x Float64x2) ConcatPermuteScalars(a, b uint8, y Float64x2) Float64x2 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -858,7 +858,7 @@ func (x Float64x2) SelectFromPair(a, b uint8, y Float64x2) Float64x2 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the two 128-bit halves of
+// ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of
 // the vectors x and y, the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
@@ -869,7 +869,7 @@ func (x Float64x2) SelectFromPair(a, b uint8, y Float64x2) Float64x2 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX
-func (x Float64x4) SelectFromPairGrouped(a, b uint8, y Float64x4) Float64x4 {
+func (x Float64x4) ConcatPermuteScalarsGrouped(a, b uint8, y Float64x4) Float64x4 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -887,7 +887,7 @@ func (x Float64x4) SelectFromPairGrouped(a, b uint8, y Float64x4) Float64x4 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the four 128-bit subvectors
+// ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors
 // of the vectors x and y, the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
@@ -898,7 +898,7 @@ func (x Float64x4) SelectFromPairGrouped(a, b uint8, y Float64x4) Float64x4 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX512
-func (x Float64x8) SelectFromPairGrouped(a, b uint8, y Float64x8) Float64x8 {
+func (x Float64x8) ConcatPermuteScalarsGrouped(a, b uint8, y Float64x8) Float64x8 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -916,7 +916,7 @@ func (x Float64x8) SelectFromPairGrouped(a, b uint8, y Float64x8) Float64x8 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPair returns the selection of two elements from the two
+// ConcatPermuteScalars returns the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
 // of y.  When the selectors are constants the selection can be
@@ -926,7 +926,7 @@ func (x Float64x8) SelectFromPairGrouped(a, b uint8, y Float64x8) Float64x8 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX
-func (x Int64x2) SelectFromPair(a, b uint8, y Int64x2) Int64x2 {
+func (x Int64x2) ConcatPermuteScalars(a, b uint8, y Int64x2) Int64x2 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -944,7 +944,7 @@ func (x Int64x2) SelectFromPair(a, b uint8, y Int64x2) Int64x2 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the two 128-bit halves of
+// ConcatPermuteScalarsGrouped returns, for each of the two 128-bit halves of
 // the vectors x and y, the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
@@ -955,7 +955,7 @@ func (x Int64x2) SelectFromPair(a, b uint8, y Int64x2) Int64x2 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX
-func (x Int64x4) SelectFromPairGrouped(a, b uint8, y Int64x4) Int64x4 {
+func (x Int64x4) ConcatPermuteScalarsGrouped(a, b uint8, y Int64x4) Int64x4 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -973,7 +973,7 @@ func (x Int64x4) SelectFromPairGrouped(a, b uint8, y Int64x4) Int64x4 {
 	panic("missing case, switch should be exhaustive")
 }
 
-// SelectFromPairGrouped returns, for each of the four 128-bit subvectors
+// ConcatPermuteScalarsGrouped returns, for each of the four 128-bit subvectors
 // of the vectors x and y, the selection of two elements from the two
 // vectors x and y, where selector values in the range 0-1 specify
 // elements from x and values in the range 2-3 specify the 0-1 elements
@@ -984,7 +984,7 @@ func (x Int64x4) SelectFromPairGrouped(a, b uint8, y Int64x4) Int64x4 {
 // call.
 //
 // Asm: VSHUFPD, CPU Feature: AVX512
-func (x Int64x8) SelectFromPairGrouped(a, b uint8, y Int64x8) Int64x8 {
+func (x Int64x8) ConcatPermuteScalarsGrouped(a, b uint8, y Int64x8) Int64x8 {
 	pattern := (a&2)>>1 + (b & 2)
 
 	a, b = a&1, b&1
@@ -1098,7 +1098,7 @@ func (x Uint32x16) PermuteScalarsGrouped(a, b, c, d uint8) Uint32x16 {
 // If a through d are constants, then an instruction will be inlined, otherwise
 // a jump table is generated.
 //
-// Asm: VPSHUFHW, CPU Feature: AVX512
+// Asm: VPSHUFHW, CPU Feature: AVX
 func (x Int16x8) PermuteScalarsHi(a, b, c, d uint8) Int16x8 {
 	return x.permuteScalarsHi(a&3 | (b&3)<<2 | (c&3)<<4 | d<<6)
 }
@@ -1111,7 +1111,7 @@ func (x Int16x8) PermuteScalarsHi(a, b, c, d uint8) Int16x8 {
 // If a through d are constants, then an instruction will be inlined, otherwise
 // a jump table is generated.
 //
-// Asm: VPSHUFHW, CPU Feature: AVX512
+// Asm: VPSHUFHW, CPU Feature: AVX
 func (x Uint16x8) PermuteScalarsHi(a, b, c, d uint8) Uint16x8 {
 	return x.permuteScalarsHi(a&3 | (b&3)<<2 | (c&3)<<4 | d<<6)
 }
@@ -1279,12 +1279,8 @@ func (x Uint16x32) PermuteScalarsLoGrouped(a, b, c, d uint8) Uint16x32 {
 	return x.permuteScalarsLoGrouped(a&3 | (b&3)<<2 | (c&3)<<4 | d<<6)
 }
 
-// CarrylessMultiply computes one of four possible carryless
-// multiplications of selected high and low halves of x and y,
-// depending on the values of a and b, returning the 128-bit
-// product in the concatenated two elements of the result.
-// a selects the low (0) or high (1) element of x and
-// b selects the low (0) or high (1) element of y.
+// CarrylessMultiplyEven computes the carryless
+// multiplications of selected even halves of the elements of x and y.
 //
 // A carryless multiplication uses bitwise XOR instead of
 // add-with-carry, for example (in base two):
@@ -1296,20 +1292,31 @@ func (x Uint16x32) PermuteScalarsLoGrouped(a, b, c, d uint8) Uint16x32 {
 // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
 // polynomial terms, but coefficients "add" with XOR.)
 //
-// constant values of a and b will result in better performance,
-// otherwise the intrinsic may translate into a jump table.
+// Asm: VPCLMULQDQ, CPU Feature: AVX
+func (x Uint64x2) CarrylessMultiplyEven(y Uint64x2) Uint64x2 {
+	return x.carrylessMultiply(0, y)
+}
+
+// CarrylessMultiplyOdd computes the carryless
+// multiplications of selected odd halves of the elements of x and y.
+//
+// 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.)
 //
 // Asm: VPCLMULQDQ, CPU Feature: AVX
-func (x Uint64x2) CarrylessMultiply(a, b uint8, y Uint64x2) Uint64x2 {
-	return x.carrylessMultiply(a&1+((b&1)<<4), y)
+func (x Uint64x2) CarrylessMultiplyOdd(y Uint64x2) Uint64x2 {
+	return x.carrylessMultiply(0b10001, y)
 }
 
-// CarrylessMultiplyGrouped computes one of four possible carryless
-// multiplications of selected high and low halves of each of the two
-// 128-bit lanes of x and y, depending on the values of a and b,
-// and returns the four 128-bit products in the result's lanes.
-// a selects the low (0) or high (1) elements of x's lanes and
-// b selects the low (0) or high (1) elements of y's lanes.
+// CarrylessMultiplyOddEven computes the carryless
+// multiplications of selected odd half of x's elements and even half of y's elements.
 //
 // A carryless multiplication uses bitwise XOR instead of
 // add-with-carry, for example (in base two):
@@ -1321,20 +1328,139 @@ func (x Uint64x2) CarrylessMultiply(a, b uint8, y Uint64x2) Uint64x2 {
 // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
 // polynomial terms, but coefficients "add" with XOR.)
 //
-// constant values of a and b will result in better performance,
-// otherwise the intrinsic may translate into a jump table.
+// Asm: VPCLMULQDQ, CPU Feature: AVX
+func (x Uint64x2) CarrylessMultiplyOddEven(y Uint64x2) Uint64x2 {
+	return x.carrylessMultiply(0b1, y)
+}
+
+// CarrylessMultiplyEvenOdd computes the carryless
+// multiplications of selected even half of x's elements and odd half of y's elements.
+//
+// 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.)
+//
+// Asm: VPCLMULQDQ, CPU Feature: AVX
+func (x Uint64x2) CarrylessMultiplyEvenOdd(y Uint64x2) Uint64x2 {
+	return x.carrylessMultiply(0b10000, y)
+}
+
+// CarrylessMultiplyEven computes the carryless
+// multiplications of selected even halves of the elements of x and y.
+//
+// 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.)
+//
+// Asm: VPCLMULQDQ, CPU Feature: AVX2
+func (x Uint64x4) CarrylessMultiplyEven(y Uint64x4) Uint64x4 {
+	return x.carrylessMultiply(0, y)
+}
+
+// CarrylessMultiplyOdd computes the carryless
+// multiplications of selected odd halves of the elements of x and y.
+//
+// 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.)
+//
+// Asm: VPCLMULQDQ, CPU Feature: AVX2
+func (x Uint64x4) CarrylessMultiplyOdd(y Uint64x4) Uint64x4 {
+	return x.carrylessMultiply(0b10001, y)
+}
+
+// CarrylessMultiplyOddEven computes the carryless
+// multiplications of selected odd half of x's elements and even half of y's elements.
+//
+// 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.)
+//
+// Asm: VPCLMULQDQ, CPU Feature: AVX2
+func (x Uint64x4) CarrylessMultiplyOddEven(y Uint64x4) Uint64x4 {
+	return x.carrylessMultiply(0b1, y)
+}
+
+// CarrylessMultiplyEvenOdd computes the carryless
+// multiplications of selected even half of x's elements and odd half of y's elements.
+//
+// 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.)
+//
+// Asm: VPCLMULQDQ, CPU Feature: AVX2
+func (x Uint64x4) CarrylessMultiplyEvenOdd(y Uint64x4) Uint64x4 {
+	return x.carrylessMultiply(0b10000, y)
+}
+
+// CarrylessMultiplyEven computes the carryless
+// multiplications of selected even halves of the elements of x and y.
+//
+// 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.)
+//
+// Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ
+func (x Uint64x8) CarrylessMultiplyEven(y Uint64x8) Uint64x8 {
+	return x.carrylessMultiply(0, y)
+}
+
+// CarrylessMultiplyOdd computes the carryless
+// multiplications of selected odd halves of the elements of x and y.
+//
+// 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.)
 //
 // Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ
-func (x Uint64x4) CarrylessMultiplyGrouped(a, b uint8, y Uint64x4) Uint64x4 {
-	return x.carrylessMultiply(a&1+((b&1)<<4), y)
+func (x Uint64x8) CarrylessMultiplyOdd(y Uint64x8) Uint64x8 {
+	return x.carrylessMultiply(0b10001, y)
 }
 
-// CarrylessMultiplyGrouped computes one of four possible carryless
-// multiplications of selected high and low halves of each of the four
-// 128-bit lanes of x and y, depending on the values of a and b,
-// and returns the four 128-bit products in the result's lanes.
-// a selects the low (0) or high (1) elements of x's lanes and
-// b selects the low (0) or high (1) elements of y's lanes.
+// CarrylessMultiplyOddEven computes the carryless
+// multiplications of selected odd half of x's elements and even half of y's elements.
 //
 // A carryless multiplication uses bitwise XOR instead of
 // add-with-carry, for example (in base two):
@@ -1346,10 +1472,25 @@ func (x Uint64x4) CarrylessMultiplyGrouped(a, b uint8, y Uint64x4) Uint64x4 {
 // x**2 + 0x + 1 = x**2 + 1 modeled by 101.  (Note that "+" adds
 // polynomial terms, but coefficients "add" with XOR.)
 //
-// constant values of a and b will result in better performance,
-// otherwise the intrinsic may translate into a jump table.
+// Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ
+func (x Uint64x8) CarrylessMultiplyOddEven(y Uint64x8) Uint64x8 {
+	return x.carrylessMultiply(0b1, y)
+}
+
+// CarrylessMultiplyEvenOdd computes the carryless
+// multiplications of selected even half of x's elements and odd half of y's elements.
+//
+// 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.)
 //
 // Asm: VPCLMULQDQ, CPU Feature: AVX512VPCLMULQDQ
-func (x Uint64x8) CarrylessMultiplyGrouped(a, b uint8, y Uint64x8) Uint64x8 {
-	return x.carrylessMultiply(a&1+((b&1)<<4), y)
+func (x Uint64x8) CarrylessMultiplyEvenOdd(y Uint64x8) Uint64x8 {
+	return x.carrylessMultiply(0b10000, y)
 }