gorgonia.org/tensor@v0.9.24/internal/execution/generic_arith_vv.go (about)

     1  // Code generated by genlib2. DO NOT EDIT.
     2  
     3  package execution
     4  
     5  import (
     6  	"math"
     7  	"math/cmplx"
     8  
     9  	"github.com/chewxy/math32"
    10  	"gorgonia.org/vecf32"
    11  	"gorgonia.org/vecf64"
    12  )
    13  
    14  func VecAddI(a []int, b []int) {
    15  	a = a[:]
    16  	b = b[:len(a)]
    17  	for i := range a {
    18  		a[i] = a[i] + b[i]
    19  	}
    20  }
    21  
    22  func VecAddI8(a []int8, b []int8) {
    23  	a = a[:]
    24  	b = b[:len(a)]
    25  	for i := range a {
    26  		a[i] = a[i] + b[i]
    27  	}
    28  }
    29  
    30  func VecAddI16(a []int16, b []int16) {
    31  	a = a[:]
    32  	b = b[:len(a)]
    33  	for i := range a {
    34  		a[i] = a[i] + b[i]
    35  	}
    36  }
    37  
    38  func VecAddI32(a []int32, b []int32) {
    39  	a = a[:]
    40  	b = b[:len(a)]
    41  	for i := range a {
    42  		a[i] = a[i] + b[i]
    43  	}
    44  }
    45  
    46  func VecAddI64(a []int64, b []int64) {
    47  	a = a[:]
    48  	b = b[:len(a)]
    49  	for i := range a {
    50  		a[i] = a[i] + b[i]
    51  	}
    52  }
    53  
    54  func VecAddU(a []uint, b []uint) {
    55  	a = a[:]
    56  	b = b[:len(a)]
    57  	for i := range a {
    58  		a[i] = a[i] + b[i]
    59  	}
    60  }
    61  
    62  func VecAddU8(a []uint8, b []uint8) {
    63  	a = a[:]
    64  	b = b[:len(a)]
    65  	for i := range a {
    66  		a[i] = a[i] + b[i]
    67  	}
    68  }
    69  
    70  func VecAddU16(a []uint16, b []uint16) {
    71  	a = a[:]
    72  	b = b[:len(a)]
    73  	for i := range a {
    74  		a[i] = a[i] + b[i]
    75  	}
    76  }
    77  
    78  func VecAddU32(a []uint32, b []uint32) {
    79  	a = a[:]
    80  	b = b[:len(a)]
    81  	for i := range a {
    82  		a[i] = a[i] + b[i]
    83  	}
    84  }
    85  
    86  func VecAddU64(a []uint64, b []uint64) {
    87  	a = a[:]
    88  	b = b[:len(a)]
    89  	for i := range a {
    90  		a[i] = a[i] + b[i]
    91  	}
    92  }
    93  
    94  func VecAddF32(a []float32, b []float32) { vecf32.Add(a, b) }
    95  func VecAddF64(a []float64, b []float64) { vecf64.Add(a, b) }
    96  func VecAddC64(a []complex64, b []complex64) {
    97  	a = a[:]
    98  	b = b[:len(a)]
    99  	for i := range a {
   100  		a[i] = a[i] + b[i]
   101  	}
   102  }
   103  
   104  func VecAddC128(a []complex128, b []complex128) {
   105  	a = a[:]
   106  	b = b[:len(a)]
   107  	for i := range a {
   108  		a[i] = a[i] + b[i]
   109  	}
   110  }
   111  
   112  func VecAddStr(a []string, b []string) {
   113  	a = a[:]
   114  	b = b[:len(a)]
   115  	for i := range a {
   116  		a[i] = a[i] + b[i]
   117  	}
   118  }
   119  
   120  func VecSubI(a []int, b []int) {
   121  	a = a[:]
   122  	b = b[:len(a)]
   123  	for i := range a {
   124  		a[i] = a[i] - b[i]
   125  	}
   126  }
   127  
   128  func VecSubI8(a []int8, b []int8) {
   129  	a = a[:]
   130  	b = b[:len(a)]
   131  	for i := range a {
   132  		a[i] = a[i] - b[i]
   133  	}
   134  }
   135  
   136  func VecSubI16(a []int16, b []int16) {
   137  	a = a[:]
   138  	b = b[:len(a)]
   139  	for i := range a {
   140  		a[i] = a[i] - b[i]
   141  	}
   142  }
   143  
   144  func VecSubI32(a []int32, b []int32) {
   145  	a = a[:]
   146  	b = b[:len(a)]
   147  	for i := range a {
   148  		a[i] = a[i] - b[i]
   149  	}
   150  }
   151  
   152  func VecSubI64(a []int64, b []int64) {
   153  	a = a[:]
   154  	b = b[:len(a)]
   155  	for i := range a {
   156  		a[i] = a[i] - b[i]
   157  	}
   158  }
   159  
   160  func VecSubU(a []uint, b []uint) {
   161  	a = a[:]
   162  	b = b[:len(a)]
   163  	for i := range a {
   164  		a[i] = a[i] - b[i]
   165  	}
   166  }
   167  
   168  func VecSubU8(a []uint8, b []uint8) {
   169  	a = a[:]
   170  	b = b[:len(a)]
   171  	for i := range a {
   172  		a[i] = a[i] - b[i]
   173  	}
   174  }
   175  
   176  func VecSubU16(a []uint16, b []uint16) {
   177  	a = a[:]
   178  	b = b[:len(a)]
   179  	for i := range a {
   180  		a[i] = a[i] - b[i]
   181  	}
   182  }
   183  
   184  func VecSubU32(a []uint32, b []uint32) {
   185  	a = a[:]
   186  	b = b[:len(a)]
   187  	for i := range a {
   188  		a[i] = a[i] - b[i]
   189  	}
   190  }
   191  
   192  func VecSubU64(a []uint64, b []uint64) {
   193  	a = a[:]
   194  	b = b[:len(a)]
   195  	for i := range a {
   196  		a[i] = a[i] - b[i]
   197  	}
   198  }
   199  
   200  func VecSubF32(a []float32, b []float32) { vecf32.Sub(a, b) }
   201  func VecSubF64(a []float64, b []float64) { vecf64.Sub(a, b) }
   202  func VecSubC64(a []complex64, b []complex64) {
   203  	a = a[:]
   204  	b = b[:len(a)]
   205  	for i := range a {
   206  		a[i] = a[i] - b[i]
   207  	}
   208  }
   209  
   210  func VecSubC128(a []complex128, b []complex128) {
   211  	a = a[:]
   212  	b = b[:len(a)]
   213  	for i := range a {
   214  		a[i] = a[i] - b[i]
   215  	}
   216  }
   217  
   218  func VecMulI(a []int, b []int) {
   219  	a = a[:]
   220  	b = b[:len(a)]
   221  	for i := range a {
   222  		a[i] = a[i] * b[i]
   223  	}
   224  }
   225  
   226  func VecMulI8(a []int8, b []int8) {
   227  	a = a[:]
   228  	b = b[:len(a)]
   229  	for i := range a {
   230  		a[i] = a[i] * b[i]
   231  	}
   232  }
   233  
   234  func VecMulI16(a []int16, b []int16) {
   235  	a = a[:]
   236  	b = b[:len(a)]
   237  	for i := range a {
   238  		a[i] = a[i] * b[i]
   239  	}
   240  }
   241  
   242  func VecMulI32(a []int32, b []int32) {
   243  	a = a[:]
   244  	b = b[:len(a)]
   245  	for i := range a {
   246  		a[i] = a[i] * b[i]
   247  	}
   248  }
   249  
   250  func VecMulI64(a []int64, b []int64) {
   251  	a = a[:]
   252  	b = b[:len(a)]
   253  	for i := range a {
   254  		a[i] = a[i] * b[i]
   255  	}
   256  }
   257  
   258  func VecMulU(a []uint, b []uint) {
   259  	a = a[:]
   260  	b = b[:len(a)]
   261  	for i := range a {
   262  		a[i] = a[i] * b[i]
   263  	}
   264  }
   265  
   266  func VecMulU8(a []uint8, b []uint8) {
   267  	a = a[:]
   268  	b = b[:len(a)]
   269  	for i := range a {
   270  		a[i] = a[i] * b[i]
   271  	}
   272  }
   273  
   274  func VecMulU16(a []uint16, b []uint16) {
   275  	a = a[:]
   276  	b = b[:len(a)]
   277  	for i := range a {
   278  		a[i] = a[i] * b[i]
   279  	}
   280  }
   281  
   282  func VecMulU32(a []uint32, b []uint32) {
   283  	a = a[:]
   284  	b = b[:len(a)]
   285  	for i := range a {
   286  		a[i] = a[i] * b[i]
   287  	}
   288  }
   289  
   290  func VecMulU64(a []uint64, b []uint64) {
   291  	a = a[:]
   292  	b = b[:len(a)]
   293  	for i := range a {
   294  		a[i] = a[i] * b[i]
   295  	}
   296  }
   297  
   298  func VecMulF32(a []float32, b []float32) { vecf32.Mul(a, b) }
   299  func VecMulF64(a []float64, b []float64) { vecf64.Mul(a, b) }
   300  func VecMulC64(a []complex64, b []complex64) {
   301  	a = a[:]
   302  	b = b[:len(a)]
   303  	for i := range a {
   304  		a[i] = a[i] * b[i]
   305  	}
   306  }
   307  
   308  func VecMulC128(a []complex128, b []complex128) {
   309  	a = a[:]
   310  	b = b[:len(a)]
   311  	for i := range a {
   312  		a[i] = a[i] * b[i]
   313  	}
   314  }
   315  
   316  func VecDivI(a []int, b []int) (err error) {
   317  	a = a[:]
   318  	b = b[:len(a)]
   319  	var errs errorIndices
   320  	for i := range a {
   321  		if b[i] == 0 {
   322  			errs = append(errs, i)
   323  			a[i] = 0
   324  			continue
   325  		}
   326  		a[i] = a[i] / b[i]
   327  	}
   328  	if err != nil {
   329  		return
   330  	}
   331  	if len(errs) > 0 {
   332  		return errs
   333  	}
   334  	return nil
   335  }
   336  
   337  func VecDivI8(a []int8, b []int8) (err error) {
   338  	a = a[:]
   339  	b = b[:len(a)]
   340  	var errs errorIndices
   341  	for i := range a {
   342  		if b[i] == 0 {
   343  			errs = append(errs, i)
   344  			a[i] = 0
   345  			continue
   346  		}
   347  		a[i] = a[i] / b[i]
   348  	}
   349  	if err != nil {
   350  		return
   351  	}
   352  	if len(errs) > 0 {
   353  		return errs
   354  	}
   355  	return nil
   356  }
   357  
   358  func VecDivI16(a []int16, b []int16) (err error) {
   359  	a = a[:]
   360  	b = b[:len(a)]
   361  	var errs errorIndices
   362  	for i := range a {
   363  		if b[i] == 0 {
   364  			errs = append(errs, i)
   365  			a[i] = 0
   366  			continue
   367  		}
   368  		a[i] = a[i] / b[i]
   369  	}
   370  	if err != nil {
   371  		return
   372  	}
   373  	if len(errs) > 0 {
   374  		return errs
   375  	}
   376  	return nil
   377  }
   378  
   379  func VecDivI32(a []int32, b []int32) (err error) {
   380  	a = a[:]
   381  	b = b[:len(a)]
   382  	var errs errorIndices
   383  	for i := range a {
   384  		if b[i] == 0 {
   385  			errs = append(errs, i)
   386  			a[i] = 0
   387  			continue
   388  		}
   389  		a[i] = a[i] / b[i]
   390  	}
   391  	if err != nil {
   392  		return
   393  	}
   394  	if len(errs) > 0 {
   395  		return errs
   396  	}
   397  	return nil
   398  }
   399  
   400  func VecDivI64(a []int64, b []int64) (err error) {
   401  	a = a[:]
   402  	b = b[:len(a)]
   403  	var errs errorIndices
   404  	for i := range a {
   405  		if b[i] == 0 {
   406  			errs = append(errs, i)
   407  			a[i] = 0
   408  			continue
   409  		}
   410  		a[i] = a[i] / b[i]
   411  	}
   412  	if err != nil {
   413  		return
   414  	}
   415  	if len(errs) > 0 {
   416  		return errs
   417  	}
   418  	return nil
   419  }
   420  
   421  func VecDivU(a []uint, b []uint) (err error) {
   422  	a = a[:]
   423  	b = b[:len(a)]
   424  	var errs errorIndices
   425  	for i := range a {
   426  		if b[i] == 0 {
   427  			errs = append(errs, i)
   428  			a[i] = 0
   429  			continue
   430  		}
   431  		a[i] = a[i] / b[i]
   432  	}
   433  	if err != nil {
   434  		return
   435  	}
   436  	if len(errs) > 0 {
   437  		return errs
   438  	}
   439  	return nil
   440  }
   441  
   442  func VecDivU8(a []uint8, b []uint8) (err error) {
   443  	a = a[:]
   444  	b = b[:len(a)]
   445  	var errs errorIndices
   446  	for i := range a {
   447  		if b[i] == 0 {
   448  			errs = append(errs, i)
   449  			a[i] = 0
   450  			continue
   451  		}
   452  		a[i] = a[i] / b[i]
   453  	}
   454  	if err != nil {
   455  		return
   456  	}
   457  	if len(errs) > 0 {
   458  		return errs
   459  	}
   460  	return nil
   461  }
   462  
   463  func VecDivU16(a []uint16, b []uint16) (err error) {
   464  	a = a[:]
   465  	b = b[:len(a)]
   466  	var errs errorIndices
   467  	for i := range a {
   468  		if b[i] == 0 {
   469  			errs = append(errs, i)
   470  			a[i] = 0
   471  			continue
   472  		}
   473  		a[i] = a[i] / b[i]
   474  	}
   475  	if err != nil {
   476  		return
   477  	}
   478  	if len(errs) > 0 {
   479  		return errs
   480  	}
   481  	return nil
   482  }
   483  
   484  func VecDivU32(a []uint32, b []uint32) (err error) {
   485  	a = a[:]
   486  	b = b[:len(a)]
   487  	var errs errorIndices
   488  	for i := range a {
   489  		if b[i] == 0 {
   490  			errs = append(errs, i)
   491  			a[i] = 0
   492  			continue
   493  		}
   494  		a[i] = a[i] / b[i]
   495  	}
   496  	if err != nil {
   497  		return
   498  	}
   499  	if len(errs) > 0 {
   500  		return errs
   501  	}
   502  	return nil
   503  }
   504  
   505  func VecDivU64(a []uint64, b []uint64) (err error) {
   506  	a = a[:]
   507  	b = b[:len(a)]
   508  	var errs errorIndices
   509  	for i := range a {
   510  		if b[i] == 0 {
   511  			errs = append(errs, i)
   512  			a[i] = 0
   513  			continue
   514  		}
   515  		a[i] = a[i] / b[i]
   516  	}
   517  	if err != nil {
   518  		return
   519  	}
   520  	if len(errs) > 0 {
   521  		return errs
   522  	}
   523  	return nil
   524  }
   525  
   526  func VecDivF32(a []float32, b []float32) { vecf32.Div(a, b) }
   527  func VecDivF64(a []float64, b []float64) { vecf64.Div(a, b) }
   528  func VecDivC64(a []complex64, b []complex64) {
   529  	a = a[:]
   530  	b = b[:len(a)]
   531  	for i := range a {
   532  		a[i] = a[i] / b[i]
   533  	}
   534  }
   535  
   536  func VecDivC128(a []complex128, b []complex128) {
   537  	a = a[:]
   538  	b = b[:len(a)]
   539  	for i := range a {
   540  		a[i] = a[i] / b[i]
   541  	}
   542  }
   543  
   544  func VecPowF32(a []float32, b []float32) { vecf32.Pow(a, b) }
   545  func VecPowF64(a []float64, b []float64) { vecf64.Pow(a, b) }
   546  func VecPowC64(a []complex64, b []complex64) {
   547  	a = a[:]
   548  	b = b[:len(a)]
   549  	for i := range a {
   550  		a[i] = complex64(cmplx.Pow(complex128(a[i]), complex128(b[i])))
   551  	}
   552  }
   553  
   554  func VecPowC128(a []complex128, b []complex128) {
   555  	a = a[:]
   556  	b = b[:len(a)]
   557  	for i := range a {
   558  		a[i] = cmplx.Pow(a[i], b[i])
   559  	}
   560  }
   561  
   562  func VecModI(a []int, b []int) {
   563  	a = a[:]
   564  	b = b[:len(a)]
   565  	for i := range a {
   566  		a[i] = a[i] % b[i]
   567  	}
   568  }
   569  
   570  func VecModI8(a []int8, b []int8) {
   571  	a = a[:]
   572  	b = b[:len(a)]
   573  	for i := range a {
   574  		a[i] = a[i] % b[i]
   575  	}
   576  }
   577  
   578  func VecModI16(a []int16, b []int16) {
   579  	a = a[:]
   580  	b = b[:len(a)]
   581  	for i := range a {
   582  		a[i] = a[i] % b[i]
   583  	}
   584  }
   585  
   586  func VecModI32(a []int32, b []int32) {
   587  	a = a[:]
   588  	b = b[:len(a)]
   589  	for i := range a {
   590  		a[i] = a[i] % b[i]
   591  	}
   592  }
   593  
   594  func VecModI64(a []int64, b []int64) {
   595  	a = a[:]
   596  	b = b[:len(a)]
   597  	for i := range a {
   598  		a[i] = a[i] % b[i]
   599  	}
   600  }
   601  
   602  func VecModU(a []uint, b []uint) {
   603  	a = a[:]
   604  	b = b[:len(a)]
   605  	for i := range a {
   606  		a[i] = a[i] % b[i]
   607  	}
   608  }
   609  
   610  func VecModU8(a []uint8, b []uint8) {
   611  	a = a[:]
   612  	b = b[:len(a)]
   613  	for i := range a {
   614  		a[i] = a[i] % b[i]
   615  	}
   616  }
   617  
   618  func VecModU16(a []uint16, b []uint16) {
   619  	a = a[:]
   620  	b = b[:len(a)]
   621  	for i := range a {
   622  		a[i] = a[i] % b[i]
   623  	}
   624  }
   625  
   626  func VecModU32(a []uint32, b []uint32) {
   627  	a = a[:]
   628  	b = b[:len(a)]
   629  	for i := range a {
   630  		a[i] = a[i] % b[i]
   631  	}
   632  }
   633  
   634  func VecModU64(a []uint64, b []uint64) {
   635  	a = a[:]
   636  	b = b[:len(a)]
   637  	for i := range a {
   638  		a[i] = a[i] % b[i]
   639  	}
   640  }
   641  
   642  func VecModF32(a []float32, b []float32) { vecf32.Mod(a, b) }
   643  func VecModF64(a []float64, b []float64) { vecf64.Mod(a, b) }
   644  func AddIncrI(a []int, b []int, incr []int) {
   645  	a = a[:]
   646  	b = b[:len(a)]
   647  	incr = incr[:len(a)]
   648  	for i := range incr {
   649  		incr[i] += a[i] + b[i]
   650  	}
   651  }
   652  
   653  func AddIncrI8(a []int8, b []int8, incr []int8) {
   654  	a = a[:]
   655  	b = b[:len(a)]
   656  	incr = incr[:len(a)]
   657  	for i := range incr {
   658  		incr[i] += a[i] + b[i]
   659  	}
   660  }
   661  
   662  func AddIncrI16(a []int16, b []int16, incr []int16) {
   663  	a = a[:]
   664  	b = b[:len(a)]
   665  	incr = incr[:len(a)]
   666  	for i := range incr {
   667  		incr[i] += a[i] + b[i]
   668  	}
   669  }
   670  
   671  func AddIncrI32(a []int32, b []int32, incr []int32) {
   672  	a = a[:]
   673  	b = b[:len(a)]
   674  	incr = incr[:len(a)]
   675  	for i := range incr {
   676  		incr[i] += a[i] + b[i]
   677  	}
   678  }
   679  
   680  func AddIncrI64(a []int64, b []int64, incr []int64) {
   681  	a = a[:]
   682  	b = b[:len(a)]
   683  	incr = incr[:len(a)]
   684  	for i := range incr {
   685  		incr[i] += a[i] + b[i]
   686  	}
   687  }
   688  
   689  func AddIncrU(a []uint, b []uint, incr []uint) {
   690  	a = a[:]
   691  	b = b[:len(a)]
   692  	incr = incr[:len(a)]
   693  	for i := range incr {
   694  		incr[i] += a[i] + b[i]
   695  	}
   696  }
   697  
   698  func AddIncrU8(a []uint8, b []uint8, incr []uint8) {
   699  	a = a[:]
   700  	b = b[:len(a)]
   701  	incr = incr[:len(a)]
   702  	for i := range incr {
   703  		incr[i] += a[i] + b[i]
   704  	}
   705  }
   706  
   707  func AddIncrU16(a []uint16, b []uint16, incr []uint16) {
   708  	a = a[:]
   709  	b = b[:len(a)]
   710  	incr = incr[:len(a)]
   711  	for i := range incr {
   712  		incr[i] += a[i] + b[i]
   713  	}
   714  }
   715  
   716  func AddIncrU32(a []uint32, b []uint32, incr []uint32) {
   717  	a = a[:]
   718  	b = b[:len(a)]
   719  	incr = incr[:len(a)]
   720  	for i := range incr {
   721  		incr[i] += a[i] + b[i]
   722  	}
   723  }
   724  
   725  func AddIncrU64(a []uint64, b []uint64, incr []uint64) {
   726  	a = a[:]
   727  	b = b[:len(a)]
   728  	incr = incr[:len(a)]
   729  	for i := range incr {
   730  		incr[i] += a[i] + b[i]
   731  	}
   732  }
   733  
   734  func AddIncrF32(a []float32, b []float32, incr []float32) { vecf32.IncrAdd(a, b, incr) }
   735  func AddIncrF64(a []float64, b []float64, incr []float64) { vecf64.IncrAdd(a, b, incr) }
   736  func AddIncrC64(a []complex64, b []complex64, incr []complex64) {
   737  	a = a[:]
   738  	b = b[:len(a)]
   739  	incr = incr[:len(a)]
   740  	for i := range incr {
   741  		incr[i] += a[i] + b[i]
   742  	}
   743  }
   744  
   745  func AddIncrC128(a []complex128, b []complex128, incr []complex128) {
   746  	a = a[:]
   747  	b = b[:len(a)]
   748  	incr = incr[:len(a)]
   749  	for i := range incr {
   750  		incr[i] += a[i] + b[i]
   751  	}
   752  }
   753  
   754  func AddIncrStr(a []string, b []string, incr []string) {
   755  	a = a[:]
   756  	b = b[:len(a)]
   757  	incr = incr[:len(a)]
   758  	for i := range incr {
   759  		incr[i] += a[i] + b[i]
   760  	}
   761  }
   762  
   763  func SubIncrI(a []int, b []int, incr []int) {
   764  	a = a[:]
   765  	b = b[:len(a)]
   766  	incr = incr[:len(a)]
   767  	for i := range incr {
   768  		incr[i] += a[i] - b[i]
   769  	}
   770  }
   771  
   772  func SubIncrI8(a []int8, b []int8, incr []int8) {
   773  	a = a[:]
   774  	b = b[:len(a)]
   775  	incr = incr[:len(a)]
   776  	for i := range incr {
   777  		incr[i] += a[i] - b[i]
   778  	}
   779  }
   780  
   781  func SubIncrI16(a []int16, b []int16, incr []int16) {
   782  	a = a[:]
   783  	b = b[:len(a)]
   784  	incr = incr[:len(a)]
   785  	for i := range incr {
   786  		incr[i] += a[i] - b[i]
   787  	}
   788  }
   789  
   790  func SubIncrI32(a []int32, b []int32, incr []int32) {
   791  	a = a[:]
   792  	b = b[:len(a)]
   793  	incr = incr[:len(a)]
   794  	for i := range incr {
   795  		incr[i] += a[i] - b[i]
   796  	}
   797  }
   798  
   799  func SubIncrI64(a []int64, b []int64, incr []int64) {
   800  	a = a[:]
   801  	b = b[:len(a)]
   802  	incr = incr[:len(a)]
   803  	for i := range incr {
   804  		incr[i] += a[i] - b[i]
   805  	}
   806  }
   807  
   808  func SubIncrU(a []uint, b []uint, incr []uint) {
   809  	a = a[:]
   810  	b = b[:len(a)]
   811  	incr = incr[:len(a)]
   812  	for i := range incr {
   813  		incr[i] += a[i] - b[i]
   814  	}
   815  }
   816  
   817  func SubIncrU8(a []uint8, b []uint8, incr []uint8) {
   818  	a = a[:]
   819  	b = b[:len(a)]
   820  	incr = incr[:len(a)]
   821  	for i := range incr {
   822  		incr[i] += a[i] - b[i]
   823  	}
   824  }
   825  
   826  func SubIncrU16(a []uint16, b []uint16, incr []uint16) {
   827  	a = a[:]
   828  	b = b[:len(a)]
   829  	incr = incr[:len(a)]
   830  	for i := range incr {
   831  		incr[i] += a[i] - b[i]
   832  	}
   833  }
   834  
   835  func SubIncrU32(a []uint32, b []uint32, incr []uint32) {
   836  	a = a[:]
   837  	b = b[:len(a)]
   838  	incr = incr[:len(a)]
   839  	for i := range incr {
   840  		incr[i] += a[i] - b[i]
   841  	}
   842  }
   843  
   844  func SubIncrU64(a []uint64, b []uint64, incr []uint64) {
   845  	a = a[:]
   846  	b = b[:len(a)]
   847  	incr = incr[:len(a)]
   848  	for i := range incr {
   849  		incr[i] += a[i] - b[i]
   850  	}
   851  }
   852  
   853  func SubIncrF32(a []float32, b []float32, incr []float32) { vecf32.IncrSub(a, b, incr) }
   854  func SubIncrF64(a []float64, b []float64, incr []float64) { vecf64.IncrSub(a, b, incr) }
   855  func SubIncrC64(a []complex64, b []complex64, incr []complex64) {
   856  	a = a[:]
   857  	b = b[:len(a)]
   858  	incr = incr[:len(a)]
   859  	for i := range incr {
   860  		incr[i] += a[i] - b[i]
   861  	}
   862  }
   863  
   864  func SubIncrC128(a []complex128, b []complex128, incr []complex128) {
   865  	a = a[:]
   866  	b = b[:len(a)]
   867  	incr = incr[:len(a)]
   868  	for i := range incr {
   869  		incr[i] += a[i] - b[i]
   870  	}
   871  }
   872  
   873  func MulIncrI(a []int, b []int, incr []int) {
   874  	a = a[:]
   875  	b = b[:len(a)]
   876  	incr = incr[:len(a)]
   877  	for i := range incr {
   878  		incr[i] += a[i] * b[i]
   879  	}
   880  }
   881  
   882  func MulIncrI8(a []int8, b []int8, incr []int8) {
   883  	a = a[:]
   884  	b = b[:len(a)]
   885  	incr = incr[:len(a)]
   886  	for i := range incr {
   887  		incr[i] += a[i] * b[i]
   888  	}
   889  }
   890  
   891  func MulIncrI16(a []int16, b []int16, incr []int16) {
   892  	a = a[:]
   893  	b = b[:len(a)]
   894  	incr = incr[:len(a)]
   895  	for i := range incr {
   896  		incr[i] += a[i] * b[i]
   897  	}
   898  }
   899  
   900  func MulIncrI32(a []int32, b []int32, incr []int32) {
   901  	a = a[:]
   902  	b = b[:len(a)]
   903  	incr = incr[:len(a)]
   904  	for i := range incr {
   905  		incr[i] += a[i] * b[i]
   906  	}
   907  }
   908  
   909  func MulIncrI64(a []int64, b []int64, incr []int64) {
   910  	a = a[:]
   911  	b = b[:len(a)]
   912  	incr = incr[:len(a)]
   913  	for i := range incr {
   914  		incr[i] += a[i] * b[i]
   915  	}
   916  }
   917  
   918  func MulIncrU(a []uint, b []uint, incr []uint) {
   919  	a = a[:]
   920  	b = b[:len(a)]
   921  	incr = incr[:len(a)]
   922  	for i := range incr {
   923  		incr[i] += a[i] * b[i]
   924  	}
   925  }
   926  
   927  func MulIncrU8(a []uint8, b []uint8, incr []uint8) {
   928  	a = a[:]
   929  	b = b[:len(a)]
   930  	incr = incr[:len(a)]
   931  	for i := range incr {
   932  		incr[i] += a[i] * b[i]
   933  	}
   934  }
   935  
   936  func MulIncrU16(a []uint16, b []uint16, incr []uint16) {
   937  	a = a[:]
   938  	b = b[:len(a)]
   939  	incr = incr[:len(a)]
   940  	for i := range incr {
   941  		incr[i] += a[i] * b[i]
   942  	}
   943  }
   944  
   945  func MulIncrU32(a []uint32, b []uint32, incr []uint32) {
   946  	a = a[:]
   947  	b = b[:len(a)]
   948  	incr = incr[:len(a)]
   949  	for i := range incr {
   950  		incr[i] += a[i] * b[i]
   951  	}
   952  }
   953  
   954  func MulIncrU64(a []uint64, b []uint64, incr []uint64) {
   955  	a = a[:]
   956  	b = b[:len(a)]
   957  	incr = incr[:len(a)]
   958  	for i := range incr {
   959  		incr[i] += a[i] * b[i]
   960  	}
   961  }
   962  
   963  func MulIncrF32(a []float32, b []float32, incr []float32) { vecf32.IncrMul(a, b, incr) }
   964  func MulIncrF64(a []float64, b []float64, incr []float64) { vecf64.IncrMul(a, b, incr) }
   965  func MulIncrC64(a []complex64, b []complex64, incr []complex64) {
   966  	a = a[:]
   967  	b = b[:len(a)]
   968  	incr = incr[:len(a)]
   969  	for i := range incr {
   970  		incr[i] += a[i] * b[i]
   971  	}
   972  }
   973  
   974  func MulIncrC128(a []complex128, b []complex128, incr []complex128) {
   975  	a = a[:]
   976  	b = b[:len(a)]
   977  	incr = incr[:len(a)]
   978  	for i := range incr {
   979  		incr[i] += a[i] * b[i]
   980  	}
   981  }
   982  
   983  func DivIncrI(a []int, b []int, incr []int) (err error) {
   984  	a = a[:]
   985  	b = b[:len(a)]
   986  	incr = incr[:len(a)]
   987  	var errs errorIndices
   988  	for i := range incr {
   989  		if b[i] == 0 {
   990  			errs = append(errs, i)
   991  			incr[i] = 0
   992  			continue
   993  		}
   994  		incr[i] += a[i] / b[i]
   995  	}
   996  	if err != nil {
   997  		return
   998  	}
   999  	if len(errs) > 0 {
  1000  		return errs
  1001  	}
  1002  	return nil
  1003  }
  1004  
  1005  func DivIncrI8(a []int8, b []int8, incr []int8) (err error) {
  1006  	a = a[:]
  1007  	b = b[:len(a)]
  1008  	incr = incr[:len(a)]
  1009  	var errs errorIndices
  1010  	for i := range incr {
  1011  		if b[i] == 0 {
  1012  			errs = append(errs, i)
  1013  			incr[i] = 0
  1014  			continue
  1015  		}
  1016  		incr[i] += a[i] / b[i]
  1017  	}
  1018  	if err != nil {
  1019  		return
  1020  	}
  1021  	if len(errs) > 0 {
  1022  		return errs
  1023  	}
  1024  	return nil
  1025  }
  1026  
  1027  func DivIncrI16(a []int16, b []int16, incr []int16) (err error) {
  1028  	a = a[:]
  1029  	b = b[:len(a)]
  1030  	incr = incr[:len(a)]
  1031  	var errs errorIndices
  1032  	for i := range incr {
  1033  		if b[i] == 0 {
  1034  			errs = append(errs, i)
  1035  			incr[i] = 0
  1036  			continue
  1037  		}
  1038  		incr[i] += a[i] / b[i]
  1039  	}
  1040  	if err != nil {
  1041  		return
  1042  	}
  1043  	if len(errs) > 0 {
  1044  		return errs
  1045  	}
  1046  	return nil
  1047  }
  1048  
  1049  func DivIncrI32(a []int32, b []int32, incr []int32) (err error) {
  1050  	a = a[:]
  1051  	b = b[:len(a)]
  1052  	incr = incr[:len(a)]
  1053  	var errs errorIndices
  1054  	for i := range incr {
  1055  		if b[i] == 0 {
  1056  			errs = append(errs, i)
  1057  			incr[i] = 0
  1058  			continue
  1059  		}
  1060  		incr[i] += a[i] / b[i]
  1061  	}
  1062  	if err != nil {
  1063  		return
  1064  	}
  1065  	if len(errs) > 0 {
  1066  		return errs
  1067  	}
  1068  	return nil
  1069  }
  1070  
  1071  func DivIncrI64(a []int64, b []int64, incr []int64) (err error) {
  1072  	a = a[:]
  1073  	b = b[:len(a)]
  1074  	incr = incr[:len(a)]
  1075  	var errs errorIndices
  1076  	for i := range incr {
  1077  		if b[i] == 0 {
  1078  			errs = append(errs, i)
  1079  			incr[i] = 0
  1080  			continue
  1081  		}
  1082  		incr[i] += a[i] / b[i]
  1083  	}
  1084  	if err != nil {
  1085  		return
  1086  	}
  1087  	if len(errs) > 0 {
  1088  		return errs
  1089  	}
  1090  	return nil
  1091  }
  1092  
  1093  func DivIncrU(a []uint, b []uint, incr []uint) (err error) {
  1094  	a = a[:]
  1095  	b = b[:len(a)]
  1096  	incr = incr[:len(a)]
  1097  	var errs errorIndices
  1098  	for i := range incr {
  1099  		if b[i] == 0 {
  1100  			errs = append(errs, i)
  1101  			incr[i] = 0
  1102  			continue
  1103  		}
  1104  		incr[i] += a[i] / b[i]
  1105  	}
  1106  	if err != nil {
  1107  		return
  1108  	}
  1109  	if len(errs) > 0 {
  1110  		return errs
  1111  	}
  1112  	return nil
  1113  }
  1114  
  1115  func DivIncrU8(a []uint8, b []uint8, incr []uint8) (err error) {
  1116  	a = a[:]
  1117  	b = b[:len(a)]
  1118  	incr = incr[:len(a)]
  1119  	var errs errorIndices
  1120  	for i := range incr {
  1121  		if b[i] == 0 {
  1122  			errs = append(errs, i)
  1123  			incr[i] = 0
  1124  			continue
  1125  		}
  1126  		incr[i] += a[i] / b[i]
  1127  	}
  1128  	if err != nil {
  1129  		return
  1130  	}
  1131  	if len(errs) > 0 {
  1132  		return errs
  1133  	}
  1134  	return nil
  1135  }
  1136  
  1137  func DivIncrU16(a []uint16, b []uint16, incr []uint16) (err error) {
  1138  	a = a[:]
  1139  	b = b[:len(a)]
  1140  	incr = incr[:len(a)]
  1141  	var errs errorIndices
  1142  	for i := range incr {
  1143  		if b[i] == 0 {
  1144  			errs = append(errs, i)
  1145  			incr[i] = 0
  1146  			continue
  1147  		}
  1148  		incr[i] += a[i] / b[i]
  1149  	}
  1150  	if err != nil {
  1151  		return
  1152  	}
  1153  	if len(errs) > 0 {
  1154  		return errs
  1155  	}
  1156  	return nil
  1157  }
  1158  
  1159  func DivIncrU32(a []uint32, b []uint32, incr []uint32) (err error) {
  1160  	a = a[:]
  1161  	b = b[:len(a)]
  1162  	incr = incr[:len(a)]
  1163  	var errs errorIndices
  1164  	for i := range incr {
  1165  		if b[i] == 0 {
  1166  			errs = append(errs, i)
  1167  			incr[i] = 0
  1168  			continue
  1169  		}
  1170  		incr[i] += a[i] / b[i]
  1171  	}
  1172  	if err != nil {
  1173  		return
  1174  	}
  1175  	if len(errs) > 0 {
  1176  		return errs
  1177  	}
  1178  	return nil
  1179  }
  1180  
  1181  func DivIncrU64(a []uint64, b []uint64, incr []uint64) (err error) {
  1182  	a = a[:]
  1183  	b = b[:len(a)]
  1184  	incr = incr[:len(a)]
  1185  	var errs errorIndices
  1186  	for i := range incr {
  1187  		if b[i] == 0 {
  1188  			errs = append(errs, i)
  1189  			incr[i] = 0
  1190  			continue
  1191  		}
  1192  		incr[i] += a[i] / b[i]
  1193  	}
  1194  	if err != nil {
  1195  		return
  1196  	}
  1197  	if len(errs) > 0 {
  1198  		return errs
  1199  	}
  1200  	return nil
  1201  }
  1202  
  1203  func DivIncrF32(a []float32, b []float32, incr []float32) { vecf32.IncrDiv(a, b, incr) }
  1204  func DivIncrF64(a []float64, b []float64, incr []float64) { vecf64.IncrDiv(a, b, incr) }
  1205  func DivIncrC64(a []complex64, b []complex64, incr []complex64) {
  1206  	a = a[:]
  1207  	b = b[:len(a)]
  1208  	incr = incr[:len(a)]
  1209  	for i := range incr {
  1210  		incr[i] += a[i] / b[i]
  1211  	}
  1212  }
  1213  
  1214  func DivIncrC128(a []complex128, b []complex128, incr []complex128) {
  1215  	a = a[:]
  1216  	b = b[:len(a)]
  1217  	incr = incr[:len(a)]
  1218  	for i := range incr {
  1219  		incr[i] += a[i] / b[i]
  1220  	}
  1221  }
  1222  
  1223  func PowIncrF32(a []float32, b []float32, incr []float32) { vecf32.IncrPow(a, b, incr) }
  1224  func PowIncrF64(a []float64, b []float64, incr []float64) { vecf64.IncrPow(a, b, incr) }
  1225  func PowIncrC64(a []complex64, b []complex64, incr []complex64) {
  1226  	a = a[:]
  1227  	b = b[:len(a)]
  1228  	incr = incr[:len(a)]
  1229  	for i := range incr {
  1230  		incr[i] += complex64(cmplx.Pow(complex128(a[i]), complex128(b[i])))
  1231  	}
  1232  }
  1233  
  1234  func PowIncrC128(a []complex128, b []complex128, incr []complex128) {
  1235  	a = a[:]
  1236  	b = b[:len(a)]
  1237  	incr = incr[:len(a)]
  1238  	for i := range incr {
  1239  		incr[i] += cmplx.Pow(a[i], b[i])
  1240  	}
  1241  }
  1242  
  1243  func ModIncrI(a []int, b []int, incr []int) {
  1244  	a = a[:]
  1245  	b = b[:len(a)]
  1246  	incr = incr[:len(a)]
  1247  	for i := range incr {
  1248  		incr[i] += a[i] % b[i]
  1249  	}
  1250  }
  1251  
  1252  func ModIncrI8(a []int8, b []int8, incr []int8) {
  1253  	a = a[:]
  1254  	b = b[:len(a)]
  1255  	incr = incr[:len(a)]
  1256  	for i := range incr {
  1257  		incr[i] += a[i] % b[i]
  1258  	}
  1259  }
  1260  
  1261  func ModIncrI16(a []int16, b []int16, incr []int16) {
  1262  	a = a[:]
  1263  	b = b[:len(a)]
  1264  	incr = incr[:len(a)]
  1265  	for i := range incr {
  1266  		incr[i] += a[i] % b[i]
  1267  	}
  1268  }
  1269  
  1270  func ModIncrI32(a []int32, b []int32, incr []int32) {
  1271  	a = a[:]
  1272  	b = b[:len(a)]
  1273  	incr = incr[:len(a)]
  1274  	for i := range incr {
  1275  		incr[i] += a[i] % b[i]
  1276  	}
  1277  }
  1278  
  1279  func ModIncrI64(a []int64, b []int64, incr []int64) {
  1280  	a = a[:]
  1281  	b = b[:len(a)]
  1282  	incr = incr[:len(a)]
  1283  	for i := range incr {
  1284  		incr[i] += a[i] % b[i]
  1285  	}
  1286  }
  1287  
  1288  func ModIncrU(a []uint, b []uint, incr []uint) {
  1289  	a = a[:]
  1290  	b = b[:len(a)]
  1291  	incr = incr[:len(a)]
  1292  	for i := range incr {
  1293  		incr[i] += a[i] % b[i]
  1294  	}
  1295  }
  1296  
  1297  func ModIncrU8(a []uint8, b []uint8, incr []uint8) {
  1298  	a = a[:]
  1299  	b = b[:len(a)]
  1300  	incr = incr[:len(a)]
  1301  	for i := range incr {
  1302  		incr[i] += a[i] % b[i]
  1303  	}
  1304  }
  1305  
  1306  func ModIncrU16(a []uint16, b []uint16, incr []uint16) {
  1307  	a = a[:]
  1308  	b = b[:len(a)]
  1309  	incr = incr[:len(a)]
  1310  	for i := range incr {
  1311  		incr[i] += a[i] % b[i]
  1312  	}
  1313  }
  1314  
  1315  func ModIncrU32(a []uint32, b []uint32, incr []uint32) {
  1316  	a = a[:]
  1317  	b = b[:len(a)]
  1318  	incr = incr[:len(a)]
  1319  	for i := range incr {
  1320  		incr[i] += a[i] % b[i]
  1321  	}
  1322  }
  1323  
  1324  func ModIncrU64(a []uint64, b []uint64, incr []uint64) {
  1325  	a = a[:]
  1326  	b = b[:len(a)]
  1327  	incr = incr[:len(a)]
  1328  	for i := range incr {
  1329  		incr[i] += a[i] % b[i]
  1330  	}
  1331  }
  1332  
  1333  func ModIncrF32(a []float32, b []float32, incr []float32) { vecf32.IncrMod(a, b, incr) }
  1334  func ModIncrF64(a []float64, b []float64, incr []float64) { vecf64.IncrMod(a, b, incr) }
  1335  func AddIterI(a []int, b []int, ait Iterator, bit Iterator) (err error) {
  1336  	var i, j int
  1337  	var validi, validj bool
  1338  	for {
  1339  		if i, validi, err = ait.NextValidity(); err != nil {
  1340  			err = handleNoOp(err)
  1341  			break
  1342  		}
  1343  		if j, validj, err = bit.NextValidity(); err != nil {
  1344  			err = handleNoOp(err)
  1345  			break
  1346  		}
  1347  		if validi && validj {
  1348  			a[i] = a[i] + b[j]
  1349  		}
  1350  	}
  1351  	return
  1352  }
  1353  
  1354  func AddIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error) {
  1355  	var i, j int
  1356  	var validi, validj bool
  1357  	for {
  1358  		if i, validi, err = ait.NextValidity(); err != nil {
  1359  			err = handleNoOp(err)
  1360  			break
  1361  		}
  1362  		if j, validj, err = bit.NextValidity(); err != nil {
  1363  			err = handleNoOp(err)
  1364  			break
  1365  		}
  1366  		if validi && validj {
  1367  			a[i] = a[i] + b[j]
  1368  		}
  1369  	}
  1370  	return
  1371  }
  1372  
  1373  func AddIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error) {
  1374  	var i, j int
  1375  	var validi, validj bool
  1376  	for {
  1377  		if i, validi, err = ait.NextValidity(); err != nil {
  1378  			err = handleNoOp(err)
  1379  			break
  1380  		}
  1381  		if j, validj, err = bit.NextValidity(); err != nil {
  1382  			err = handleNoOp(err)
  1383  			break
  1384  		}
  1385  		if validi && validj {
  1386  			a[i] = a[i] + b[j]
  1387  		}
  1388  	}
  1389  	return
  1390  }
  1391  
  1392  func AddIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error) {
  1393  	var i, j int
  1394  	var validi, validj bool
  1395  	for {
  1396  		if i, validi, err = ait.NextValidity(); err != nil {
  1397  			err = handleNoOp(err)
  1398  			break
  1399  		}
  1400  		if j, validj, err = bit.NextValidity(); err != nil {
  1401  			err = handleNoOp(err)
  1402  			break
  1403  		}
  1404  		if validi && validj {
  1405  			a[i] = a[i] + b[j]
  1406  		}
  1407  	}
  1408  	return
  1409  }
  1410  
  1411  func AddIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error) {
  1412  	var i, j int
  1413  	var validi, validj bool
  1414  	for {
  1415  		if i, validi, err = ait.NextValidity(); err != nil {
  1416  			err = handleNoOp(err)
  1417  			break
  1418  		}
  1419  		if j, validj, err = bit.NextValidity(); err != nil {
  1420  			err = handleNoOp(err)
  1421  			break
  1422  		}
  1423  		if validi && validj {
  1424  			a[i] = a[i] + b[j]
  1425  		}
  1426  	}
  1427  	return
  1428  }
  1429  
  1430  func AddIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error) {
  1431  	var i, j int
  1432  	var validi, validj bool
  1433  	for {
  1434  		if i, validi, err = ait.NextValidity(); err != nil {
  1435  			err = handleNoOp(err)
  1436  			break
  1437  		}
  1438  		if j, validj, err = bit.NextValidity(); err != nil {
  1439  			err = handleNoOp(err)
  1440  			break
  1441  		}
  1442  		if validi && validj {
  1443  			a[i] = a[i] + b[j]
  1444  		}
  1445  	}
  1446  	return
  1447  }
  1448  
  1449  func AddIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error) {
  1450  	var i, j int
  1451  	var validi, validj bool
  1452  	for {
  1453  		if i, validi, err = ait.NextValidity(); err != nil {
  1454  			err = handleNoOp(err)
  1455  			break
  1456  		}
  1457  		if j, validj, err = bit.NextValidity(); err != nil {
  1458  			err = handleNoOp(err)
  1459  			break
  1460  		}
  1461  		if validi && validj {
  1462  			a[i] = a[i] + b[j]
  1463  		}
  1464  	}
  1465  	return
  1466  }
  1467  
  1468  func AddIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error) {
  1469  	var i, j int
  1470  	var validi, validj bool
  1471  	for {
  1472  		if i, validi, err = ait.NextValidity(); err != nil {
  1473  			err = handleNoOp(err)
  1474  			break
  1475  		}
  1476  		if j, validj, err = bit.NextValidity(); err != nil {
  1477  			err = handleNoOp(err)
  1478  			break
  1479  		}
  1480  		if validi && validj {
  1481  			a[i] = a[i] + b[j]
  1482  		}
  1483  	}
  1484  	return
  1485  }
  1486  
  1487  func AddIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error) {
  1488  	var i, j int
  1489  	var validi, validj bool
  1490  	for {
  1491  		if i, validi, err = ait.NextValidity(); err != nil {
  1492  			err = handleNoOp(err)
  1493  			break
  1494  		}
  1495  		if j, validj, err = bit.NextValidity(); err != nil {
  1496  			err = handleNoOp(err)
  1497  			break
  1498  		}
  1499  		if validi && validj {
  1500  			a[i] = a[i] + b[j]
  1501  		}
  1502  	}
  1503  	return
  1504  }
  1505  
  1506  func AddIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error) {
  1507  	var i, j int
  1508  	var validi, validj bool
  1509  	for {
  1510  		if i, validi, err = ait.NextValidity(); err != nil {
  1511  			err = handleNoOp(err)
  1512  			break
  1513  		}
  1514  		if j, validj, err = bit.NextValidity(); err != nil {
  1515  			err = handleNoOp(err)
  1516  			break
  1517  		}
  1518  		if validi && validj {
  1519  			a[i] = a[i] + b[j]
  1520  		}
  1521  	}
  1522  	return
  1523  }
  1524  
  1525  func AddIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error) {
  1526  	var i, j int
  1527  	var validi, validj bool
  1528  	for {
  1529  		if i, validi, err = ait.NextValidity(); err != nil {
  1530  			err = handleNoOp(err)
  1531  			break
  1532  		}
  1533  		if j, validj, err = bit.NextValidity(); err != nil {
  1534  			err = handleNoOp(err)
  1535  			break
  1536  		}
  1537  		if validi && validj {
  1538  			a[i] = a[i] + b[j]
  1539  		}
  1540  	}
  1541  	return
  1542  }
  1543  
  1544  func AddIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error) {
  1545  	var i, j int
  1546  	var validi, validj bool
  1547  	for {
  1548  		if i, validi, err = ait.NextValidity(); err != nil {
  1549  			err = handleNoOp(err)
  1550  			break
  1551  		}
  1552  		if j, validj, err = bit.NextValidity(); err != nil {
  1553  			err = handleNoOp(err)
  1554  			break
  1555  		}
  1556  		if validi && validj {
  1557  			a[i] = a[i] + b[j]
  1558  		}
  1559  	}
  1560  	return
  1561  }
  1562  
  1563  func AddIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error) {
  1564  	var i, j int
  1565  	var validi, validj bool
  1566  	for {
  1567  		if i, validi, err = ait.NextValidity(); err != nil {
  1568  			err = handleNoOp(err)
  1569  			break
  1570  		}
  1571  		if j, validj, err = bit.NextValidity(); err != nil {
  1572  			err = handleNoOp(err)
  1573  			break
  1574  		}
  1575  		if validi && validj {
  1576  			a[i] = a[i] + b[j]
  1577  		}
  1578  	}
  1579  	return
  1580  }
  1581  
  1582  func AddIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error) {
  1583  	var i, j int
  1584  	var validi, validj bool
  1585  	for {
  1586  		if i, validi, err = ait.NextValidity(); err != nil {
  1587  			err = handleNoOp(err)
  1588  			break
  1589  		}
  1590  		if j, validj, err = bit.NextValidity(); err != nil {
  1591  			err = handleNoOp(err)
  1592  			break
  1593  		}
  1594  		if validi && validj {
  1595  			a[i] = a[i] + b[j]
  1596  		}
  1597  	}
  1598  	return
  1599  }
  1600  
  1601  func AddIterStr(a []string, b []string, ait Iterator, bit Iterator) (err error) {
  1602  	var i, j int
  1603  	var validi, validj bool
  1604  	for {
  1605  		if i, validi, err = ait.NextValidity(); err != nil {
  1606  			err = handleNoOp(err)
  1607  			break
  1608  		}
  1609  		if j, validj, err = bit.NextValidity(); err != nil {
  1610  			err = handleNoOp(err)
  1611  			break
  1612  		}
  1613  		if validi && validj {
  1614  			a[i] = a[i] + b[j]
  1615  		}
  1616  	}
  1617  	return
  1618  }
  1619  
  1620  func SubIterI(a []int, b []int, ait Iterator, bit Iterator) (err error) {
  1621  	var i, j int
  1622  	var validi, validj bool
  1623  	for {
  1624  		if i, validi, err = ait.NextValidity(); err != nil {
  1625  			err = handleNoOp(err)
  1626  			break
  1627  		}
  1628  		if j, validj, err = bit.NextValidity(); err != nil {
  1629  			err = handleNoOp(err)
  1630  			break
  1631  		}
  1632  		if validi && validj {
  1633  			a[i] = a[i] - b[j]
  1634  		}
  1635  	}
  1636  	return
  1637  }
  1638  
  1639  func SubIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error) {
  1640  	var i, j int
  1641  	var validi, validj bool
  1642  	for {
  1643  		if i, validi, err = ait.NextValidity(); err != nil {
  1644  			err = handleNoOp(err)
  1645  			break
  1646  		}
  1647  		if j, validj, err = bit.NextValidity(); err != nil {
  1648  			err = handleNoOp(err)
  1649  			break
  1650  		}
  1651  		if validi && validj {
  1652  			a[i] = a[i] - b[j]
  1653  		}
  1654  	}
  1655  	return
  1656  }
  1657  
  1658  func SubIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error) {
  1659  	var i, j int
  1660  	var validi, validj bool
  1661  	for {
  1662  		if i, validi, err = ait.NextValidity(); err != nil {
  1663  			err = handleNoOp(err)
  1664  			break
  1665  		}
  1666  		if j, validj, err = bit.NextValidity(); err != nil {
  1667  			err = handleNoOp(err)
  1668  			break
  1669  		}
  1670  		if validi && validj {
  1671  			a[i] = a[i] - b[j]
  1672  		}
  1673  	}
  1674  	return
  1675  }
  1676  
  1677  func SubIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error) {
  1678  	var i, j int
  1679  	var validi, validj bool
  1680  	for {
  1681  		if i, validi, err = ait.NextValidity(); err != nil {
  1682  			err = handleNoOp(err)
  1683  			break
  1684  		}
  1685  		if j, validj, err = bit.NextValidity(); err != nil {
  1686  			err = handleNoOp(err)
  1687  			break
  1688  		}
  1689  		if validi && validj {
  1690  			a[i] = a[i] - b[j]
  1691  		}
  1692  	}
  1693  	return
  1694  }
  1695  
  1696  func SubIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error) {
  1697  	var i, j int
  1698  	var validi, validj bool
  1699  	for {
  1700  		if i, validi, err = ait.NextValidity(); err != nil {
  1701  			err = handleNoOp(err)
  1702  			break
  1703  		}
  1704  		if j, validj, err = bit.NextValidity(); err != nil {
  1705  			err = handleNoOp(err)
  1706  			break
  1707  		}
  1708  		if validi && validj {
  1709  			a[i] = a[i] - b[j]
  1710  		}
  1711  	}
  1712  	return
  1713  }
  1714  
  1715  func SubIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error) {
  1716  	var i, j int
  1717  	var validi, validj bool
  1718  	for {
  1719  		if i, validi, err = ait.NextValidity(); err != nil {
  1720  			err = handleNoOp(err)
  1721  			break
  1722  		}
  1723  		if j, validj, err = bit.NextValidity(); err != nil {
  1724  			err = handleNoOp(err)
  1725  			break
  1726  		}
  1727  		if validi && validj {
  1728  			a[i] = a[i] - b[j]
  1729  		}
  1730  	}
  1731  	return
  1732  }
  1733  
  1734  func SubIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error) {
  1735  	var i, j int
  1736  	var validi, validj bool
  1737  	for {
  1738  		if i, validi, err = ait.NextValidity(); err != nil {
  1739  			err = handleNoOp(err)
  1740  			break
  1741  		}
  1742  		if j, validj, err = bit.NextValidity(); err != nil {
  1743  			err = handleNoOp(err)
  1744  			break
  1745  		}
  1746  		if validi && validj {
  1747  			a[i] = a[i] - b[j]
  1748  		}
  1749  	}
  1750  	return
  1751  }
  1752  
  1753  func SubIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error) {
  1754  	var i, j int
  1755  	var validi, validj bool
  1756  	for {
  1757  		if i, validi, err = ait.NextValidity(); err != nil {
  1758  			err = handleNoOp(err)
  1759  			break
  1760  		}
  1761  		if j, validj, err = bit.NextValidity(); err != nil {
  1762  			err = handleNoOp(err)
  1763  			break
  1764  		}
  1765  		if validi && validj {
  1766  			a[i] = a[i] - b[j]
  1767  		}
  1768  	}
  1769  	return
  1770  }
  1771  
  1772  func SubIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error) {
  1773  	var i, j int
  1774  	var validi, validj bool
  1775  	for {
  1776  		if i, validi, err = ait.NextValidity(); err != nil {
  1777  			err = handleNoOp(err)
  1778  			break
  1779  		}
  1780  		if j, validj, err = bit.NextValidity(); err != nil {
  1781  			err = handleNoOp(err)
  1782  			break
  1783  		}
  1784  		if validi && validj {
  1785  			a[i] = a[i] - b[j]
  1786  		}
  1787  	}
  1788  	return
  1789  }
  1790  
  1791  func SubIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error) {
  1792  	var i, j int
  1793  	var validi, validj bool
  1794  	for {
  1795  		if i, validi, err = ait.NextValidity(); err != nil {
  1796  			err = handleNoOp(err)
  1797  			break
  1798  		}
  1799  		if j, validj, err = bit.NextValidity(); err != nil {
  1800  			err = handleNoOp(err)
  1801  			break
  1802  		}
  1803  		if validi && validj {
  1804  			a[i] = a[i] - b[j]
  1805  		}
  1806  	}
  1807  	return
  1808  }
  1809  
  1810  func SubIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error) {
  1811  	var i, j int
  1812  	var validi, validj bool
  1813  	for {
  1814  		if i, validi, err = ait.NextValidity(); err != nil {
  1815  			err = handleNoOp(err)
  1816  			break
  1817  		}
  1818  		if j, validj, err = bit.NextValidity(); err != nil {
  1819  			err = handleNoOp(err)
  1820  			break
  1821  		}
  1822  		if validi && validj {
  1823  			a[i] = a[i] - b[j]
  1824  		}
  1825  	}
  1826  	return
  1827  }
  1828  
  1829  func SubIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error) {
  1830  	var i, j int
  1831  	var validi, validj bool
  1832  	for {
  1833  		if i, validi, err = ait.NextValidity(); err != nil {
  1834  			err = handleNoOp(err)
  1835  			break
  1836  		}
  1837  		if j, validj, err = bit.NextValidity(); err != nil {
  1838  			err = handleNoOp(err)
  1839  			break
  1840  		}
  1841  		if validi && validj {
  1842  			a[i] = a[i] - b[j]
  1843  		}
  1844  	}
  1845  	return
  1846  }
  1847  
  1848  func SubIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error) {
  1849  	var i, j int
  1850  	var validi, validj bool
  1851  	for {
  1852  		if i, validi, err = ait.NextValidity(); err != nil {
  1853  			err = handleNoOp(err)
  1854  			break
  1855  		}
  1856  		if j, validj, err = bit.NextValidity(); err != nil {
  1857  			err = handleNoOp(err)
  1858  			break
  1859  		}
  1860  		if validi && validj {
  1861  			a[i] = a[i] - b[j]
  1862  		}
  1863  	}
  1864  	return
  1865  }
  1866  
  1867  func SubIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error) {
  1868  	var i, j int
  1869  	var validi, validj bool
  1870  	for {
  1871  		if i, validi, err = ait.NextValidity(); err != nil {
  1872  			err = handleNoOp(err)
  1873  			break
  1874  		}
  1875  		if j, validj, err = bit.NextValidity(); err != nil {
  1876  			err = handleNoOp(err)
  1877  			break
  1878  		}
  1879  		if validi && validj {
  1880  			a[i] = a[i] - b[j]
  1881  		}
  1882  	}
  1883  	return
  1884  }
  1885  
  1886  func MulIterI(a []int, b []int, ait Iterator, bit Iterator) (err error) {
  1887  	var i, j int
  1888  	var validi, validj bool
  1889  	for {
  1890  		if i, validi, err = ait.NextValidity(); err != nil {
  1891  			err = handleNoOp(err)
  1892  			break
  1893  		}
  1894  		if j, validj, err = bit.NextValidity(); err != nil {
  1895  			err = handleNoOp(err)
  1896  			break
  1897  		}
  1898  		if validi && validj {
  1899  			a[i] = a[i] * b[j]
  1900  		}
  1901  	}
  1902  	return
  1903  }
  1904  
  1905  func MulIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error) {
  1906  	var i, j int
  1907  	var validi, validj bool
  1908  	for {
  1909  		if i, validi, err = ait.NextValidity(); err != nil {
  1910  			err = handleNoOp(err)
  1911  			break
  1912  		}
  1913  		if j, validj, err = bit.NextValidity(); err != nil {
  1914  			err = handleNoOp(err)
  1915  			break
  1916  		}
  1917  		if validi && validj {
  1918  			a[i] = a[i] * b[j]
  1919  		}
  1920  	}
  1921  	return
  1922  }
  1923  
  1924  func MulIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error) {
  1925  	var i, j int
  1926  	var validi, validj bool
  1927  	for {
  1928  		if i, validi, err = ait.NextValidity(); err != nil {
  1929  			err = handleNoOp(err)
  1930  			break
  1931  		}
  1932  		if j, validj, err = bit.NextValidity(); err != nil {
  1933  			err = handleNoOp(err)
  1934  			break
  1935  		}
  1936  		if validi && validj {
  1937  			a[i] = a[i] * b[j]
  1938  		}
  1939  	}
  1940  	return
  1941  }
  1942  
  1943  func MulIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error) {
  1944  	var i, j int
  1945  	var validi, validj bool
  1946  	for {
  1947  		if i, validi, err = ait.NextValidity(); err != nil {
  1948  			err = handleNoOp(err)
  1949  			break
  1950  		}
  1951  		if j, validj, err = bit.NextValidity(); err != nil {
  1952  			err = handleNoOp(err)
  1953  			break
  1954  		}
  1955  		if validi && validj {
  1956  			a[i] = a[i] * b[j]
  1957  		}
  1958  	}
  1959  	return
  1960  }
  1961  
  1962  func MulIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error) {
  1963  	var i, j int
  1964  	var validi, validj bool
  1965  	for {
  1966  		if i, validi, err = ait.NextValidity(); err != nil {
  1967  			err = handleNoOp(err)
  1968  			break
  1969  		}
  1970  		if j, validj, err = bit.NextValidity(); err != nil {
  1971  			err = handleNoOp(err)
  1972  			break
  1973  		}
  1974  		if validi && validj {
  1975  			a[i] = a[i] * b[j]
  1976  		}
  1977  	}
  1978  	return
  1979  }
  1980  
  1981  func MulIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error) {
  1982  	var i, j int
  1983  	var validi, validj bool
  1984  	for {
  1985  		if i, validi, err = ait.NextValidity(); err != nil {
  1986  			err = handleNoOp(err)
  1987  			break
  1988  		}
  1989  		if j, validj, err = bit.NextValidity(); err != nil {
  1990  			err = handleNoOp(err)
  1991  			break
  1992  		}
  1993  		if validi && validj {
  1994  			a[i] = a[i] * b[j]
  1995  		}
  1996  	}
  1997  	return
  1998  }
  1999  
  2000  func MulIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error) {
  2001  	var i, j int
  2002  	var validi, validj bool
  2003  	for {
  2004  		if i, validi, err = ait.NextValidity(); err != nil {
  2005  			err = handleNoOp(err)
  2006  			break
  2007  		}
  2008  		if j, validj, err = bit.NextValidity(); err != nil {
  2009  			err = handleNoOp(err)
  2010  			break
  2011  		}
  2012  		if validi && validj {
  2013  			a[i] = a[i] * b[j]
  2014  		}
  2015  	}
  2016  	return
  2017  }
  2018  
  2019  func MulIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error) {
  2020  	var i, j int
  2021  	var validi, validj bool
  2022  	for {
  2023  		if i, validi, err = ait.NextValidity(); err != nil {
  2024  			err = handleNoOp(err)
  2025  			break
  2026  		}
  2027  		if j, validj, err = bit.NextValidity(); err != nil {
  2028  			err = handleNoOp(err)
  2029  			break
  2030  		}
  2031  		if validi && validj {
  2032  			a[i] = a[i] * b[j]
  2033  		}
  2034  	}
  2035  	return
  2036  }
  2037  
  2038  func MulIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error) {
  2039  	var i, j int
  2040  	var validi, validj bool
  2041  	for {
  2042  		if i, validi, err = ait.NextValidity(); err != nil {
  2043  			err = handleNoOp(err)
  2044  			break
  2045  		}
  2046  		if j, validj, err = bit.NextValidity(); err != nil {
  2047  			err = handleNoOp(err)
  2048  			break
  2049  		}
  2050  		if validi && validj {
  2051  			a[i] = a[i] * b[j]
  2052  		}
  2053  	}
  2054  	return
  2055  }
  2056  
  2057  func MulIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error) {
  2058  	var i, j int
  2059  	var validi, validj bool
  2060  	for {
  2061  		if i, validi, err = ait.NextValidity(); err != nil {
  2062  			err = handleNoOp(err)
  2063  			break
  2064  		}
  2065  		if j, validj, err = bit.NextValidity(); err != nil {
  2066  			err = handleNoOp(err)
  2067  			break
  2068  		}
  2069  		if validi && validj {
  2070  			a[i] = a[i] * b[j]
  2071  		}
  2072  	}
  2073  	return
  2074  }
  2075  
  2076  func MulIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error) {
  2077  	var i, j int
  2078  	var validi, validj bool
  2079  	for {
  2080  		if i, validi, err = ait.NextValidity(); err != nil {
  2081  			err = handleNoOp(err)
  2082  			break
  2083  		}
  2084  		if j, validj, err = bit.NextValidity(); err != nil {
  2085  			err = handleNoOp(err)
  2086  			break
  2087  		}
  2088  		if validi && validj {
  2089  			a[i] = a[i] * b[j]
  2090  		}
  2091  	}
  2092  	return
  2093  }
  2094  
  2095  func MulIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error) {
  2096  	var i, j int
  2097  	var validi, validj bool
  2098  	for {
  2099  		if i, validi, err = ait.NextValidity(); err != nil {
  2100  			err = handleNoOp(err)
  2101  			break
  2102  		}
  2103  		if j, validj, err = bit.NextValidity(); err != nil {
  2104  			err = handleNoOp(err)
  2105  			break
  2106  		}
  2107  		if validi && validj {
  2108  			a[i] = a[i] * b[j]
  2109  		}
  2110  	}
  2111  	return
  2112  }
  2113  
  2114  func MulIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error) {
  2115  	var i, j int
  2116  	var validi, validj bool
  2117  	for {
  2118  		if i, validi, err = ait.NextValidity(); err != nil {
  2119  			err = handleNoOp(err)
  2120  			break
  2121  		}
  2122  		if j, validj, err = bit.NextValidity(); err != nil {
  2123  			err = handleNoOp(err)
  2124  			break
  2125  		}
  2126  		if validi && validj {
  2127  			a[i] = a[i] * b[j]
  2128  		}
  2129  	}
  2130  	return
  2131  }
  2132  
  2133  func MulIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error) {
  2134  	var i, j int
  2135  	var validi, validj bool
  2136  	for {
  2137  		if i, validi, err = ait.NextValidity(); err != nil {
  2138  			err = handleNoOp(err)
  2139  			break
  2140  		}
  2141  		if j, validj, err = bit.NextValidity(); err != nil {
  2142  			err = handleNoOp(err)
  2143  			break
  2144  		}
  2145  		if validi && validj {
  2146  			a[i] = a[i] * b[j]
  2147  		}
  2148  	}
  2149  	return
  2150  }
  2151  
  2152  func DivIterI(a []int, b []int, ait Iterator, bit Iterator) (err error) {
  2153  	var errs errorIndices
  2154  	var i, j int
  2155  	var validi, validj bool
  2156  	for {
  2157  		if i, validi, err = ait.NextValidity(); err != nil {
  2158  			err = handleNoOp(err)
  2159  			break
  2160  		}
  2161  		if j, validj, err = bit.NextValidity(); err != nil {
  2162  			err = handleNoOp(err)
  2163  			break
  2164  		}
  2165  		if validi && validj {
  2166  			if b[j] == 0 {
  2167  				errs = append(errs, i)
  2168  				a[i] = 0
  2169  				continue
  2170  			}
  2171  			a[i] = a[i] / b[j]
  2172  		}
  2173  	}
  2174  	if err != nil {
  2175  		return
  2176  	}
  2177  	if len(errs) > 0 {
  2178  		return errs
  2179  	}
  2180  	return nil
  2181  }
  2182  
  2183  func DivIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error) {
  2184  	var errs errorIndices
  2185  	var i, j int
  2186  	var validi, validj bool
  2187  	for {
  2188  		if i, validi, err = ait.NextValidity(); err != nil {
  2189  			err = handleNoOp(err)
  2190  			break
  2191  		}
  2192  		if j, validj, err = bit.NextValidity(); err != nil {
  2193  			err = handleNoOp(err)
  2194  			break
  2195  		}
  2196  		if validi && validj {
  2197  			if b[j] == 0 {
  2198  				errs = append(errs, i)
  2199  				a[i] = 0
  2200  				continue
  2201  			}
  2202  			a[i] = a[i] / b[j]
  2203  		}
  2204  	}
  2205  	if err != nil {
  2206  		return
  2207  	}
  2208  	if len(errs) > 0 {
  2209  		return errs
  2210  	}
  2211  	return nil
  2212  }
  2213  
  2214  func DivIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error) {
  2215  	var errs errorIndices
  2216  	var i, j int
  2217  	var validi, validj bool
  2218  	for {
  2219  		if i, validi, err = ait.NextValidity(); err != nil {
  2220  			err = handleNoOp(err)
  2221  			break
  2222  		}
  2223  		if j, validj, err = bit.NextValidity(); err != nil {
  2224  			err = handleNoOp(err)
  2225  			break
  2226  		}
  2227  		if validi && validj {
  2228  			if b[j] == 0 {
  2229  				errs = append(errs, i)
  2230  				a[i] = 0
  2231  				continue
  2232  			}
  2233  			a[i] = a[i] / b[j]
  2234  		}
  2235  	}
  2236  	if err != nil {
  2237  		return
  2238  	}
  2239  	if len(errs) > 0 {
  2240  		return errs
  2241  	}
  2242  	return nil
  2243  }
  2244  
  2245  func DivIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error) {
  2246  	var errs errorIndices
  2247  	var i, j int
  2248  	var validi, validj bool
  2249  	for {
  2250  		if i, validi, err = ait.NextValidity(); err != nil {
  2251  			err = handleNoOp(err)
  2252  			break
  2253  		}
  2254  		if j, validj, err = bit.NextValidity(); err != nil {
  2255  			err = handleNoOp(err)
  2256  			break
  2257  		}
  2258  		if validi && validj {
  2259  			if b[j] == 0 {
  2260  				errs = append(errs, i)
  2261  				a[i] = 0
  2262  				continue
  2263  			}
  2264  			a[i] = a[i] / b[j]
  2265  		}
  2266  	}
  2267  	if err != nil {
  2268  		return
  2269  	}
  2270  	if len(errs) > 0 {
  2271  		return errs
  2272  	}
  2273  	return nil
  2274  }
  2275  
  2276  func DivIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error) {
  2277  	var errs errorIndices
  2278  	var i, j int
  2279  	var validi, validj bool
  2280  	for {
  2281  		if i, validi, err = ait.NextValidity(); err != nil {
  2282  			err = handleNoOp(err)
  2283  			break
  2284  		}
  2285  		if j, validj, err = bit.NextValidity(); err != nil {
  2286  			err = handleNoOp(err)
  2287  			break
  2288  		}
  2289  		if validi && validj {
  2290  			if b[j] == 0 {
  2291  				errs = append(errs, i)
  2292  				a[i] = 0
  2293  				continue
  2294  			}
  2295  			a[i] = a[i] / b[j]
  2296  		}
  2297  	}
  2298  	if err != nil {
  2299  		return
  2300  	}
  2301  	if len(errs) > 0 {
  2302  		return errs
  2303  	}
  2304  	return nil
  2305  }
  2306  
  2307  func DivIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error) {
  2308  	var errs errorIndices
  2309  	var i, j int
  2310  	var validi, validj bool
  2311  	for {
  2312  		if i, validi, err = ait.NextValidity(); err != nil {
  2313  			err = handleNoOp(err)
  2314  			break
  2315  		}
  2316  		if j, validj, err = bit.NextValidity(); err != nil {
  2317  			err = handleNoOp(err)
  2318  			break
  2319  		}
  2320  		if validi && validj {
  2321  			if b[j] == 0 {
  2322  				errs = append(errs, i)
  2323  				a[i] = 0
  2324  				continue
  2325  			}
  2326  			a[i] = a[i] / b[j]
  2327  		}
  2328  	}
  2329  	if err != nil {
  2330  		return
  2331  	}
  2332  	if len(errs) > 0 {
  2333  		return errs
  2334  	}
  2335  	return nil
  2336  }
  2337  
  2338  func DivIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error) {
  2339  	var errs errorIndices
  2340  	var i, j int
  2341  	var validi, validj bool
  2342  	for {
  2343  		if i, validi, err = ait.NextValidity(); err != nil {
  2344  			err = handleNoOp(err)
  2345  			break
  2346  		}
  2347  		if j, validj, err = bit.NextValidity(); err != nil {
  2348  			err = handleNoOp(err)
  2349  			break
  2350  		}
  2351  		if validi && validj {
  2352  			if b[j] == 0 {
  2353  				errs = append(errs, i)
  2354  				a[i] = 0
  2355  				continue
  2356  			}
  2357  			a[i] = a[i] / b[j]
  2358  		}
  2359  	}
  2360  	if err != nil {
  2361  		return
  2362  	}
  2363  	if len(errs) > 0 {
  2364  		return errs
  2365  	}
  2366  	return nil
  2367  }
  2368  
  2369  func DivIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error) {
  2370  	var errs errorIndices
  2371  	var i, j int
  2372  	var validi, validj bool
  2373  	for {
  2374  		if i, validi, err = ait.NextValidity(); err != nil {
  2375  			err = handleNoOp(err)
  2376  			break
  2377  		}
  2378  		if j, validj, err = bit.NextValidity(); err != nil {
  2379  			err = handleNoOp(err)
  2380  			break
  2381  		}
  2382  		if validi && validj {
  2383  			if b[j] == 0 {
  2384  				errs = append(errs, i)
  2385  				a[i] = 0
  2386  				continue
  2387  			}
  2388  			a[i] = a[i] / b[j]
  2389  		}
  2390  	}
  2391  	if err != nil {
  2392  		return
  2393  	}
  2394  	if len(errs) > 0 {
  2395  		return errs
  2396  	}
  2397  	return nil
  2398  }
  2399  
  2400  func DivIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error) {
  2401  	var errs errorIndices
  2402  	var i, j int
  2403  	var validi, validj bool
  2404  	for {
  2405  		if i, validi, err = ait.NextValidity(); err != nil {
  2406  			err = handleNoOp(err)
  2407  			break
  2408  		}
  2409  		if j, validj, err = bit.NextValidity(); err != nil {
  2410  			err = handleNoOp(err)
  2411  			break
  2412  		}
  2413  		if validi && validj {
  2414  			if b[j] == 0 {
  2415  				errs = append(errs, i)
  2416  				a[i] = 0
  2417  				continue
  2418  			}
  2419  			a[i] = a[i] / b[j]
  2420  		}
  2421  	}
  2422  	if err != nil {
  2423  		return
  2424  	}
  2425  	if len(errs) > 0 {
  2426  		return errs
  2427  	}
  2428  	return nil
  2429  }
  2430  
  2431  func DivIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error) {
  2432  	var errs errorIndices
  2433  	var i, j int
  2434  	var validi, validj bool
  2435  	for {
  2436  		if i, validi, err = ait.NextValidity(); err != nil {
  2437  			err = handleNoOp(err)
  2438  			break
  2439  		}
  2440  		if j, validj, err = bit.NextValidity(); err != nil {
  2441  			err = handleNoOp(err)
  2442  			break
  2443  		}
  2444  		if validi && validj {
  2445  			if b[j] == 0 {
  2446  				errs = append(errs, i)
  2447  				a[i] = 0
  2448  				continue
  2449  			}
  2450  			a[i] = a[i] / b[j]
  2451  		}
  2452  	}
  2453  	if err != nil {
  2454  		return
  2455  	}
  2456  	if len(errs) > 0 {
  2457  		return errs
  2458  	}
  2459  	return nil
  2460  }
  2461  
  2462  func DivIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error) {
  2463  	var i, j int
  2464  	var validi, validj bool
  2465  	for {
  2466  		if i, validi, err = ait.NextValidity(); err != nil {
  2467  			err = handleNoOp(err)
  2468  			break
  2469  		}
  2470  		if j, validj, err = bit.NextValidity(); err != nil {
  2471  			err = handleNoOp(err)
  2472  			break
  2473  		}
  2474  		if validi && validj {
  2475  			a[i] = a[i] / b[j]
  2476  		}
  2477  	}
  2478  	return
  2479  }
  2480  
  2481  func DivIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error) {
  2482  	var i, j int
  2483  	var validi, validj bool
  2484  	for {
  2485  		if i, validi, err = ait.NextValidity(); err != nil {
  2486  			err = handleNoOp(err)
  2487  			break
  2488  		}
  2489  		if j, validj, err = bit.NextValidity(); err != nil {
  2490  			err = handleNoOp(err)
  2491  			break
  2492  		}
  2493  		if validi && validj {
  2494  			a[i] = a[i] / b[j]
  2495  		}
  2496  	}
  2497  	return
  2498  }
  2499  
  2500  func DivIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error) {
  2501  	var i, j int
  2502  	var validi, validj bool
  2503  	for {
  2504  		if i, validi, err = ait.NextValidity(); err != nil {
  2505  			err = handleNoOp(err)
  2506  			break
  2507  		}
  2508  		if j, validj, err = bit.NextValidity(); err != nil {
  2509  			err = handleNoOp(err)
  2510  			break
  2511  		}
  2512  		if validi && validj {
  2513  			a[i] = a[i] / b[j]
  2514  		}
  2515  	}
  2516  	return
  2517  }
  2518  
  2519  func DivIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error) {
  2520  	var i, j int
  2521  	var validi, validj bool
  2522  	for {
  2523  		if i, validi, err = ait.NextValidity(); err != nil {
  2524  			err = handleNoOp(err)
  2525  			break
  2526  		}
  2527  		if j, validj, err = bit.NextValidity(); err != nil {
  2528  			err = handleNoOp(err)
  2529  			break
  2530  		}
  2531  		if validi && validj {
  2532  			a[i] = a[i] / b[j]
  2533  		}
  2534  	}
  2535  	return
  2536  }
  2537  
  2538  func PowIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error) {
  2539  	var i, j int
  2540  	var validi, validj bool
  2541  	for {
  2542  		if i, validi, err = ait.NextValidity(); err != nil {
  2543  			err = handleNoOp(err)
  2544  			break
  2545  		}
  2546  		if j, validj, err = bit.NextValidity(); err != nil {
  2547  			err = handleNoOp(err)
  2548  			break
  2549  		}
  2550  		if validi && validj {
  2551  			a[i] = math32.Pow(a[i], b[j])
  2552  		}
  2553  	}
  2554  	return
  2555  }
  2556  
  2557  func PowIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error) {
  2558  	var i, j int
  2559  	var validi, validj bool
  2560  	for {
  2561  		if i, validi, err = ait.NextValidity(); err != nil {
  2562  			err = handleNoOp(err)
  2563  			break
  2564  		}
  2565  		if j, validj, err = bit.NextValidity(); err != nil {
  2566  			err = handleNoOp(err)
  2567  			break
  2568  		}
  2569  		if validi && validj {
  2570  			a[i] = math.Pow(a[i], b[j])
  2571  		}
  2572  	}
  2573  	return
  2574  }
  2575  
  2576  func PowIterC64(a []complex64, b []complex64, ait Iterator, bit Iterator) (err error) {
  2577  	var i, j int
  2578  	var validi, validj bool
  2579  	for {
  2580  		if i, validi, err = ait.NextValidity(); err != nil {
  2581  			err = handleNoOp(err)
  2582  			break
  2583  		}
  2584  		if j, validj, err = bit.NextValidity(); err != nil {
  2585  			err = handleNoOp(err)
  2586  			break
  2587  		}
  2588  		if validi && validj {
  2589  			a[i] = complex64(cmplx.Pow(complex128(a[i]), complex128(b[j])))
  2590  		}
  2591  	}
  2592  	return
  2593  }
  2594  
  2595  func PowIterC128(a []complex128, b []complex128, ait Iterator, bit Iterator) (err error) {
  2596  	var i, j int
  2597  	var validi, validj bool
  2598  	for {
  2599  		if i, validi, err = ait.NextValidity(); err != nil {
  2600  			err = handleNoOp(err)
  2601  			break
  2602  		}
  2603  		if j, validj, err = bit.NextValidity(); err != nil {
  2604  			err = handleNoOp(err)
  2605  			break
  2606  		}
  2607  		if validi && validj {
  2608  			a[i] = cmplx.Pow(a[i], b[j])
  2609  		}
  2610  	}
  2611  	return
  2612  }
  2613  
  2614  func ModIterI(a []int, b []int, ait Iterator, bit Iterator) (err error) {
  2615  	var i, j int
  2616  	var validi, validj bool
  2617  	for {
  2618  		if i, validi, err = ait.NextValidity(); err != nil {
  2619  			err = handleNoOp(err)
  2620  			break
  2621  		}
  2622  		if j, validj, err = bit.NextValidity(); err != nil {
  2623  			err = handleNoOp(err)
  2624  			break
  2625  		}
  2626  		if validi && validj {
  2627  			a[i] = a[i] % b[j]
  2628  		}
  2629  	}
  2630  	return
  2631  }
  2632  
  2633  func ModIterI8(a []int8, b []int8, ait Iterator, bit Iterator) (err error) {
  2634  	var i, j int
  2635  	var validi, validj bool
  2636  	for {
  2637  		if i, validi, err = ait.NextValidity(); err != nil {
  2638  			err = handleNoOp(err)
  2639  			break
  2640  		}
  2641  		if j, validj, err = bit.NextValidity(); err != nil {
  2642  			err = handleNoOp(err)
  2643  			break
  2644  		}
  2645  		if validi && validj {
  2646  			a[i] = a[i] % b[j]
  2647  		}
  2648  	}
  2649  	return
  2650  }
  2651  
  2652  func ModIterI16(a []int16, b []int16, ait Iterator, bit Iterator) (err error) {
  2653  	var i, j int
  2654  	var validi, validj bool
  2655  	for {
  2656  		if i, validi, err = ait.NextValidity(); err != nil {
  2657  			err = handleNoOp(err)
  2658  			break
  2659  		}
  2660  		if j, validj, err = bit.NextValidity(); err != nil {
  2661  			err = handleNoOp(err)
  2662  			break
  2663  		}
  2664  		if validi && validj {
  2665  			a[i] = a[i] % b[j]
  2666  		}
  2667  	}
  2668  	return
  2669  }
  2670  
  2671  func ModIterI32(a []int32, b []int32, ait Iterator, bit Iterator) (err error) {
  2672  	var i, j int
  2673  	var validi, validj bool
  2674  	for {
  2675  		if i, validi, err = ait.NextValidity(); err != nil {
  2676  			err = handleNoOp(err)
  2677  			break
  2678  		}
  2679  		if j, validj, err = bit.NextValidity(); err != nil {
  2680  			err = handleNoOp(err)
  2681  			break
  2682  		}
  2683  		if validi && validj {
  2684  			a[i] = a[i] % b[j]
  2685  		}
  2686  	}
  2687  	return
  2688  }
  2689  
  2690  func ModIterI64(a []int64, b []int64, ait Iterator, bit Iterator) (err error) {
  2691  	var i, j int
  2692  	var validi, validj bool
  2693  	for {
  2694  		if i, validi, err = ait.NextValidity(); err != nil {
  2695  			err = handleNoOp(err)
  2696  			break
  2697  		}
  2698  		if j, validj, err = bit.NextValidity(); err != nil {
  2699  			err = handleNoOp(err)
  2700  			break
  2701  		}
  2702  		if validi && validj {
  2703  			a[i] = a[i] % b[j]
  2704  		}
  2705  	}
  2706  	return
  2707  }
  2708  
  2709  func ModIterU(a []uint, b []uint, ait Iterator, bit Iterator) (err error) {
  2710  	var i, j int
  2711  	var validi, validj bool
  2712  	for {
  2713  		if i, validi, err = ait.NextValidity(); err != nil {
  2714  			err = handleNoOp(err)
  2715  			break
  2716  		}
  2717  		if j, validj, err = bit.NextValidity(); err != nil {
  2718  			err = handleNoOp(err)
  2719  			break
  2720  		}
  2721  		if validi && validj {
  2722  			a[i] = a[i] % b[j]
  2723  		}
  2724  	}
  2725  	return
  2726  }
  2727  
  2728  func ModIterU8(a []uint8, b []uint8, ait Iterator, bit Iterator) (err error) {
  2729  	var i, j int
  2730  	var validi, validj bool
  2731  	for {
  2732  		if i, validi, err = ait.NextValidity(); err != nil {
  2733  			err = handleNoOp(err)
  2734  			break
  2735  		}
  2736  		if j, validj, err = bit.NextValidity(); err != nil {
  2737  			err = handleNoOp(err)
  2738  			break
  2739  		}
  2740  		if validi && validj {
  2741  			a[i] = a[i] % b[j]
  2742  		}
  2743  	}
  2744  	return
  2745  }
  2746  
  2747  func ModIterU16(a []uint16, b []uint16, ait Iterator, bit Iterator) (err error) {
  2748  	var i, j int
  2749  	var validi, validj bool
  2750  	for {
  2751  		if i, validi, err = ait.NextValidity(); err != nil {
  2752  			err = handleNoOp(err)
  2753  			break
  2754  		}
  2755  		if j, validj, err = bit.NextValidity(); err != nil {
  2756  			err = handleNoOp(err)
  2757  			break
  2758  		}
  2759  		if validi && validj {
  2760  			a[i] = a[i] % b[j]
  2761  		}
  2762  	}
  2763  	return
  2764  }
  2765  
  2766  func ModIterU32(a []uint32, b []uint32, ait Iterator, bit Iterator) (err error) {
  2767  	var i, j int
  2768  	var validi, validj bool
  2769  	for {
  2770  		if i, validi, err = ait.NextValidity(); err != nil {
  2771  			err = handleNoOp(err)
  2772  			break
  2773  		}
  2774  		if j, validj, err = bit.NextValidity(); err != nil {
  2775  			err = handleNoOp(err)
  2776  			break
  2777  		}
  2778  		if validi && validj {
  2779  			a[i] = a[i] % b[j]
  2780  		}
  2781  	}
  2782  	return
  2783  }
  2784  
  2785  func ModIterU64(a []uint64, b []uint64, ait Iterator, bit Iterator) (err error) {
  2786  	var i, j int
  2787  	var validi, validj bool
  2788  	for {
  2789  		if i, validi, err = ait.NextValidity(); err != nil {
  2790  			err = handleNoOp(err)
  2791  			break
  2792  		}
  2793  		if j, validj, err = bit.NextValidity(); err != nil {
  2794  			err = handleNoOp(err)
  2795  			break
  2796  		}
  2797  		if validi && validj {
  2798  			a[i] = a[i] % b[j]
  2799  		}
  2800  	}
  2801  	return
  2802  }
  2803  
  2804  func ModIterF32(a []float32, b []float32, ait Iterator, bit Iterator) (err error) {
  2805  	var i, j int
  2806  	var validi, validj bool
  2807  	for {
  2808  		if i, validi, err = ait.NextValidity(); err != nil {
  2809  			err = handleNoOp(err)
  2810  			break
  2811  		}
  2812  		if j, validj, err = bit.NextValidity(); err != nil {
  2813  			err = handleNoOp(err)
  2814  			break
  2815  		}
  2816  		if validi && validj {
  2817  			a[i] = math32.Mod(a[i], b[j])
  2818  		}
  2819  	}
  2820  	return
  2821  }
  2822  
  2823  func ModIterF64(a []float64, b []float64, ait Iterator, bit Iterator) (err error) {
  2824  	var i, j int
  2825  	var validi, validj bool
  2826  	for {
  2827  		if i, validi, err = ait.NextValidity(); err != nil {
  2828  			err = handleNoOp(err)
  2829  			break
  2830  		}
  2831  		if j, validj, err = bit.NextValidity(); err != nil {
  2832  			err = handleNoOp(err)
  2833  			break
  2834  		}
  2835  		if validi && validj {
  2836  			a[i] = math.Mod(a[i], b[j])
  2837  		}
  2838  	}
  2839  	return
  2840  }
  2841  
  2842  func AddIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2843  	var i, j, k int
  2844  	var validi, validj, validk bool
  2845  	for {
  2846  		if i, validi, err = ait.NextValidity(); err != nil {
  2847  			err = handleNoOp(err)
  2848  			break
  2849  		}
  2850  		if j, validj, err = bit.NextValidity(); err != nil {
  2851  			err = handleNoOp(err)
  2852  			break
  2853  		}
  2854  		if k, validk, err = iit.NextValidity(); err != nil {
  2855  			err = handleNoOp(err)
  2856  			break
  2857  		}
  2858  		if validi && validj && validk {
  2859  			incr[k] += a[i] + b[j]
  2860  		}
  2861  	}
  2862  	return
  2863  }
  2864  
  2865  func AddIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2866  	var i, j, k int
  2867  	var validi, validj, validk bool
  2868  	for {
  2869  		if i, validi, err = ait.NextValidity(); err != nil {
  2870  			err = handleNoOp(err)
  2871  			break
  2872  		}
  2873  		if j, validj, err = bit.NextValidity(); err != nil {
  2874  			err = handleNoOp(err)
  2875  			break
  2876  		}
  2877  		if k, validk, err = iit.NextValidity(); err != nil {
  2878  			err = handleNoOp(err)
  2879  			break
  2880  		}
  2881  		if validi && validj && validk {
  2882  			incr[k] += a[i] + b[j]
  2883  		}
  2884  	}
  2885  	return
  2886  }
  2887  
  2888  func AddIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2889  	var i, j, k int
  2890  	var validi, validj, validk bool
  2891  	for {
  2892  		if i, validi, err = ait.NextValidity(); err != nil {
  2893  			err = handleNoOp(err)
  2894  			break
  2895  		}
  2896  		if j, validj, err = bit.NextValidity(); err != nil {
  2897  			err = handleNoOp(err)
  2898  			break
  2899  		}
  2900  		if k, validk, err = iit.NextValidity(); err != nil {
  2901  			err = handleNoOp(err)
  2902  			break
  2903  		}
  2904  		if validi && validj && validk {
  2905  			incr[k] += a[i] + b[j]
  2906  		}
  2907  	}
  2908  	return
  2909  }
  2910  
  2911  func AddIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2912  	var i, j, k int
  2913  	var validi, validj, validk bool
  2914  	for {
  2915  		if i, validi, err = ait.NextValidity(); err != nil {
  2916  			err = handleNoOp(err)
  2917  			break
  2918  		}
  2919  		if j, validj, err = bit.NextValidity(); err != nil {
  2920  			err = handleNoOp(err)
  2921  			break
  2922  		}
  2923  		if k, validk, err = iit.NextValidity(); err != nil {
  2924  			err = handleNoOp(err)
  2925  			break
  2926  		}
  2927  		if validi && validj && validk {
  2928  			incr[k] += a[i] + b[j]
  2929  		}
  2930  	}
  2931  	return
  2932  }
  2933  
  2934  func AddIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2935  	var i, j, k int
  2936  	var validi, validj, validk bool
  2937  	for {
  2938  		if i, validi, err = ait.NextValidity(); err != nil {
  2939  			err = handleNoOp(err)
  2940  			break
  2941  		}
  2942  		if j, validj, err = bit.NextValidity(); err != nil {
  2943  			err = handleNoOp(err)
  2944  			break
  2945  		}
  2946  		if k, validk, err = iit.NextValidity(); err != nil {
  2947  			err = handleNoOp(err)
  2948  			break
  2949  		}
  2950  		if validi && validj && validk {
  2951  			incr[k] += a[i] + b[j]
  2952  		}
  2953  	}
  2954  	return
  2955  }
  2956  
  2957  func AddIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2958  	var i, j, k int
  2959  	var validi, validj, validk bool
  2960  	for {
  2961  		if i, validi, err = ait.NextValidity(); err != nil {
  2962  			err = handleNoOp(err)
  2963  			break
  2964  		}
  2965  		if j, validj, err = bit.NextValidity(); err != nil {
  2966  			err = handleNoOp(err)
  2967  			break
  2968  		}
  2969  		if k, validk, err = iit.NextValidity(); err != nil {
  2970  			err = handleNoOp(err)
  2971  			break
  2972  		}
  2973  		if validi && validj && validk {
  2974  			incr[k] += a[i] + b[j]
  2975  		}
  2976  	}
  2977  	return
  2978  }
  2979  
  2980  func AddIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  2981  	var i, j, k int
  2982  	var validi, validj, validk bool
  2983  	for {
  2984  		if i, validi, err = ait.NextValidity(); err != nil {
  2985  			err = handleNoOp(err)
  2986  			break
  2987  		}
  2988  		if j, validj, err = bit.NextValidity(); err != nil {
  2989  			err = handleNoOp(err)
  2990  			break
  2991  		}
  2992  		if k, validk, err = iit.NextValidity(); err != nil {
  2993  			err = handleNoOp(err)
  2994  			break
  2995  		}
  2996  		if validi && validj && validk {
  2997  			incr[k] += a[i] + b[j]
  2998  		}
  2999  	}
  3000  	return
  3001  }
  3002  
  3003  func AddIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3004  	var i, j, k int
  3005  	var validi, validj, validk bool
  3006  	for {
  3007  		if i, validi, err = ait.NextValidity(); err != nil {
  3008  			err = handleNoOp(err)
  3009  			break
  3010  		}
  3011  		if j, validj, err = bit.NextValidity(); err != nil {
  3012  			err = handleNoOp(err)
  3013  			break
  3014  		}
  3015  		if k, validk, err = iit.NextValidity(); err != nil {
  3016  			err = handleNoOp(err)
  3017  			break
  3018  		}
  3019  		if validi && validj && validk {
  3020  			incr[k] += a[i] + b[j]
  3021  		}
  3022  	}
  3023  	return
  3024  }
  3025  
  3026  func AddIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3027  	var i, j, k int
  3028  	var validi, validj, validk bool
  3029  	for {
  3030  		if i, validi, err = ait.NextValidity(); err != nil {
  3031  			err = handleNoOp(err)
  3032  			break
  3033  		}
  3034  		if j, validj, err = bit.NextValidity(); err != nil {
  3035  			err = handleNoOp(err)
  3036  			break
  3037  		}
  3038  		if k, validk, err = iit.NextValidity(); err != nil {
  3039  			err = handleNoOp(err)
  3040  			break
  3041  		}
  3042  		if validi && validj && validk {
  3043  			incr[k] += a[i] + b[j]
  3044  		}
  3045  	}
  3046  	return
  3047  }
  3048  
  3049  func AddIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3050  	var i, j, k int
  3051  	var validi, validj, validk bool
  3052  	for {
  3053  		if i, validi, err = ait.NextValidity(); err != nil {
  3054  			err = handleNoOp(err)
  3055  			break
  3056  		}
  3057  		if j, validj, err = bit.NextValidity(); err != nil {
  3058  			err = handleNoOp(err)
  3059  			break
  3060  		}
  3061  		if k, validk, err = iit.NextValidity(); err != nil {
  3062  			err = handleNoOp(err)
  3063  			break
  3064  		}
  3065  		if validi && validj && validk {
  3066  			incr[k] += a[i] + b[j]
  3067  		}
  3068  	}
  3069  	return
  3070  }
  3071  
  3072  func AddIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3073  	var i, j, k int
  3074  	var validi, validj, validk bool
  3075  	for {
  3076  		if i, validi, err = ait.NextValidity(); err != nil {
  3077  			err = handleNoOp(err)
  3078  			break
  3079  		}
  3080  		if j, validj, err = bit.NextValidity(); err != nil {
  3081  			err = handleNoOp(err)
  3082  			break
  3083  		}
  3084  		if k, validk, err = iit.NextValidity(); err != nil {
  3085  			err = handleNoOp(err)
  3086  			break
  3087  		}
  3088  		if validi && validj && validk {
  3089  			incr[k] += a[i] + b[j]
  3090  		}
  3091  	}
  3092  	return
  3093  }
  3094  
  3095  func AddIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3096  	var i, j, k int
  3097  	var validi, validj, validk bool
  3098  	for {
  3099  		if i, validi, err = ait.NextValidity(); err != nil {
  3100  			err = handleNoOp(err)
  3101  			break
  3102  		}
  3103  		if j, validj, err = bit.NextValidity(); err != nil {
  3104  			err = handleNoOp(err)
  3105  			break
  3106  		}
  3107  		if k, validk, err = iit.NextValidity(); err != nil {
  3108  			err = handleNoOp(err)
  3109  			break
  3110  		}
  3111  		if validi && validj && validk {
  3112  			incr[k] += a[i] + b[j]
  3113  		}
  3114  	}
  3115  	return
  3116  }
  3117  
  3118  func AddIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3119  	var i, j, k int
  3120  	var validi, validj, validk bool
  3121  	for {
  3122  		if i, validi, err = ait.NextValidity(); err != nil {
  3123  			err = handleNoOp(err)
  3124  			break
  3125  		}
  3126  		if j, validj, err = bit.NextValidity(); err != nil {
  3127  			err = handleNoOp(err)
  3128  			break
  3129  		}
  3130  		if k, validk, err = iit.NextValidity(); err != nil {
  3131  			err = handleNoOp(err)
  3132  			break
  3133  		}
  3134  		if validi && validj && validk {
  3135  			incr[k] += a[i] + b[j]
  3136  		}
  3137  	}
  3138  	return
  3139  }
  3140  
  3141  func AddIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3142  	var i, j, k int
  3143  	var validi, validj, validk bool
  3144  	for {
  3145  		if i, validi, err = ait.NextValidity(); err != nil {
  3146  			err = handleNoOp(err)
  3147  			break
  3148  		}
  3149  		if j, validj, err = bit.NextValidity(); err != nil {
  3150  			err = handleNoOp(err)
  3151  			break
  3152  		}
  3153  		if k, validk, err = iit.NextValidity(); err != nil {
  3154  			err = handleNoOp(err)
  3155  			break
  3156  		}
  3157  		if validi && validj && validk {
  3158  			incr[k] += a[i] + b[j]
  3159  		}
  3160  	}
  3161  	return
  3162  }
  3163  
  3164  func AddIterIncrStr(a []string, b []string, incr []string, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3165  	var i, j, k int
  3166  	var validi, validj, validk bool
  3167  	for {
  3168  		if i, validi, err = ait.NextValidity(); err != nil {
  3169  			err = handleNoOp(err)
  3170  			break
  3171  		}
  3172  		if j, validj, err = bit.NextValidity(); err != nil {
  3173  			err = handleNoOp(err)
  3174  			break
  3175  		}
  3176  		if k, validk, err = iit.NextValidity(); err != nil {
  3177  			err = handleNoOp(err)
  3178  			break
  3179  		}
  3180  		if validi && validj && validk {
  3181  			incr[k] += a[i] + b[j]
  3182  		}
  3183  	}
  3184  	return
  3185  }
  3186  
  3187  func SubIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3188  	var i, j, k int
  3189  	var validi, validj, validk bool
  3190  	for {
  3191  		if i, validi, err = ait.NextValidity(); err != nil {
  3192  			err = handleNoOp(err)
  3193  			break
  3194  		}
  3195  		if j, validj, err = bit.NextValidity(); err != nil {
  3196  			err = handleNoOp(err)
  3197  			break
  3198  		}
  3199  		if k, validk, err = iit.NextValidity(); err != nil {
  3200  			err = handleNoOp(err)
  3201  			break
  3202  		}
  3203  		if validi && validj && validk {
  3204  			incr[k] += a[i] - b[j]
  3205  		}
  3206  	}
  3207  	return
  3208  }
  3209  
  3210  func SubIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3211  	var i, j, k int
  3212  	var validi, validj, validk bool
  3213  	for {
  3214  		if i, validi, err = ait.NextValidity(); err != nil {
  3215  			err = handleNoOp(err)
  3216  			break
  3217  		}
  3218  		if j, validj, err = bit.NextValidity(); err != nil {
  3219  			err = handleNoOp(err)
  3220  			break
  3221  		}
  3222  		if k, validk, err = iit.NextValidity(); err != nil {
  3223  			err = handleNoOp(err)
  3224  			break
  3225  		}
  3226  		if validi && validj && validk {
  3227  			incr[k] += a[i] - b[j]
  3228  		}
  3229  	}
  3230  	return
  3231  }
  3232  
  3233  func SubIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3234  	var i, j, k int
  3235  	var validi, validj, validk bool
  3236  	for {
  3237  		if i, validi, err = ait.NextValidity(); err != nil {
  3238  			err = handleNoOp(err)
  3239  			break
  3240  		}
  3241  		if j, validj, err = bit.NextValidity(); err != nil {
  3242  			err = handleNoOp(err)
  3243  			break
  3244  		}
  3245  		if k, validk, err = iit.NextValidity(); err != nil {
  3246  			err = handleNoOp(err)
  3247  			break
  3248  		}
  3249  		if validi && validj && validk {
  3250  			incr[k] += a[i] - b[j]
  3251  		}
  3252  	}
  3253  	return
  3254  }
  3255  
  3256  func SubIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3257  	var i, j, k int
  3258  	var validi, validj, validk bool
  3259  	for {
  3260  		if i, validi, err = ait.NextValidity(); err != nil {
  3261  			err = handleNoOp(err)
  3262  			break
  3263  		}
  3264  		if j, validj, err = bit.NextValidity(); err != nil {
  3265  			err = handleNoOp(err)
  3266  			break
  3267  		}
  3268  		if k, validk, err = iit.NextValidity(); err != nil {
  3269  			err = handleNoOp(err)
  3270  			break
  3271  		}
  3272  		if validi && validj && validk {
  3273  			incr[k] += a[i] - b[j]
  3274  		}
  3275  	}
  3276  	return
  3277  }
  3278  
  3279  func SubIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3280  	var i, j, k int
  3281  	var validi, validj, validk bool
  3282  	for {
  3283  		if i, validi, err = ait.NextValidity(); err != nil {
  3284  			err = handleNoOp(err)
  3285  			break
  3286  		}
  3287  		if j, validj, err = bit.NextValidity(); err != nil {
  3288  			err = handleNoOp(err)
  3289  			break
  3290  		}
  3291  		if k, validk, err = iit.NextValidity(); err != nil {
  3292  			err = handleNoOp(err)
  3293  			break
  3294  		}
  3295  		if validi && validj && validk {
  3296  			incr[k] += a[i] - b[j]
  3297  		}
  3298  	}
  3299  	return
  3300  }
  3301  
  3302  func SubIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3303  	var i, j, k int
  3304  	var validi, validj, validk bool
  3305  	for {
  3306  		if i, validi, err = ait.NextValidity(); err != nil {
  3307  			err = handleNoOp(err)
  3308  			break
  3309  		}
  3310  		if j, validj, err = bit.NextValidity(); err != nil {
  3311  			err = handleNoOp(err)
  3312  			break
  3313  		}
  3314  		if k, validk, err = iit.NextValidity(); err != nil {
  3315  			err = handleNoOp(err)
  3316  			break
  3317  		}
  3318  		if validi && validj && validk {
  3319  			incr[k] += a[i] - b[j]
  3320  		}
  3321  	}
  3322  	return
  3323  }
  3324  
  3325  func SubIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3326  	var i, j, k int
  3327  	var validi, validj, validk bool
  3328  	for {
  3329  		if i, validi, err = ait.NextValidity(); err != nil {
  3330  			err = handleNoOp(err)
  3331  			break
  3332  		}
  3333  		if j, validj, err = bit.NextValidity(); err != nil {
  3334  			err = handleNoOp(err)
  3335  			break
  3336  		}
  3337  		if k, validk, err = iit.NextValidity(); err != nil {
  3338  			err = handleNoOp(err)
  3339  			break
  3340  		}
  3341  		if validi && validj && validk {
  3342  			incr[k] += a[i] - b[j]
  3343  		}
  3344  	}
  3345  	return
  3346  }
  3347  
  3348  func SubIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3349  	var i, j, k int
  3350  	var validi, validj, validk bool
  3351  	for {
  3352  		if i, validi, err = ait.NextValidity(); err != nil {
  3353  			err = handleNoOp(err)
  3354  			break
  3355  		}
  3356  		if j, validj, err = bit.NextValidity(); err != nil {
  3357  			err = handleNoOp(err)
  3358  			break
  3359  		}
  3360  		if k, validk, err = iit.NextValidity(); err != nil {
  3361  			err = handleNoOp(err)
  3362  			break
  3363  		}
  3364  		if validi && validj && validk {
  3365  			incr[k] += a[i] - b[j]
  3366  		}
  3367  	}
  3368  	return
  3369  }
  3370  
  3371  func SubIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3372  	var i, j, k int
  3373  	var validi, validj, validk bool
  3374  	for {
  3375  		if i, validi, err = ait.NextValidity(); err != nil {
  3376  			err = handleNoOp(err)
  3377  			break
  3378  		}
  3379  		if j, validj, err = bit.NextValidity(); err != nil {
  3380  			err = handleNoOp(err)
  3381  			break
  3382  		}
  3383  		if k, validk, err = iit.NextValidity(); err != nil {
  3384  			err = handleNoOp(err)
  3385  			break
  3386  		}
  3387  		if validi && validj && validk {
  3388  			incr[k] += a[i] - b[j]
  3389  		}
  3390  	}
  3391  	return
  3392  }
  3393  
  3394  func SubIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3395  	var i, j, k int
  3396  	var validi, validj, validk bool
  3397  	for {
  3398  		if i, validi, err = ait.NextValidity(); err != nil {
  3399  			err = handleNoOp(err)
  3400  			break
  3401  		}
  3402  		if j, validj, err = bit.NextValidity(); err != nil {
  3403  			err = handleNoOp(err)
  3404  			break
  3405  		}
  3406  		if k, validk, err = iit.NextValidity(); err != nil {
  3407  			err = handleNoOp(err)
  3408  			break
  3409  		}
  3410  		if validi && validj && validk {
  3411  			incr[k] += a[i] - b[j]
  3412  		}
  3413  	}
  3414  	return
  3415  }
  3416  
  3417  func SubIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3418  	var i, j, k int
  3419  	var validi, validj, validk bool
  3420  	for {
  3421  		if i, validi, err = ait.NextValidity(); err != nil {
  3422  			err = handleNoOp(err)
  3423  			break
  3424  		}
  3425  		if j, validj, err = bit.NextValidity(); err != nil {
  3426  			err = handleNoOp(err)
  3427  			break
  3428  		}
  3429  		if k, validk, err = iit.NextValidity(); err != nil {
  3430  			err = handleNoOp(err)
  3431  			break
  3432  		}
  3433  		if validi && validj && validk {
  3434  			incr[k] += a[i] - b[j]
  3435  		}
  3436  	}
  3437  	return
  3438  }
  3439  
  3440  func SubIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3441  	var i, j, k int
  3442  	var validi, validj, validk bool
  3443  	for {
  3444  		if i, validi, err = ait.NextValidity(); err != nil {
  3445  			err = handleNoOp(err)
  3446  			break
  3447  		}
  3448  		if j, validj, err = bit.NextValidity(); err != nil {
  3449  			err = handleNoOp(err)
  3450  			break
  3451  		}
  3452  		if k, validk, err = iit.NextValidity(); err != nil {
  3453  			err = handleNoOp(err)
  3454  			break
  3455  		}
  3456  		if validi && validj && validk {
  3457  			incr[k] += a[i] - b[j]
  3458  		}
  3459  	}
  3460  	return
  3461  }
  3462  
  3463  func SubIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3464  	var i, j, k int
  3465  	var validi, validj, validk bool
  3466  	for {
  3467  		if i, validi, err = ait.NextValidity(); err != nil {
  3468  			err = handleNoOp(err)
  3469  			break
  3470  		}
  3471  		if j, validj, err = bit.NextValidity(); err != nil {
  3472  			err = handleNoOp(err)
  3473  			break
  3474  		}
  3475  		if k, validk, err = iit.NextValidity(); err != nil {
  3476  			err = handleNoOp(err)
  3477  			break
  3478  		}
  3479  		if validi && validj && validk {
  3480  			incr[k] += a[i] - b[j]
  3481  		}
  3482  	}
  3483  	return
  3484  }
  3485  
  3486  func SubIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3487  	var i, j, k int
  3488  	var validi, validj, validk bool
  3489  	for {
  3490  		if i, validi, err = ait.NextValidity(); err != nil {
  3491  			err = handleNoOp(err)
  3492  			break
  3493  		}
  3494  		if j, validj, err = bit.NextValidity(); err != nil {
  3495  			err = handleNoOp(err)
  3496  			break
  3497  		}
  3498  		if k, validk, err = iit.NextValidity(); err != nil {
  3499  			err = handleNoOp(err)
  3500  			break
  3501  		}
  3502  		if validi && validj && validk {
  3503  			incr[k] += a[i] - b[j]
  3504  		}
  3505  	}
  3506  	return
  3507  }
  3508  
  3509  func MulIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3510  	var i, j, k int
  3511  	var validi, validj, validk bool
  3512  	for {
  3513  		if i, validi, err = ait.NextValidity(); err != nil {
  3514  			err = handleNoOp(err)
  3515  			break
  3516  		}
  3517  		if j, validj, err = bit.NextValidity(); err != nil {
  3518  			err = handleNoOp(err)
  3519  			break
  3520  		}
  3521  		if k, validk, err = iit.NextValidity(); err != nil {
  3522  			err = handleNoOp(err)
  3523  			break
  3524  		}
  3525  		if validi && validj && validk {
  3526  			incr[k] += a[i] * b[j]
  3527  		}
  3528  	}
  3529  	return
  3530  }
  3531  
  3532  func MulIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3533  	var i, j, k int
  3534  	var validi, validj, validk bool
  3535  	for {
  3536  		if i, validi, err = ait.NextValidity(); err != nil {
  3537  			err = handleNoOp(err)
  3538  			break
  3539  		}
  3540  		if j, validj, err = bit.NextValidity(); err != nil {
  3541  			err = handleNoOp(err)
  3542  			break
  3543  		}
  3544  		if k, validk, err = iit.NextValidity(); err != nil {
  3545  			err = handleNoOp(err)
  3546  			break
  3547  		}
  3548  		if validi && validj && validk {
  3549  			incr[k] += a[i] * b[j]
  3550  		}
  3551  	}
  3552  	return
  3553  }
  3554  
  3555  func MulIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3556  	var i, j, k int
  3557  	var validi, validj, validk bool
  3558  	for {
  3559  		if i, validi, err = ait.NextValidity(); err != nil {
  3560  			err = handleNoOp(err)
  3561  			break
  3562  		}
  3563  		if j, validj, err = bit.NextValidity(); err != nil {
  3564  			err = handleNoOp(err)
  3565  			break
  3566  		}
  3567  		if k, validk, err = iit.NextValidity(); err != nil {
  3568  			err = handleNoOp(err)
  3569  			break
  3570  		}
  3571  		if validi && validj && validk {
  3572  			incr[k] += a[i] * b[j]
  3573  		}
  3574  	}
  3575  	return
  3576  }
  3577  
  3578  func MulIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3579  	var i, j, k int
  3580  	var validi, validj, validk bool
  3581  	for {
  3582  		if i, validi, err = ait.NextValidity(); err != nil {
  3583  			err = handleNoOp(err)
  3584  			break
  3585  		}
  3586  		if j, validj, err = bit.NextValidity(); err != nil {
  3587  			err = handleNoOp(err)
  3588  			break
  3589  		}
  3590  		if k, validk, err = iit.NextValidity(); err != nil {
  3591  			err = handleNoOp(err)
  3592  			break
  3593  		}
  3594  		if validi && validj && validk {
  3595  			incr[k] += a[i] * b[j]
  3596  		}
  3597  	}
  3598  	return
  3599  }
  3600  
  3601  func MulIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3602  	var i, j, k int
  3603  	var validi, validj, validk bool
  3604  	for {
  3605  		if i, validi, err = ait.NextValidity(); err != nil {
  3606  			err = handleNoOp(err)
  3607  			break
  3608  		}
  3609  		if j, validj, err = bit.NextValidity(); err != nil {
  3610  			err = handleNoOp(err)
  3611  			break
  3612  		}
  3613  		if k, validk, err = iit.NextValidity(); err != nil {
  3614  			err = handleNoOp(err)
  3615  			break
  3616  		}
  3617  		if validi && validj && validk {
  3618  			incr[k] += a[i] * b[j]
  3619  		}
  3620  	}
  3621  	return
  3622  }
  3623  
  3624  func MulIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3625  	var i, j, k int
  3626  	var validi, validj, validk bool
  3627  	for {
  3628  		if i, validi, err = ait.NextValidity(); err != nil {
  3629  			err = handleNoOp(err)
  3630  			break
  3631  		}
  3632  		if j, validj, err = bit.NextValidity(); err != nil {
  3633  			err = handleNoOp(err)
  3634  			break
  3635  		}
  3636  		if k, validk, err = iit.NextValidity(); err != nil {
  3637  			err = handleNoOp(err)
  3638  			break
  3639  		}
  3640  		if validi && validj && validk {
  3641  			incr[k] += a[i] * b[j]
  3642  		}
  3643  	}
  3644  	return
  3645  }
  3646  
  3647  func MulIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3648  	var i, j, k int
  3649  	var validi, validj, validk bool
  3650  	for {
  3651  		if i, validi, err = ait.NextValidity(); err != nil {
  3652  			err = handleNoOp(err)
  3653  			break
  3654  		}
  3655  		if j, validj, err = bit.NextValidity(); err != nil {
  3656  			err = handleNoOp(err)
  3657  			break
  3658  		}
  3659  		if k, validk, err = iit.NextValidity(); err != nil {
  3660  			err = handleNoOp(err)
  3661  			break
  3662  		}
  3663  		if validi && validj && validk {
  3664  			incr[k] += a[i] * b[j]
  3665  		}
  3666  	}
  3667  	return
  3668  }
  3669  
  3670  func MulIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3671  	var i, j, k int
  3672  	var validi, validj, validk bool
  3673  	for {
  3674  		if i, validi, err = ait.NextValidity(); err != nil {
  3675  			err = handleNoOp(err)
  3676  			break
  3677  		}
  3678  		if j, validj, err = bit.NextValidity(); err != nil {
  3679  			err = handleNoOp(err)
  3680  			break
  3681  		}
  3682  		if k, validk, err = iit.NextValidity(); err != nil {
  3683  			err = handleNoOp(err)
  3684  			break
  3685  		}
  3686  		if validi && validj && validk {
  3687  			incr[k] += a[i] * b[j]
  3688  		}
  3689  	}
  3690  	return
  3691  }
  3692  
  3693  func MulIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3694  	var i, j, k int
  3695  	var validi, validj, validk bool
  3696  	for {
  3697  		if i, validi, err = ait.NextValidity(); err != nil {
  3698  			err = handleNoOp(err)
  3699  			break
  3700  		}
  3701  		if j, validj, err = bit.NextValidity(); err != nil {
  3702  			err = handleNoOp(err)
  3703  			break
  3704  		}
  3705  		if k, validk, err = iit.NextValidity(); err != nil {
  3706  			err = handleNoOp(err)
  3707  			break
  3708  		}
  3709  		if validi && validj && validk {
  3710  			incr[k] += a[i] * b[j]
  3711  		}
  3712  	}
  3713  	return
  3714  }
  3715  
  3716  func MulIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3717  	var i, j, k int
  3718  	var validi, validj, validk bool
  3719  	for {
  3720  		if i, validi, err = ait.NextValidity(); err != nil {
  3721  			err = handleNoOp(err)
  3722  			break
  3723  		}
  3724  		if j, validj, err = bit.NextValidity(); err != nil {
  3725  			err = handleNoOp(err)
  3726  			break
  3727  		}
  3728  		if k, validk, err = iit.NextValidity(); err != nil {
  3729  			err = handleNoOp(err)
  3730  			break
  3731  		}
  3732  		if validi && validj && validk {
  3733  			incr[k] += a[i] * b[j]
  3734  		}
  3735  	}
  3736  	return
  3737  }
  3738  
  3739  func MulIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3740  	var i, j, k int
  3741  	var validi, validj, validk bool
  3742  	for {
  3743  		if i, validi, err = ait.NextValidity(); err != nil {
  3744  			err = handleNoOp(err)
  3745  			break
  3746  		}
  3747  		if j, validj, err = bit.NextValidity(); err != nil {
  3748  			err = handleNoOp(err)
  3749  			break
  3750  		}
  3751  		if k, validk, err = iit.NextValidity(); err != nil {
  3752  			err = handleNoOp(err)
  3753  			break
  3754  		}
  3755  		if validi && validj && validk {
  3756  			incr[k] += a[i] * b[j]
  3757  		}
  3758  	}
  3759  	return
  3760  }
  3761  
  3762  func MulIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3763  	var i, j, k int
  3764  	var validi, validj, validk bool
  3765  	for {
  3766  		if i, validi, err = ait.NextValidity(); err != nil {
  3767  			err = handleNoOp(err)
  3768  			break
  3769  		}
  3770  		if j, validj, err = bit.NextValidity(); err != nil {
  3771  			err = handleNoOp(err)
  3772  			break
  3773  		}
  3774  		if k, validk, err = iit.NextValidity(); err != nil {
  3775  			err = handleNoOp(err)
  3776  			break
  3777  		}
  3778  		if validi && validj && validk {
  3779  			incr[k] += a[i] * b[j]
  3780  		}
  3781  	}
  3782  	return
  3783  }
  3784  
  3785  func MulIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3786  	var i, j, k int
  3787  	var validi, validj, validk bool
  3788  	for {
  3789  		if i, validi, err = ait.NextValidity(); err != nil {
  3790  			err = handleNoOp(err)
  3791  			break
  3792  		}
  3793  		if j, validj, err = bit.NextValidity(); err != nil {
  3794  			err = handleNoOp(err)
  3795  			break
  3796  		}
  3797  		if k, validk, err = iit.NextValidity(); err != nil {
  3798  			err = handleNoOp(err)
  3799  			break
  3800  		}
  3801  		if validi && validj && validk {
  3802  			incr[k] += a[i] * b[j]
  3803  		}
  3804  	}
  3805  	return
  3806  }
  3807  
  3808  func MulIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3809  	var i, j, k int
  3810  	var validi, validj, validk bool
  3811  	for {
  3812  		if i, validi, err = ait.NextValidity(); err != nil {
  3813  			err = handleNoOp(err)
  3814  			break
  3815  		}
  3816  		if j, validj, err = bit.NextValidity(); err != nil {
  3817  			err = handleNoOp(err)
  3818  			break
  3819  		}
  3820  		if k, validk, err = iit.NextValidity(); err != nil {
  3821  			err = handleNoOp(err)
  3822  			break
  3823  		}
  3824  		if validi && validj && validk {
  3825  			incr[k] += a[i] * b[j]
  3826  		}
  3827  	}
  3828  	return
  3829  }
  3830  
  3831  func DivIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3832  	var errs errorIndices
  3833  	var i, j, k int
  3834  	var validi, validj, validk bool
  3835  	for {
  3836  		if i, validi, err = ait.NextValidity(); err != nil {
  3837  			err = handleNoOp(err)
  3838  			break
  3839  		}
  3840  		if j, validj, err = bit.NextValidity(); err != nil {
  3841  			err = handleNoOp(err)
  3842  			break
  3843  		}
  3844  		if k, validk, err = iit.NextValidity(); err != nil {
  3845  			err = handleNoOp(err)
  3846  			break
  3847  		}
  3848  		if validi && validj && validk {
  3849  			if b[j] == 0 {
  3850  				errs = append(errs, i)
  3851  				incr[i] = 0
  3852  				continue
  3853  			}
  3854  			incr[k] += a[i] / b[j]
  3855  		}
  3856  	}
  3857  	if err != nil {
  3858  		return
  3859  	}
  3860  	if len(errs) > 0 {
  3861  		return errs
  3862  	}
  3863  	return nil
  3864  }
  3865  
  3866  func DivIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3867  	var errs errorIndices
  3868  	var i, j, k int
  3869  	var validi, validj, validk bool
  3870  	for {
  3871  		if i, validi, err = ait.NextValidity(); err != nil {
  3872  			err = handleNoOp(err)
  3873  			break
  3874  		}
  3875  		if j, validj, err = bit.NextValidity(); err != nil {
  3876  			err = handleNoOp(err)
  3877  			break
  3878  		}
  3879  		if k, validk, err = iit.NextValidity(); err != nil {
  3880  			err = handleNoOp(err)
  3881  			break
  3882  		}
  3883  		if validi && validj && validk {
  3884  			if b[j] == 0 {
  3885  				errs = append(errs, i)
  3886  				incr[i] = 0
  3887  				continue
  3888  			}
  3889  			incr[k] += a[i] / b[j]
  3890  		}
  3891  	}
  3892  	if err != nil {
  3893  		return
  3894  	}
  3895  	if len(errs) > 0 {
  3896  		return errs
  3897  	}
  3898  	return nil
  3899  }
  3900  
  3901  func DivIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3902  	var errs errorIndices
  3903  	var i, j, k int
  3904  	var validi, validj, validk bool
  3905  	for {
  3906  		if i, validi, err = ait.NextValidity(); err != nil {
  3907  			err = handleNoOp(err)
  3908  			break
  3909  		}
  3910  		if j, validj, err = bit.NextValidity(); err != nil {
  3911  			err = handleNoOp(err)
  3912  			break
  3913  		}
  3914  		if k, validk, err = iit.NextValidity(); err != nil {
  3915  			err = handleNoOp(err)
  3916  			break
  3917  		}
  3918  		if validi && validj && validk {
  3919  			if b[j] == 0 {
  3920  				errs = append(errs, i)
  3921  				incr[i] = 0
  3922  				continue
  3923  			}
  3924  			incr[k] += a[i] / b[j]
  3925  		}
  3926  	}
  3927  	if err != nil {
  3928  		return
  3929  	}
  3930  	if len(errs) > 0 {
  3931  		return errs
  3932  	}
  3933  	return nil
  3934  }
  3935  
  3936  func DivIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3937  	var errs errorIndices
  3938  	var i, j, k int
  3939  	var validi, validj, validk bool
  3940  	for {
  3941  		if i, validi, err = ait.NextValidity(); err != nil {
  3942  			err = handleNoOp(err)
  3943  			break
  3944  		}
  3945  		if j, validj, err = bit.NextValidity(); err != nil {
  3946  			err = handleNoOp(err)
  3947  			break
  3948  		}
  3949  		if k, validk, err = iit.NextValidity(); err != nil {
  3950  			err = handleNoOp(err)
  3951  			break
  3952  		}
  3953  		if validi && validj && validk {
  3954  			if b[j] == 0 {
  3955  				errs = append(errs, i)
  3956  				incr[i] = 0
  3957  				continue
  3958  			}
  3959  			incr[k] += a[i] / b[j]
  3960  		}
  3961  	}
  3962  	if err != nil {
  3963  		return
  3964  	}
  3965  	if len(errs) > 0 {
  3966  		return errs
  3967  	}
  3968  	return nil
  3969  }
  3970  
  3971  func DivIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  3972  	var errs errorIndices
  3973  	var i, j, k int
  3974  	var validi, validj, validk bool
  3975  	for {
  3976  		if i, validi, err = ait.NextValidity(); err != nil {
  3977  			err = handleNoOp(err)
  3978  			break
  3979  		}
  3980  		if j, validj, err = bit.NextValidity(); err != nil {
  3981  			err = handleNoOp(err)
  3982  			break
  3983  		}
  3984  		if k, validk, err = iit.NextValidity(); err != nil {
  3985  			err = handleNoOp(err)
  3986  			break
  3987  		}
  3988  		if validi && validj && validk {
  3989  			if b[j] == 0 {
  3990  				errs = append(errs, i)
  3991  				incr[i] = 0
  3992  				continue
  3993  			}
  3994  			incr[k] += a[i] / b[j]
  3995  		}
  3996  	}
  3997  	if err != nil {
  3998  		return
  3999  	}
  4000  	if len(errs) > 0 {
  4001  		return errs
  4002  	}
  4003  	return nil
  4004  }
  4005  
  4006  func DivIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4007  	var errs errorIndices
  4008  	var i, j, k int
  4009  	var validi, validj, validk bool
  4010  	for {
  4011  		if i, validi, err = ait.NextValidity(); err != nil {
  4012  			err = handleNoOp(err)
  4013  			break
  4014  		}
  4015  		if j, validj, err = bit.NextValidity(); err != nil {
  4016  			err = handleNoOp(err)
  4017  			break
  4018  		}
  4019  		if k, validk, err = iit.NextValidity(); err != nil {
  4020  			err = handleNoOp(err)
  4021  			break
  4022  		}
  4023  		if validi && validj && validk {
  4024  			if b[j] == 0 {
  4025  				errs = append(errs, i)
  4026  				incr[i] = 0
  4027  				continue
  4028  			}
  4029  			incr[k] += a[i] / b[j]
  4030  		}
  4031  	}
  4032  	if err != nil {
  4033  		return
  4034  	}
  4035  	if len(errs) > 0 {
  4036  		return errs
  4037  	}
  4038  	return nil
  4039  }
  4040  
  4041  func DivIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4042  	var errs errorIndices
  4043  	var i, j, k int
  4044  	var validi, validj, validk bool
  4045  	for {
  4046  		if i, validi, err = ait.NextValidity(); err != nil {
  4047  			err = handleNoOp(err)
  4048  			break
  4049  		}
  4050  		if j, validj, err = bit.NextValidity(); err != nil {
  4051  			err = handleNoOp(err)
  4052  			break
  4053  		}
  4054  		if k, validk, err = iit.NextValidity(); err != nil {
  4055  			err = handleNoOp(err)
  4056  			break
  4057  		}
  4058  		if validi && validj && validk {
  4059  			if b[j] == 0 {
  4060  				errs = append(errs, i)
  4061  				incr[i] = 0
  4062  				continue
  4063  			}
  4064  			incr[k] += a[i] / b[j]
  4065  		}
  4066  	}
  4067  	if err != nil {
  4068  		return
  4069  	}
  4070  	if len(errs) > 0 {
  4071  		return errs
  4072  	}
  4073  	return nil
  4074  }
  4075  
  4076  func DivIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4077  	var errs errorIndices
  4078  	var i, j, k int
  4079  	var validi, validj, validk bool
  4080  	for {
  4081  		if i, validi, err = ait.NextValidity(); err != nil {
  4082  			err = handleNoOp(err)
  4083  			break
  4084  		}
  4085  		if j, validj, err = bit.NextValidity(); err != nil {
  4086  			err = handleNoOp(err)
  4087  			break
  4088  		}
  4089  		if k, validk, err = iit.NextValidity(); err != nil {
  4090  			err = handleNoOp(err)
  4091  			break
  4092  		}
  4093  		if validi && validj && validk {
  4094  			if b[j] == 0 {
  4095  				errs = append(errs, i)
  4096  				incr[i] = 0
  4097  				continue
  4098  			}
  4099  			incr[k] += a[i] / b[j]
  4100  		}
  4101  	}
  4102  	if err != nil {
  4103  		return
  4104  	}
  4105  	if len(errs) > 0 {
  4106  		return errs
  4107  	}
  4108  	return nil
  4109  }
  4110  
  4111  func DivIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4112  	var errs errorIndices
  4113  	var i, j, k int
  4114  	var validi, validj, validk bool
  4115  	for {
  4116  		if i, validi, err = ait.NextValidity(); err != nil {
  4117  			err = handleNoOp(err)
  4118  			break
  4119  		}
  4120  		if j, validj, err = bit.NextValidity(); err != nil {
  4121  			err = handleNoOp(err)
  4122  			break
  4123  		}
  4124  		if k, validk, err = iit.NextValidity(); err != nil {
  4125  			err = handleNoOp(err)
  4126  			break
  4127  		}
  4128  		if validi && validj && validk {
  4129  			if b[j] == 0 {
  4130  				errs = append(errs, i)
  4131  				incr[i] = 0
  4132  				continue
  4133  			}
  4134  			incr[k] += a[i] / b[j]
  4135  		}
  4136  	}
  4137  	if err != nil {
  4138  		return
  4139  	}
  4140  	if len(errs) > 0 {
  4141  		return errs
  4142  	}
  4143  	return nil
  4144  }
  4145  
  4146  func DivIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4147  	var errs errorIndices
  4148  	var i, j, k int
  4149  	var validi, validj, validk bool
  4150  	for {
  4151  		if i, validi, err = ait.NextValidity(); err != nil {
  4152  			err = handleNoOp(err)
  4153  			break
  4154  		}
  4155  		if j, validj, err = bit.NextValidity(); err != nil {
  4156  			err = handleNoOp(err)
  4157  			break
  4158  		}
  4159  		if k, validk, err = iit.NextValidity(); err != nil {
  4160  			err = handleNoOp(err)
  4161  			break
  4162  		}
  4163  		if validi && validj && validk {
  4164  			if b[j] == 0 {
  4165  				errs = append(errs, i)
  4166  				incr[i] = 0
  4167  				continue
  4168  			}
  4169  			incr[k] += a[i] / b[j]
  4170  		}
  4171  	}
  4172  	if err != nil {
  4173  		return
  4174  	}
  4175  	if len(errs) > 0 {
  4176  		return errs
  4177  	}
  4178  	return nil
  4179  }
  4180  
  4181  func DivIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4182  	var i, j, k int
  4183  	var validi, validj, validk bool
  4184  	for {
  4185  		if i, validi, err = ait.NextValidity(); err != nil {
  4186  			err = handleNoOp(err)
  4187  			break
  4188  		}
  4189  		if j, validj, err = bit.NextValidity(); err != nil {
  4190  			err = handleNoOp(err)
  4191  			break
  4192  		}
  4193  		if k, validk, err = iit.NextValidity(); err != nil {
  4194  			err = handleNoOp(err)
  4195  			break
  4196  		}
  4197  		if validi && validj && validk {
  4198  			incr[k] += a[i] / b[j]
  4199  		}
  4200  	}
  4201  	return
  4202  }
  4203  
  4204  func DivIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4205  	var i, j, k int
  4206  	var validi, validj, validk bool
  4207  	for {
  4208  		if i, validi, err = ait.NextValidity(); err != nil {
  4209  			err = handleNoOp(err)
  4210  			break
  4211  		}
  4212  		if j, validj, err = bit.NextValidity(); err != nil {
  4213  			err = handleNoOp(err)
  4214  			break
  4215  		}
  4216  		if k, validk, err = iit.NextValidity(); err != nil {
  4217  			err = handleNoOp(err)
  4218  			break
  4219  		}
  4220  		if validi && validj && validk {
  4221  			incr[k] += a[i] / b[j]
  4222  		}
  4223  	}
  4224  	return
  4225  }
  4226  
  4227  func DivIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4228  	var i, j, k int
  4229  	var validi, validj, validk bool
  4230  	for {
  4231  		if i, validi, err = ait.NextValidity(); err != nil {
  4232  			err = handleNoOp(err)
  4233  			break
  4234  		}
  4235  		if j, validj, err = bit.NextValidity(); err != nil {
  4236  			err = handleNoOp(err)
  4237  			break
  4238  		}
  4239  		if k, validk, err = iit.NextValidity(); err != nil {
  4240  			err = handleNoOp(err)
  4241  			break
  4242  		}
  4243  		if validi && validj && validk {
  4244  			incr[k] += a[i] / b[j]
  4245  		}
  4246  	}
  4247  	return
  4248  }
  4249  
  4250  func DivIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4251  	var i, j, k int
  4252  	var validi, validj, validk bool
  4253  	for {
  4254  		if i, validi, err = ait.NextValidity(); err != nil {
  4255  			err = handleNoOp(err)
  4256  			break
  4257  		}
  4258  		if j, validj, err = bit.NextValidity(); err != nil {
  4259  			err = handleNoOp(err)
  4260  			break
  4261  		}
  4262  		if k, validk, err = iit.NextValidity(); err != nil {
  4263  			err = handleNoOp(err)
  4264  			break
  4265  		}
  4266  		if validi && validj && validk {
  4267  			incr[k] += a[i] / b[j]
  4268  		}
  4269  	}
  4270  	return
  4271  }
  4272  
  4273  func PowIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4274  	var i, j, k int
  4275  	var validi, validj, validk bool
  4276  	for {
  4277  		if i, validi, err = ait.NextValidity(); err != nil {
  4278  			err = handleNoOp(err)
  4279  			break
  4280  		}
  4281  		if j, validj, err = bit.NextValidity(); err != nil {
  4282  			err = handleNoOp(err)
  4283  			break
  4284  		}
  4285  		if k, validk, err = iit.NextValidity(); err != nil {
  4286  			err = handleNoOp(err)
  4287  			break
  4288  		}
  4289  		if validi && validj && validk {
  4290  			incr[k] += math32.Pow(a[i], b[j])
  4291  		}
  4292  	}
  4293  	return
  4294  }
  4295  
  4296  func PowIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4297  	var i, j, k int
  4298  	var validi, validj, validk bool
  4299  	for {
  4300  		if i, validi, err = ait.NextValidity(); err != nil {
  4301  			err = handleNoOp(err)
  4302  			break
  4303  		}
  4304  		if j, validj, err = bit.NextValidity(); err != nil {
  4305  			err = handleNoOp(err)
  4306  			break
  4307  		}
  4308  		if k, validk, err = iit.NextValidity(); err != nil {
  4309  			err = handleNoOp(err)
  4310  			break
  4311  		}
  4312  		if validi && validj && validk {
  4313  			incr[k] += math.Pow(a[i], b[j])
  4314  		}
  4315  	}
  4316  	return
  4317  }
  4318  
  4319  func PowIterIncrC64(a []complex64, b []complex64, incr []complex64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4320  	var i, j, k int
  4321  	var validi, validj, validk bool
  4322  	for {
  4323  		if i, validi, err = ait.NextValidity(); err != nil {
  4324  			err = handleNoOp(err)
  4325  			break
  4326  		}
  4327  		if j, validj, err = bit.NextValidity(); err != nil {
  4328  			err = handleNoOp(err)
  4329  			break
  4330  		}
  4331  		if k, validk, err = iit.NextValidity(); err != nil {
  4332  			err = handleNoOp(err)
  4333  			break
  4334  		}
  4335  		if validi && validj && validk {
  4336  			incr[k] += complex64(cmplx.Pow(complex128(a[i]), complex128(b[j])))
  4337  		}
  4338  	}
  4339  	return
  4340  }
  4341  
  4342  func PowIterIncrC128(a []complex128, b []complex128, incr []complex128, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4343  	var i, j, k int
  4344  	var validi, validj, validk bool
  4345  	for {
  4346  		if i, validi, err = ait.NextValidity(); err != nil {
  4347  			err = handleNoOp(err)
  4348  			break
  4349  		}
  4350  		if j, validj, err = bit.NextValidity(); err != nil {
  4351  			err = handleNoOp(err)
  4352  			break
  4353  		}
  4354  		if k, validk, err = iit.NextValidity(); err != nil {
  4355  			err = handleNoOp(err)
  4356  			break
  4357  		}
  4358  		if validi && validj && validk {
  4359  			incr[k] += cmplx.Pow(a[i], b[j])
  4360  		}
  4361  	}
  4362  	return
  4363  }
  4364  
  4365  func ModIterIncrI(a []int, b []int, incr []int, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4366  	var i, j, k int
  4367  	var validi, validj, validk bool
  4368  	for {
  4369  		if i, validi, err = ait.NextValidity(); err != nil {
  4370  			err = handleNoOp(err)
  4371  			break
  4372  		}
  4373  		if j, validj, err = bit.NextValidity(); err != nil {
  4374  			err = handleNoOp(err)
  4375  			break
  4376  		}
  4377  		if k, validk, err = iit.NextValidity(); err != nil {
  4378  			err = handleNoOp(err)
  4379  			break
  4380  		}
  4381  		if validi && validj && validk {
  4382  			incr[k] += a[i] % b[j]
  4383  		}
  4384  	}
  4385  	return
  4386  }
  4387  
  4388  func ModIterIncrI8(a []int8, b []int8, incr []int8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4389  	var i, j, k int
  4390  	var validi, validj, validk bool
  4391  	for {
  4392  		if i, validi, err = ait.NextValidity(); err != nil {
  4393  			err = handleNoOp(err)
  4394  			break
  4395  		}
  4396  		if j, validj, err = bit.NextValidity(); err != nil {
  4397  			err = handleNoOp(err)
  4398  			break
  4399  		}
  4400  		if k, validk, err = iit.NextValidity(); err != nil {
  4401  			err = handleNoOp(err)
  4402  			break
  4403  		}
  4404  		if validi && validj && validk {
  4405  			incr[k] += a[i] % b[j]
  4406  		}
  4407  	}
  4408  	return
  4409  }
  4410  
  4411  func ModIterIncrI16(a []int16, b []int16, incr []int16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4412  	var i, j, k int
  4413  	var validi, validj, validk bool
  4414  	for {
  4415  		if i, validi, err = ait.NextValidity(); err != nil {
  4416  			err = handleNoOp(err)
  4417  			break
  4418  		}
  4419  		if j, validj, err = bit.NextValidity(); err != nil {
  4420  			err = handleNoOp(err)
  4421  			break
  4422  		}
  4423  		if k, validk, err = iit.NextValidity(); err != nil {
  4424  			err = handleNoOp(err)
  4425  			break
  4426  		}
  4427  		if validi && validj && validk {
  4428  			incr[k] += a[i] % b[j]
  4429  		}
  4430  	}
  4431  	return
  4432  }
  4433  
  4434  func ModIterIncrI32(a []int32, b []int32, incr []int32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4435  	var i, j, k int
  4436  	var validi, validj, validk bool
  4437  	for {
  4438  		if i, validi, err = ait.NextValidity(); err != nil {
  4439  			err = handleNoOp(err)
  4440  			break
  4441  		}
  4442  		if j, validj, err = bit.NextValidity(); err != nil {
  4443  			err = handleNoOp(err)
  4444  			break
  4445  		}
  4446  		if k, validk, err = iit.NextValidity(); err != nil {
  4447  			err = handleNoOp(err)
  4448  			break
  4449  		}
  4450  		if validi && validj && validk {
  4451  			incr[k] += a[i] % b[j]
  4452  		}
  4453  	}
  4454  	return
  4455  }
  4456  
  4457  func ModIterIncrI64(a []int64, b []int64, incr []int64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4458  	var i, j, k int
  4459  	var validi, validj, validk bool
  4460  	for {
  4461  		if i, validi, err = ait.NextValidity(); err != nil {
  4462  			err = handleNoOp(err)
  4463  			break
  4464  		}
  4465  		if j, validj, err = bit.NextValidity(); err != nil {
  4466  			err = handleNoOp(err)
  4467  			break
  4468  		}
  4469  		if k, validk, err = iit.NextValidity(); err != nil {
  4470  			err = handleNoOp(err)
  4471  			break
  4472  		}
  4473  		if validi && validj && validk {
  4474  			incr[k] += a[i] % b[j]
  4475  		}
  4476  	}
  4477  	return
  4478  }
  4479  
  4480  func ModIterIncrU(a []uint, b []uint, incr []uint, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4481  	var i, j, k int
  4482  	var validi, validj, validk bool
  4483  	for {
  4484  		if i, validi, err = ait.NextValidity(); err != nil {
  4485  			err = handleNoOp(err)
  4486  			break
  4487  		}
  4488  		if j, validj, err = bit.NextValidity(); err != nil {
  4489  			err = handleNoOp(err)
  4490  			break
  4491  		}
  4492  		if k, validk, err = iit.NextValidity(); err != nil {
  4493  			err = handleNoOp(err)
  4494  			break
  4495  		}
  4496  		if validi && validj && validk {
  4497  			incr[k] += a[i] % b[j]
  4498  		}
  4499  	}
  4500  	return
  4501  }
  4502  
  4503  func ModIterIncrU8(a []uint8, b []uint8, incr []uint8, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4504  	var i, j, k int
  4505  	var validi, validj, validk bool
  4506  	for {
  4507  		if i, validi, err = ait.NextValidity(); err != nil {
  4508  			err = handleNoOp(err)
  4509  			break
  4510  		}
  4511  		if j, validj, err = bit.NextValidity(); err != nil {
  4512  			err = handleNoOp(err)
  4513  			break
  4514  		}
  4515  		if k, validk, err = iit.NextValidity(); err != nil {
  4516  			err = handleNoOp(err)
  4517  			break
  4518  		}
  4519  		if validi && validj && validk {
  4520  			incr[k] += a[i] % b[j]
  4521  		}
  4522  	}
  4523  	return
  4524  }
  4525  
  4526  func ModIterIncrU16(a []uint16, b []uint16, incr []uint16, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4527  	var i, j, k int
  4528  	var validi, validj, validk bool
  4529  	for {
  4530  		if i, validi, err = ait.NextValidity(); err != nil {
  4531  			err = handleNoOp(err)
  4532  			break
  4533  		}
  4534  		if j, validj, err = bit.NextValidity(); err != nil {
  4535  			err = handleNoOp(err)
  4536  			break
  4537  		}
  4538  		if k, validk, err = iit.NextValidity(); err != nil {
  4539  			err = handleNoOp(err)
  4540  			break
  4541  		}
  4542  		if validi && validj && validk {
  4543  			incr[k] += a[i] % b[j]
  4544  		}
  4545  	}
  4546  	return
  4547  }
  4548  
  4549  func ModIterIncrU32(a []uint32, b []uint32, incr []uint32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4550  	var i, j, k int
  4551  	var validi, validj, validk bool
  4552  	for {
  4553  		if i, validi, err = ait.NextValidity(); err != nil {
  4554  			err = handleNoOp(err)
  4555  			break
  4556  		}
  4557  		if j, validj, err = bit.NextValidity(); err != nil {
  4558  			err = handleNoOp(err)
  4559  			break
  4560  		}
  4561  		if k, validk, err = iit.NextValidity(); err != nil {
  4562  			err = handleNoOp(err)
  4563  			break
  4564  		}
  4565  		if validi && validj && validk {
  4566  			incr[k] += a[i] % b[j]
  4567  		}
  4568  	}
  4569  	return
  4570  }
  4571  
  4572  func ModIterIncrU64(a []uint64, b []uint64, incr []uint64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4573  	var i, j, k int
  4574  	var validi, validj, validk bool
  4575  	for {
  4576  		if i, validi, err = ait.NextValidity(); err != nil {
  4577  			err = handleNoOp(err)
  4578  			break
  4579  		}
  4580  		if j, validj, err = bit.NextValidity(); err != nil {
  4581  			err = handleNoOp(err)
  4582  			break
  4583  		}
  4584  		if k, validk, err = iit.NextValidity(); err != nil {
  4585  			err = handleNoOp(err)
  4586  			break
  4587  		}
  4588  		if validi && validj && validk {
  4589  			incr[k] += a[i] % b[j]
  4590  		}
  4591  	}
  4592  	return
  4593  }
  4594  
  4595  func ModIterIncrF32(a []float32, b []float32, incr []float32, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4596  	var i, j, k int
  4597  	var validi, validj, validk bool
  4598  	for {
  4599  		if i, validi, err = ait.NextValidity(); err != nil {
  4600  			err = handleNoOp(err)
  4601  			break
  4602  		}
  4603  		if j, validj, err = bit.NextValidity(); err != nil {
  4604  			err = handleNoOp(err)
  4605  			break
  4606  		}
  4607  		if k, validk, err = iit.NextValidity(); err != nil {
  4608  			err = handleNoOp(err)
  4609  			break
  4610  		}
  4611  		if validi && validj && validk {
  4612  			incr[k] += math32.Mod(a[i], b[j])
  4613  		}
  4614  	}
  4615  	return
  4616  }
  4617  
  4618  func ModIterIncrF64(a []float64, b []float64, incr []float64, ait Iterator, bit Iterator, iit Iterator) (err error) {
  4619  	var i, j, k int
  4620  	var validi, validj, validk bool
  4621  	for {
  4622  		if i, validi, err = ait.NextValidity(); err != nil {
  4623  			err = handleNoOp(err)
  4624  			break
  4625  		}
  4626  		if j, validj, err = bit.NextValidity(); err != nil {
  4627  			err = handleNoOp(err)
  4628  			break
  4629  		}
  4630  		if k, validk, err = iit.NextValidity(); err != nil {
  4631  			err = handleNoOp(err)
  4632  			break
  4633  		}
  4634  		if validi && validj && validk {
  4635  			incr[k] += math.Mod(a[i], b[j])
  4636  		}
  4637  	}
  4638  	return
  4639  }
  4640  
  4641  func AddRecvI(a []int, b []int, recv []int) {
  4642  	a = a[:len(recv)]
  4643  	b = b[:len(recv)]
  4644  	for i := range recv {
  4645  		recv[i] = a[i] + b[i]
  4646  	}
  4647  }
  4648  
  4649  func AddRecvI8(a []int8, b []int8, recv []int8) {
  4650  	a = a[:len(recv)]
  4651  	b = b[:len(recv)]
  4652  	for i := range recv {
  4653  		recv[i] = a[i] + b[i]
  4654  	}
  4655  }
  4656  
  4657  func AddRecvI16(a []int16, b []int16, recv []int16) {
  4658  	a = a[:len(recv)]
  4659  	b = b[:len(recv)]
  4660  	for i := range recv {
  4661  		recv[i] = a[i] + b[i]
  4662  	}
  4663  }
  4664  
  4665  func AddRecvI32(a []int32, b []int32, recv []int32) {
  4666  	a = a[:len(recv)]
  4667  	b = b[:len(recv)]
  4668  	for i := range recv {
  4669  		recv[i] = a[i] + b[i]
  4670  	}
  4671  }
  4672  
  4673  func AddRecvI64(a []int64, b []int64, recv []int64) {
  4674  	a = a[:len(recv)]
  4675  	b = b[:len(recv)]
  4676  	for i := range recv {
  4677  		recv[i] = a[i] + b[i]
  4678  	}
  4679  }
  4680  
  4681  func AddRecvU(a []uint, b []uint, recv []uint) {
  4682  	a = a[:len(recv)]
  4683  	b = b[:len(recv)]
  4684  	for i := range recv {
  4685  		recv[i] = a[i] + b[i]
  4686  	}
  4687  }
  4688  
  4689  func AddRecvU8(a []uint8, b []uint8, recv []uint8) {
  4690  	a = a[:len(recv)]
  4691  	b = b[:len(recv)]
  4692  	for i := range recv {
  4693  		recv[i] = a[i] + b[i]
  4694  	}
  4695  }
  4696  
  4697  func AddRecvU16(a []uint16, b []uint16, recv []uint16) {
  4698  	a = a[:len(recv)]
  4699  	b = b[:len(recv)]
  4700  	for i := range recv {
  4701  		recv[i] = a[i] + b[i]
  4702  	}
  4703  }
  4704  
  4705  func AddRecvU32(a []uint32, b []uint32, recv []uint32) {
  4706  	a = a[:len(recv)]
  4707  	b = b[:len(recv)]
  4708  	for i := range recv {
  4709  		recv[i] = a[i] + b[i]
  4710  	}
  4711  }
  4712  
  4713  func AddRecvU64(a []uint64, b []uint64, recv []uint64) {
  4714  	a = a[:len(recv)]
  4715  	b = b[:len(recv)]
  4716  	for i := range recv {
  4717  		recv[i] = a[i] + b[i]
  4718  	}
  4719  }
  4720  
  4721  func AddRecvF32(a []float32, b []float32, recv []float32) {
  4722  	a = a[:len(recv)]
  4723  	b = b[:len(recv)]
  4724  	for i := range recv {
  4725  		recv[i] = a[i] + b[i]
  4726  	}
  4727  }
  4728  
  4729  func AddRecvF64(a []float64, b []float64, recv []float64) {
  4730  	a = a[:len(recv)]
  4731  	b = b[:len(recv)]
  4732  	for i := range recv {
  4733  		recv[i] = a[i] + b[i]
  4734  	}
  4735  }
  4736  
  4737  func AddRecvC64(a []complex64, b []complex64, recv []complex64) {
  4738  	a = a[:len(recv)]
  4739  	b = b[:len(recv)]
  4740  	for i := range recv {
  4741  		recv[i] = a[i] + b[i]
  4742  	}
  4743  }
  4744  
  4745  func AddRecvC128(a []complex128, b []complex128, recv []complex128) {
  4746  	a = a[:len(recv)]
  4747  	b = b[:len(recv)]
  4748  	for i := range recv {
  4749  		recv[i] = a[i] + b[i]
  4750  	}
  4751  }
  4752  
  4753  func AddRecvStr(a []string, b []string, recv []string) {
  4754  	a = a[:len(recv)]
  4755  	b = b[:len(recv)]
  4756  	for i := range recv {
  4757  		recv[i] = a[i] + b[i]
  4758  	}
  4759  }
  4760  
  4761  func SubRecvI(a []int, b []int, recv []int) {
  4762  	a = a[:len(recv)]
  4763  	b = b[:len(recv)]
  4764  	for i := range recv {
  4765  		recv[i] = a[i] - b[i]
  4766  	}
  4767  }
  4768  
  4769  func SubRecvI8(a []int8, b []int8, recv []int8) {
  4770  	a = a[:len(recv)]
  4771  	b = b[:len(recv)]
  4772  	for i := range recv {
  4773  		recv[i] = a[i] - b[i]
  4774  	}
  4775  }
  4776  
  4777  func SubRecvI16(a []int16, b []int16, recv []int16) {
  4778  	a = a[:len(recv)]
  4779  	b = b[:len(recv)]
  4780  	for i := range recv {
  4781  		recv[i] = a[i] - b[i]
  4782  	}
  4783  }
  4784  
  4785  func SubRecvI32(a []int32, b []int32, recv []int32) {
  4786  	a = a[:len(recv)]
  4787  	b = b[:len(recv)]
  4788  	for i := range recv {
  4789  		recv[i] = a[i] - b[i]
  4790  	}
  4791  }
  4792  
  4793  func SubRecvI64(a []int64, b []int64, recv []int64) {
  4794  	a = a[:len(recv)]
  4795  	b = b[:len(recv)]
  4796  	for i := range recv {
  4797  		recv[i] = a[i] - b[i]
  4798  	}
  4799  }
  4800  
  4801  func SubRecvU(a []uint, b []uint, recv []uint) {
  4802  	a = a[:len(recv)]
  4803  	b = b[:len(recv)]
  4804  	for i := range recv {
  4805  		recv[i] = a[i] - b[i]
  4806  	}
  4807  }
  4808  
  4809  func SubRecvU8(a []uint8, b []uint8, recv []uint8) {
  4810  	a = a[:len(recv)]
  4811  	b = b[:len(recv)]
  4812  	for i := range recv {
  4813  		recv[i] = a[i] - b[i]
  4814  	}
  4815  }
  4816  
  4817  func SubRecvU16(a []uint16, b []uint16, recv []uint16) {
  4818  	a = a[:len(recv)]
  4819  	b = b[:len(recv)]
  4820  	for i := range recv {
  4821  		recv[i] = a[i] - b[i]
  4822  	}
  4823  }
  4824  
  4825  func SubRecvU32(a []uint32, b []uint32, recv []uint32) {
  4826  	a = a[:len(recv)]
  4827  	b = b[:len(recv)]
  4828  	for i := range recv {
  4829  		recv[i] = a[i] - b[i]
  4830  	}
  4831  }
  4832  
  4833  func SubRecvU64(a []uint64, b []uint64, recv []uint64) {
  4834  	a = a[:len(recv)]
  4835  	b = b[:len(recv)]
  4836  	for i := range recv {
  4837  		recv[i] = a[i] - b[i]
  4838  	}
  4839  }
  4840  
  4841  func SubRecvF32(a []float32, b []float32, recv []float32) {
  4842  	a = a[:len(recv)]
  4843  	b = b[:len(recv)]
  4844  	for i := range recv {
  4845  		recv[i] = a[i] - b[i]
  4846  	}
  4847  }
  4848  
  4849  func SubRecvF64(a []float64, b []float64, recv []float64) {
  4850  	a = a[:len(recv)]
  4851  	b = b[:len(recv)]
  4852  	for i := range recv {
  4853  		recv[i] = a[i] - b[i]
  4854  	}
  4855  }
  4856  
  4857  func SubRecvC64(a []complex64, b []complex64, recv []complex64) {
  4858  	a = a[:len(recv)]
  4859  	b = b[:len(recv)]
  4860  	for i := range recv {
  4861  		recv[i] = a[i] - b[i]
  4862  	}
  4863  }
  4864  
  4865  func SubRecvC128(a []complex128, b []complex128, recv []complex128) {
  4866  	a = a[:len(recv)]
  4867  	b = b[:len(recv)]
  4868  	for i := range recv {
  4869  		recv[i] = a[i] - b[i]
  4870  	}
  4871  }
  4872  
  4873  func MulRecvI(a []int, b []int, recv []int) {
  4874  	a = a[:len(recv)]
  4875  	b = b[:len(recv)]
  4876  	for i := range recv {
  4877  		recv[i] = a[i] * b[i]
  4878  	}
  4879  }
  4880  
  4881  func MulRecvI8(a []int8, b []int8, recv []int8) {
  4882  	a = a[:len(recv)]
  4883  	b = b[:len(recv)]
  4884  	for i := range recv {
  4885  		recv[i] = a[i] * b[i]
  4886  	}
  4887  }
  4888  
  4889  func MulRecvI16(a []int16, b []int16, recv []int16) {
  4890  	a = a[:len(recv)]
  4891  	b = b[:len(recv)]
  4892  	for i := range recv {
  4893  		recv[i] = a[i] * b[i]
  4894  	}
  4895  }
  4896  
  4897  func MulRecvI32(a []int32, b []int32, recv []int32) {
  4898  	a = a[:len(recv)]
  4899  	b = b[:len(recv)]
  4900  	for i := range recv {
  4901  		recv[i] = a[i] * b[i]
  4902  	}
  4903  }
  4904  
  4905  func MulRecvI64(a []int64, b []int64, recv []int64) {
  4906  	a = a[:len(recv)]
  4907  	b = b[:len(recv)]
  4908  	for i := range recv {
  4909  		recv[i] = a[i] * b[i]
  4910  	}
  4911  }
  4912  
  4913  func MulRecvU(a []uint, b []uint, recv []uint) {
  4914  	a = a[:len(recv)]
  4915  	b = b[:len(recv)]
  4916  	for i := range recv {
  4917  		recv[i] = a[i] * b[i]
  4918  	}
  4919  }
  4920  
  4921  func MulRecvU8(a []uint8, b []uint8, recv []uint8) {
  4922  	a = a[:len(recv)]
  4923  	b = b[:len(recv)]
  4924  	for i := range recv {
  4925  		recv[i] = a[i] * b[i]
  4926  	}
  4927  }
  4928  
  4929  func MulRecvU16(a []uint16, b []uint16, recv []uint16) {
  4930  	a = a[:len(recv)]
  4931  	b = b[:len(recv)]
  4932  	for i := range recv {
  4933  		recv[i] = a[i] * b[i]
  4934  	}
  4935  }
  4936  
  4937  func MulRecvU32(a []uint32, b []uint32, recv []uint32) {
  4938  	a = a[:len(recv)]
  4939  	b = b[:len(recv)]
  4940  	for i := range recv {
  4941  		recv[i] = a[i] * b[i]
  4942  	}
  4943  }
  4944  
  4945  func MulRecvU64(a []uint64, b []uint64, recv []uint64) {
  4946  	a = a[:len(recv)]
  4947  	b = b[:len(recv)]
  4948  	for i := range recv {
  4949  		recv[i] = a[i] * b[i]
  4950  	}
  4951  }
  4952  
  4953  func MulRecvF32(a []float32, b []float32, recv []float32) {
  4954  	a = a[:len(recv)]
  4955  	b = b[:len(recv)]
  4956  	for i := range recv {
  4957  		recv[i] = a[i] * b[i]
  4958  	}
  4959  }
  4960  
  4961  func MulRecvF64(a []float64, b []float64, recv []float64) {
  4962  	a = a[:len(recv)]
  4963  	b = b[:len(recv)]
  4964  	for i := range recv {
  4965  		recv[i] = a[i] * b[i]
  4966  	}
  4967  }
  4968  
  4969  func MulRecvC64(a []complex64, b []complex64, recv []complex64) {
  4970  	a = a[:len(recv)]
  4971  	b = b[:len(recv)]
  4972  	for i := range recv {
  4973  		recv[i] = a[i] * b[i]
  4974  	}
  4975  }
  4976  
  4977  func MulRecvC128(a []complex128, b []complex128, recv []complex128) {
  4978  	a = a[:len(recv)]
  4979  	b = b[:len(recv)]
  4980  	for i := range recv {
  4981  		recv[i] = a[i] * b[i]
  4982  	}
  4983  }
  4984  
  4985  func DivRecvI(a []int, b []int, recv []int) (err error) {
  4986  	a = a[:len(recv)]
  4987  	b = b[:len(recv)]
  4988  	var errs errorIndices
  4989  	for i := range recv {
  4990  		if b[i] == 0 {
  4991  			errs = append(errs, i)
  4992  			recv[i] = 0
  4993  			continue
  4994  		}
  4995  		recv[i] = a[i] / b[i]
  4996  	}
  4997  	if err != nil {
  4998  		return
  4999  	}
  5000  	if len(errs) > 0 {
  5001  		return errs
  5002  	}
  5003  	return nil
  5004  }
  5005  
  5006  func DivRecvI8(a []int8, b []int8, recv []int8) (err error) {
  5007  	a = a[:len(recv)]
  5008  	b = b[:len(recv)]
  5009  	var errs errorIndices
  5010  	for i := range recv {
  5011  		if b[i] == 0 {
  5012  			errs = append(errs, i)
  5013  			recv[i] = 0
  5014  			continue
  5015  		}
  5016  		recv[i] = a[i] / b[i]
  5017  	}
  5018  	if err != nil {
  5019  		return
  5020  	}
  5021  	if len(errs) > 0 {
  5022  		return errs
  5023  	}
  5024  	return nil
  5025  }
  5026  
  5027  func DivRecvI16(a []int16, b []int16, recv []int16) (err error) {
  5028  	a = a[:len(recv)]
  5029  	b = b[:len(recv)]
  5030  	var errs errorIndices
  5031  	for i := range recv {
  5032  		if b[i] == 0 {
  5033  			errs = append(errs, i)
  5034  			recv[i] = 0
  5035  			continue
  5036  		}
  5037  		recv[i] = a[i] / b[i]
  5038  	}
  5039  	if err != nil {
  5040  		return
  5041  	}
  5042  	if len(errs) > 0 {
  5043  		return errs
  5044  	}
  5045  	return nil
  5046  }
  5047  
  5048  func DivRecvI32(a []int32, b []int32, recv []int32) (err error) {
  5049  	a = a[:len(recv)]
  5050  	b = b[:len(recv)]
  5051  	var errs errorIndices
  5052  	for i := range recv {
  5053  		if b[i] == 0 {
  5054  			errs = append(errs, i)
  5055  			recv[i] = 0
  5056  			continue
  5057  		}
  5058  		recv[i] = a[i] / b[i]
  5059  	}
  5060  	if err != nil {
  5061  		return
  5062  	}
  5063  	if len(errs) > 0 {
  5064  		return errs
  5065  	}
  5066  	return nil
  5067  }
  5068  
  5069  func DivRecvI64(a []int64, b []int64, recv []int64) (err error) {
  5070  	a = a[:len(recv)]
  5071  	b = b[:len(recv)]
  5072  	var errs errorIndices
  5073  	for i := range recv {
  5074  		if b[i] == 0 {
  5075  			errs = append(errs, i)
  5076  			recv[i] = 0
  5077  			continue
  5078  		}
  5079  		recv[i] = a[i] / b[i]
  5080  	}
  5081  	if err != nil {
  5082  		return
  5083  	}
  5084  	if len(errs) > 0 {
  5085  		return errs
  5086  	}
  5087  	return nil
  5088  }
  5089  
  5090  func DivRecvU(a []uint, b []uint, recv []uint) (err error) {
  5091  	a = a[:len(recv)]
  5092  	b = b[:len(recv)]
  5093  	var errs errorIndices
  5094  	for i := range recv {
  5095  		if b[i] == 0 {
  5096  			errs = append(errs, i)
  5097  			recv[i] = 0
  5098  			continue
  5099  		}
  5100  		recv[i] = a[i] / b[i]
  5101  	}
  5102  	if err != nil {
  5103  		return
  5104  	}
  5105  	if len(errs) > 0 {
  5106  		return errs
  5107  	}
  5108  	return nil
  5109  }
  5110  
  5111  func DivRecvU8(a []uint8, b []uint8, recv []uint8) (err error) {
  5112  	a = a[:len(recv)]
  5113  	b = b[:len(recv)]
  5114  	var errs errorIndices
  5115  	for i := range recv {
  5116  		if b[i] == 0 {
  5117  			errs = append(errs, i)
  5118  			recv[i] = 0
  5119  			continue
  5120  		}
  5121  		recv[i] = a[i] / b[i]
  5122  	}
  5123  	if err != nil {
  5124  		return
  5125  	}
  5126  	if len(errs) > 0 {
  5127  		return errs
  5128  	}
  5129  	return nil
  5130  }
  5131  
  5132  func DivRecvU16(a []uint16, b []uint16, recv []uint16) (err error) {
  5133  	a = a[:len(recv)]
  5134  	b = b[:len(recv)]
  5135  	var errs errorIndices
  5136  	for i := range recv {
  5137  		if b[i] == 0 {
  5138  			errs = append(errs, i)
  5139  			recv[i] = 0
  5140  			continue
  5141  		}
  5142  		recv[i] = a[i] / b[i]
  5143  	}
  5144  	if err != nil {
  5145  		return
  5146  	}
  5147  	if len(errs) > 0 {
  5148  		return errs
  5149  	}
  5150  	return nil
  5151  }
  5152  
  5153  func DivRecvU32(a []uint32, b []uint32, recv []uint32) (err error) {
  5154  	a = a[:len(recv)]
  5155  	b = b[:len(recv)]
  5156  	var errs errorIndices
  5157  	for i := range recv {
  5158  		if b[i] == 0 {
  5159  			errs = append(errs, i)
  5160  			recv[i] = 0
  5161  			continue
  5162  		}
  5163  		recv[i] = a[i] / b[i]
  5164  	}
  5165  	if err != nil {
  5166  		return
  5167  	}
  5168  	if len(errs) > 0 {
  5169  		return errs
  5170  	}
  5171  	return nil
  5172  }
  5173  
  5174  func DivRecvU64(a []uint64, b []uint64, recv []uint64) (err error) {
  5175  	a = a[:len(recv)]
  5176  	b = b[:len(recv)]
  5177  	var errs errorIndices
  5178  	for i := range recv {
  5179  		if b[i] == 0 {
  5180  			errs = append(errs, i)
  5181  			recv[i] = 0
  5182  			continue
  5183  		}
  5184  		recv[i] = a[i] / b[i]
  5185  	}
  5186  	if err != nil {
  5187  		return
  5188  	}
  5189  	if len(errs) > 0 {
  5190  		return errs
  5191  	}
  5192  	return nil
  5193  }
  5194  
  5195  func DivRecvF32(a []float32, b []float32, recv []float32) {
  5196  	a = a[:len(recv)]
  5197  	b = b[:len(recv)]
  5198  	for i := range recv {
  5199  		recv[i] = a[i] / b[i]
  5200  	}
  5201  }
  5202  
  5203  func DivRecvF64(a []float64, b []float64, recv []float64) {
  5204  	a = a[:len(recv)]
  5205  	b = b[:len(recv)]
  5206  	for i := range recv {
  5207  		recv[i] = a[i] / b[i]
  5208  	}
  5209  }
  5210  
  5211  func DivRecvC64(a []complex64, b []complex64, recv []complex64) {
  5212  	a = a[:len(recv)]
  5213  	b = b[:len(recv)]
  5214  	for i := range recv {
  5215  		recv[i] = a[i] / b[i]
  5216  	}
  5217  }
  5218  
  5219  func DivRecvC128(a []complex128, b []complex128, recv []complex128) {
  5220  	a = a[:len(recv)]
  5221  	b = b[:len(recv)]
  5222  	for i := range recv {
  5223  		recv[i] = a[i] / b[i]
  5224  	}
  5225  }
  5226  
  5227  func PowRecvF32(a []float32, b []float32, recv []float32) {
  5228  	a = a[:len(recv)]
  5229  	b = b[:len(recv)]
  5230  	for i := range recv {
  5231  		recv[i] = math32.Pow(a[i], b[i])
  5232  	}
  5233  }
  5234  
  5235  func PowRecvF64(a []float64, b []float64, recv []float64) {
  5236  	a = a[:len(recv)]
  5237  	b = b[:len(recv)]
  5238  	for i := range recv {
  5239  		recv[i] = math.Pow(a[i], b[i])
  5240  	}
  5241  }
  5242  
  5243  func PowRecvC64(a []complex64, b []complex64, recv []complex64) {
  5244  	a = a[:len(recv)]
  5245  	b = b[:len(recv)]
  5246  	for i := range recv {
  5247  		recv[i] = complex64(cmplx.Pow(complex128(a[i]), complex128(b[i])))
  5248  	}
  5249  }
  5250  
  5251  func PowRecvC128(a []complex128, b []complex128, recv []complex128) {
  5252  	a = a[:len(recv)]
  5253  	b = b[:len(recv)]
  5254  	for i := range recv {
  5255  		recv[i] = cmplx.Pow(a[i], b[i])
  5256  	}
  5257  }
  5258  
  5259  func ModRecvI(a []int, b []int, recv []int) {
  5260  	a = a[:len(recv)]
  5261  	b = b[:len(recv)]
  5262  	for i := range recv {
  5263  		recv[i] = a[i] % b[i]
  5264  	}
  5265  }
  5266  
  5267  func ModRecvI8(a []int8, b []int8, recv []int8) {
  5268  	a = a[:len(recv)]
  5269  	b = b[:len(recv)]
  5270  	for i := range recv {
  5271  		recv[i] = a[i] % b[i]
  5272  	}
  5273  }
  5274  
  5275  func ModRecvI16(a []int16, b []int16, recv []int16) {
  5276  	a = a[:len(recv)]
  5277  	b = b[:len(recv)]
  5278  	for i := range recv {
  5279  		recv[i] = a[i] % b[i]
  5280  	}
  5281  }
  5282  
  5283  func ModRecvI32(a []int32, b []int32, recv []int32) {
  5284  	a = a[:len(recv)]
  5285  	b = b[:len(recv)]
  5286  	for i := range recv {
  5287  		recv[i] = a[i] % b[i]
  5288  	}
  5289  }
  5290  
  5291  func ModRecvI64(a []int64, b []int64, recv []int64) {
  5292  	a = a[:len(recv)]
  5293  	b = b[:len(recv)]
  5294  	for i := range recv {
  5295  		recv[i] = a[i] % b[i]
  5296  	}
  5297  }
  5298  
  5299  func ModRecvU(a []uint, b []uint, recv []uint) {
  5300  	a = a[:len(recv)]
  5301  	b = b[:len(recv)]
  5302  	for i := range recv {
  5303  		recv[i] = a[i] % b[i]
  5304  	}
  5305  }
  5306  
  5307  func ModRecvU8(a []uint8, b []uint8, recv []uint8) {
  5308  	a = a[:len(recv)]
  5309  	b = b[:len(recv)]
  5310  	for i := range recv {
  5311  		recv[i] = a[i] % b[i]
  5312  	}
  5313  }
  5314  
  5315  func ModRecvU16(a []uint16, b []uint16, recv []uint16) {
  5316  	a = a[:len(recv)]
  5317  	b = b[:len(recv)]
  5318  	for i := range recv {
  5319  		recv[i] = a[i] % b[i]
  5320  	}
  5321  }
  5322  
  5323  func ModRecvU32(a []uint32, b []uint32, recv []uint32) {
  5324  	a = a[:len(recv)]
  5325  	b = b[:len(recv)]
  5326  	for i := range recv {
  5327  		recv[i] = a[i] % b[i]
  5328  	}
  5329  }
  5330  
  5331  func ModRecvU64(a []uint64, b []uint64, recv []uint64) {
  5332  	a = a[:len(recv)]
  5333  	b = b[:len(recv)]
  5334  	for i := range recv {
  5335  		recv[i] = a[i] % b[i]
  5336  	}
  5337  }
  5338  
  5339  func ModRecvF32(a []float32, b []float32, recv []float32) {
  5340  	a = a[:len(recv)]
  5341  	b = b[:len(recv)]
  5342  	for i := range recv {
  5343  		recv[i] = math32.Mod(a[i], b[i])
  5344  	}
  5345  }
  5346  
  5347  func ModRecvF64(a []float64, b []float64, recv []float64) {
  5348  	a = a[:len(recv)]
  5349  	b = b[:len(recv)]
  5350  	for i := range recv {
  5351  		recv[i] = math.Mod(a[i], b[i])
  5352  	}
  5353  }