github.com/sandwich-go/boost@v1.3.29/xmap/equal.go (about)

     1  // Code generated by tools. DO NOT EDIT.
     2  package xmap
     3  
     4  func EqualFloat32Float32Map(a, b map[float32]float32) bool {
     5  	if a == nil && b == nil {
     6  		return true
     7  	}
     8  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
     9  		return false
    10  	}
    11  	for k, v := range a {
    12  		v1, ok := b[k]
    13  		if !ok || v != v1 {
    14  			return false
    15  		}
    16  	}
    17  	return true
    18  }
    19  
    20  func EqualFloat32Float64Map(a, b map[float32]float64) bool {
    21  	if a == nil && b == nil {
    22  		return true
    23  	}
    24  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
    25  		return false
    26  	}
    27  	for k, v := range a {
    28  		v1, ok := b[k]
    29  		if !ok || v != v1 {
    30  			return false
    31  		}
    32  	}
    33  	return true
    34  }
    35  
    36  func EqualFloat32IntMap(a, b map[float32]int) bool {
    37  	if a == nil && b == nil {
    38  		return true
    39  	}
    40  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
    41  		return false
    42  	}
    43  	for k, v := range a {
    44  		v1, ok := b[k]
    45  		if !ok || v != v1 {
    46  			return false
    47  		}
    48  	}
    49  	return true
    50  }
    51  
    52  func EqualFloat32Int16Map(a, b map[float32]int16) bool {
    53  	if a == nil && b == nil {
    54  		return true
    55  	}
    56  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
    57  		return false
    58  	}
    59  	for k, v := range a {
    60  		v1, ok := b[k]
    61  		if !ok || v != v1 {
    62  			return false
    63  		}
    64  	}
    65  	return true
    66  }
    67  
    68  func EqualFloat32Int32Map(a, b map[float32]int32) bool {
    69  	if a == nil && b == nil {
    70  		return true
    71  	}
    72  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
    73  		return false
    74  	}
    75  	for k, v := range a {
    76  		v1, ok := b[k]
    77  		if !ok || v != v1 {
    78  			return false
    79  		}
    80  	}
    81  	return true
    82  }
    83  
    84  func EqualFloat32Int64Map(a, b map[float32]int64) bool {
    85  	if a == nil && b == nil {
    86  		return true
    87  	}
    88  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
    89  		return false
    90  	}
    91  	for k, v := range a {
    92  		v1, ok := b[k]
    93  		if !ok || v != v1 {
    94  			return false
    95  		}
    96  	}
    97  	return true
    98  }
    99  
   100  func EqualFloat32Int8Map(a, b map[float32]int8) bool {
   101  	if a == nil && b == nil {
   102  		return true
   103  	}
   104  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   105  		return false
   106  	}
   107  	for k, v := range a {
   108  		v1, ok := b[k]
   109  		if !ok || v != v1 {
   110  			return false
   111  		}
   112  	}
   113  	return true
   114  }
   115  
   116  func EqualFloat32StringMap(a, b map[float32]string) bool {
   117  	if a == nil && b == nil {
   118  		return true
   119  	}
   120  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   121  		return false
   122  	}
   123  	for k, v := range a {
   124  		v1, ok := b[k]
   125  		if !ok || v != v1 {
   126  			return false
   127  		}
   128  	}
   129  	return true
   130  }
   131  
   132  func EqualFloat32UintMap(a, b map[float32]uint) bool {
   133  	if a == nil && b == nil {
   134  		return true
   135  	}
   136  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   137  		return false
   138  	}
   139  	for k, v := range a {
   140  		v1, ok := b[k]
   141  		if !ok || v != v1 {
   142  			return false
   143  		}
   144  	}
   145  	return true
   146  }
   147  
   148  func EqualFloat32Uint16Map(a, b map[float32]uint16) bool {
   149  	if a == nil && b == nil {
   150  		return true
   151  	}
   152  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   153  		return false
   154  	}
   155  	for k, v := range a {
   156  		v1, ok := b[k]
   157  		if !ok || v != v1 {
   158  			return false
   159  		}
   160  	}
   161  	return true
   162  }
   163  
   164  func EqualFloat32Uint32Map(a, b map[float32]uint32) bool {
   165  	if a == nil && b == nil {
   166  		return true
   167  	}
   168  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   169  		return false
   170  	}
   171  	for k, v := range a {
   172  		v1, ok := b[k]
   173  		if !ok || v != v1 {
   174  			return false
   175  		}
   176  	}
   177  	return true
   178  }
   179  
   180  func EqualFloat32Uint64Map(a, b map[float32]uint64) bool {
   181  	if a == nil && b == nil {
   182  		return true
   183  	}
   184  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   185  		return false
   186  	}
   187  	for k, v := range a {
   188  		v1, ok := b[k]
   189  		if !ok || v != v1 {
   190  			return false
   191  		}
   192  	}
   193  	return true
   194  }
   195  
   196  func EqualFloat32Uint8Map(a, b map[float32]uint8) bool {
   197  	if a == nil && b == nil {
   198  		return true
   199  	}
   200  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   201  		return false
   202  	}
   203  	for k, v := range a {
   204  		v1, ok := b[k]
   205  		if !ok || v != v1 {
   206  			return false
   207  		}
   208  	}
   209  	return true
   210  }
   211  
   212  func EqualFloat64Float32Map(a, b map[float64]float32) bool {
   213  	if a == nil && b == nil {
   214  		return true
   215  	}
   216  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   217  		return false
   218  	}
   219  	for k, v := range a {
   220  		v1, ok := b[k]
   221  		if !ok || v != v1 {
   222  			return false
   223  		}
   224  	}
   225  	return true
   226  }
   227  
   228  func EqualFloat64Float64Map(a, b map[float64]float64) bool {
   229  	if a == nil && b == nil {
   230  		return true
   231  	}
   232  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   233  		return false
   234  	}
   235  	for k, v := range a {
   236  		v1, ok := b[k]
   237  		if !ok || v != v1 {
   238  			return false
   239  		}
   240  	}
   241  	return true
   242  }
   243  
   244  func EqualFloat64IntMap(a, b map[float64]int) bool {
   245  	if a == nil && b == nil {
   246  		return true
   247  	}
   248  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   249  		return false
   250  	}
   251  	for k, v := range a {
   252  		v1, ok := b[k]
   253  		if !ok || v != v1 {
   254  			return false
   255  		}
   256  	}
   257  	return true
   258  }
   259  
   260  func EqualFloat64Int16Map(a, b map[float64]int16) bool {
   261  	if a == nil && b == nil {
   262  		return true
   263  	}
   264  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   265  		return false
   266  	}
   267  	for k, v := range a {
   268  		v1, ok := b[k]
   269  		if !ok || v != v1 {
   270  			return false
   271  		}
   272  	}
   273  	return true
   274  }
   275  
   276  func EqualFloat64Int32Map(a, b map[float64]int32) bool {
   277  	if a == nil && b == nil {
   278  		return true
   279  	}
   280  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   281  		return false
   282  	}
   283  	for k, v := range a {
   284  		v1, ok := b[k]
   285  		if !ok || v != v1 {
   286  			return false
   287  		}
   288  	}
   289  	return true
   290  }
   291  
   292  func EqualFloat64Int64Map(a, b map[float64]int64) bool {
   293  	if a == nil && b == nil {
   294  		return true
   295  	}
   296  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   297  		return false
   298  	}
   299  	for k, v := range a {
   300  		v1, ok := b[k]
   301  		if !ok || v != v1 {
   302  			return false
   303  		}
   304  	}
   305  	return true
   306  }
   307  
   308  func EqualFloat64Int8Map(a, b map[float64]int8) bool {
   309  	if a == nil && b == nil {
   310  		return true
   311  	}
   312  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   313  		return false
   314  	}
   315  	for k, v := range a {
   316  		v1, ok := b[k]
   317  		if !ok || v != v1 {
   318  			return false
   319  		}
   320  	}
   321  	return true
   322  }
   323  
   324  func EqualFloat64StringMap(a, b map[float64]string) bool {
   325  	if a == nil && b == nil {
   326  		return true
   327  	}
   328  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   329  		return false
   330  	}
   331  	for k, v := range a {
   332  		v1, ok := b[k]
   333  		if !ok || v != v1 {
   334  			return false
   335  		}
   336  	}
   337  	return true
   338  }
   339  
   340  func EqualFloat64UintMap(a, b map[float64]uint) bool {
   341  	if a == nil && b == nil {
   342  		return true
   343  	}
   344  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   345  		return false
   346  	}
   347  	for k, v := range a {
   348  		v1, ok := b[k]
   349  		if !ok || v != v1 {
   350  			return false
   351  		}
   352  	}
   353  	return true
   354  }
   355  
   356  func EqualFloat64Uint16Map(a, b map[float64]uint16) bool {
   357  	if a == nil && b == nil {
   358  		return true
   359  	}
   360  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   361  		return false
   362  	}
   363  	for k, v := range a {
   364  		v1, ok := b[k]
   365  		if !ok || v != v1 {
   366  			return false
   367  		}
   368  	}
   369  	return true
   370  }
   371  
   372  func EqualFloat64Uint32Map(a, b map[float64]uint32) bool {
   373  	if a == nil && b == nil {
   374  		return true
   375  	}
   376  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   377  		return false
   378  	}
   379  	for k, v := range a {
   380  		v1, ok := b[k]
   381  		if !ok || v != v1 {
   382  			return false
   383  		}
   384  	}
   385  	return true
   386  }
   387  
   388  func EqualFloat64Uint64Map(a, b map[float64]uint64) bool {
   389  	if a == nil && b == nil {
   390  		return true
   391  	}
   392  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   393  		return false
   394  	}
   395  	for k, v := range a {
   396  		v1, ok := b[k]
   397  		if !ok || v != v1 {
   398  			return false
   399  		}
   400  	}
   401  	return true
   402  }
   403  
   404  func EqualFloat64Uint8Map(a, b map[float64]uint8) bool {
   405  	if a == nil && b == nil {
   406  		return true
   407  	}
   408  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   409  		return false
   410  	}
   411  	for k, v := range a {
   412  		v1, ok := b[k]
   413  		if !ok || v != v1 {
   414  			return false
   415  		}
   416  	}
   417  	return true
   418  }
   419  
   420  func EqualIntFloat32Map(a, b map[int]float32) bool {
   421  	if a == nil && b == nil {
   422  		return true
   423  	}
   424  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   425  		return false
   426  	}
   427  	for k, v := range a {
   428  		v1, ok := b[k]
   429  		if !ok || v != v1 {
   430  			return false
   431  		}
   432  	}
   433  	return true
   434  }
   435  
   436  func EqualIntFloat64Map(a, b map[int]float64) bool {
   437  	if a == nil && b == nil {
   438  		return true
   439  	}
   440  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   441  		return false
   442  	}
   443  	for k, v := range a {
   444  		v1, ok := b[k]
   445  		if !ok || v != v1 {
   446  			return false
   447  		}
   448  	}
   449  	return true
   450  }
   451  
   452  func EqualIntIntMap(a, b map[int]int) bool {
   453  	if a == nil && b == nil {
   454  		return true
   455  	}
   456  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   457  		return false
   458  	}
   459  	for k, v := range a {
   460  		v1, ok := b[k]
   461  		if !ok || v != v1 {
   462  			return false
   463  		}
   464  	}
   465  	return true
   466  }
   467  
   468  func EqualIntInt16Map(a, b map[int]int16) bool {
   469  	if a == nil && b == nil {
   470  		return true
   471  	}
   472  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   473  		return false
   474  	}
   475  	for k, v := range a {
   476  		v1, ok := b[k]
   477  		if !ok || v != v1 {
   478  			return false
   479  		}
   480  	}
   481  	return true
   482  }
   483  
   484  func EqualIntInt32Map(a, b map[int]int32) bool {
   485  	if a == nil && b == nil {
   486  		return true
   487  	}
   488  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   489  		return false
   490  	}
   491  	for k, v := range a {
   492  		v1, ok := b[k]
   493  		if !ok || v != v1 {
   494  			return false
   495  		}
   496  	}
   497  	return true
   498  }
   499  
   500  func EqualIntInt64Map(a, b map[int]int64) bool {
   501  	if a == nil && b == nil {
   502  		return true
   503  	}
   504  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   505  		return false
   506  	}
   507  	for k, v := range a {
   508  		v1, ok := b[k]
   509  		if !ok || v != v1 {
   510  			return false
   511  		}
   512  	}
   513  	return true
   514  }
   515  
   516  func EqualIntInt8Map(a, b map[int]int8) bool {
   517  	if a == nil && b == nil {
   518  		return true
   519  	}
   520  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   521  		return false
   522  	}
   523  	for k, v := range a {
   524  		v1, ok := b[k]
   525  		if !ok || v != v1 {
   526  			return false
   527  		}
   528  	}
   529  	return true
   530  }
   531  
   532  func EqualIntStringMap(a, b map[int]string) bool {
   533  	if a == nil && b == nil {
   534  		return true
   535  	}
   536  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   537  		return false
   538  	}
   539  	for k, v := range a {
   540  		v1, ok := b[k]
   541  		if !ok || v != v1 {
   542  			return false
   543  		}
   544  	}
   545  	return true
   546  }
   547  
   548  func EqualIntUintMap(a, b map[int]uint) bool {
   549  	if a == nil && b == nil {
   550  		return true
   551  	}
   552  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   553  		return false
   554  	}
   555  	for k, v := range a {
   556  		v1, ok := b[k]
   557  		if !ok || v != v1 {
   558  			return false
   559  		}
   560  	}
   561  	return true
   562  }
   563  
   564  func EqualIntUint16Map(a, b map[int]uint16) bool {
   565  	if a == nil && b == nil {
   566  		return true
   567  	}
   568  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   569  		return false
   570  	}
   571  	for k, v := range a {
   572  		v1, ok := b[k]
   573  		if !ok || v != v1 {
   574  			return false
   575  		}
   576  	}
   577  	return true
   578  }
   579  
   580  func EqualIntUint32Map(a, b map[int]uint32) bool {
   581  	if a == nil && b == nil {
   582  		return true
   583  	}
   584  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   585  		return false
   586  	}
   587  	for k, v := range a {
   588  		v1, ok := b[k]
   589  		if !ok || v != v1 {
   590  			return false
   591  		}
   592  	}
   593  	return true
   594  }
   595  
   596  func EqualIntUint64Map(a, b map[int]uint64) bool {
   597  	if a == nil && b == nil {
   598  		return true
   599  	}
   600  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   601  		return false
   602  	}
   603  	for k, v := range a {
   604  		v1, ok := b[k]
   605  		if !ok || v != v1 {
   606  			return false
   607  		}
   608  	}
   609  	return true
   610  }
   611  
   612  func EqualIntUint8Map(a, b map[int]uint8) bool {
   613  	if a == nil && b == nil {
   614  		return true
   615  	}
   616  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   617  		return false
   618  	}
   619  	for k, v := range a {
   620  		v1, ok := b[k]
   621  		if !ok || v != v1 {
   622  			return false
   623  		}
   624  	}
   625  	return true
   626  }
   627  
   628  func EqualInt16Float32Map(a, b map[int16]float32) bool {
   629  	if a == nil && b == nil {
   630  		return true
   631  	}
   632  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   633  		return false
   634  	}
   635  	for k, v := range a {
   636  		v1, ok := b[k]
   637  		if !ok || v != v1 {
   638  			return false
   639  		}
   640  	}
   641  	return true
   642  }
   643  
   644  func EqualInt16Float64Map(a, b map[int16]float64) bool {
   645  	if a == nil && b == nil {
   646  		return true
   647  	}
   648  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   649  		return false
   650  	}
   651  	for k, v := range a {
   652  		v1, ok := b[k]
   653  		if !ok || v != v1 {
   654  			return false
   655  		}
   656  	}
   657  	return true
   658  }
   659  
   660  func EqualInt16IntMap(a, b map[int16]int) bool {
   661  	if a == nil && b == nil {
   662  		return true
   663  	}
   664  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   665  		return false
   666  	}
   667  	for k, v := range a {
   668  		v1, ok := b[k]
   669  		if !ok || v != v1 {
   670  			return false
   671  		}
   672  	}
   673  	return true
   674  }
   675  
   676  func EqualInt16Int16Map(a, b map[int16]int16) bool {
   677  	if a == nil && b == nil {
   678  		return true
   679  	}
   680  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   681  		return false
   682  	}
   683  	for k, v := range a {
   684  		v1, ok := b[k]
   685  		if !ok || v != v1 {
   686  			return false
   687  		}
   688  	}
   689  	return true
   690  }
   691  
   692  func EqualInt16Int32Map(a, b map[int16]int32) bool {
   693  	if a == nil && b == nil {
   694  		return true
   695  	}
   696  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   697  		return false
   698  	}
   699  	for k, v := range a {
   700  		v1, ok := b[k]
   701  		if !ok || v != v1 {
   702  			return false
   703  		}
   704  	}
   705  	return true
   706  }
   707  
   708  func EqualInt16Int64Map(a, b map[int16]int64) bool {
   709  	if a == nil && b == nil {
   710  		return true
   711  	}
   712  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   713  		return false
   714  	}
   715  	for k, v := range a {
   716  		v1, ok := b[k]
   717  		if !ok || v != v1 {
   718  			return false
   719  		}
   720  	}
   721  	return true
   722  }
   723  
   724  func EqualInt16Int8Map(a, b map[int16]int8) bool {
   725  	if a == nil && b == nil {
   726  		return true
   727  	}
   728  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   729  		return false
   730  	}
   731  	for k, v := range a {
   732  		v1, ok := b[k]
   733  		if !ok || v != v1 {
   734  			return false
   735  		}
   736  	}
   737  	return true
   738  }
   739  
   740  func EqualInt16StringMap(a, b map[int16]string) bool {
   741  	if a == nil && b == nil {
   742  		return true
   743  	}
   744  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   745  		return false
   746  	}
   747  	for k, v := range a {
   748  		v1, ok := b[k]
   749  		if !ok || v != v1 {
   750  			return false
   751  		}
   752  	}
   753  	return true
   754  }
   755  
   756  func EqualInt16UintMap(a, b map[int16]uint) bool {
   757  	if a == nil && b == nil {
   758  		return true
   759  	}
   760  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   761  		return false
   762  	}
   763  	for k, v := range a {
   764  		v1, ok := b[k]
   765  		if !ok || v != v1 {
   766  			return false
   767  		}
   768  	}
   769  	return true
   770  }
   771  
   772  func EqualInt16Uint16Map(a, b map[int16]uint16) bool {
   773  	if a == nil && b == nil {
   774  		return true
   775  	}
   776  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   777  		return false
   778  	}
   779  	for k, v := range a {
   780  		v1, ok := b[k]
   781  		if !ok || v != v1 {
   782  			return false
   783  		}
   784  	}
   785  	return true
   786  }
   787  
   788  func EqualInt16Uint32Map(a, b map[int16]uint32) bool {
   789  	if a == nil && b == nil {
   790  		return true
   791  	}
   792  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   793  		return false
   794  	}
   795  	for k, v := range a {
   796  		v1, ok := b[k]
   797  		if !ok || v != v1 {
   798  			return false
   799  		}
   800  	}
   801  	return true
   802  }
   803  
   804  func EqualInt16Uint64Map(a, b map[int16]uint64) bool {
   805  	if a == nil && b == nil {
   806  		return true
   807  	}
   808  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   809  		return false
   810  	}
   811  	for k, v := range a {
   812  		v1, ok := b[k]
   813  		if !ok || v != v1 {
   814  			return false
   815  		}
   816  	}
   817  	return true
   818  }
   819  
   820  func EqualInt16Uint8Map(a, b map[int16]uint8) bool {
   821  	if a == nil && b == nil {
   822  		return true
   823  	}
   824  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   825  		return false
   826  	}
   827  	for k, v := range a {
   828  		v1, ok := b[k]
   829  		if !ok || v != v1 {
   830  			return false
   831  		}
   832  	}
   833  	return true
   834  }
   835  
   836  func EqualInt32Float32Map(a, b map[int32]float32) bool {
   837  	if a == nil && b == nil {
   838  		return true
   839  	}
   840  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   841  		return false
   842  	}
   843  	for k, v := range a {
   844  		v1, ok := b[k]
   845  		if !ok || v != v1 {
   846  			return false
   847  		}
   848  	}
   849  	return true
   850  }
   851  
   852  func EqualInt32Float64Map(a, b map[int32]float64) bool {
   853  	if a == nil && b == nil {
   854  		return true
   855  	}
   856  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   857  		return false
   858  	}
   859  	for k, v := range a {
   860  		v1, ok := b[k]
   861  		if !ok || v != v1 {
   862  			return false
   863  		}
   864  	}
   865  	return true
   866  }
   867  
   868  func EqualInt32IntMap(a, b map[int32]int) bool {
   869  	if a == nil && b == nil {
   870  		return true
   871  	}
   872  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   873  		return false
   874  	}
   875  	for k, v := range a {
   876  		v1, ok := b[k]
   877  		if !ok || v != v1 {
   878  			return false
   879  		}
   880  	}
   881  	return true
   882  }
   883  
   884  func EqualInt32Int16Map(a, b map[int32]int16) bool {
   885  	if a == nil && b == nil {
   886  		return true
   887  	}
   888  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   889  		return false
   890  	}
   891  	for k, v := range a {
   892  		v1, ok := b[k]
   893  		if !ok || v != v1 {
   894  			return false
   895  		}
   896  	}
   897  	return true
   898  }
   899  
   900  func EqualInt32Int32Map(a, b map[int32]int32) bool {
   901  	if a == nil && b == nil {
   902  		return true
   903  	}
   904  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   905  		return false
   906  	}
   907  	for k, v := range a {
   908  		v1, ok := b[k]
   909  		if !ok || v != v1 {
   910  			return false
   911  		}
   912  	}
   913  	return true
   914  }
   915  
   916  func EqualInt32Int64Map(a, b map[int32]int64) bool {
   917  	if a == nil && b == nil {
   918  		return true
   919  	}
   920  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   921  		return false
   922  	}
   923  	for k, v := range a {
   924  		v1, ok := b[k]
   925  		if !ok || v != v1 {
   926  			return false
   927  		}
   928  	}
   929  	return true
   930  }
   931  
   932  func EqualInt32Int8Map(a, b map[int32]int8) bool {
   933  	if a == nil && b == nil {
   934  		return true
   935  	}
   936  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   937  		return false
   938  	}
   939  	for k, v := range a {
   940  		v1, ok := b[k]
   941  		if !ok || v != v1 {
   942  			return false
   943  		}
   944  	}
   945  	return true
   946  }
   947  
   948  func EqualInt32StringMap(a, b map[int32]string) bool {
   949  	if a == nil && b == nil {
   950  		return true
   951  	}
   952  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   953  		return false
   954  	}
   955  	for k, v := range a {
   956  		v1, ok := b[k]
   957  		if !ok || v != v1 {
   958  			return false
   959  		}
   960  	}
   961  	return true
   962  }
   963  
   964  func EqualInt32UintMap(a, b map[int32]uint) bool {
   965  	if a == nil && b == nil {
   966  		return true
   967  	}
   968  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   969  		return false
   970  	}
   971  	for k, v := range a {
   972  		v1, ok := b[k]
   973  		if !ok || v != v1 {
   974  			return false
   975  		}
   976  	}
   977  	return true
   978  }
   979  
   980  func EqualInt32Uint16Map(a, b map[int32]uint16) bool {
   981  	if a == nil && b == nil {
   982  		return true
   983  	}
   984  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
   985  		return false
   986  	}
   987  	for k, v := range a {
   988  		v1, ok := b[k]
   989  		if !ok || v != v1 {
   990  			return false
   991  		}
   992  	}
   993  	return true
   994  }
   995  
   996  func EqualInt32Uint32Map(a, b map[int32]uint32) bool {
   997  	if a == nil && b == nil {
   998  		return true
   999  	}
  1000  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1001  		return false
  1002  	}
  1003  	for k, v := range a {
  1004  		v1, ok := b[k]
  1005  		if !ok || v != v1 {
  1006  			return false
  1007  		}
  1008  	}
  1009  	return true
  1010  }
  1011  
  1012  func EqualInt32Uint64Map(a, b map[int32]uint64) bool {
  1013  	if a == nil && b == nil {
  1014  		return true
  1015  	}
  1016  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1017  		return false
  1018  	}
  1019  	for k, v := range a {
  1020  		v1, ok := b[k]
  1021  		if !ok || v != v1 {
  1022  			return false
  1023  		}
  1024  	}
  1025  	return true
  1026  }
  1027  
  1028  func EqualInt32Uint8Map(a, b map[int32]uint8) bool {
  1029  	if a == nil && b == nil {
  1030  		return true
  1031  	}
  1032  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1033  		return false
  1034  	}
  1035  	for k, v := range a {
  1036  		v1, ok := b[k]
  1037  		if !ok || v != v1 {
  1038  			return false
  1039  		}
  1040  	}
  1041  	return true
  1042  }
  1043  
  1044  func EqualInt64Float32Map(a, b map[int64]float32) bool {
  1045  	if a == nil && b == nil {
  1046  		return true
  1047  	}
  1048  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1049  		return false
  1050  	}
  1051  	for k, v := range a {
  1052  		v1, ok := b[k]
  1053  		if !ok || v != v1 {
  1054  			return false
  1055  		}
  1056  	}
  1057  	return true
  1058  }
  1059  
  1060  func EqualInt64Float64Map(a, b map[int64]float64) bool {
  1061  	if a == nil && b == nil {
  1062  		return true
  1063  	}
  1064  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1065  		return false
  1066  	}
  1067  	for k, v := range a {
  1068  		v1, ok := b[k]
  1069  		if !ok || v != v1 {
  1070  			return false
  1071  		}
  1072  	}
  1073  	return true
  1074  }
  1075  
  1076  func EqualInt64IntMap(a, b map[int64]int) bool {
  1077  	if a == nil && b == nil {
  1078  		return true
  1079  	}
  1080  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1081  		return false
  1082  	}
  1083  	for k, v := range a {
  1084  		v1, ok := b[k]
  1085  		if !ok || v != v1 {
  1086  			return false
  1087  		}
  1088  	}
  1089  	return true
  1090  }
  1091  
  1092  func EqualInt64Int16Map(a, b map[int64]int16) bool {
  1093  	if a == nil && b == nil {
  1094  		return true
  1095  	}
  1096  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1097  		return false
  1098  	}
  1099  	for k, v := range a {
  1100  		v1, ok := b[k]
  1101  		if !ok || v != v1 {
  1102  			return false
  1103  		}
  1104  	}
  1105  	return true
  1106  }
  1107  
  1108  func EqualInt64Int32Map(a, b map[int64]int32) bool {
  1109  	if a == nil && b == nil {
  1110  		return true
  1111  	}
  1112  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1113  		return false
  1114  	}
  1115  	for k, v := range a {
  1116  		v1, ok := b[k]
  1117  		if !ok || v != v1 {
  1118  			return false
  1119  		}
  1120  	}
  1121  	return true
  1122  }
  1123  
  1124  func EqualInt64Int64Map(a, b map[int64]int64) bool {
  1125  	if a == nil && b == nil {
  1126  		return true
  1127  	}
  1128  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1129  		return false
  1130  	}
  1131  	for k, v := range a {
  1132  		v1, ok := b[k]
  1133  		if !ok || v != v1 {
  1134  			return false
  1135  		}
  1136  	}
  1137  	return true
  1138  }
  1139  
  1140  func EqualInt64Int8Map(a, b map[int64]int8) bool {
  1141  	if a == nil && b == nil {
  1142  		return true
  1143  	}
  1144  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1145  		return false
  1146  	}
  1147  	for k, v := range a {
  1148  		v1, ok := b[k]
  1149  		if !ok || v != v1 {
  1150  			return false
  1151  		}
  1152  	}
  1153  	return true
  1154  }
  1155  
  1156  func EqualInt64StringMap(a, b map[int64]string) bool {
  1157  	if a == nil && b == nil {
  1158  		return true
  1159  	}
  1160  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1161  		return false
  1162  	}
  1163  	for k, v := range a {
  1164  		v1, ok := b[k]
  1165  		if !ok || v != v1 {
  1166  			return false
  1167  		}
  1168  	}
  1169  	return true
  1170  }
  1171  
  1172  func EqualInt64UintMap(a, b map[int64]uint) bool {
  1173  	if a == nil && b == nil {
  1174  		return true
  1175  	}
  1176  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1177  		return false
  1178  	}
  1179  	for k, v := range a {
  1180  		v1, ok := b[k]
  1181  		if !ok || v != v1 {
  1182  			return false
  1183  		}
  1184  	}
  1185  	return true
  1186  }
  1187  
  1188  func EqualInt64Uint16Map(a, b map[int64]uint16) bool {
  1189  	if a == nil && b == nil {
  1190  		return true
  1191  	}
  1192  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1193  		return false
  1194  	}
  1195  	for k, v := range a {
  1196  		v1, ok := b[k]
  1197  		if !ok || v != v1 {
  1198  			return false
  1199  		}
  1200  	}
  1201  	return true
  1202  }
  1203  
  1204  func EqualInt64Uint32Map(a, b map[int64]uint32) bool {
  1205  	if a == nil && b == nil {
  1206  		return true
  1207  	}
  1208  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1209  		return false
  1210  	}
  1211  	for k, v := range a {
  1212  		v1, ok := b[k]
  1213  		if !ok || v != v1 {
  1214  			return false
  1215  		}
  1216  	}
  1217  	return true
  1218  }
  1219  
  1220  func EqualInt64Uint64Map(a, b map[int64]uint64) bool {
  1221  	if a == nil && b == nil {
  1222  		return true
  1223  	}
  1224  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1225  		return false
  1226  	}
  1227  	for k, v := range a {
  1228  		v1, ok := b[k]
  1229  		if !ok || v != v1 {
  1230  			return false
  1231  		}
  1232  	}
  1233  	return true
  1234  }
  1235  
  1236  func EqualInt64Uint8Map(a, b map[int64]uint8) bool {
  1237  	if a == nil && b == nil {
  1238  		return true
  1239  	}
  1240  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1241  		return false
  1242  	}
  1243  	for k, v := range a {
  1244  		v1, ok := b[k]
  1245  		if !ok || v != v1 {
  1246  			return false
  1247  		}
  1248  	}
  1249  	return true
  1250  }
  1251  
  1252  func EqualInt8Float32Map(a, b map[int8]float32) bool {
  1253  	if a == nil && b == nil {
  1254  		return true
  1255  	}
  1256  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1257  		return false
  1258  	}
  1259  	for k, v := range a {
  1260  		v1, ok := b[k]
  1261  		if !ok || v != v1 {
  1262  			return false
  1263  		}
  1264  	}
  1265  	return true
  1266  }
  1267  
  1268  func EqualInt8Float64Map(a, b map[int8]float64) bool {
  1269  	if a == nil && b == nil {
  1270  		return true
  1271  	}
  1272  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1273  		return false
  1274  	}
  1275  	for k, v := range a {
  1276  		v1, ok := b[k]
  1277  		if !ok || v != v1 {
  1278  			return false
  1279  		}
  1280  	}
  1281  	return true
  1282  }
  1283  
  1284  func EqualInt8IntMap(a, b map[int8]int) bool {
  1285  	if a == nil && b == nil {
  1286  		return true
  1287  	}
  1288  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1289  		return false
  1290  	}
  1291  	for k, v := range a {
  1292  		v1, ok := b[k]
  1293  		if !ok || v != v1 {
  1294  			return false
  1295  		}
  1296  	}
  1297  	return true
  1298  }
  1299  
  1300  func EqualInt8Int16Map(a, b map[int8]int16) bool {
  1301  	if a == nil && b == nil {
  1302  		return true
  1303  	}
  1304  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1305  		return false
  1306  	}
  1307  	for k, v := range a {
  1308  		v1, ok := b[k]
  1309  		if !ok || v != v1 {
  1310  			return false
  1311  		}
  1312  	}
  1313  	return true
  1314  }
  1315  
  1316  func EqualInt8Int32Map(a, b map[int8]int32) bool {
  1317  	if a == nil && b == nil {
  1318  		return true
  1319  	}
  1320  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1321  		return false
  1322  	}
  1323  	for k, v := range a {
  1324  		v1, ok := b[k]
  1325  		if !ok || v != v1 {
  1326  			return false
  1327  		}
  1328  	}
  1329  	return true
  1330  }
  1331  
  1332  func EqualInt8Int64Map(a, b map[int8]int64) bool {
  1333  	if a == nil && b == nil {
  1334  		return true
  1335  	}
  1336  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1337  		return false
  1338  	}
  1339  	for k, v := range a {
  1340  		v1, ok := b[k]
  1341  		if !ok || v != v1 {
  1342  			return false
  1343  		}
  1344  	}
  1345  	return true
  1346  }
  1347  
  1348  func EqualInt8Int8Map(a, b map[int8]int8) bool {
  1349  	if a == nil && b == nil {
  1350  		return true
  1351  	}
  1352  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1353  		return false
  1354  	}
  1355  	for k, v := range a {
  1356  		v1, ok := b[k]
  1357  		if !ok || v != v1 {
  1358  			return false
  1359  		}
  1360  	}
  1361  	return true
  1362  }
  1363  
  1364  func EqualInt8StringMap(a, b map[int8]string) bool {
  1365  	if a == nil && b == nil {
  1366  		return true
  1367  	}
  1368  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1369  		return false
  1370  	}
  1371  	for k, v := range a {
  1372  		v1, ok := b[k]
  1373  		if !ok || v != v1 {
  1374  			return false
  1375  		}
  1376  	}
  1377  	return true
  1378  }
  1379  
  1380  func EqualInt8UintMap(a, b map[int8]uint) bool {
  1381  	if a == nil && b == nil {
  1382  		return true
  1383  	}
  1384  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1385  		return false
  1386  	}
  1387  	for k, v := range a {
  1388  		v1, ok := b[k]
  1389  		if !ok || v != v1 {
  1390  			return false
  1391  		}
  1392  	}
  1393  	return true
  1394  }
  1395  
  1396  func EqualInt8Uint16Map(a, b map[int8]uint16) bool {
  1397  	if a == nil && b == nil {
  1398  		return true
  1399  	}
  1400  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1401  		return false
  1402  	}
  1403  	for k, v := range a {
  1404  		v1, ok := b[k]
  1405  		if !ok || v != v1 {
  1406  			return false
  1407  		}
  1408  	}
  1409  	return true
  1410  }
  1411  
  1412  func EqualInt8Uint32Map(a, b map[int8]uint32) bool {
  1413  	if a == nil && b == nil {
  1414  		return true
  1415  	}
  1416  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1417  		return false
  1418  	}
  1419  	for k, v := range a {
  1420  		v1, ok := b[k]
  1421  		if !ok || v != v1 {
  1422  			return false
  1423  		}
  1424  	}
  1425  	return true
  1426  }
  1427  
  1428  func EqualInt8Uint64Map(a, b map[int8]uint64) bool {
  1429  	if a == nil && b == nil {
  1430  		return true
  1431  	}
  1432  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1433  		return false
  1434  	}
  1435  	for k, v := range a {
  1436  		v1, ok := b[k]
  1437  		if !ok || v != v1 {
  1438  			return false
  1439  		}
  1440  	}
  1441  	return true
  1442  }
  1443  
  1444  func EqualInt8Uint8Map(a, b map[int8]uint8) bool {
  1445  	if a == nil && b == nil {
  1446  		return true
  1447  	}
  1448  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1449  		return false
  1450  	}
  1451  	for k, v := range a {
  1452  		v1, ok := b[k]
  1453  		if !ok || v != v1 {
  1454  			return false
  1455  		}
  1456  	}
  1457  	return true
  1458  }
  1459  
  1460  func EqualStringFloat32Map(a, b map[string]float32) bool {
  1461  	if a == nil && b == nil {
  1462  		return true
  1463  	}
  1464  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1465  		return false
  1466  	}
  1467  	for k, v := range a {
  1468  		v1, ok := b[k]
  1469  		if !ok || v != v1 {
  1470  			return false
  1471  		}
  1472  	}
  1473  	return true
  1474  }
  1475  
  1476  func EqualStringFloat64Map(a, b map[string]float64) bool {
  1477  	if a == nil && b == nil {
  1478  		return true
  1479  	}
  1480  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1481  		return false
  1482  	}
  1483  	for k, v := range a {
  1484  		v1, ok := b[k]
  1485  		if !ok || v != v1 {
  1486  			return false
  1487  		}
  1488  	}
  1489  	return true
  1490  }
  1491  
  1492  func EqualStringIntMap(a, b map[string]int) bool {
  1493  	if a == nil && b == nil {
  1494  		return true
  1495  	}
  1496  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1497  		return false
  1498  	}
  1499  	for k, v := range a {
  1500  		v1, ok := b[k]
  1501  		if !ok || v != v1 {
  1502  			return false
  1503  		}
  1504  	}
  1505  	return true
  1506  }
  1507  
  1508  func EqualStringInt16Map(a, b map[string]int16) bool {
  1509  	if a == nil && b == nil {
  1510  		return true
  1511  	}
  1512  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1513  		return false
  1514  	}
  1515  	for k, v := range a {
  1516  		v1, ok := b[k]
  1517  		if !ok || v != v1 {
  1518  			return false
  1519  		}
  1520  	}
  1521  	return true
  1522  }
  1523  
  1524  func EqualStringInt32Map(a, b map[string]int32) bool {
  1525  	if a == nil && b == nil {
  1526  		return true
  1527  	}
  1528  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1529  		return false
  1530  	}
  1531  	for k, v := range a {
  1532  		v1, ok := b[k]
  1533  		if !ok || v != v1 {
  1534  			return false
  1535  		}
  1536  	}
  1537  	return true
  1538  }
  1539  
  1540  func EqualStringInt64Map(a, b map[string]int64) bool {
  1541  	if a == nil && b == nil {
  1542  		return true
  1543  	}
  1544  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1545  		return false
  1546  	}
  1547  	for k, v := range a {
  1548  		v1, ok := b[k]
  1549  		if !ok || v != v1 {
  1550  			return false
  1551  		}
  1552  	}
  1553  	return true
  1554  }
  1555  
  1556  func EqualStringInt8Map(a, b map[string]int8) bool {
  1557  	if a == nil && b == nil {
  1558  		return true
  1559  	}
  1560  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1561  		return false
  1562  	}
  1563  	for k, v := range a {
  1564  		v1, ok := b[k]
  1565  		if !ok || v != v1 {
  1566  			return false
  1567  		}
  1568  	}
  1569  	return true
  1570  }
  1571  
  1572  func EqualStringStringMap(a, b map[string]string) bool {
  1573  	if a == nil && b == nil {
  1574  		return true
  1575  	}
  1576  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1577  		return false
  1578  	}
  1579  	for k, v := range a {
  1580  		v1, ok := b[k]
  1581  		if !ok || v != v1 {
  1582  			return false
  1583  		}
  1584  	}
  1585  	return true
  1586  }
  1587  
  1588  func EqualStringUintMap(a, b map[string]uint) bool {
  1589  	if a == nil && b == nil {
  1590  		return true
  1591  	}
  1592  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1593  		return false
  1594  	}
  1595  	for k, v := range a {
  1596  		v1, ok := b[k]
  1597  		if !ok || v != v1 {
  1598  			return false
  1599  		}
  1600  	}
  1601  	return true
  1602  }
  1603  
  1604  func EqualStringUint16Map(a, b map[string]uint16) bool {
  1605  	if a == nil && b == nil {
  1606  		return true
  1607  	}
  1608  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1609  		return false
  1610  	}
  1611  	for k, v := range a {
  1612  		v1, ok := b[k]
  1613  		if !ok || v != v1 {
  1614  			return false
  1615  		}
  1616  	}
  1617  	return true
  1618  }
  1619  
  1620  func EqualStringUint32Map(a, b map[string]uint32) bool {
  1621  	if a == nil && b == nil {
  1622  		return true
  1623  	}
  1624  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1625  		return false
  1626  	}
  1627  	for k, v := range a {
  1628  		v1, ok := b[k]
  1629  		if !ok || v != v1 {
  1630  			return false
  1631  		}
  1632  	}
  1633  	return true
  1634  }
  1635  
  1636  func EqualStringUint64Map(a, b map[string]uint64) bool {
  1637  	if a == nil && b == nil {
  1638  		return true
  1639  	}
  1640  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1641  		return false
  1642  	}
  1643  	for k, v := range a {
  1644  		v1, ok := b[k]
  1645  		if !ok || v != v1 {
  1646  			return false
  1647  		}
  1648  	}
  1649  	return true
  1650  }
  1651  
  1652  func EqualStringUint8Map(a, b map[string]uint8) bool {
  1653  	if a == nil && b == nil {
  1654  		return true
  1655  	}
  1656  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1657  		return false
  1658  	}
  1659  	for k, v := range a {
  1660  		v1, ok := b[k]
  1661  		if !ok || v != v1 {
  1662  			return false
  1663  		}
  1664  	}
  1665  	return true
  1666  }
  1667  
  1668  func EqualUintFloat32Map(a, b map[uint]float32) bool {
  1669  	if a == nil && b == nil {
  1670  		return true
  1671  	}
  1672  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1673  		return false
  1674  	}
  1675  	for k, v := range a {
  1676  		v1, ok := b[k]
  1677  		if !ok || v != v1 {
  1678  			return false
  1679  		}
  1680  	}
  1681  	return true
  1682  }
  1683  
  1684  func EqualUintFloat64Map(a, b map[uint]float64) bool {
  1685  	if a == nil && b == nil {
  1686  		return true
  1687  	}
  1688  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1689  		return false
  1690  	}
  1691  	for k, v := range a {
  1692  		v1, ok := b[k]
  1693  		if !ok || v != v1 {
  1694  			return false
  1695  		}
  1696  	}
  1697  	return true
  1698  }
  1699  
  1700  func EqualUintIntMap(a, b map[uint]int) bool {
  1701  	if a == nil && b == nil {
  1702  		return true
  1703  	}
  1704  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1705  		return false
  1706  	}
  1707  	for k, v := range a {
  1708  		v1, ok := b[k]
  1709  		if !ok || v != v1 {
  1710  			return false
  1711  		}
  1712  	}
  1713  	return true
  1714  }
  1715  
  1716  func EqualUintInt16Map(a, b map[uint]int16) bool {
  1717  	if a == nil && b == nil {
  1718  		return true
  1719  	}
  1720  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1721  		return false
  1722  	}
  1723  	for k, v := range a {
  1724  		v1, ok := b[k]
  1725  		if !ok || v != v1 {
  1726  			return false
  1727  		}
  1728  	}
  1729  	return true
  1730  }
  1731  
  1732  func EqualUintInt32Map(a, b map[uint]int32) bool {
  1733  	if a == nil && b == nil {
  1734  		return true
  1735  	}
  1736  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1737  		return false
  1738  	}
  1739  	for k, v := range a {
  1740  		v1, ok := b[k]
  1741  		if !ok || v != v1 {
  1742  			return false
  1743  		}
  1744  	}
  1745  	return true
  1746  }
  1747  
  1748  func EqualUintInt64Map(a, b map[uint]int64) bool {
  1749  	if a == nil && b == nil {
  1750  		return true
  1751  	}
  1752  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1753  		return false
  1754  	}
  1755  	for k, v := range a {
  1756  		v1, ok := b[k]
  1757  		if !ok || v != v1 {
  1758  			return false
  1759  		}
  1760  	}
  1761  	return true
  1762  }
  1763  
  1764  func EqualUintInt8Map(a, b map[uint]int8) bool {
  1765  	if a == nil && b == nil {
  1766  		return true
  1767  	}
  1768  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1769  		return false
  1770  	}
  1771  	for k, v := range a {
  1772  		v1, ok := b[k]
  1773  		if !ok || v != v1 {
  1774  			return false
  1775  		}
  1776  	}
  1777  	return true
  1778  }
  1779  
  1780  func EqualUintStringMap(a, b map[uint]string) bool {
  1781  	if a == nil && b == nil {
  1782  		return true
  1783  	}
  1784  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1785  		return false
  1786  	}
  1787  	for k, v := range a {
  1788  		v1, ok := b[k]
  1789  		if !ok || v != v1 {
  1790  			return false
  1791  		}
  1792  	}
  1793  	return true
  1794  }
  1795  
  1796  func EqualUintUintMap(a, b map[uint]uint) bool {
  1797  	if a == nil && b == nil {
  1798  		return true
  1799  	}
  1800  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1801  		return false
  1802  	}
  1803  	for k, v := range a {
  1804  		v1, ok := b[k]
  1805  		if !ok || v != v1 {
  1806  			return false
  1807  		}
  1808  	}
  1809  	return true
  1810  }
  1811  
  1812  func EqualUintUint16Map(a, b map[uint]uint16) bool {
  1813  	if a == nil && b == nil {
  1814  		return true
  1815  	}
  1816  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1817  		return false
  1818  	}
  1819  	for k, v := range a {
  1820  		v1, ok := b[k]
  1821  		if !ok || v != v1 {
  1822  			return false
  1823  		}
  1824  	}
  1825  	return true
  1826  }
  1827  
  1828  func EqualUintUint32Map(a, b map[uint]uint32) bool {
  1829  	if a == nil && b == nil {
  1830  		return true
  1831  	}
  1832  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1833  		return false
  1834  	}
  1835  	for k, v := range a {
  1836  		v1, ok := b[k]
  1837  		if !ok || v != v1 {
  1838  			return false
  1839  		}
  1840  	}
  1841  	return true
  1842  }
  1843  
  1844  func EqualUintUint64Map(a, b map[uint]uint64) bool {
  1845  	if a == nil && b == nil {
  1846  		return true
  1847  	}
  1848  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1849  		return false
  1850  	}
  1851  	for k, v := range a {
  1852  		v1, ok := b[k]
  1853  		if !ok || v != v1 {
  1854  			return false
  1855  		}
  1856  	}
  1857  	return true
  1858  }
  1859  
  1860  func EqualUintUint8Map(a, b map[uint]uint8) bool {
  1861  	if a == nil && b == nil {
  1862  		return true
  1863  	}
  1864  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1865  		return false
  1866  	}
  1867  	for k, v := range a {
  1868  		v1, ok := b[k]
  1869  		if !ok || v != v1 {
  1870  			return false
  1871  		}
  1872  	}
  1873  	return true
  1874  }
  1875  
  1876  func EqualUint16Float32Map(a, b map[uint16]float32) bool {
  1877  	if a == nil && b == nil {
  1878  		return true
  1879  	}
  1880  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1881  		return false
  1882  	}
  1883  	for k, v := range a {
  1884  		v1, ok := b[k]
  1885  		if !ok || v != v1 {
  1886  			return false
  1887  		}
  1888  	}
  1889  	return true
  1890  }
  1891  
  1892  func EqualUint16Float64Map(a, b map[uint16]float64) bool {
  1893  	if a == nil && b == nil {
  1894  		return true
  1895  	}
  1896  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1897  		return false
  1898  	}
  1899  	for k, v := range a {
  1900  		v1, ok := b[k]
  1901  		if !ok || v != v1 {
  1902  			return false
  1903  		}
  1904  	}
  1905  	return true
  1906  }
  1907  
  1908  func EqualUint16IntMap(a, b map[uint16]int) bool {
  1909  	if a == nil && b == nil {
  1910  		return true
  1911  	}
  1912  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1913  		return false
  1914  	}
  1915  	for k, v := range a {
  1916  		v1, ok := b[k]
  1917  		if !ok || v != v1 {
  1918  			return false
  1919  		}
  1920  	}
  1921  	return true
  1922  }
  1923  
  1924  func EqualUint16Int16Map(a, b map[uint16]int16) bool {
  1925  	if a == nil && b == nil {
  1926  		return true
  1927  	}
  1928  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1929  		return false
  1930  	}
  1931  	for k, v := range a {
  1932  		v1, ok := b[k]
  1933  		if !ok || v != v1 {
  1934  			return false
  1935  		}
  1936  	}
  1937  	return true
  1938  }
  1939  
  1940  func EqualUint16Int32Map(a, b map[uint16]int32) bool {
  1941  	if a == nil && b == nil {
  1942  		return true
  1943  	}
  1944  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1945  		return false
  1946  	}
  1947  	for k, v := range a {
  1948  		v1, ok := b[k]
  1949  		if !ok || v != v1 {
  1950  			return false
  1951  		}
  1952  	}
  1953  	return true
  1954  }
  1955  
  1956  func EqualUint16Int64Map(a, b map[uint16]int64) bool {
  1957  	if a == nil && b == nil {
  1958  		return true
  1959  	}
  1960  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1961  		return false
  1962  	}
  1963  	for k, v := range a {
  1964  		v1, ok := b[k]
  1965  		if !ok || v != v1 {
  1966  			return false
  1967  		}
  1968  	}
  1969  	return true
  1970  }
  1971  
  1972  func EqualUint16Int8Map(a, b map[uint16]int8) bool {
  1973  	if a == nil && b == nil {
  1974  		return true
  1975  	}
  1976  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1977  		return false
  1978  	}
  1979  	for k, v := range a {
  1980  		v1, ok := b[k]
  1981  		if !ok || v != v1 {
  1982  			return false
  1983  		}
  1984  	}
  1985  	return true
  1986  }
  1987  
  1988  func EqualUint16StringMap(a, b map[uint16]string) bool {
  1989  	if a == nil && b == nil {
  1990  		return true
  1991  	}
  1992  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  1993  		return false
  1994  	}
  1995  	for k, v := range a {
  1996  		v1, ok := b[k]
  1997  		if !ok || v != v1 {
  1998  			return false
  1999  		}
  2000  	}
  2001  	return true
  2002  }
  2003  
  2004  func EqualUint16UintMap(a, b map[uint16]uint) bool {
  2005  	if a == nil && b == nil {
  2006  		return true
  2007  	}
  2008  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2009  		return false
  2010  	}
  2011  	for k, v := range a {
  2012  		v1, ok := b[k]
  2013  		if !ok || v != v1 {
  2014  			return false
  2015  		}
  2016  	}
  2017  	return true
  2018  }
  2019  
  2020  func EqualUint16Uint16Map(a, b map[uint16]uint16) bool {
  2021  	if a == nil && b == nil {
  2022  		return true
  2023  	}
  2024  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2025  		return false
  2026  	}
  2027  	for k, v := range a {
  2028  		v1, ok := b[k]
  2029  		if !ok || v != v1 {
  2030  			return false
  2031  		}
  2032  	}
  2033  	return true
  2034  }
  2035  
  2036  func EqualUint16Uint32Map(a, b map[uint16]uint32) bool {
  2037  	if a == nil && b == nil {
  2038  		return true
  2039  	}
  2040  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2041  		return false
  2042  	}
  2043  	for k, v := range a {
  2044  		v1, ok := b[k]
  2045  		if !ok || v != v1 {
  2046  			return false
  2047  		}
  2048  	}
  2049  	return true
  2050  }
  2051  
  2052  func EqualUint16Uint64Map(a, b map[uint16]uint64) bool {
  2053  	if a == nil && b == nil {
  2054  		return true
  2055  	}
  2056  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2057  		return false
  2058  	}
  2059  	for k, v := range a {
  2060  		v1, ok := b[k]
  2061  		if !ok || v != v1 {
  2062  			return false
  2063  		}
  2064  	}
  2065  	return true
  2066  }
  2067  
  2068  func EqualUint16Uint8Map(a, b map[uint16]uint8) bool {
  2069  	if a == nil && b == nil {
  2070  		return true
  2071  	}
  2072  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2073  		return false
  2074  	}
  2075  	for k, v := range a {
  2076  		v1, ok := b[k]
  2077  		if !ok || v != v1 {
  2078  			return false
  2079  		}
  2080  	}
  2081  	return true
  2082  }
  2083  
  2084  func EqualUint32Float32Map(a, b map[uint32]float32) bool {
  2085  	if a == nil && b == nil {
  2086  		return true
  2087  	}
  2088  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2089  		return false
  2090  	}
  2091  	for k, v := range a {
  2092  		v1, ok := b[k]
  2093  		if !ok || v != v1 {
  2094  			return false
  2095  		}
  2096  	}
  2097  	return true
  2098  }
  2099  
  2100  func EqualUint32Float64Map(a, b map[uint32]float64) bool {
  2101  	if a == nil && b == nil {
  2102  		return true
  2103  	}
  2104  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2105  		return false
  2106  	}
  2107  	for k, v := range a {
  2108  		v1, ok := b[k]
  2109  		if !ok || v != v1 {
  2110  			return false
  2111  		}
  2112  	}
  2113  	return true
  2114  }
  2115  
  2116  func EqualUint32IntMap(a, b map[uint32]int) bool {
  2117  	if a == nil && b == nil {
  2118  		return true
  2119  	}
  2120  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2121  		return false
  2122  	}
  2123  	for k, v := range a {
  2124  		v1, ok := b[k]
  2125  		if !ok || v != v1 {
  2126  			return false
  2127  		}
  2128  	}
  2129  	return true
  2130  }
  2131  
  2132  func EqualUint32Int16Map(a, b map[uint32]int16) bool {
  2133  	if a == nil && b == nil {
  2134  		return true
  2135  	}
  2136  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2137  		return false
  2138  	}
  2139  	for k, v := range a {
  2140  		v1, ok := b[k]
  2141  		if !ok || v != v1 {
  2142  			return false
  2143  		}
  2144  	}
  2145  	return true
  2146  }
  2147  
  2148  func EqualUint32Int32Map(a, b map[uint32]int32) bool {
  2149  	if a == nil && b == nil {
  2150  		return true
  2151  	}
  2152  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2153  		return false
  2154  	}
  2155  	for k, v := range a {
  2156  		v1, ok := b[k]
  2157  		if !ok || v != v1 {
  2158  			return false
  2159  		}
  2160  	}
  2161  	return true
  2162  }
  2163  
  2164  func EqualUint32Int64Map(a, b map[uint32]int64) bool {
  2165  	if a == nil && b == nil {
  2166  		return true
  2167  	}
  2168  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2169  		return false
  2170  	}
  2171  	for k, v := range a {
  2172  		v1, ok := b[k]
  2173  		if !ok || v != v1 {
  2174  			return false
  2175  		}
  2176  	}
  2177  	return true
  2178  }
  2179  
  2180  func EqualUint32Int8Map(a, b map[uint32]int8) bool {
  2181  	if a == nil && b == nil {
  2182  		return true
  2183  	}
  2184  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2185  		return false
  2186  	}
  2187  	for k, v := range a {
  2188  		v1, ok := b[k]
  2189  		if !ok || v != v1 {
  2190  			return false
  2191  		}
  2192  	}
  2193  	return true
  2194  }
  2195  
  2196  func EqualUint32StringMap(a, b map[uint32]string) bool {
  2197  	if a == nil && b == nil {
  2198  		return true
  2199  	}
  2200  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2201  		return false
  2202  	}
  2203  	for k, v := range a {
  2204  		v1, ok := b[k]
  2205  		if !ok || v != v1 {
  2206  			return false
  2207  		}
  2208  	}
  2209  	return true
  2210  }
  2211  
  2212  func EqualUint32UintMap(a, b map[uint32]uint) bool {
  2213  	if a == nil && b == nil {
  2214  		return true
  2215  	}
  2216  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2217  		return false
  2218  	}
  2219  	for k, v := range a {
  2220  		v1, ok := b[k]
  2221  		if !ok || v != v1 {
  2222  			return false
  2223  		}
  2224  	}
  2225  	return true
  2226  }
  2227  
  2228  func EqualUint32Uint16Map(a, b map[uint32]uint16) bool {
  2229  	if a == nil && b == nil {
  2230  		return true
  2231  	}
  2232  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2233  		return false
  2234  	}
  2235  	for k, v := range a {
  2236  		v1, ok := b[k]
  2237  		if !ok || v != v1 {
  2238  			return false
  2239  		}
  2240  	}
  2241  	return true
  2242  }
  2243  
  2244  func EqualUint32Uint32Map(a, b map[uint32]uint32) bool {
  2245  	if a == nil && b == nil {
  2246  		return true
  2247  	}
  2248  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2249  		return false
  2250  	}
  2251  	for k, v := range a {
  2252  		v1, ok := b[k]
  2253  		if !ok || v != v1 {
  2254  			return false
  2255  		}
  2256  	}
  2257  	return true
  2258  }
  2259  
  2260  func EqualUint32Uint64Map(a, b map[uint32]uint64) bool {
  2261  	if a == nil && b == nil {
  2262  		return true
  2263  	}
  2264  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2265  		return false
  2266  	}
  2267  	for k, v := range a {
  2268  		v1, ok := b[k]
  2269  		if !ok || v != v1 {
  2270  			return false
  2271  		}
  2272  	}
  2273  	return true
  2274  }
  2275  
  2276  func EqualUint32Uint8Map(a, b map[uint32]uint8) bool {
  2277  	if a == nil && b == nil {
  2278  		return true
  2279  	}
  2280  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2281  		return false
  2282  	}
  2283  	for k, v := range a {
  2284  		v1, ok := b[k]
  2285  		if !ok || v != v1 {
  2286  			return false
  2287  		}
  2288  	}
  2289  	return true
  2290  }
  2291  
  2292  func EqualUint64Float32Map(a, b map[uint64]float32) bool {
  2293  	if a == nil && b == nil {
  2294  		return true
  2295  	}
  2296  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2297  		return false
  2298  	}
  2299  	for k, v := range a {
  2300  		v1, ok := b[k]
  2301  		if !ok || v != v1 {
  2302  			return false
  2303  		}
  2304  	}
  2305  	return true
  2306  }
  2307  
  2308  func EqualUint64Float64Map(a, b map[uint64]float64) bool {
  2309  	if a == nil && b == nil {
  2310  		return true
  2311  	}
  2312  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2313  		return false
  2314  	}
  2315  	for k, v := range a {
  2316  		v1, ok := b[k]
  2317  		if !ok || v != v1 {
  2318  			return false
  2319  		}
  2320  	}
  2321  	return true
  2322  }
  2323  
  2324  func EqualUint64IntMap(a, b map[uint64]int) bool {
  2325  	if a == nil && b == nil {
  2326  		return true
  2327  	}
  2328  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2329  		return false
  2330  	}
  2331  	for k, v := range a {
  2332  		v1, ok := b[k]
  2333  		if !ok || v != v1 {
  2334  			return false
  2335  		}
  2336  	}
  2337  	return true
  2338  }
  2339  
  2340  func EqualUint64Int16Map(a, b map[uint64]int16) bool {
  2341  	if a == nil && b == nil {
  2342  		return true
  2343  	}
  2344  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2345  		return false
  2346  	}
  2347  	for k, v := range a {
  2348  		v1, ok := b[k]
  2349  		if !ok || v != v1 {
  2350  			return false
  2351  		}
  2352  	}
  2353  	return true
  2354  }
  2355  
  2356  func EqualUint64Int32Map(a, b map[uint64]int32) bool {
  2357  	if a == nil && b == nil {
  2358  		return true
  2359  	}
  2360  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2361  		return false
  2362  	}
  2363  	for k, v := range a {
  2364  		v1, ok := b[k]
  2365  		if !ok || v != v1 {
  2366  			return false
  2367  		}
  2368  	}
  2369  	return true
  2370  }
  2371  
  2372  func EqualUint64Int64Map(a, b map[uint64]int64) bool {
  2373  	if a == nil && b == nil {
  2374  		return true
  2375  	}
  2376  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2377  		return false
  2378  	}
  2379  	for k, v := range a {
  2380  		v1, ok := b[k]
  2381  		if !ok || v != v1 {
  2382  			return false
  2383  		}
  2384  	}
  2385  	return true
  2386  }
  2387  
  2388  func EqualUint64Int8Map(a, b map[uint64]int8) bool {
  2389  	if a == nil && b == nil {
  2390  		return true
  2391  	}
  2392  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2393  		return false
  2394  	}
  2395  	for k, v := range a {
  2396  		v1, ok := b[k]
  2397  		if !ok || v != v1 {
  2398  			return false
  2399  		}
  2400  	}
  2401  	return true
  2402  }
  2403  
  2404  func EqualUint64StringMap(a, b map[uint64]string) bool {
  2405  	if a == nil && b == nil {
  2406  		return true
  2407  	}
  2408  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2409  		return false
  2410  	}
  2411  	for k, v := range a {
  2412  		v1, ok := b[k]
  2413  		if !ok || v != v1 {
  2414  			return false
  2415  		}
  2416  	}
  2417  	return true
  2418  }
  2419  
  2420  func EqualUint64UintMap(a, b map[uint64]uint) bool {
  2421  	if a == nil && b == nil {
  2422  		return true
  2423  	}
  2424  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2425  		return false
  2426  	}
  2427  	for k, v := range a {
  2428  		v1, ok := b[k]
  2429  		if !ok || v != v1 {
  2430  			return false
  2431  		}
  2432  	}
  2433  	return true
  2434  }
  2435  
  2436  func EqualUint64Uint16Map(a, b map[uint64]uint16) bool {
  2437  	if a == nil && b == nil {
  2438  		return true
  2439  	}
  2440  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2441  		return false
  2442  	}
  2443  	for k, v := range a {
  2444  		v1, ok := b[k]
  2445  		if !ok || v != v1 {
  2446  			return false
  2447  		}
  2448  	}
  2449  	return true
  2450  }
  2451  
  2452  func EqualUint64Uint32Map(a, b map[uint64]uint32) bool {
  2453  	if a == nil && b == nil {
  2454  		return true
  2455  	}
  2456  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2457  		return false
  2458  	}
  2459  	for k, v := range a {
  2460  		v1, ok := b[k]
  2461  		if !ok || v != v1 {
  2462  			return false
  2463  		}
  2464  	}
  2465  	return true
  2466  }
  2467  
  2468  func EqualUint64Uint64Map(a, b map[uint64]uint64) bool {
  2469  	if a == nil && b == nil {
  2470  		return true
  2471  	}
  2472  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2473  		return false
  2474  	}
  2475  	for k, v := range a {
  2476  		v1, ok := b[k]
  2477  		if !ok || v != v1 {
  2478  			return false
  2479  		}
  2480  	}
  2481  	return true
  2482  }
  2483  
  2484  func EqualUint64Uint8Map(a, b map[uint64]uint8) bool {
  2485  	if a == nil && b == nil {
  2486  		return true
  2487  	}
  2488  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2489  		return false
  2490  	}
  2491  	for k, v := range a {
  2492  		v1, ok := b[k]
  2493  		if !ok || v != v1 {
  2494  			return false
  2495  		}
  2496  	}
  2497  	return true
  2498  }
  2499  
  2500  func EqualUint8Float32Map(a, b map[uint8]float32) bool {
  2501  	if a == nil && b == nil {
  2502  		return true
  2503  	}
  2504  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2505  		return false
  2506  	}
  2507  	for k, v := range a {
  2508  		v1, ok := b[k]
  2509  		if !ok || v != v1 {
  2510  			return false
  2511  		}
  2512  	}
  2513  	return true
  2514  }
  2515  
  2516  func EqualUint8Float64Map(a, b map[uint8]float64) bool {
  2517  	if a == nil && b == nil {
  2518  		return true
  2519  	}
  2520  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2521  		return false
  2522  	}
  2523  	for k, v := range a {
  2524  		v1, ok := b[k]
  2525  		if !ok || v != v1 {
  2526  			return false
  2527  		}
  2528  	}
  2529  	return true
  2530  }
  2531  
  2532  func EqualUint8IntMap(a, b map[uint8]int) bool {
  2533  	if a == nil && b == nil {
  2534  		return true
  2535  	}
  2536  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2537  		return false
  2538  	}
  2539  	for k, v := range a {
  2540  		v1, ok := b[k]
  2541  		if !ok || v != v1 {
  2542  			return false
  2543  		}
  2544  	}
  2545  	return true
  2546  }
  2547  
  2548  func EqualUint8Int16Map(a, b map[uint8]int16) bool {
  2549  	if a == nil && b == nil {
  2550  		return true
  2551  	}
  2552  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2553  		return false
  2554  	}
  2555  	for k, v := range a {
  2556  		v1, ok := b[k]
  2557  		if !ok || v != v1 {
  2558  			return false
  2559  		}
  2560  	}
  2561  	return true
  2562  }
  2563  
  2564  func EqualUint8Int32Map(a, b map[uint8]int32) bool {
  2565  	if a == nil && b == nil {
  2566  		return true
  2567  	}
  2568  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2569  		return false
  2570  	}
  2571  	for k, v := range a {
  2572  		v1, ok := b[k]
  2573  		if !ok || v != v1 {
  2574  			return false
  2575  		}
  2576  	}
  2577  	return true
  2578  }
  2579  
  2580  func EqualUint8Int64Map(a, b map[uint8]int64) bool {
  2581  	if a == nil && b == nil {
  2582  		return true
  2583  	}
  2584  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2585  		return false
  2586  	}
  2587  	for k, v := range a {
  2588  		v1, ok := b[k]
  2589  		if !ok || v != v1 {
  2590  			return false
  2591  		}
  2592  	}
  2593  	return true
  2594  }
  2595  
  2596  func EqualUint8Int8Map(a, b map[uint8]int8) bool {
  2597  	if a == nil && b == nil {
  2598  		return true
  2599  	}
  2600  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2601  		return false
  2602  	}
  2603  	for k, v := range a {
  2604  		v1, ok := b[k]
  2605  		if !ok || v != v1 {
  2606  			return false
  2607  		}
  2608  	}
  2609  	return true
  2610  }
  2611  
  2612  func EqualUint8StringMap(a, b map[uint8]string) bool {
  2613  	if a == nil && b == nil {
  2614  		return true
  2615  	}
  2616  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2617  		return false
  2618  	}
  2619  	for k, v := range a {
  2620  		v1, ok := b[k]
  2621  		if !ok || v != v1 {
  2622  			return false
  2623  		}
  2624  	}
  2625  	return true
  2626  }
  2627  
  2628  func EqualUint8UintMap(a, b map[uint8]uint) bool {
  2629  	if a == nil && b == nil {
  2630  		return true
  2631  	}
  2632  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2633  		return false
  2634  	}
  2635  	for k, v := range a {
  2636  		v1, ok := b[k]
  2637  		if !ok || v != v1 {
  2638  			return false
  2639  		}
  2640  	}
  2641  	return true
  2642  }
  2643  
  2644  func EqualUint8Uint16Map(a, b map[uint8]uint16) bool {
  2645  	if a == nil && b == nil {
  2646  		return true
  2647  	}
  2648  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2649  		return false
  2650  	}
  2651  	for k, v := range a {
  2652  		v1, ok := b[k]
  2653  		if !ok || v != v1 {
  2654  			return false
  2655  		}
  2656  	}
  2657  	return true
  2658  }
  2659  
  2660  func EqualUint8Uint32Map(a, b map[uint8]uint32) bool {
  2661  	if a == nil && b == nil {
  2662  		return true
  2663  	}
  2664  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2665  		return false
  2666  	}
  2667  	for k, v := range a {
  2668  		v1, ok := b[k]
  2669  		if !ok || v != v1 {
  2670  			return false
  2671  		}
  2672  	}
  2673  	return true
  2674  }
  2675  
  2676  func EqualUint8Uint64Map(a, b map[uint8]uint64) bool {
  2677  	if a == nil && b == nil {
  2678  		return true
  2679  	}
  2680  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2681  		return false
  2682  	}
  2683  	for k, v := range a {
  2684  		v1, ok := b[k]
  2685  		if !ok || v != v1 {
  2686  			return false
  2687  		}
  2688  	}
  2689  	return true
  2690  }
  2691  
  2692  func EqualUint8Uint8Map(a, b map[uint8]uint8) bool {
  2693  	if a == nil && b == nil {
  2694  		return true
  2695  	}
  2696  	if (a != nil && b == nil) || (b != nil && a == nil) || (len(a) != len(b)) {
  2697  		return false
  2698  	}
  2699  	for k, v := range a {
  2700  		v1, ok := b[k]
  2701  		if !ok || v != v1 {
  2702  			return false
  2703  		}
  2704  	}
  2705  	return true
  2706  }