Source file src/simd/archsimd/slice_gen_amd64.go

     1  // Code generated by 'tmplgen'; DO NOT EDIT.
     2  
     3  //go:build goexperiment.simd
     4  
     5  package archsimd
     6  
     7  import "unsafe"
     8  
     9  // LoadInt8x16 loads an Int8x16 from a slice of elements.
    10  // If s does not have at least 16 elements, it panics.
    11  func LoadInt8x16(s []int8) Int8x16 {
    12  	return LoadInt8x16Array((*[16]int8)(s))
    13  }
    14  
    15  // Store stores the elements of x into a slice.
    16  // If s does not have at least 16 elements, it panics.
    17  func (x Int8x16) Store(s []int8) {
    18  	x.StoreArray((*[16]int8)(s))
    19  }
    20  
    21  // LoadInt16x8 loads an Int16x8 from a slice of elements.
    22  // If s does not have at least 8 elements, it panics.
    23  func LoadInt16x8(s []int16) Int16x8 {
    24  	return LoadInt16x8Array((*[8]int16)(s))
    25  }
    26  
    27  // Store stores the elements of x into a slice.
    28  // If s does not have at least 8 elements, it panics.
    29  func (x Int16x8) Store(s []int16) {
    30  	x.StoreArray((*[8]int16)(s))
    31  }
    32  
    33  // LoadInt32x4 loads an Int32x4 from a slice of elements.
    34  // If s does not have at least 4 elements, it panics.
    35  func LoadInt32x4(s []int32) Int32x4 {
    36  	return LoadInt32x4Array((*[4]int32)(s))
    37  }
    38  
    39  // Store stores the elements of x into a slice.
    40  // If s does not have at least 4 elements, it panics.
    41  func (x Int32x4) Store(s []int32) {
    42  	x.StoreArray((*[4]int32)(s))
    43  }
    44  
    45  // LoadInt64x2 loads an Int64x2 from a slice of elements.
    46  // If s does not have at least 2 elements, it panics.
    47  func LoadInt64x2(s []int64) Int64x2 {
    48  	return LoadInt64x2Array((*[2]int64)(s))
    49  }
    50  
    51  // Store stores the elements of x into a slice.
    52  // If s does not have at least 2 elements, it panics.
    53  func (x Int64x2) Store(s []int64) {
    54  	x.StoreArray((*[2]int64)(s))
    55  }
    56  
    57  // LoadUint8x16 loads an Uint8x16 from a slice of elements.
    58  // If s does not have at least 16 elements, it panics.
    59  func LoadUint8x16(s []uint8) Uint8x16 {
    60  	return LoadUint8x16Array((*[16]uint8)(s))
    61  }
    62  
    63  // Store stores the elements of x into a slice.
    64  // If s does not have at least 16 elements, it panics.
    65  func (x Uint8x16) Store(s []uint8) {
    66  	x.StoreArray((*[16]uint8)(s))
    67  }
    68  
    69  // LoadUint16x8 loads an Uint16x8 from a slice of elements.
    70  // If s does not have at least 8 elements, it panics.
    71  func LoadUint16x8(s []uint16) Uint16x8 {
    72  	return LoadUint16x8Array((*[8]uint16)(s))
    73  }
    74  
    75  // Store stores the elements of x into a slice.
    76  // If s does not have at least 8 elements, it panics.
    77  func (x Uint16x8) Store(s []uint16) {
    78  	x.StoreArray((*[8]uint16)(s))
    79  }
    80  
    81  // LoadUint32x4 loads an Uint32x4 from a slice of elements.
    82  // If s does not have at least 4 elements, it panics.
    83  func LoadUint32x4(s []uint32) Uint32x4 {
    84  	return LoadUint32x4Array((*[4]uint32)(s))
    85  }
    86  
    87  // Store stores the elements of x into a slice.
    88  // If s does not have at least 4 elements, it panics.
    89  func (x Uint32x4) Store(s []uint32) {
    90  	x.StoreArray((*[4]uint32)(s))
    91  }
    92  
    93  // LoadUint64x2 loads an Uint64x2 from a slice of elements.
    94  // If s does not have at least 2 elements, it panics.
    95  func LoadUint64x2(s []uint64) Uint64x2 {
    96  	return LoadUint64x2Array((*[2]uint64)(s))
    97  }
    98  
    99  // Store stores the elements of x into a slice.
   100  // If s does not have at least 2 elements, it panics.
   101  func (x Uint64x2) Store(s []uint64) {
   102  	x.StoreArray((*[2]uint64)(s))
   103  }
   104  
   105  // LoadFloat32x4 loads a Float32x4 from a slice of elements.
   106  // If s does not have at least 4 elements, it panics.
   107  func LoadFloat32x4(s []float32) Float32x4 {
   108  	return LoadFloat32x4Array((*[4]float32)(s))
   109  }
   110  
   111  // Store stores the elements of x into a slice.
   112  // If s does not have at least 4 elements, it panics.
   113  func (x Float32x4) Store(s []float32) {
   114  	x.StoreArray((*[4]float32)(s))
   115  }
   116  
   117  // LoadFloat64x2 loads a Float64x2 from a slice of elements.
   118  // If s does not have at least 2 elements, it panics.
   119  func LoadFloat64x2(s []float64) Float64x2 {
   120  	return LoadFloat64x2Array((*[2]float64)(s))
   121  }
   122  
   123  // Store stores the elements of x into a slice.
   124  // If s does not have at least 2 elements, it panics.
   125  func (x Float64x2) Store(s []float64) {
   126  	x.StoreArray((*[2]float64)(s))
   127  }
   128  
   129  // LoadInt8x32 loads an Int8x32 from a slice of elements.
   130  // If s does not have at least 32 elements, it panics.
   131  func LoadInt8x32(s []int8) Int8x32 {
   132  	return LoadInt8x32Array((*[32]int8)(s))
   133  }
   134  
   135  // Store stores the elements of x into a slice.
   136  // If s does not have at least 32 elements, it panics.
   137  func (x Int8x32) Store(s []int8) {
   138  	x.StoreArray((*[32]int8)(s))
   139  }
   140  
   141  // LoadInt16x16 loads an Int16x16 from a slice of elements.
   142  // If s does not have at least 16 elements, it panics.
   143  func LoadInt16x16(s []int16) Int16x16 {
   144  	return LoadInt16x16Array((*[16]int16)(s))
   145  }
   146  
   147  // Store stores the elements of x into a slice.
   148  // If s does not have at least 16 elements, it panics.
   149  func (x Int16x16) Store(s []int16) {
   150  	x.StoreArray((*[16]int16)(s))
   151  }
   152  
   153  // LoadInt32x8 loads an Int32x8 from a slice of elements.
   154  // If s does not have at least 8 elements, it panics.
   155  func LoadInt32x8(s []int32) Int32x8 {
   156  	return LoadInt32x8Array((*[8]int32)(s))
   157  }
   158  
   159  // Store stores the elements of x into a slice.
   160  // If s does not have at least 8 elements, it panics.
   161  func (x Int32x8) Store(s []int32) {
   162  	x.StoreArray((*[8]int32)(s))
   163  }
   164  
   165  // LoadInt64x4 loads an Int64x4 from a slice of elements.
   166  // If s does not have at least 4 elements, it panics.
   167  func LoadInt64x4(s []int64) Int64x4 {
   168  	return LoadInt64x4Array((*[4]int64)(s))
   169  }
   170  
   171  // Store stores the elements of x into a slice.
   172  // If s does not have at least 4 elements, it panics.
   173  func (x Int64x4) Store(s []int64) {
   174  	x.StoreArray((*[4]int64)(s))
   175  }
   176  
   177  // LoadUint8x32 loads an Uint8x32 from a slice of elements.
   178  // If s does not have at least 32 elements, it panics.
   179  func LoadUint8x32(s []uint8) Uint8x32 {
   180  	return LoadUint8x32Array((*[32]uint8)(s))
   181  }
   182  
   183  // Store stores the elements of x into a slice.
   184  // If s does not have at least 32 elements, it panics.
   185  func (x Uint8x32) Store(s []uint8) {
   186  	x.StoreArray((*[32]uint8)(s))
   187  }
   188  
   189  // LoadUint16x16 loads an Uint16x16 from a slice of elements.
   190  // If s does not have at least 16 elements, it panics.
   191  func LoadUint16x16(s []uint16) Uint16x16 {
   192  	return LoadUint16x16Array((*[16]uint16)(s))
   193  }
   194  
   195  // Store stores the elements of x into a slice.
   196  // If s does not have at least 16 elements, it panics.
   197  func (x Uint16x16) Store(s []uint16) {
   198  	x.StoreArray((*[16]uint16)(s))
   199  }
   200  
   201  // LoadUint32x8 loads an Uint32x8 from a slice of elements.
   202  // If s does not have at least 8 elements, it panics.
   203  func LoadUint32x8(s []uint32) Uint32x8 {
   204  	return LoadUint32x8Array((*[8]uint32)(s))
   205  }
   206  
   207  // Store stores the elements of x into a slice.
   208  // If s does not have at least 8 elements, it panics.
   209  func (x Uint32x8) Store(s []uint32) {
   210  	x.StoreArray((*[8]uint32)(s))
   211  }
   212  
   213  // LoadUint64x4 loads an Uint64x4 from a slice of elements.
   214  // If s does not have at least 4 elements, it panics.
   215  func LoadUint64x4(s []uint64) Uint64x4 {
   216  	return LoadUint64x4Array((*[4]uint64)(s))
   217  }
   218  
   219  // Store stores the elements of x into a slice.
   220  // If s does not have at least 4 elements, it panics.
   221  func (x Uint64x4) Store(s []uint64) {
   222  	x.StoreArray((*[4]uint64)(s))
   223  }
   224  
   225  // LoadFloat32x8 loads a Float32x8 from a slice of elements.
   226  // If s does not have at least 8 elements, it panics.
   227  func LoadFloat32x8(s []float32) Float32x8 {
   228  	return LoadFloat32x8Array((*[8]float32)(s))
   229  }
   230  
   231  // Store stores the elements of x into a slice.
   232  // If s does not have at least 8 elements, it panics.
   233  func (x Float32x8) Store(s []float32) {
   234  	x.StoreArray((*[8]float32)(s))
   235  }
   236  
   237  // LoadFloat64x4 loads a Float64x4 from a slice of elements.
   238  // If s does not have at least 4 elements, it panics.
   239  func LoadFloat64x4(s []float64) Float64x4 {
   240  	return LoadFloat64x4Array((*[4]float64)(s))
   241  }
   242  
   243  // Store stores the elements of x into a slice.
   244  // If s does not have at least 4 elements, it panics.
   245  func (x Float64x4) Store(s []float64) {
   246  	x.StoreArray((*[4]float64)(s))
   247  }
   248  
   249  // LoadInt8x64 loads an Int8x64 from a slice of elements.
   250  // If s does not have at least 64 elements, it panics.
   251  func LoadInt8x64(s []int8) Int8x64 {
   252  	return LoadInt8x64Array((*[64]int8)(s))
   253  }
   254  
   255  // Store stores the elements of x into a slice.
   256  // If s does not have at least 64 elements, it panics.
   257  func (x Int8x64) Store(s []int8) {
   258  	x.StoreArray((*[64]int8)(s))
   259  }
   260  
   261  // LoadInt16x32 loads an Int16x32 from a slice of elements.
   262  // If s does not have at least 32 elements, it panics.
   263  func LoadInt16x32(s []int16) Int16x32 {
   264  	return LoadInt16x32Array((*[32]int16)(s))
   265  }
   266  
   267  // Store stores the elements of x into a slice.
   268  // If s does not have at least 32 elements, it panics.
   269  func (x Int16x32) Store(s []int16) {
   270  	x.StoreArray((*[32]int16)(s))
   271  }
   272  
   273  // LoadInt32x16 loads an Int32x16 from a slice of elements.
   274  // If s does not have at least 16 elements, it panics.
   275  func LoadInt32x16(s []int32) Int32x16 {
   276  	return LoadInt32x16Array((*[16]int32)(s))
   277  }
   278  
   279  // Store stores the elements of x into a slice.
   280  // If s does not have at least 16 elements, it panics.
   281  func (x Int32x16) Store(s []int32) {
   282  	x.StoreArray((*[16]int32)(s))
   283  }
   284  
   285  // LoadInt64x8 loads an Int64x8 from a slice of elements.
   286  // If s does not have at least 8 elements, it panics.
   287  func LoadInt64x8(s []int64) Int64x8 {
   288  	return LoadInt64x8Array((*[8]int64)(s))
   289  }
   290  
   291  // Store stores the elements of x into a slice.
   292  // If s does not have at least 8 elements, it panics.
   293  func (x Int64x8) Store(s []int64) {
   294  	x.StoreArray((*[8]int64)(s))
   295  }
   296  
   297  // LoadUint8x64 loads an Uint8x64 from a slice of elements.
   298  // If s does not have at least 64 elements, it panics.
   299  func LoadUint8x64(s []uint8) Uint8x64 {
   300  	return LoadUint8x64Array((*[64]uint8)(s))
   301  }
   302  
   303  // Store stores the elements of x into a slice.
   304  // If s does not have at least 64 elements, it panics.
   305  func (x Uint8x64) Store(s []uint8) {
   306  	x.StoreArray((*[64]uint8)(s))
   307  }
   308  
   309  // LoadUint16x32 loads an Uint16x32 from a slice of elements.
   310  // If s does not have at least 32 elements, it panics.
   311  func LoadUint16x32(s []uint16) Uint16x32 {
   312  	return LoadUint16x32Array((*[32]uint16)(s))
   313  }
   314  
   315  // Store stores the elements of x into a slice.
   316  // If s does not have at least 32 elements, it panics.
   317  func (x Uint16x32) Store(s []uint16) {
   318  	x.StoreArray((*[32]uint16)(s))
   319  }
   320  
   321  // LoadUint32x16 loads an Uint32x16 from a slice of elements.
   322  // If s does not have at least 16 elements, it panics.
   323  func LoadUint32x16(s []uint32) Uint32x16 {
   324  	return LoadUint32x16Array((*[16]uint32)(s))
   325  }
   326  
   327  // Store stores the elements of x into a slice.
   328  // If s does not have at least 16 elements, it panics.
   329  func (x Uint32x16) Store(s []uint32) {
   330  	x.StoreArray((*[16]uint32)(s))
   331  }
   332  
   333  // LoadUint64x8 loads an Uint64x8 from a slice of elements.
   334  // If s does not have at least 8 elements, it panics.
   335  func LoadUint64x8(s []uint64) Uint64x8 {
   336  	return LoadUint64x8Array((*[8]uint64)(s))
   337  }
   338  
   339  // Store stores the elements of x into a slice.
   340  // If s does not have at least 8 elements, it panics.
   341  func (x Uint64x8) Store(s []uint64) {
   342  	x.StoreArray((*[8]uint64)(s))
   343  }
   344  
   345  // LoadFloat32x16 loads a Float32x16 from a slice of elements.
   346  // If s does not have at least 16 elements, it panics.
   347  func LoadFloat32x16(s []float32) Float32x16 {
   348  	return LoadFloat32x16Array((*[16]float32)(s))
   349  }
   350  
   351  // Store stores the elements of x into a slice.
   352  // If s does not have at least 16 elements, it panics.
   353  func (x Float32x16) Store(s []float32) {
   354  	x.StoreArray((*[16]float32)(s))
   355  }
   356  
   357  // LoadFloat64x8 loads a Float64x8 from a slice of elements.
   358  // If s does not have at least 8 elements, it panics.
   359  func LoadFloat64x8(s []float64) Float64x8 {
   360  	return LoadFloat64x8Array((*[8]float64)(s))
   361  }
   362  
   363  // Store stores the elements of x into a slice.
   364  // If s does not have at least 8 elements, it panics.
   365  func (x Float64x8) Store(s []float64) {
   366  	x.StoreArray((*[8]float64)(s))
   367  }
   368  
   369  // LoadInt8x64Part loads a Int8x64 from the slice s, it returns the loaded vector and the
   370  // number of elements loaded.
   371  // If s has fewer than 64 elements, the remaining elements of the vector are filled with zeroes.
   372  // If s has 64 or more elements, the function is equivalent to LoadInt8x64.
   373  func LoadInt8x64Part(s []int8) (Int8x64, int) {
   374  	l := len(s)
   375  	if l >= 64 {
   376  		return LoadInt8x64(s), 64
   377  	}
   378  	if l == 0 {
   379  		var x Int8x64
   380  		return x, 0
   381  	}
   382  	mask := Mask8x64FromBits(0xffffffffffffffff >> (64 - l))
   383  	return LoadInt8x64Array(paInt8x64(s)).Masked(mask), l
   384  }
   385  
   386  // StorePart stores the 64 elements of x into the slice s.
   387  // It stores as many elements as will fit in s.
   388  // If s has 64 or more elements, the method is equivalent to x.Store.
   389  func (x Int8x64) StorePart(s []int8) int {
   390  	l := len(s)
   391  	if l >= 64 {
   392  		x.Store(s)
   393  		return 64
   394  	}
   395  	if l == 0 {
   396  		return 0
   397  	}
   398  	mask := Mask8x64FromBits(0xffffffffffffffff >> (64 - l))
   399  	x.StoreArrayMasked(paInt8x64(s), mask)
   400  	return l
   401  }
   402  
   403  // LoadInt16x32Part loads a Int16x32 from the slice s, it returns the loaded vector and the
   404  // number of elements loaded.
   405  // If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes.
   406  // If s has 32 or more elements, the function is equivalent to LoadInt16x32.
   407  func LoadInt16x32Part(s []int16) (Int16x32, int) {
   408  	l := len(s)
   409  	if l >= 32 {
   410  		return LoadInt16x32(s), 32
   411  	}
   412  	if l == 0 {
   413  		var x Int16x32
   414  		return x, 0
   415  	}
   416  	mask := Mask16x32FromBits(0xffffffff >> (32 - l))
   417  	return LoadInt16x32Array(paInt16x32(s)).Masked(mask), l
   418  }
   419  
   420  // StorePart stores the 32 elements of x into the slice s.
   421  // It stores as many elements as will fit in s.
   422  // If s has 32 or more elements, the method is equivalent to x.Store.
   423  func (x Int16x32) StorePart(s []int16) int {
   424  	l := len(s)
   425  	if l >= 32 {
   426  		x.Store(s)
   427  		return 32
   428  	}
   429  	if l == 0 {
   430  		return 0
   431  	}
   432  	mask := Mask16x32FromBits(0xffffffff >> (32 - l))
   433  	x.StoreArrayMasked(paInt16x32(s), mask)
   434  	return l
   435  }
   436  
   437  // LoadInt32x16Part loads a Int32x16 from the slice s, it returns the loaded vector and the
   438  // number of elements loaded.
   439  // If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes.
   440  // If s has 16 or more elements, the function is equivalent to LoadInt32x16.
   441  func LoadInt32x16Part(s []int32) (Int32x16, int) {
   442  	l := len(s)
   443  	if l >= 16 {
   444  		return LoadInt32x16(s), 16
   445  	}
   446  	if l == 0 {
   447  		var x Int32x16
   448  		return x, 0
   449  	}
   450  	mask := Mask32x16FromBits(0xffff >> (16 - l))
   451  	return LoadInt32x16Array(paInt32x16(s)).Masked(mask), l
   452  }
   453  
   454  // StorePart stores the 16 elements of x into the slice s.
   455  // It stores as many elements as will fit in s.
   456  // If s has 16 or more elements, the method is equivalent to x.Store.
   457  func (x Int32x16) StorePart(s []int32) int {
   458  	l := len(s)
   459  	if l >= 16 {
   460  		x.Store(s)
   461  		return 16
   462  	}
   463  	if l == 0 {
   464  		return 0
   465  	}
   466  	mask := Mask32x16FromBits(0xffff >> (16 - l))
   467  	x.StoreArrayMasked(paInt32x16(s), mask)
   468  	return l
   469  }
   470  
   471  // LoadInt64x8Part loads a Int64x8 from the slice s, it returns the loaded vector and the
   472  // number of elements loaded.
   473  // If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes.
   474  // If s has 8 or more elements, the function is equivalent to LoadInt64x8.
   475  func LoadInt64x8Part(s []int64) (Int64x8, int) {
   476  	l := len(s)
   477  	if l >= 8 {
   478  		return LoadInt64x8(s), 8
   479  	}
   480  	if l == 0 {
   481  		var x Int64x8
   482  		return x, 0
   483  	}
   484  	mask := Mask64x8FromBits(0xff >> (8 - l))
   485  	return LoadInt64x8Array(paInt64x8(s)).Masked(mask), l
   486  }
   487  
   488  // StorePart stores the 8 elements of x into the slice s.
   489  // It stores as many elements as will fit in s.
   490  // If s has 8 or more elements, the method is equivalent to x.Store.
   491  func (x Int64x8) StorePart(s []int64) int {
   492  	l := len(s)
   493  	if l >= 8 {
   494  		x.Store(s)
   495  		return 8
   496  	}
   497  	if l == 0 {
   498  		return 0
   499  	}
   500  	mask := Mask64x8FromBits(0xff >> (8 - l))
   501  	x.StoreArrayMasked(paInt64x8(s), mask)
   502  	return l
   503  }
   504  
   505  // LoadUint8x64Part loads a Uint8x64 from the slice s, it returns the loaded vector and the
   506  // number of elements loaded.
   507  // If s has fewer than 64 elements, the remaining elements of the vector are filled with zeroes.
   508  // If s has 64 or more elements, the function is equivalent to LoadUint8x64.
   509  func LoadUint8x64Part(s []uint8) (Uint8x64, int) {
   510  	l := len(s)
   511  	if l >= 64 {
   512  		return LoadUint8x64(s), 64
   513  	}
   514  	if l == 0 {
   515  		var x Uint8x64
   516  		return x, 0
   517  	}
   518  	mask := Mask8x64FromBits(0xffffffffffffffff >> (64 - l))
   519  	return LoadUint8x64Array(paUint8x64(s)).Masked(mask), l
   520  }
   521  
   522  // StorePart stores the 64 elements of x into the slice s.
   523  // It stores as many elements as will fit in s.
   524  // If s has 64 or more elements, the method is equivalent to x.Store.
   525  func (x Uint8x64) StorePart(s []uint8) int {
   526  	l := len(s)
   527  	if l >= 64 {
   528  		x.Store(s)
   529  		return 64
   530  	}
   531  	if l == 0 {
   532  		return 0
   533  	}
   534  	mask := Mask8x64FromBits(0xffffffffffffffff >> (64 - l))
   535  	x.StoreArrayMasked(paUint8x64(s), mask)
   536  	return l
   537  }
   538  
   539  // LoadUint16x32Part loads a Uint16x32 from the slice s, it returns the loaded vector and the
   540  // number of elements loaded.
   541  // If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes.
   542  // If s has 32 or more elements, the function is equivalent to LoadUint16x32.
   543  func LoadUint16x32Part(s []uint16) (Uint16x32, int) {
   544  	l := len(s)
   545  	if l >= 32 {
   546  		return LoadUint16x32(s), 32
   547  	}
   548  	if l == 0 {
   549  		var x Uint16x32
   550  		return x, 0
   551  	}
   552  	mask := Mask16x32FromBits(0xffffffff >> (32 - l))
   553  	return LoadUint16x32Array(paUint16x32(s)).Masked(mask), l
   554  }
   555  
   556  // StorePart stores the 32 elements of x into the slice s.
   557  // It stores as many elements as will fit in s.
   558  // If s has 32 or more elements, the method is equivalent to x.Store.
   559  func (x Uint16x32) StorePart(s []uint16) int {
   560  	l := len(s)
   561  	if l >= 32 {
   562  		x.Store(s)
   563  		return 32
   564  	}
   565  	if l == 0 {
   566  		return 0
   567  	}
   568  	mask := Mask16x32FromBits(0xffffffff >> (32 - l))
   569  	x.StoreArrayMasked(paUint16x32(s), mask)
   570  	return l
   571  }
   572  
   573  // LoadUint32x16Part loads a Uint32x16 from the slice s, it returns the loaded vector and the
   574  // number of elements loaded.
   575  // If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes.
   576  // If s has 16 or more elements, the function is equivalent to LoadUint32x16.
   577  func LoadUint32x16Part(s []uint32) (Uint32x16, int) {
   578  	l := len(s)
   579  	if l >= 16 {
   580  		return LoadUint32x16(s), 16
   581  	}
   582  	if l == 0 {
   583  		var x Uint32x16
   584  		return x, 0
   585  	}
   586  	mask := Mask32x16FromBits(0xffff >> (16 - l))
   587  	return LoadUint32x16Array(paUint32x16(s)).Masked(mask), l
   588  }
   589  
   590  // StorePart stores the 16 elements of x into the slice s.
   591  // It stores as many elements as will fit in s.
   592  // If s has 16 or more elements, the method is equivalent to x.Store.
   593  func (x Uint32x16) StorePart(s []uint32) int {
   594  	l := len(s)
   595  	if l >= 16 {
   596  		x.Store(s)
   597  		return 16
   598  	}
   599  	if l == 0 {
   600  		return 0
   601  	}
   602  	mask := Mask32x16FromBits(0xffff >> (16 - l))
   603  	x.StoreArrayMasked(paUint32x16(s), mask)
   604  	return l
   605  }
   606  
   607  // LoadUint64x8Part loads a Uint64x8 from the slice s, it returns the loaded vector and the
   608  // number of elements loaded.
   609  // If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes.
   610  // If s has 8 or more elements, the function is equivalent to LoadUint64x8.
   611  func LoadUint64x8Part(s []uint64) (Uint64x8, int) {
   612  	l := len(s)
   613  	if l >= 8 {
   614  		return LoadUint64x8(s), 8
   615  	}
   616  	if l == 0 {
   617  		var x Uint64x8
   618  		return x, 0
   619  	}
   620  	mask := Mask64x8FromBits(0xff >> (8 - l))
   621  	return LoadUint64x8Array(paUint64x8(s)).Masked(mask), l
   622  }
   623  
   624  // StorePart stores the 8 elements of x into the slice s.
   625  // It stores as many elements as will fit in s.
   626  // If s has 8 or more elements, the method is equivalent to x.Store.
   627  func (x Uint64x8) StorePart(s []uint64) int {
   628  	l := len(s)
   629  	if l >= 8 {
   630  		x.Store(s)
   631  		return 8
   632  	}
   633  	if l == 0 {
   634  		return 0
   635  	}
   636  	mask := Mask64x8FromBits(0xff >> (8 - l))
   637  	x.StoreArrayMasked(paUint64x8(s), mask)
   638  	return l
   639  }
   640  
   641  // LoadFloat32x16Part loads a Float32x16 from the slice s, it returns the loaded vector and the
   642  // number of elements loaded.
   643  // If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes.
   644  // If s has 16 or more elements, the function is equivalent to LoadFloat32x16.
   645  func LoadFloat32x16Part(s []float32) (Float32x16, int) {
   646  	l := len(s)
   647  	if l >= 16 {
   648  		return LoadFloat32x16(s), 16
   649  	}
   650  	if l == 0 {
   651  		var x Float32x16
   652  		return x, 0
   653  	}
   654  	mask := Mask32x16FromBits(0xffff >> (16 - l))
   655  	return LoadFloat32x16Array(paFloat32x16(s)).Masked(mask), l
   656  }
   657  
   658  // StorePart stores the 16 elements of x into the slice s.
   659  // It stores as many elements as will fit in s.
   660  // If s has 16 or more elements, the method is equivalent to x.Store.
   661  func (x Float32x16) StorePart(s []float32) int {
   662  	l := len(s)
   663  	if l >= 16 {
   664  		x.Store(s)
   665  		return 16
   666  	}
   667  	if l == 0 {
   668  		return 0
   669  	}
   670  	mask := Mask32x16FromBits(0xffff >> (16 - l))
   671  	x.StoreArrayMasked(paFloat32x16(s), mask)
   672  	return l
   673  }
   674  
   675  // LoadFloat64x8Part loads a Float64x8 from the slice s, it returns the loaded vector and the
   676  // number of elements loaded.
   677  // If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes.
   678  // If s has 8 or more elements, the function is equivalent to LoadFloat64x8.
   679  func LoadFloat64x8Part(s []float64) (Float64x8, int) {
   680  	l := len(s)
   681  	if l >= 8 {
   682  		return LoadFloat64x8(s), 8
   683  	}
   684  	if l == 0 {
   685  		var x Float64x8
   686  		return x, 0
   687  	}
   688  	mask := Mask64x8FromBits(0xff >> (8 - l))
   689  	return LoadFloat64x8Array(paFloat64x8(s)).Masked(mask), l
   690  }
   691  
   692  // StorePart stores the 8 elements of x into the slice s.
   693  // It stores as many elements as will fit in s.
   694  // If s has 8 or more elements, the method is equivalent to x.Store.
   695  func (x Float64x8) StorePart(s []float64) int {
   696  	l := len(s)
   697  	if l >= 8 {
   698  		x.Store(s)
   699  		return 8
   700  	}
   701  	if l == 0 {
   702  		return 0
   703  	}
   704  	mask := Mask64x8FromBits(0xff >> (8 - l))
   705  	x.StoreArrayMasked(paFloat64x8(s), mask)
   706  	return l
   707  }
   708  
   709  // LoadInt32x4Part loads a Int32x4 from the slice s, it returns the loaded vector and the
   710  // number of elements loaded.
   711  // If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes.
   712  // If s has 4 or more elements, the function is equivalent to LoadInt32x4.
   713  func LoadInt32x4Part(s []int32) (Int32x4, int) {
   714  	l := len(s)
   715  	if l >= 4 {
   716  		return LoadInt32x4(s), 4
   717  	}
   718  	if l == 0 {
   719  		var x Int32x4
   720  		return x, 0
   721  	}
   722  	mask := vecMask32[len(vecMask32)/2-l:]
   723  	return LoadInt32x4Array(paInt32x4(s)).Masked(LoadInt32x4(mask).asMask()), l
   724  }
   725  
   726  // StorePart stores the 4 elements of x into the slice s.
   727  // It stores as many elements as will fit in s.
   728  // If s has 4 or more elements, the method is equivalent to x.Store.
   729  func (x Int32x4) StorePart(s []int32) int {
   730  	l := len(s)
   731  	if l >= 4 {
   732  		x.Store(s)
   733  		return 4
   734  	}
   735  	if l == 0 {
   736  		return 0
   737  	}
   738  	mask := vecMask32[len(vecMask32)/2-l:]
   739  	x.StoreArrayMasked(paInt32x4(s), LoadInt32x4(mask).asMask())
   740  	return l
   741  }
   742  
   743  // LoadInt64x2Part loads a Int64x2 from the slice s, it returns the loaded vector and the
   744  // number of elements loaded.
   745  // If s has fewer than 2 elements, the remaining elements of the vector are filled with zeroes.
   746  // If s has 2 or more elements, the function is equivalent to LoadInt64x2.
   747  func LoadInt64x2Part(s []int64) (Int64x2, int) {
   748  	l := len(s)
   749  	if l >= 2 {
   750  		return LoadInt64x2(s), 2
   751  	}
   752  	if l == 0 {
   753  		var x Int64x2
   754  		return x, 0
   755  	}
   756  	mask := vecMask64[len(vecMask64)/2-l:]
   757  	return LoadInt64x2Array(paInt64x2(s)).Masked(LoadInt64x2(mask).asMask()), l
   758  }
   759  
   760  // StorePart stores the 2 elements of x into the slice s.
   761  // It stores as many elements as will fit in s.
   762  // If s has 2 or more elements, the method is equivalent to x.Store.
   763  func (x Int64x2) StorePart(s []int64) int {
   764  	l := len(s)
   765  	if l >= 2 {
   766  		x.Store(s)
   767  		return 2
   768  	}
   769  	if l == 0 {
   770  		return 0
   771  	}
   772  	mask := vecMask64[len(vecMask64)/2-l:]
   773  	x.StoreArrayMasked(paInt64x2(s), LoadInt64x2(mask).asMask())
   774  	return l
   775  }
   776  
   777  // LoadUint32x4Part loads a Uint32x4 from the slice s, it returns the loaded vector and the
   778  // number of elements loaded.
   779  // If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes.
   780  // If s has 4 or more elements, the function is equivalent to LoadUint32x4.
   781  func LoadUint32x4Part(s []uint32) (Uint32x4, int) {
   782  	l := len(s)
   783  	if l >= 4 {
   784  		return LoadUint32x4(s), 4
   785  	}
   786  	if l == 0 {
   787  		var x Uint32x4
   788  		return x, 0
   789  	}
   790  	mask := vecMask32[len(vecMask32)/2-l:]
   791  	return LoadUint32x4Array(paUint32x4(s)).Masked(LoadInt32x4(mask).asMask()), l
   792  }
   793  
   794  // StorePart stores the 4 elements of x into the slice s.
   795  // It stores as many elements as will fit in s.
   796  // If s has 4 or more elements, the method is equivalent to x.Store.
   797  func (x Uint32x4) StorePart(s []uint32) int {
   798  	l := len(s)
   799  	if l >= 4 {
   800  		x.Store(s)
   801  		return 4
   802  	}
   803  	if l == 0 {
   804  		return 0
   805  	}
   806  	mask := vecMask32[len(vecMask32)/2-l:]
   807  	x.StoreArrayMasked(paUint32x4(s), LoadInt32x4(mask).asMask())
   808  	return l
   809  }
   810  
   811  // LoadUint64x2Part loads a Uint64x2 from the slice s, it returns the loaded vector and the
   812  // number of elements loaded.
   813  // If s has fewer than 2 elements, the remaining elements of the vector are filled with zeroes.
   814  // If s has 2 or more elements, the function is equivalent to LoadUint64x2.
   815  func LoadUint64x2Part(s []uint64) (Uint64x2, int) {
   816  	l := len(s)
   817  	if l >= 2 {
   818  		return LoadUint64x2(s), 2
   819  	}
   820  	if l == 0 {
   821  		var x Uint64x2
   822  		return x, 0
   823  	}
   824  	mask := vecMask64[len(vecMask64)/2-l:]
   825  	return LoadUint64x2Array(paUint64x2(s)).Masked(LoadInt64x2(mask).asMask()), l
   826  }
   827  
   828  // StorePart stores the 2 elements of x into the slice s.
   829  // It stores as many elements as will fit in s.
   830  // If s has 2 or more elements, the method is equivalent to x.Store.
   831  func (x Uint64x2) StorePart(s []uint64) int {
   832  	l := len(s)
   833  	if l >= 2 {
   834  		x.Store(s)
   835  		return 2
   836  	}
   837  	if l == 0 {
   838  		return 0
   839  	}
   840  	mask := vecMask64[len(vecMask64)/2-l:]
   841  	x.StoreArrayMasked(paUint64x2(s), LoadInt64x2(mask).asMask())
   842  	return l
   843  }
   844  
   845  // LoadFloat32x4Part loads a Float32x4 from the slice s, it returns the loaded vector and the
   846  // number of elements loaded.
   847  // If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes.
   848  // If s has 4 or more elements, the function is equivalent to LoadFloat32x4.
   849  func LoadFloat32x4Part(s []float32) (Float32x4, int) {
   850  	l := len(s)
   851  	if l >= 4 {
   852  		return LoadFloat32x4(s), 4
   853  	}
   854  	if l == 0 {
   855  		var x Float32x4
   856  		return x, 0
   857  	}
   858  	mask := vecMask32[len(vecMask32)/2-l:]
   859  	return LoadFloat32x4Array(paFloat32x4(s)).Masked(LoadInt32x4(mask).asMask()), l
   860  }
   861  
   862  // StorePart stores the 4 elements of x into the slice s.
   863  // It stores as many elements as will fit in s.
   864  // If s has 4 or more elements, the method is equivalent to x.Store.
   865  func (x Float32x4) StorePart(s []float32) int {
   866  	l := len(s)
   867  	if l >= 4 {
   868  		x.Store(s)
   869  		return 4
   870  	}
   871  	if l == 0 {
   872  		return 0
   873  	}
   874  	mask := vecMask32[len(vecMask32)/2-l:]
   875  	x.StoreArrayMasked(paFloat32x4(s), LoadInt32x4(mask).asMask())
   876  	return l
   877  }
   878  
   879  // LoadFloat64x2Part loads a Float64x2 from the slice s, it returns the loaded vector and the
   880  // number of elements loaded.
   881  // If s has fewer than 2 elements, the remaining elements of the vector are filled with zeroes.
   882  // If s has 2 or more elements, the function is equivalent to LoadFloat64x2.
   883  func LoadFloat64x2Part(s []float64) (Float64x2, int) {
   884  	l := len(s)
   885  	if l >= 2 {
   886  		return LoadFloat64x2(s), 2
   887  	}
   888  	if l == 0 {
   889  		var x Float64x2
   890  		return x, 0
   891  	}
   892  	mask := vecMask64[len(vecMask64)/2-l:]
   893  	return LoadFloat64x2Array(paFloat64x2(s)).Masked(LoadInt64x2(mask).asMask()), l
   894  }
   895  
   896  // StorePart stores the 2 elements of x into the slice s.
   897  // It stores as many elements as will fit in s.
   898  // If s has 2 or more elements, the method is equivalent to x.Store.
   899  func (x Float64x2) StorePart(s []float64) int {
   900  	l := len(s)
   901  	if l >= 2 {
   902  		x.Store(s)
   903  		return 2
   904  	}
   905  	if l == 0 {
   906  		return 0
   907  	}
   908  	mask := vecMask64[len(vecMask64)/2-l:]
   909  	x.StoreArrayMasked(paFloat64x2(s), LoadInt64x2(mask).asMask())
   910  	return l
   911  }
   912  
   913  // LoadInt32x8Part loads a Int32x8 from the slice s, it returns the loaded vector and the
   914  // number of elements loaded.
   915  // If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes.
   916  // If s has 8 or more elements, the function is equivalent to LoadInt32x8.
   917  func LoadInt32x8Part(s []int32) (Int32x8, int) {
   918  	l := len(s)
   919  	if l >= 8 {
   920  		return LoadInt32x8(s), 8
   921  	}
   922  	if l == 0 {
   923  		var x Int32x8
   924  		return x, 0
   925  	}
   926  	mask := vecMask32[len(vecMask32)/2-l:]
   927  	return LoadInt32x8Array(paInt32x8(s)).Masked(LoadInt32x8(mask).asMask()), l
   928  }
   929  
   930  // StorePart stores the 8 elements of x into the slice s.
   931  // It stores as many elements as will fit in s.
   932  // If s has 8 or more elements, the method is equivalent to x.Store.
   933  func (x Int32x8) StorePart(s []int32) int {
   934  	l := len(s)
   935  	if l >= 8 {
   936  		x.Store(s)
   937  		return 8
   938  	}
   939  	if l == 0 {
   940  		return 0
   941  	}
   942  	mask := vecMask32[len(vecMask32)/2-l:]
   943  	x.StoreArrayMasked(paInt32x8(s), LoadInt32x8(mask).asMask())
   944  	return l
   945  }
   946  
   947  // LoadInt64x4Part loads a Int64x4 from the slice s, it returns the loaded vector and the
   948  // number of elements loaded.
   949  // If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes.
   950  // If s has 4 or more elements, the function is equivalent to LoadInt64x4.
   951  func LoadInt64x4Part(s []int64) (Int64x4, int) {
   952  	l := len(s)
   953  	if l >= 4 {
   954  		return LoadInt64x4(s), 4
   955  	}
   956  	if l == 0 {
   957  		var x Int64x4
   958  		return x, 0
   959  	}
   960  	mask := vecMask64[len(vecMask64)/2-l:]
   961  	return LoadInt64x4Array(paInt64x4(s)).Masked(LoadInt64x4(mask).asMask()), l
   962  }
   963  
   964  // StorePart stores the 4 elements of x into the slice s.
   965  // It stores as many elements as will fit in s.
   966  // If s has 4 or more elements, the method is equivalent to x.Store.
   967  func (x Int64x4) StorePart(s []int64) int {
   968  	l := len(s)
   969  	if l >= 4 {
   970  		x.Store(s)
   971  		return 4
   972  	}
   973  	if l == 0 {
   974  		return 0
   975  	}
   976  	mask := vecMask64[len(vecMask64)/2-l:]
   977  	x.StoreArrayMasked(paInt64x4(s), LoadInt64x4(mask).asMask())
   978  	return l
   979  }
   980  
   981  // LoadUint32x8Part loads a Uint32x8 from the slice s, it returns the loaded vector and the
   982  // number of elements loaded.
   983  // If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes.
   984  // If s has 8 or more elements, the function is equivalent to LoadUint32x8.
   985  func LoadUint32x8Part(s []uint32) (Uint32x8, int) {
   986  	l := len(s)
   987  	if l >= 8 {
   988  		return LoadUint32x8(s), 8
   989  	}
   990  	if l == 0 {
   991  		var x Uint32x8
   992  		return x, 0
   993  	}
   994  	mask := vecMask32[len(vecMask32)/2-l:]
   995  	return LoadUint32x8Array(paUint32x8(s)).Masked(LoadInt32x8(mask).asMask()), l
   996  }
   997  
   998  // StorePart stores the 8 elements of x into the slice s.
   999  // It stores as many elements as will fit in s.
  1000  // If s has 8 or more elements, the method is equivalent to x.Store.
  1001  func (x Uint32x8) StorePart(s []uint32) int {
  1002  	l := len(s)
  1003  	if l >= 8 {
  1004  		x.Store(s)
  1005  		return 8
  1006  	}
  1007  	if l == 0 {
  1008  		return 0
  1009  	}
  1010  	mask := vecMask32[len(vecMask32)/2-l:]
  1011  	x.StoreArrayMasked(paUint32x8(s), LoadInt32x8(mask).asMask())
  1012  	return l
  1013  }
  1014  
  1015  // LoadUint64x4Part loads a Uint64x4 from the slice s, it returns the loaded vector and the
  1016  // number of elements loaded.
  1017  // If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes.
  1018  // If s has 4 or more elements, the function is equivalent to LoadUint64x4.
  1019  func LoadUint64x4Part(s []uint64) (Uint64x4, int) {
  1020  	l := len(s)
  1021  	if l >= 4 {
  1022  		return LoadUint64x4(s), 4
  1023  	}
  1024  	if l == 0 {
  1025  		var x Uint64x4
  1026  		return x, 0
  1027  	}
  1028  	mask := vecMask64[len(vecMask64)/2-l:]
  1029  	return LoadUint64x4Array(paUint64x4(s)).Masked(LoadInt64x4(mask).asMask()), l
  1030  }
  1031  
  1032  // StorePart stores the 4 elements of x into the slice s.
  1033  // It stores as many elements as will fit in s.
  1034  // If s has 4 or more elements, the method is equivalent to x.Store.
  1035  func (x Uint64x4) StorePart(s []uint64) int {
  1036  	l := len(s)
  1037  	if l >= 4 {
  1038  		x.Store(s)
  1039  		return 4
  1040  	}
  1041  	if l == 0 {
  1042  		return 0
  1043  	}
  1044  	mask := vecMask64[len(vecMask64)/2-l:]
  1045  	x.StoreArrayMasked(paUint64x4(s), LoadInt64x4(mask).asMask())
  1046  	return l
  1047  }
  1048  
  1049  // LoadFloat32x8Part loads a Float32x8 from the slice s, it returns the loaded vector and the
  1050  // number of elements loaded.
  1051  // If s has fewer than 8 elements, the remaining elements of the vector are filled with zeroes.
  1052  // If s has 8 or more elements, the function is equivalent to LoadFloat32x8.
  1053  func LoadFloat32x8Part(s []float32) (Float32x8, int) {
  1054  	l := len(s)
  1055  	if l >= 8 {
  1056  		return LoadFloat32x8(s), 8
  1057  	}
  1058  	if l == 0 {
  1059  		var x Float32x8
  1060  		return x, 0
  1061  	}
  1062  	mask := vecMask32[len(vecMask32)/2-l:]
  1063  	return LoadFloat32x8Array(paFloat32x8(s)).Masked(LoadInt32x8(mask).asMask()), l
  1064  }
  1065  
  1066  // StorePart stores the 8 elements of x into the slice s.
  1067  // It stores as many elements as will fit in s.
  1068  // If s has 8 or more elements, the method is equivalent to x.Store.
  1069  func (x Float32x8) StorePart(s []float32) int {
  1070  	l := len(s)
  1071  	if l >= 8 {
  1072  		x.Store(s)
  1073  		return 8
  1074  	}
  1075  	if l == 0 {
  1076  		return 0
  1077  	}
  1078  	mask := vecMask32[len(vecMask32)/2-l:]
  1079  	x.StoreArrayMasked(paFloat32x8(s), LoadInt32x8(mask).asMask())
  1080  	return l
  1081  }
  1082  
  1083  // LoadFloat64x4Part loads a Float64x4 from the slice s, it returns the loaded vector and the
  1084  // number of elements loaded.
  1085  // If s has fewer than 4 elements, the remaining elements of the vector are filled with zeroes.
  1086  // If s has 4 or more elements, the function is equivalent to LoadFloat64x4.
  1087  func LoadFloat64x4Part(s []float64) (Float64x4, int) {
  1088  	l := len(s)
  1089  	if l >= 4 {
  1090  		return LoadFloat64x4(s), 4
  1091  	}
  1092  	if l == 0 {
  1093  		var x Float64x4
  1094  		return x, 0
  1095  	}
  1096  	mask := vecMask64[len(vecMask64)/2-l:]
  1097  	return LoadFloat64x4Array(paFloat64x4(s)).Masked(LoadInt64x4(mask).asMask()), l
  1098  }
  1099  
  1100  // StorePart stores the 4 elements of x into the slice s.
  1101  // It stores as many elements as will fit in s.
  1102  // If s has 4 or more elements, the method is equivalent to x.Store.
  1103  func (x Float64x4) StorePart(s []float64) int {
  1104  	l := len(s)
  1105  	if l >= 4 {
  1106  		x.Store(s)
  1107  		return 4
  1108  	}
  1109  	if l == 0 {
  1110  		return 0
  1111  	}
  1112  	mask := vecMask64[len(vecMask64)/2-l:]
  1113  	x.StoreArrayMasked(paFloat64x4(s), LoadInt64x4(mask).asMask())
  1114  	return l
  1115  }
  1116  
  1117  // LoadUint8x32Part loads a Uint8x32 from the slice s, it returns the loaded vector and the
  1118  // number of elements loaded.
  1119  // If s has fewer than 32 elements, the remaining elements of the vector are filled with zeroes.
  1120  // If s has 32 or more elements, the function is equivalent to LoadUint8x32.
  1121  func LoadUint8x32Part(s []uint8) (Uint8x32, int) {
  1122  	if len(s) == 0 {
  1123  		var zero Uint8x32
  1124  		return zero, 0
  1125  	}
  1126  	t := unsafe.Slice((*int8)(unsafe.Pointer(&s[0])), len(s))
  1127  	v, l := LoadInt8x32Part(t)
  1128  	return v.AsUint8x32(), l
  1129  }
  1130  
  1131  // StorePart stores the 32 elements of x into the slice s.
  1132  // It stores as many elements as will fit in s.
  1133  // If s has 32 or more elements, the method is equivalent to x.Store.
  1134  func (x Uint8x32) StorePart(s []uint8) int {
  1135  	if len(s) == 0 {
  1136  		return 0
  1137  	}
  1138  	t := unsafe.Slice((*int8)(unsafe.Pointer(&s[0])), len(s))
  1139  	return x.AsInt8x32().StorePart(t)
  1140  }
  1141  
  1142  // LoadUint16x16Part loads a Uint16x16 from the slice s, it returns the loaded vector and the
  1143  // number of elements loaded.
  1144  // If s has fewer than 16 elements, the remaining elements of the vector are filled with zeroes.
  1145  // If s has 16 or more elements, the function is equivalent to LoadUint16x16.
  1146  func LoadUint16x16Part(s []uint16) (Uint16x16, int) {
  1147  	if len(s) == 0 {
  1148  		var zero Uint16x16
  1149  		return zero, 0
  1150  	}
  1151  	t := unsafe.Slice((*int16)(unsafe.Pointer(&s[0])), len(s))
  1152  	v, l := LoadInt16x16Part(t)
  1153  	return v.AsUint16x16(), l
  1154  }
  1155  
  1156  // StorePart stores the 16 elements of x into the slice s.
  1157  // It stores as many elements as will fit in s.
  1158  // If s has 16 or more elements, the method is equivalent to x.Store.
  1159  func (x Uint16x16) StorePart(s []uint16) int {
  1160  	if len(s) == 0 {
  1161  		return 0
  1162  	}
  1163  	t := unsafe.Slice((*int16)(unsafe.Pointer(&s[0])), len(s))
  1164  	return x.AsInt16x16().StorePart(t)
  1165  }
  1166  

View as plain text