github.com/egonelbre/exp@v0.0.0-20240430123955-ed1d3aa93911/brutecheck/check/twohashshift.go (about)

     1  package check
     2  
     3  func TwoHash_XorXor_Shift015(name string) bool {
     4  	if len(name) < 2 {
     5  		return false
     6  	}
     7  	switch ((byte(len(name)) << 0) ^ (name[0] << 1)) ^ (name[1] << 5) {
     8  	case 0:
     9  		return name == "switch"
    10  	case 16:
    11  		return name == "if"
    12  	case 27:
    13  		return name == "interface"
    14  	case 35:
    15  		return name == "const"
    16  	case 42:
    17  		return name == "goto"
    18  	case 44:
    19  		return name == "go"
    20  	case 46:
    21  		return name == "continue"
    22  	case 47:
    23  		return name == "for"
    24  	case 64:
    25  		return name == "select"
    26  	case 66:
    27  		return name == "return"
    28  	case 78:
    29  		return name == "else"
    30  	case 96:
    31  		return name == "struct"
    32  	case 104:
    33  		return name == "func"
    34  	case 109:
    35  		return name == "defer"
    36  	case 111:
    37  		return name == "default"
    38  	case 116:
    39  		return name == "import"
    40  	case 129:
    41  		return name == "break"
    42  	case 193:
    43  		return name == "range"
    44  	case 194:
    45  		return name == "chan"
    46  	case 199:
    47  		return name == "package"
    48  	case 204:
    49  		return name == "type"
    50  	case 207:
    51  		return name == "var"
    52  	case 226:
    53  		return name == "case"
    54  	case 231:
    55  		return name == "fallthrough"
    56  	case 249:
    57  		return name == "map"
    58  	}
    59  	return false
    60  }
    61  
    62  func TwoHash_XorXor_Shift016(name string) bool {
    63  	if len(name) < 2 {
    64  		return false
    65  	}
    66  	switch ((byte(len(name)) << 0) ^ (name[0] << 1)) ^ (name[1] << 6) {
    67  	case 3:
    68  		return name == "const"
    69  	case 10:
    70  		return name == "goto"
    71  	case 12:
    72  		return name == "go"
    73  	case 14:
    74  		return name == "continue"
    75  	case 15:
    76  		return name == "for"
    77  	case 32:
    78  		return name == "switch"
    79  	case 65:
    80  		return name == "break"
    81  	case 80:
    82  		return name == "if"
    83  	case 91:
    84  		return name == "interface"
    85  	case 130:
    86  		return name == "case"
    87  	case 135:
    88  		return name == "fallthrough"
    89  	case 136:
    90  		return name == "func"
    91  	case 141:
    92  		return name == "defer"
    93  	case 143:
    94  		return name == "default"
    95  	case 148:
    96  		return name == "import"
    97  	case 153:
    98  		return name == "map"
    99  	case 160:
   100  		return name == "select"
   101  	case 161:
   102  		return name == "range"
   103  	case 162:
   104  		return name == "return"
   105  	case 167:
   106  		return name == "package"
   107  	case 172:
   108  		return name == "type"
   109  	case 175:
   110  		return name == "var"
   111  	case 194:
   112  		return name == "chan"
   113  	case 206:
   114  		return name == "else"
   115  	case 224:
   116  		return name == "struct"
   117  	}
   118  	return false
   119  }
   120  
   121  func TwoHash_XorXor_Shift021(name string) bool {
   122  	if len(name) < 2 {
   123  		return false
   124  	}
   125  	switch ((byte(len(name)) << 0) ^ (name[0] << 2)) ^ (name[1] << 1) {
   126  	case 0:
   127  		return name == "select"
   128  	case 4:
   129  		return name == "return"
   130  	case 5:
   131  		return name == "package"
   132  	case 15:
   133  		return name == "range"
   134  	case 25:
   135  		return name == "var"
   136  	case 34:
   137  		return name == "struct"
   138  	case 36:
   139  		return name == "switch"
   140  	case 38:
   141  		return name == "type"
   142  	case 64:
   143  		return name == "go"
   144  	case 69:
   145  		return name == "for"
   146  	case 70:
   147  		return name == "goto"
   148  	case 72:
   149  		return name == "else"
   150  	case 74:
   151  		return name == "case"
   152  	case 81:
   153  		return name == "fallthrough"
   154  	case 87:
   155  		return name == "const"
   156  	case 88:
   157  		return name == "chan"
   158  	case 90:
   159  		return name == "continue"
   160  	case 93:
   161  		return name == "default"
   162  	case 95:
   163  		return name == "defer"
   164  	case 105:
   165  		return name == "break"
   166  	case 106:
   167  		return name == "if"
   168  	case 113:
   169  		return name == "interface"
   170  	case 117:
   171  		return name == "map"
   172  	case 118:
   173  		return name == "func"
   174  	case 120:
   175  		return name == "import"
   176  	}
   177  	return false
   178  }
   179  
   180  func TwoHash_XorXor_Shift024(name string) bool {
   181  	if len(name) < 2 {
   182  		return false
   183  	}
   184  	switch ((byte(len(name)) << 0) ^ (name[0] << 2)) ^ (name[1] << 4) {
   185  	case 8:
   186  		return name == "chan"
   187  	case 68:
   188  		return name == "type"
   189  	case 77:
   190  		return name == "interface"
   191  	case 80:
   192  		return name == "else"
   193  	case 104:
   194  		return name == "goto"
   195  	case 107:
   196  		return name == "for"
   197  	case 110:
   198  		return name == "go"
   199  	case 114:
   200  		return name == "import"
   201  	case 116:
   202  		return name == "continue"
   203  	case 121:
   204  		return name == "const"
   205  	case 131:
   206  		return name == "fallthrough"
   207  	case 138:
   208  		return name == "struct"
   209  	case 152:
   210  		return name == "case"
   211  	case 154:
   212  		return name == "select"
   213  	case 158:
   214  		return name == "return"
   215  	case 167:
   216  		return name == "map"
   217  	case 173:
   218  		return name == "break"
   219  	case 186:
   220  		return name == "switch"
   221  	case 197:
   222  		return name == "defer"
   223  	case 198:
   224  		return name == "if"
   225  	case 199:
   226  		return name == "default"
   227  	case 203:
   228  		return name == "var"
   229  	case 204:
   230  		return name == "func"
   231  	case 215:
   232  		return name == "package"
   233  	case 221:
   234  		return name == "range"
   235  	}
   236  	return false
   237  }
   238  
   239  func TwoHash_XorXor_Shift025(name string) bool {
   240  	if len(name) < 2 {
   241  		return false
   242  	}
   243  	switch ((byte(len(name)) << 0) ^ (name[0] << 2)) ^ (name[1] << 5) {
   244  	case 2:
   245  		return name == "import"
   246  	case 16:
   247  		return name == "else"
   248  	case 42:
   249  		return name == "switch"
   250  	case 53:
   251  		return name == "defer"
   252  	case 55:
   253  		return name == "default"
   254  	case 60:
   255  		return name == "func"
   256  	case 74:
   257  		return name == "struct"
   258  	case 100:
   259  		return name == "continue"
   260  	case 102:
   261  		return name == "if"
   262  	case 105:
   263  		return name == "const"
   264  	case 106:
   265  		return name == "select"
   266  	case 109:
   267  		return name == "interface"
   268  	case 110:
   269  		return name == "return"
   270  	case 120:
   271  		return name == "goto"
   272  	case 123:
   273  		return name == "for"
   274  	case 126:
   275  		return name == "go"
   276  	case 136:
   277  		return name == "chan"
   278  	case 151:
   279  		return name == "map"
   280  	case 168:
   281  		return name == "case"
   282  	case 179:
   283  		return name == "fallthrough"
   284  	case 205:
   285  		return name == "break"
   286  	case 231:
   287  		return name == "package"
   288  	case 237:
   289  		return name == "range"
   290  	case 244:
   291  		return name == "type"
   292  	case 251:
   293  		return name == "var"
   294  	}
   295  	return false
   296  }
   297  
   298  func TwoHash_XorXor_Shift026(name string) bool {
   299  	if len(name) < 2 {
   300  		return false
   301  	}
   302  	switch ((byte(len(name)) << 0) ^ (name[0] << 2)) ^ (name[1] << 6) {
   303  	case 10:
   304  		return name == "switch"
   305  	case 13:
   306  		return name == "break"
   307  	case 38:
   308  		return name == "if"
   309  	case 45:
   310  		return name == "interface"
   311  	case 68:
   312  		return name == "continue"
   313  	case 73:
   314  		return name == "const"
   315  	case 88:
   316  		return name == "goto"
   317  	case 91:
   318  		return name == "for"
   319  	case 94:
   320  		return name == "go"
   321  	case 135:
   322  		return name == "package"
   323  	case 136:
   324  		return name == "chan"
   325  	case 138:
   326  		return name == "select"
   327  	case 141:
   328  		return name == "range"
   329  	case 142:
   330  		return name == "return"
   331  	case 144:
   332  		return name == "else"
   333  	case 148:
   334  		return name == "type"
   335  	case 155:
   336  		return name == "var"
   337  	case 200:
   338  		return name == "case"
   339  	case 202:
   340  		return name == "struct"
   341  	case 211:
   342  		return name == "fallthrough"
   343  	case 213:
   344  		return name == "defer"
   345  	case 215:
   346  		return name == "default"
   347  	case 220:
   348  		return name == "func"
   349  	case 226:
   350  		return name == "import"
   351  	case 247:
   352  		return name == "map"
   353  	}
   354  	return false
   355  }
   356  
   357  func TwoHash_XorXor_Shift032(name string) bool {
   358  	if len(name) < 2 {
   359  		return false
   360  	}
   361  	switch ((byte(len(name)) << 0) ^ (name[0] << 3)) ^ (name[1] << 2) {
   362  	case 2:
   363  		return name == "return"
   364  	case 3:
   365  		return name == "package"
   366  	case 10:
   367  		return name == "select"
   368  	case 17:
   369  		return name == "range"
   370  	case 55:
   371  		return name == "var"
   372  	case 64:
   373  		return name == "type"
   374  	case 66:
   375  		return name == "switch"
   376  	case 78:
   377  		return name == "struct"
   378  	case 128:
   379  		return name == "goto"
   380  	case 134:
   381  		return name == "go"
   382  	case 143:
   383  		return name == "for"
   384  	case 152:
   385  		return name == "case"
   386  	case 156:
   387  		return name == "else"
   388  	case 161:
   389  		return name == "const"
   390  	case 172:
   391  		return name == "continue"
   392  	case 177:
   393  		return name == "defer"
   394  	case 179:
   395  		return name == "default"
   396  	case 188:
   397  		return name == "chan"
   398  	case 191:
   399  		return name == "fallthrough"
   400  	case 210:
   401  		return name == "if"
   402  	case 221:
   403  		return name == "break"
   404  	case 224:
   405  		return name == "func"
   406  	case 239:
   407  		return name == "map"
   408  	case 249:
   409  		return name == "interface"
   410  	case 250:
   411  		return name == "import"
   412  	}
   413  	return false
   414  }
   415  
   416  func TwoHash_XorXor_Shift034(name string) bool {
   417  	if len(name) < 2 {
   418  		return false
   419  	}
   420  	switch ((byte(len(name)) << 0) ^ (name[0] << 3)) ^ (name[1] << 4) {
   421  	case 12:
   422  		return name == "case"
   423  	case 42:
   424  		return name == "if"
   425  	case 43:
   426  		return name == "fallthrough"
   427  	case 52:
   428  		return name == "type"
   429  	case 53:
   430  		return name == "break"
   431  	case 100:
   432  		return name == "func"
   433  	case 117:
   434  		return name == "defer"
   435  	case 119:
   436  		return name == "default"
   437  	case 123:
   438  		return name == "map"
   439  	case 133:
   440  		return name == "range"
   441  	case 151:
   442  		return name == "package"
   443  	case 156:
   444  		return name == "chan"
   445  	case 158:
   446  		return name == "import"
   447  	case 161:
   448  		return name == "interface"
   449  	case 163:
   450  		return name == "var"
   451  	case 195:
   452  		return name == "for"
   453  	case 198:
   454  		return name == "return"
   455  	case 202:
   456  		return name == "go"
   457  	case 204:
   458  		return name == "goto"
   459  	case 206:
   460  		return name == "select"
   461  	case 222:
   462  		return name == "struct"
   463  	case 224:
   464  		return name == "continue"
   465  	case 236:
   466  		return name == "else"
   467  	case 237:
   468  		return name == "const"
   469  	case 238:
   470  		return name == "switch"
   471  	}
   472  	return false
   473  }
   474  
   475  func TwoHash_XorXor_Shift035(name string) bool {
   476  	if len(name) < 2 {
   477  		return false
   478  	}
   479  	switch ((byte(len(name)) << 0) ^ (name[0] << 3)) ^ (name[1] << 5) {
   480  	case 27:
   481  		return name == "fallthrough"
   482  	case 28:
   483  		return name == "chan"
   484  	case 30:
   485  		return name == "struct"
   486  	case 54:
   487  		return name == "return"
   488  	case 60:
   489  		return name == "case"
   490  	case 62:
   491  		return name == "select"
   492  	case 75:
   493  		return name == "map"
   494  	case 85:
   495  		return name == "break"
   496  	case 126:
   497  		return name == "switch"
   498  	case 129:
   499  		return name == "interface"
   500  	case 132:
   501  		return name == "type"
   502  	case 133:
   503  		return name == "defer"
   504  	case 135:
   505  		return name == "default"
   506  	case 138:
   507  		return name == "if"
   508  	case 147:
   509  		return name == "var"
   510  	case 148:
   511  		return name == "func"
   512  	case 167:
   513  		return name == "package"
   514  	case 172:
   515  		return name == "else"
   516  	case 181:
   517  		return name == "range"
   518  	case 211:
   519  		return name == "for"
   520  	case 218:
   521  		return name == "go"
   522  	case 220:
   523  		return name == "goto"
   524  	case 238:
   525  		return name == "import"
   526  	case 240:
   527  		return name == "continue"
   528  	case 253:
   529  		return name == "const"
   530  	}
   531  	return false
   532  }
   533  
   534  func TwoHash_XorXor_Shift041(name string) bool {
   535  	if len(name) < 2 {
   536  		return false
   537  	}
   538  	switch ((byte(len(name)) << 0) ^ (name[0] << 4)) ^ (name[1] << 1) {
   539  	case 17:
   540  		return name == "map"
   541  	case 69:
   542  		return name == "interface"
   543  	case 76:
   544  		return name == "import"
   545  	case 94:
   546  		return name == "if"
   547  	case 140:
   548  		return name == "else"
   549  	case 141:
   550  		return name == "default"
   551  	case 142:
   552  		return name == "func"
   553  	case 143:
   554  		return name == "defer"
   555  	case 161:
   556  		return name == "var"
   557  	case 169:
   558  		return name == "fallthrough"
   559  	case 170:
   560  		return name == "goto"
   561  	case 172:
   562  		return name == "go"
   563  	case 182:
   564  		return name == "type"
   565  	case 189:
   566  		return name == "for"
   567  	case 193:
   568  		return name == "break"
   569  	case 197:
   570  		return name == "package"
   571  	case 216:
   572  		return name == "switch"
   573  	case 222:
   574  		return name == "struct"
   575  	case 228:
   576  		return name == "chan"
   577  	case 230:
   578  		return name == "continue"
   579  	case 231:
   580  		return name == "range"
   581  	case 235:
   582  		return name == "const"
   583  	case 236:
   584  		return name == "return"
   585  	case 246:
   586  		return name == "case"
   587  	case 252:
   588  		return name == "select"
   589  	}
   590  	return false
   591  }
   592  
   593  func TwoHash_XorXor_Shift043(name string) bool {
   594  	if len(name) < 2 {
   595  		return false
   596  	}
   597  	switch ((byte(len(name)) << 0) ^ (name[0] << 4)) ^ (name[1] << 3) {
   598  	case 10:
   599  		return name == "go"
   600  	case 12:
   601  		return name == "goto"
   602  	case 14:
   603  		return name == "return"
   604  	case 15:
   605  		return name == "package"
   606  	case 27:
   607  		return name == "for"
   608  	case 30:
   609  		return name == "select"
   610  	case 45:
   611  		return name == "range"
   612  	case 52:
   613  		return name == "else"
   614  	case 60:
   615  		return name == "case"
   616  	case 64:
   617  		return name == "continue"
   618  	case 77:
   619  		return name == "const"
   620  	case 99:
   621  		return name == "fallthrough"
   622  	case 107:
   623  		return name == "var"
   624  	case 109:
   625  		return name == "defer"
   626  	case 111:
   627  		return name == "default"
   628  	case 116:
   629  		return name == "chan"
   630  	case 140:
   631  		return name == "type"
   632  	case 142:
   633  		return name == "switch"
   634  	case 150:
   635  		return name == "struct"
   636  	case 162:
   637  		return name == "if"
   638  	case 181:
   639  		return name == "break"
   640  	case 204:
   641  		return name == "func"
   642  	case 219:
   643  		return name == "map"
   644  	case 233:
   645  		return name == "interface"
   646  	case 254:
   647  		return name == "import"
   648  	}
   649  	return false
   650  }
   651  
   652  func TwoHash_XorXor_Shift045(name string) bool {
   653  	if len(name) < 2 {
   654  		return false
   655  	}
   656  	switch ((byte(len(name)) << 0) ^ (name[0] << 4)) ^ (name[1] << 5) {
   657  	case 5:
   658  		return name == "range"
   659  	case 20:
   660  		return name == "case"
   661  	case 39:
   662  		return name == "package"
   663  	case 52:
   664  		return name == "chan"
   665  	case 54:
   666  		return name == "import"
   667  	case 67:
   668  		return name == "var"
   669  	case 75:
   670  		return name == "fallthrough"
   671  	case 82:
   672  		return name == "if"
   673  	case 89:
   674  		return name == "interface"
   675  	case 100:
   676  		return name == "type"
   677  	case 101:
   678  		return name == "break"
   679  	case 131:
   680  		return name == "for"
   681  	case 134:
   682  		return name == "return"
   683  	case 146:
   684  		return name == "go"
   685  	case 148:
   686  		return name == "goto"
   687  	case 150:
   688  		return name == "select"
   689  	case 182:
   690  		return name == "struct"
   691  	case 196:
   692  		return name == "func"
   693  	case 212:
   694  		return name == "else"
   695  	case 213:
   696  		return name == "const"
   697  	case 214:
   698  		return name == "switch"
   699  	case 216:
   700  		return name == "continue"
   701  	case 229:
   702  		return name == "defer"
   703  	case 231:
   704  		return name == "default"
   705  	case 243:
   706  		return name == "map"
   707  	}
   708  	return false
   709  }
   710  
   711  func TwoHash_XorXor_Shift046(name string) bool {
   712  	if len(name) < 2 {
   713  		return false
   714  	}
   715  	switch ((byte(len(name)) << 0) ^ (name[0] << 4)) ^ (name[1] << 6) {
   716  	case 4:
   717  		return name == "type"
   718  	case 5:
   719  		return name == "defer"
   720  	case 7:
   721  		return name == "default"
   722  	case 18:
   723  		return name == "if"
   724  	case 25:
   725  		return name == "interface"
   726  	case 35:
   727  		return name == "var"
   728  	case 36:
   729  		return name == "func"
   730  	case 43:
   731  		return name == "fallthrough"
   732  	case 52:
   733  		return name == "chan"
   734  	case 54:
   735  		return name == "struct"
   736  	case 71:
   737  		return name == "package"
   738  	case 84:
   739  		return name == "else"
   740  	case 101:
   741  		return name == "range"
   742  	case 102:
   743  		return name == "return"
   744  	case 116:
   745  		return name == "case"
   746  	case 118:
   747  		return name == "select"
   748  	case 147:
   749  		return name == "map"
   750  	case 163:
   751  		return name == "for"
   752  	case 165:
   753  		return name == "break"
   754  	case 178:
   755  		return name == "go"
   756  	case 180:
   757  		return name == "goto"
   758  	case 214:
   759  		return name == "import"
   760  	case 245:
   761  		return name == "const"
   762  	case 246:
   763  		return name == "switch"
   764  	case 248:
   765  		return name == "continue"
   766  	}
   767  	return false
   768  }
   769  
   770  func TwoHash_XorXor_Shift050(name string) bool {
   771  	if len(name) < 2 {
   772  		return false
   773  	}
   774  	switch ((byte(len(name)) << 0) ^ (name[0] << 5)) ^ (name[1] << 0) {
   775  	case 3:
   776  		return name == "select"
   777  	case 5:
   778  		return name == "case"
   779  	case 7:
   780  		return name == "continue"
   781  	case 10:
   782  		return name == "const"
   783  	case 12:
   784  		return name == "chan"
   785  	case 17:
   786  		return name == "switch"
   787  	case 18:
   788  		return name == "struct"
   789  	case 35:
   790  		return name == "return"
   791  	case 36:
   792  		return name == "range"
   793  	case 55:
   794  		return name == "break"
   795  	case 68:
   796  		return name == "if"
   797  	case 71:
   798  		return name == "interface"
   799  	case 75:
   800  		return name == "import"
   801  	case 102:
   802  		return name == "package"
   803  	case 139:
   804  		return name == "goto"
   805  	case 141:
   806  		return name == "go"
   807  	case 162:
   808  		return name == "var"
   809  	case 170:
   810  		return name == "fallthrough"
   811  	case 172:
   812  		return name == "for"
   813  	case 177:
   814  		return name == "func"
   815  	case 194:
   816  		return name == "map"
   817  	case 200:
   818  		return name == "else"
   819  	case 224:
   820  		return name == "defer"
   821  	case 226:
   822  		return name == "default"
   823  	case 253:
   824  		return name == "type"
   825  	}
   826  	return false
   827  }
   828  
   829  func TwoHash_XorXor_Shift051(name string) bool {
   830  	if len(name) < 2 {
   831  		return false
   832  	}
   833  	switch ((byte(len(name)) << 0) ^ (name[0] << 5)) ^ (name[1] << 1) {
   834  	case 1:
   835  		return name == "var"
   836  	case 9:
   837  		return name == "fallthrough"
   838  	case 29:
   839  		return name == "for"
   840  	case 46:
   841  		return name == "func"
   842  	case 58:
   843  		return name == "goto"
   844  	case 60:
   845  		return name == "go"
   846  	case 77:
   847  		return name == "default"
   848  	case 79:
   849  		return name == "defer"
   850  	case 97:
   851  		return name == "map"
   852  	case 118:
   853  		return name == "type"
   854  	case 124:
   855  		return name == "else"
   856  	case 135:
   857  		return name == "range"
   858  	case 136:
   859  		return name == "switch"
   860  	case 140:
   861  		return name == "return"
   862  	case 142:
   863  		return name == "struct"
   864  	case 161:
   865  		return name == "break"
   866  	case 166:
   867  		return name == "case"
   868  	case 172:
   869  		return name == "select"
   870  	case 180:
   871  		return name == "chan"
   872  	case 182:
   873  		return name == "continue"
   874  	case 187:
   875  		return name == "const"
   876  	case 197:
   877  		return name == "package"
   878  	case 238:
   879  		return name == "if"
   880  	case 245:
   881  		return name == "interface"
   882  	case 252:
   883  		return name == "import"
   884  	}
   885  	return false
   886  }
   887  
   888  func TwoHash_XorXor_Shift060(name string) bool {
   889  	if len(name) < 2 {
   890  		return false
   891  	}
   892  	switch ((byte(len(name)) << 0) ^ (name[0] << 6)) ^ (name[1] << 0) {
   893  	case 34:
   894  		return name == "map"
   895  	case 36:
   896  		return name == "if"
   897  	case 39:
   898  		return name == "interface"
   899  	case 40:
   900  		return name == "else"
   901  	case 43:
   902  		return name == "import"
   903  	case 96:
   904  		return name == "defer"
   905  	case 98:
   906  		return name == "default"
   907  	case 102:
   908  		return name == "package"
   909  	case 125:
   910  		return name == "type"
   911  	case 163:
   912  		return name == "select"
   913  	case 165:
   914  		return name == "case"
   915  	case 167:
   916  		return name == "continue"
   917  	case 170:
   918  		return name == "const"
   919  	case 171:
   920  		return name == "goto"
   921  	case 172:
   922  		return name == "chan"
   923  	case 173:
   924  		return name == "go"
   925  	case 177:
   926  		return name == "switch"
   927  	case 178:
   928  		return name == "struct"
   929  	case 226:
   930  		return name == "var"
   931  	case 227:
   932  		return name == "return"
   933  	case 228:
   934  		return name == "range"
   935  	case 234:
   936  		return name == "fallthrough"
   937  	case 236:
   938  		return name == "for"
   939  	case 241:
   940  		return name == "func"
   941  	case 247:
   942  		return name == "break"
   943  	}
   944  	return false
   945  }
   946  
   947  func TwoHash_XorXor_Shift062(name string) bool {
   948  	if len(name) < 2 {
   949  		return false
   950  	}
   951  	switch ((byte(len(name)) << 0) ^ (name[0] << 6)) ^ (name[1] << 2) {
   952  	case 1:
   953  		return name == "range"
   954  	case 7:
   955  		return name == "var"
   956  	case 15:
   957  		return name == "fallthrough"
   958  	case 18:
   959  		return name == "return"
   960  	case 22:
   961  		return name == "struct"
   962  	case 26:
   963  		return name == "switch"
   964  	case 63:
   965  		return name == "for"
   966  	case 64:
   967  		return name == "case"
   968  	case 77:
   969  		return name == "break"
   970  	case 80:
   971  		return name == "func"
   972  	case 82:
   973  		return name == "select"
   974  	case 100:
   975  		return name == "chan"
   976  	case 116:
   977  		return name == "continue"
   978  	case 120:
   979  		return name == "goto"
   980  	case 121:
   981  		return name == "const"
   982  	case 126:
   983  		return name == "go"
   984  	case 131:
   985  		return name == "package"
   986  	case 145:
   987  		return name == "defer"
   988  	case 147:
   989  		return name == "default"
   990  	case 199:
   991  		return name == "map"
   992  	case 218:
   993  		return name == "if"
   994  	case 224:
   995  		return name == "type"
   996  	case 241:
   997  		return name == "interface"
   998  	case 242:
   999  		return name == "import"
  1000  	case 244:
  1001  		return name == "else"
  1002  	}
  1003  	return false
  1004  }
  1005  
  1006  func TwoHash_XorXor_Shift073(name string) bool {
  1007  	if len(name) < 2 {
  1008  		return false
  1009  	}
  1010  	switch ((byte(len(name)) << 0) ^ (name[0] << 7)) ^ (name[1] << 3) {
  1011  	case 3:
  1012  		return name == "fallthrough"
  1013  	case 11:
  1014  		return name == "var"
  1015  	case 13:
  1016  		return name == "range"
  1017  	case 15:
  1018  		return name == "package"
  1019  	case 38:
  1020  		return name == "struct"
  1021  	case 45:
  1022  		return name == "defer"
  1023  	case 46:
  1024  		return name == "return"
  1025  	case 47:
  1026  		return name == "default"
  1027  	case 62:
  1028  		return name == "switch"
  1029  	case 123:
  1030  		return name == "for"
  1031  	case 139:
  1032  		return name == "map"
  1033  	case 140:
  1034  		return name == "case"
  1035  	case 149:
  1036  		return name == "break"
  1037  	case 172:
  1038  		return name == "func"
  1039  	case 174:
  1040  		return name == "select"
  1041  	case 178:
  1042  		return name == "if"
  1043  	case 196:
  1044  		return name == "chan"
  1045  	case 204:
  1046  		return name == "type"
  1047  	case 228:
  1048  		return name == "else"
  1049  	case 238:
  1050  		return name == "import"
  1051  	case 240:
  1052  		return name == "continue"
  1053  	case 249:
  1054  		return name == "interface"
  1055  	case 250:
  1056  		return name == "go"
  1057  	case 252:
  1058  		return name == "goto"
  1059  	case 253:
  1060  		return name == "const"
  1061  	}
  1062  	return false
  1063  }
  1064  
  1065  func TwoHash_XorXor_Shift130(name string) bool {
  1066  	if len(name) < 2 {
  1067  		return false
  1068  	}
  1069  	switch ((byte(len(name)) << 1) ^ (name[0] << 3)) ^ (name[1] << 0) {
  1070  	case 15:
  1071  		return name == "map"
  1072  	case 41:
  1073  		return name == "import"
  1074  	case 42:
  1075  		return name == "if"
  1076  	case 52:
  1077  		return name == "interface"
  1078  	case 71:
  1079  		return name == "fallthrough"
  1080  	case 75:
  1081  		return name == "default"
  1082  	case 76:
  1083  		return name == "else"
  1084  	case 77:
  1085  		return name == "func"
  1086  	case 79:
  1087  		return name == "defer"
  1088  	case 83:
  1089  		return name == "go"
  1090  	case 89:
  1091  		return name == "for"
  1092  	case 95:
  1093  		return name == "goto"
  1094  	case 103:
  1095  		return name == "continue"
  1096  	case 104:
  1097  		return name == "break"
  1098  	case 113:
  1099  		return name == "case"
  1100  	case 120:
  1101  		return name == "chan"
  1102  	case 125:
  1103  		return name == "const"
  1104  	case 209:
  1105  		return name == "type"
  1106  	case 215:
  1107  		return name == "var"
  1108  	case 224:
  1109  		return name == "struct"
  1110  	case 227:
  1111  		return name == "switch"
  1112  	case 239:
  1113  		return name == "package"
  1114  	case 241:
  1115  		return name == "select"
  1116  	case 249:
  1117  		return name == "return"
  1118  	case 251:
  1119  		return name == "range"
  1120  	}
  1121  	return false
  1122  }
  1123  
  1124  func TwoHash_XorXor_Shift132(name string) bool {
  1125  	if len(name) < 2 {
  1126  		return false
  1127  	}
  1128  	switch ((byte(len(name)) << 1) ^ (name[0] << 3)) ^ (name[1] << 2) {
  1129  	case 0:
  1130  		return name == "select"
  1131  	case 8:
  1132  		return name == "return"
  1133  	case 10:
  1134  		return name == "package"
  1135  	case 30:
  1136  		return name == "range"
  1137  	case 50:
  1138  		return name == "var"
  1139  	case 68:
  1140  		return name == "struct"
  1141  	case 72:
  1142  		return name == "switch"
  1143  	case 76:
  1144  		return name == "type"
  1145  	case 128:
  1146  		return name == "go"
  1147  	case 138:
  1148  		return name == "for"
  1149  	case 140:
  1150  		return name == "goto"
  1151  	case 144:
  1152  		return name == "else"
  1153  	case 148:
  1154  		return name == "case"
  1155  	case 162:
  1156  		return name == "fallthrough"
  1157  	case 174:
  1158  		return name == "const"
  1159  	case 176:
  1160  		return name == "chan"
  1161  	case 180:
  1162  		return name == "continue"
  1163  	case 186:
  1164  		return name == "default"
  1165  	case 190:
  1166  		return name == "defer"
  1167  	case 210:
  1168  		return name == "break"
  1169  	case 212:
  1170  		return name == "if"
  1171  	case 226:
  1172  		return name == "interface"
  1173  	case 234:
  1174  		return name == "map"
  1175  	case 236:
  1176  		return name == "func"
  1177  	case 240:
  1178  		return name == "import"
  1179  	}
  1180  	return false
  1181  }
  1182  
  1183  func TwoHash_XorXor_Shift135(name string) bool {
  1184  	if len(name) < 2 {
  1185  		return false
  1186  	}
  1187  	switch ((byte(len(name)) << 1) ^ (name[0] << 3)) ^ (name[1] << 5) {
  1188  	case 6:
  1189  		return name == "fallthrough"
  1190  	case 16:
  1191  		return name == "chan"
  1192  	case 20:
  1193  		return name == "struct"
  1194  	case 48:
  1195  		return name == "case"
  1196  	case 52:
  1197  		return name == "select"
  1198  	case 60:
  1199  		return name == "return"
  1200  	case 78:
  1201  		return name == "map"
  1202  	case 90:
  1203  		return name == "break"
  1204  	case 116:
  1205  		return name == "switch"
  1206  	case 136:
  1207  		return name == "type"
  1208  	case 138:
  1209  		return name == "defer"
  1210  	case 140:
  1211  		return name == "if"
  1212  	case 142:
  1213  		return name == "default"
  1214  	case 150:
  1215  		return name == "var"
  1216  	case 152:
  1217  		return name == "func"
  1218  	case 154:
  1219  		return name == "interface"
  1220  	case 160:
  1221  		return name == "else"
  1222  	case 174:
  1223  		return name == "package"
  1224  	case 186:
  1225  		return name == "range"
  1226  	case 208:
  1227  		return name == "goto"
  1228  	case 214:
  1229  		return name == "for"
  1230  	case 220:
  1231  		return name == "go"
  1232  	case 228:
  1233  		return name == "import"
  1234  	case 232:
  1235  		return name == "continue"
  1236  	case 242:
  1237  		return name == "const"
  1238  	}
  1239  	return false
  1240  }
  1241  
  1242  func TwoHash_XorXor_Shift143(name string) bool {
  1243  	if len(name) < 2 {
  1244  		return false
  1245  	}
  1246  	switch ((byte(len(name)) << 1) ^ (name[0] << 4)) ^ (name[1] << 3) {
  1247  	case 0:
  1248  		return name == "goto"
  1249  	case 4:
  1250  		return name == "return"
  1251  	case 6:
  1252  		return name == "package"
  1253  	case 12:
  1254  		return name == "go"
  1255  	case 20:
  1256  		return name == "select"
  1257  	case 30:
  1258  		return name == "for"
  1259  	case 34:
  1260  		return name == "range"
  1261  	case 48:
  1262  		return name == "case"
  1263  	case 56:
  1264  		return name == "else"
  1265  	case 66:
  1266  		return name == "const"
  1267  	case 88:
  1268  		return name == "continue"
  1269  	case 98:
  1270  		return name == "defer"
  1271  	case 102:
  1272  		return name == "default"
  1273  	case 110:
  1274  		return name == "var"
  1275  	case 120:
  1276  		return name == "chan"
  1277  	case 126:
  1278  		return name == "fallthrough"
  1279  	case 128:
  1280  		return name == "type"
  1281  	case 132:
  1282  		return name == "switch"
  1283  	case 156:
  1284  		return name == "struct"
  1285  	case 164:
  1286  		return name == "if"
  1287  	case 186:
  1288  		return name == "break"
  1289  	case 192:
  1290  		return name == "func"
  1291  	case 222:
  1292  		return name == "map"
  1293  	case 242:
  1294  		return name == "interface"
  1295  	case 244:
  1296  		return name == "import"
  1297  	}
  1298  	return false
  1299  }
  1300  
  1301  func TwoHash_XorXor_Shift145(name string) bool {
  1302  	if len(name) < 2 {
  1303  		return false
  1304  	}
  1305  	switch ((byte(len(name)) << 1) ^ (name[0] << 4)) ^ (name[1] << 5) {
  1306  	case 10:
  1307  		return name == "range"
  1308  	case 24:
  1309  		return name == "case"
  1310  	case 46:
  1311  		return name == "package"
  1312  	case 56:
  1313  		return name == "chan"
  1314  	case 60:
  1315  		return name == "import"
  1316  	case 66:
  1317  		return name == "interface"
  1318  	case 70:
  1319  		return name == "var"
  1320  	case 84:
  1321  		return name == "if"
  1322  	case 86:
  1323  		return name == "fallthrough"
  1324  	case 104:
  1325  		return name == "type"
  1326  	case 106:
  1327  		return name == "break"
  1328  	case 134:
  1329  		return name == "for"
  1330  	case 140:
  1331  		return name == "return"
  1332  	case 148:
  1333  		return name == "go"
  1334  	case 152:
  1335  		return name == "goto"
  1336  	case 156:
  1337  		return name == "select"
  1338  	case 188:
  1339  		return name == "struct"
  1340  	case 192:
  1341  		return name == "continue"
  1342  	case 200:
  1343  		return name == "func"
  1344  	case 216:
  1345  		return name == "else"
  1346  	case 218:
  1347  		return name == "const"
  1348  	case 220:
  1349  		return name == "switch"
  1350  	case 234:
  1351  		return name == "defer"
  1352  	case 238:
  1353  		return name == "default"
  1354  	case 246:
  1355  		return name == "map"
  1356  	}
  1357  	return false
  1358  }
  1359  
  1360  func TwoHash_XorXor_Shift146(name string) bool {
  1361  	if len(name) < 2 {
  1362  		return false
  1363  	}
  1364  	switch ((byte(len(name)) << 1) ^ (name[0] << 4)) ^ (name[1] << 6) {
  1365  	case 2:
  1366  		return name == "interface"
  1367  	case 8:
  1368  		return name == "type"
  1369  	case 10:
  1370  		return name == "defer"
  1371  	case 14:
  1372  		return name == "default"
  1373  	case 20:
  1374  		return name == "if"
  1375  	case 38:
  1376  		return name == "var"
  1377  	case 40:
  1378  		return name == "func"
  1379  	case 54:
  1380  		return name == "fallthrough"
  1381  	case 56:
  1382  		return name == "chan"
  1383  	case 60:
  1384  		return name == "struct"
  1385  	case 78:
  1386  		return name == "package"
  1387  	case 88:
  1388  		return name == "else"
  1389  	case 106:
  1390  		return name == "range"
  1391  	case 108:
  1392  		return name == "return"
  1393  	case 120:
  1394  		return name == "case"
  1395  	case 124:
  1396  		return name == "select"
  1397  	case 150:
  1398  		return name == "map"
  1399  	case 166:
  1400  		return name == "for"
  1401  	case 170:
  1402  		return name == "break"
  1403  	case 180:
  1404  		return name == "go"
  1405  	case 184:
  1406  		return name == "goto"
  1407  	case 220:
  1408  		return name == "import"
  1409  	case 224:
  1410  		return name == "continue"
  1411  	case 250:
  1412  		return name == "const"
  1413  	case 252:
  1414  		return name == "switch"
  1415  	}
  1416  	return false
  1417  }
  1418  
  1419  func TwoHash_XorXor_Shift161(name string) bool {
  1420  	if len(name) < 2 {
  1421  		return false
  1422  	}
  1423  	switch ((byte(len(name)) << 1) ^ (name[0] << 6)) ^ (name[1] << 1) {
  1424  	case 6:
  1425  		return name == "select"
  1426  	case 10:
  1427  		return name == "case"
  1428  	case 14:
  1429  		return name == "continue"
  1430  	case 20:
  1431  		return name == "const"
  1432  	case 22:
  1433  		return name == "goto"
  1434  	case 24:
  1435  		return name == "chan"
  1436  	case 26:
  1437  		return name == "go"
  1438  	case 34:
  1439  		return name == "switch"
  1440  	case 36:
  1441  		return name == "struct"
  1442  	case 68:
  1443  		return name == "var"
  1444  	case 70:
  1445  		return name == "return"
  1446  	case 72:
  1447  		return name == "range"
  1448  	case 84:
  1449  		return name == "fallthrough"
  1450  	case 88:
  1451  		return name == "for"
  1452  	case 98:
  1453  		return name == "func"
  1454  	case 110:
  1455  		return name == "break"
  1456  	case 132:
  1457  		return name == "map"
  1458  	case 136:
  1459  		return name == "if"
  1460  	case 142:
  1461  		return name == "interface"
  1462  	case 144:
  1463  		return name == "else"
  1464  	case 150:
  1465  		return name == "import"
  1466  	case 192:
  1467  		return name == "defer"
  1468  	case 196:
  1469  		return name == "default"
  1470  	case 204:
  1471  		return name == "package"
  1472  	case 250:
  1473  		return name == "type"
  1474  	}
  1475  	return false
  1476  }
  1477  
  1478  func TwoHash_XorXor_Shift240(name string) bool {
  1479  	if len(name) < 2 {
  1480  		return false
  1481  	}
  1482  	switch ((byte(len(name)) << 2) ^ (name[0] << 4)) ^ (name[1] << 0) {
  1483  	case 3:
  1484  		return name == "for"
  1485  	case 5:
  1486  		return name == "func"
  1487  	case 13:
  1488  		return name == "var"
  1489  	case 15:
  1490  		return name == "goto"
  1491  	case 23:
  1492  		return name == "go"
  1493  	case 41:
  1494  		return name == "type"
  1495  	case 44:
  1496  		return name == "else"
  1497  	case 45:
  1498  		return name == "fallthrough"
  1499  	case 49:
  1500  		return name == "defer"
  1501  	case 57:
  1502  		return name == "default"
  1503  	case 65:
  1504  		return name == "case"
  1505  	case 70:
  1506  		return name == "break"
  1507  	case 72:
  1508  		return name == "chan"
  1509  	case 75:
  1510  		return name == "const"
  1511  	case 77:
  1512  		return name == "select"
  1513  	case 85:
  1514  		return name == "range"
  1515  	case 92:
  1516  		return name == "struct"
  1517  	case 93:
  1518  		return name == "return"
  1519  	case 95:
  1520  		return name == "switch"
  1521  	case 125:
  1522  		return name == "package"
  1523  	case 127:
  1524  		return name == "continue"
  1525  	case 189:
  1526  		return name == "map"
  1527  	case 218:
  1528  		return name == "interface"
  1529  	case 229:
  1530  		return name == "import"
  1531  	case 254:
  1532  		return name == "if"
  1533  	}
  1534  	return false
  1535  }
  1536  
  1537  func TwoHash_XorXor_Shift246(name string) bool {
  1538  	if len(name) < 2 {
  1539  		return false
  1540  	}
  1541  	switch ((byte(len(name)) << 2) ^ (name[0] << 4)) ^ (name[1] << 6) {
  1542  	case 12:
  1543  		return name == "fallthrough"
  1544  	case 16:
  1545  		return name == "type"
  1546  	case 20:
  1547  		return name == "defer"
  1548  	case 24:
  1549  		return name == "if"
  1550  	case 28:
  1551  		return name == "default"
  1552  	case 32:
  1553  		return name == "chan"
  1554  	case 40:
  1555  		return name == "struct"
  1556  	case 44:
  1557  		return name == "var"
  1558  	case 48:
  1559  		return name == "func"
  1560  	case 52:
  1561  		return name == "interface"
  1562  	case 64:
  1563  		return name == "else"
  1564  	case 92:
  1565  		return name == "package"
  1566  	case 96:
  1567  		return name == "case"
  1568  	case 104:
  1569  		return name == "select"
  1570  	case 116:
  1571  		return name == "range"
  1572  	case 120:
  1573  		return name == "return"
  1574  	case 156:
  1575  		return name == "map"
  1576  	case 160:
  1577  		return name == "goto"
  1578  	case 172:
  1579  		return name == "for"
  1580  	case 180:
  1581  		return name == "break"
  1582  	case 184:
  1583  		return name == "go"
  1584  	case 200:
  1585  		return name == "import"
  1586  	case 208:
  1587  		return name == "continue"
  1588  	case 228:
  1589  		return name == "const"
  1590  	case 232:
  1591  		return name == "switch"
  1592  	}
  1593  	return false
  1594  }
  1595  
  1596  func TwoHash_XorXor_Shift250(name string) bool {
  1597  	if len(name) < 2 {
  1598  		return false
  1599  	}
  1600  	switch ((byte(len(name)) << 2) ^ (name[0] << 5)) ^ (name[1] << 0) {
  1601  	case 12:
  1602  		return name == "struct"
  1603  	case 15:
  1604  		return name == "switch"
  1605  	case 17:
  1606  		return name == "case"
  1607  	case 24:
  1608  		return name == "chan"
  1609  	case 27:
  1610  		return name == "const"
  1611  	case 29:
  1612  		return name == "select"
  1613  	case 38:
  1614  		return name == "break"
  1615  	case 47:
  1616  		return name == "continue"
  1617  	case 53:
  1618  		return name == "range"
  1619  	case 61:
  1620  		return name == "return"
  1621  	case 78:
  1622  		return name == "if"
  1623  	case 85:
  1624  		return name == "import"
  1625  	case 106:
  1626  		return name == "interface"
  1627  	case 125:
  1628  		return name == "package"
  1629  	case 135:
  1630  		return name == "go"
  1631  	case 141:
  1632  		return name == "fallthrough"
  1633  	case 159:
  1634  		return name == "goto"
  1635  	case 163:
  1636  		return name == "for"
  1637  	case 165:
  1638  		return name == "func"
  1639  	case 173:
  1640  		return name == "var"
  1641  	case 205:
  1642  		return name == "map"
  1643  	case 220:
  1644  		return name == "else"
  1645  	case 233:
  1646  		return name == "type"
  1647  	case 241:
  1648  		return name == "defer"
  1649  	case 249:
  1650  		return name == "default"
  1651  	}
  1652  	return false
  1653  }
  1654  
  1655  func TwoHash_XorXor_Shift260(name string) bool {
  1656  	if len(name) < 2 {
  1657  		return false
  1658  	}
  1659  	switch ((byte(len(name)) << 2) ^ (name[0] << 6)) ^ (name[1] << 0) {
  1660  	case 10:
  1661  		return name == "interface"
  1662  	case 45:
  1663  		return name == "map"
  1664  	case 46:
  1665  		return name == "if"
  1666  	case 53:
  1667  		return name == "import"
  1668  	case 60:
  1669  		return name == "else"
  1670  	case 105:
  1671  		return name == "type"
  1672  	case 113:
  1673  		return name == "defer"
  1674  	case 121:
  1675  		return name == "default"
  1676  	case 125:
  1677  		return name == "package"
  1678  	case 143:
  1679  		return name == "continue"
  1680  	case 167:
  1681  		return name == "go"
  1682  	case 172:
  1683  		return name == "struct"
  1684  	case 175:
  1685  		return name == "switch"
  1686  	case 177:
  1687  		return name == "case"
  1688  	case 184:
  1689  		return name == "chan"
  1690  	case 187:
  1691  		return name == "const"
  1692  	case 189:
  1693  		return name == "select"
  1694  	case 191:
  1695  		return name == "goto"
  1696  	case 205:
  1697  		return name == "fallthrough"
  1698  	case 227:
  1699  		return name == "for"
  1700  	case 229:
  1701  		return name == "func"
  1702  	case 230:
  1703  		return name == "break"
  1704  	case 237:
  1705  		return name == "var"
  1706  	case 245:
  1707  		return name == "range"
  1708  	case 253:
  1709  		return name == "return"
  1710  	}
  1711  	return false
  1712  }
  1713  
  1714  func TwoHash_XorXor_Shift303(name string) bool {
  1715  	if len(name) < 2 {
  1716  		return false
  1717  	}
  1718  	switch ((byte(len(name)) << 3) ^ (name[0] << 0)) ^ (name[1] << 3) {
  1719  	case 3:
  1720  		return name == "chan"
  1721  	case 6:
  1722  		return name == "for"
  1723  	case 15:
  1724  		return name == "go"
  1725  	case 37:
  1726  		return name == "else"
  1727  	case 49:
  1728  		return name == "import"
  1729  	case 51:
  1730  		return name == "const"
  1731  	case 54:
  1732  		return name == "fallthrough"
  1733  	case 63:
  1734  		return name == "goto"
  1735  	case 64:
  1736  		return name == "package"
  1737  	case 73:
  1738  		return name == "if"
  1739  	case 75:
  1740  		return name == "case"
  1741  	case 81:
  1742  		return name == "interface"
  1743  	case 82:
  1744  		return name == "range"
  1745  	case 91:
  1746  		return name == "continue"
  1747  	case 100:
  1748  		return name == "defer"
  1749  	case 102:
  1750  		return name == "var"
  1751  	case 106:
  1752  		return name == "return"
  1753  	case 107:
  1754  		return name == "select"
  1755  	case 116:
  1756  		return name == "default"
  1757  	case 125:
  1758  		return name == "map"
  1759  	case 156:
  1760  		return name == "type"
  1761  	case 218:
  1762  		return name == "break"
  1763  	case 227:
  1764  		return name == "struct"
  1765  	case 238:
  1766  		return name == "func"
  1767  	case 251:
  1768  		return name == "switch"
  1769  	}
  1770  	return false
  1771  }
  1772  
  1773  func TwoHash_XorXor_Shift304(name string) bool {
  1774  	if len(name) < 2 {
  1775  		return false
  1776  	}
  1777  	switch ((byte(len(name)) << 3) ^ (name[0] << 0)) ^ (name[1] << 4) {
  1778  	case 3:
  1779  		return name == "struct"
  1780  	case 12:
  1781  		return name == "default"
  1782  	case 18:
  1783  		return name == "return"
  1784  	case 19:
  1785  		return name == "select"
  1786  	case 22:
  1787  		return name == "func"
  1788  	case 25:
  1789  		return name == "if"
  1790  	case 28:
  1791  		return name == "defer"
  1792  	case 46:
  1793  		return name == "fallthrough"
  1794  	case 51:
  1795  		return name == "switch"
  1796  	case 74:
  1797  		return name == "range"
  1798  	case 83:
  1799  		return name == "case"
  1800  	case 88:
  1801  		return name == "package"
  1802  	case 101:
  1803  		return name == "map"
  1804  	case 106:
  1805  		return name == "break"
  1806  	case 126:
  1807  		return name == "var"
  1808  	case 133:
  1809  		return name == "else"
  1810  	case 135:
  1811  		return name == "go"
  1812  	case 137:
  1813  		return name == "import"
  1814  	case 142:
  1815  		return name == "for"
  1816  	case 183:
  1817  		return name == "goto"
  1818  	case 187:
  1819  		return name == "const"
  1820  	case 193:
  1821  		return name == "interface"
  1822  	case 195:
  1823  		return name == "chan"
  1824  	case 196:
  1825  		return name == "type"
  1826  	case 211:
  1827  		return name == "continue"
  1828  	}
  1829  	return false
  1830  }
  1831  
  1832  func TwoHash_XorXor_Shift351(name string) bool {
  1833  	if len(name) < 2 {
  1834  		return false
  1835  	}
  1836  	switch ((byte(len(name)) << 3) ^ (name[0] << 5)) ^ (name[1] << 1) {
  1837  	case 6:
  1838  		return name == "for"
  1839  	case 10:
  1840  		return name == "func"
  1841  	case 26:
  1842  		return name == "var"
  1843  	case 30:
  1844  		return name == "goto"
  1845  	case 46:
  1846  		return name == "go"
  1847  	case 82:
  1848  		return name == "type"
  1849  	case 88:
  1850  		return name == "else"
  1851  	case 90:
  1852  		return name == "fallthrough"
  1853  	case 98:
  1854  		return name == "defer"
  1855  	case 114:
  1856  		return name == "default"
  1857  	case 122:
  1858  		return name == "map"
  1859  	case 130:
  1860  		return name == "case"
  1861  	case 140:
  1862  		return name == "break"
  1863  	case 144:
  1864  		return name == "chan"
  1865  	case 150:
  1866  		return name == "const"
  1867  	case 154:
  1868  		return name == "select"
  1869  	case 170:
  1870  		return name == "range"
  1871  	case 180:
  1872  		return name == "interface"
  1873  	case 184:
  1874  		return name == "struct"
  1875  	case 186:
  1876  		return name == "return"
  1877  	case 190:
  1878  		return name == "switch"
  1879  	case 202:
  1880  		return name == "import"
  1881  	case 250:
  1882  		return name == "package"
  1883  	case 252:
  1884  		return name == "if"
  1885  	case 254:
  1886  		return name == "continue"
  1887  	}
  1888  	return false
  1889  }
  1890  
  1891  func TwoHash_XorXor_Shift361(name string) bool {
  1892  	if len(name) < 2 {
  1893  		return false
  1894  	}
  1895  	switch ((byte(len(name)) << 3) ^ (name[0] << 6)) ^ (name[1] << 1) {
  1896  	case 14:
  1897  		return name == "go"
  1898  	case 24:
  1899  		return name == "struct"
  1900  	case 26:
  1901  		return name == "fallthrough"
  1902  	case 30:
  1903  		return name == "switch"
  1904  	case 34:
  1905  		return name == "case"
  1906  	case 48:
  1907  		return name == "chan"
  1908  	case 54:
  1909  		return name == "const"
  1910  	case 58:
  1911  		return name == "select"
  1912  	case 62:
  1913  		return name == "goto"
  1914  	case 70:
  1915  		return name == "for"
  1916  	case 74:
  1917  		return name == "func"
  1918  	case 76:
  1919  		return name == "break"
  1920  	case 90:
  1921  		return name == "var"
  1922  	case 94:
  1923  		return name == "continue"
  1924  	case 106:
  1925  		return name == "range"
  1926  	case 122:
  1927  		return name == "return"
  1928  	case 154:
  1929  		return name == "map"
  1930  	case 156:
  1931  		return name == "if"
  1932  	case 170:
  1933  		return name == "import"
  1934  	case 184:
  1935  		return name == "else"
  1936  	case 210:
  1937  		return name == "type"
  1938  	case 212:
  1939  		return name == "interface"
  1940  	case 226:
  1941  		return name == "defer"
  1942  	case 242:
  1943  		return name == "default"
  1944  	case 250:
  1945  		return name == "package"
  1946  	}
  1947  	return false
  1948  }
  1949  
  1950  func TwoHash_XorXor_Shift402(name string) bool {
  1951  	if len(name) < 2 {
  1952  		return false
  1953  	}
  1954  	switch ((byte(len(name)) << 4) ^ (name[0] << 0)) ^ (name[1] << 2) {
  1955  	case 65:
  1956  		return name == "interface"
  1957  	case 82:
  1958  		return name == "fallthrough"
  1959  	case 95:
  1960  		return name == "continue"
  1961  	case 128:
  1962  		return name == "default"
  1963  	case 131:
  1964  		return name == "chan"
  1965  	case 132:
  1966  		return name == "package"
  1967  	case 134:
  1968  		return name == "return"
  1969  	case 135:
  1970  		return name == "select"
  1971  	case 143:
  1972  		return name == "const"
  1973  	case 149:
  1974  		return name == "else"
  1975  	case 155:
  1976  		return name == "goto"
  1977  	case 160:
  1978  		return name == "defer"
  1979  	case 166:
  1980  		return name == "range"
  1981  	case 167:
  1982  		return name == "case"
  1983  	case 189:
  1984  		return name == "import"
  1985  	case 194:
  1986  		return name == "var"
  1987  	case 195:
  1988  		return name == "struct"
  1989  	case 207:
  1990  		return name == "switch"
  1991  	case 208:
  1992  		return name == "type"
  1993  	case 209:
  1994  		return name == "if"
  1995  	case 217:
  1996  		return name == "map"
  1997  	case 234:
  1998  		return name == "for"
  1999  	case 242:
  2000  		return name == "func"
  2001  	case 250:
  2002  		return name == "break"
  2003  	case 251:
  2004  		return name == "go"
  2005  	}
  2006  	return false
  2007  }
  2008  
  2009  func TwoHash_XorXor_Shift403(name string) bool {
  2010  	if len(name) < 2 {
  2011  		return false
  2012  	}
  2013  	switch ((byte(len(name)) << 4) ^ (name[0] << 0)) ^ (name[1] << 3) {
  2014  	case 8:
  2015  		return name == "package"
  2016  	case 28:
  2017  		return name == "defer"
  2018  	case 42:
  2019  		return name == "range"
  2020  	case 43:
  2021  		return name == "case"
  2022  	case 46:
  2023  		return name == "for"
  2024  	case 58:
  2025  		return name == "return"
  2026  	case 59:
  2027  		return name == "select"
  2028  	case 60:
  2029  		return name == "default"
  2030  	case 63:
  2031  		return name == "go"
  2032  	case 69:
  2033  		return name == "else"
  2034  	case 75:
  2035  		return name == "const"
  2036  	case 78:
  2037  		return name == "var"
  2038  	case 85:
  2039  		return name == "map"
  2040  	case 95:
  2041  		return name == "goto"
  2042  	case 97:
  2043  		return name == "import"
  2044  	case 99:
  2045  		return name == "chan"
  2046  	case 121:
  2047  		return name == "if"
  2048  	case 137:
  2049  		return name == "interface"
  2050  	case 142:
  2051  		return name == "func"
  2052  	case 155:
  2053  		return name == "continue"
  2054  	case 162:
  2055  		return name == "break"
  2056  	case 171:
  2057  		return name == "switch"
  2058  	case 179:
  2059  		return name == "struct"
  2060  	case 222:
  2061  		return name == "fallthrough"
  2062  	case 252:
  2063  		return name == "type"
  2064  	}
  2065  	return false
  2066  }
  2067  
  2068  func TwoHash_XorXor_Shift404(name string) bool {
  2069  	if len(name) < 2 {
  2070  		return false
  2071  	}
  2072  	switch ((byte(len(name)) << 4) ^ (name[0] << 0)) ^ (name[1] << 4) {
  2073  	case 16:
  2074  		return name == "package"
  2075  	case 18:
  2076  		return name == "break"
  2077  	case 19:
  2078  		return name == "continue"
  2079  	case 25:
  2080  		return name == "interface"
  2081  	case 41:
  2082  		return name == "if"
  2083  	case 50:
  2084  		return name == "range"
  2085  	case 51:
  2086  		return name == "case"
  2087  	case 66:
  2088  		return name == "return"
  2089  	case 67:
  2090  		return name == "select"
  2091  	case 68:
  2092  		return name == "default"
  2093  	case 77:
  2094  		return name == "map"
  2095  	case 83:
  2096  		return name == "struct"
  2097  	case 86:
  2098  		return name == "var"
  2099  	case 99:
  2100  		return name == "switch"
  2101  	case 100:
  2102  		return name == "defer"
  2103  	case 118:
  2104  		return name == "func"
  2105  	case 163:
  2106  		return name == "chan"
  2107  	case 164:
  2108  		return name == "type"
  2109  	case 166:
  2110  		return name == "for"
  2111  	case 183:
  2112  		return name == "go"
  2113  	case 195:
  2114  		return name == "const"
  2115  	case 198:
  2116  		return name == "fallthrough"
  2117  	case 215:
  2118  		return name == "goto"
  2119  	case 217:
  2120  		return name == "import"
  2121  	case 229:
  2122  		return name == "else"
  2123  	}
  2124  	return false
  2125  }
  2126  
  2127  func TwoHash_XorXor_Shift414(name string) bool {
  2128  	if len(name) < 2 {
  2129  		return false
  2130  	}
  2131  	switch ((byte(len(name)) << 4) ^ (name[0] << 1)) ^ (name[1] << 4) {
  2132  	case 6:
  2133  		return name == "chan"
  2134  	case 12:
  2135  		return name == "for"
  2136  	case 30:
  2137  		return name == "go"
  2138  	case 56:
  2139  		return name == "type"
  2140  	case 74:
  2141  		return name == "else"
  2142  	case 98:
  2143  		return name == "import"
  2144  	case 102:
  2145  		return name == "const"
  2146  	case 108:
  2147  		return name == "fallthrough"
  2148  	case 126:
  2149  		return name == "goto"
  2150  	case 128:
  2151  		return name == "package"
  2152  	case 146:
  2153  		return name == "if"
  2154  	case 150:
  2155  		return name == "case"
  2156  	case 162:
  2157  		return name == "interface"
  2158  	case 164:
  2159  		return name == "range"
  2160  	case 180:
  2161  		return name == "break"
  2162  	case 182:
  2163  		return name == "continue"
  2164  	case 198:
  2165  		return name == "struct"
  2166  	case 200:
  2167  		return name == "defer"
  2168  	case 204:
  2169  		return name == "var"
  2170  	case 212:
  2171  		return name == "return"
  2172  	case 214:
  2173  		return name == "select"
  2174  	case 220:
  2175  		return name == "func"
  2176  	case 232:
  2177  		return name == "default"
  2178  	case 246:
  2179  		return name == "switch"
  2180  	case 250:
  2181  		return name == "map"
  2182  	}
  2183  	return false
  2184  }
  2185  
  2186  func TwoHash_XorXor_Shift501(name string) bool {
  2187  	if len(name) < 2 {
  2188  		return false
  2189  	}
  2190  	switch ((byte(len(name)) << 5) ^ (name[0] << 0)) ^ (name[1] << 1) {
  2191  	case 6:
  2192  		return name == "type"
  2193  	case 12:
  2194  		return name == "func"
  2195  	case 14:
  2196  		return name == "defer"
  2197  	case 16:
  2198  		return name == "range"
  2199  	case 29:
  2200  		return name == "const"
  2201  	case 33:
  2202  		return name == "case"
  2203  	case 38:
  2204  		return name == "break"
  2205  	case 51:
  2206  		return name == "chan"
  2207  	case 57:
  2208  		return name == "goto"
  2209  	case 61:
  2210  		return name == "else"
  2211  	case 78:
  2212  		return name == "default"
  2213  	case 82:
  2214  		return name == "package"
  2215  	case 91:
  2216  		return name == "struct"
  2217  	case 93:
  2218  		return name == "switch"
  2219  	case 115:
  2220  		return name == "import"
  2221  	case 120:
  2222  		return name == "return"
  2223  	case 121:
  2224  		return name == "select"
  2225  	case 149:
  2226  		return name == "interface"
  2227  	case 189:
  2228  		return name == "continue"
  2229  	case 196:
  2230  		return name == "fallthrough"
  2231  	case 207:
  2232  		return name == "map"
  2233  	case 212:
  2234  		return name == "var"
  2235  	case 216:
  2236  		return name == "for"
  2237  	case 229:
  2238  		return name == "if"
  2239  	case 249:
  2240  		return name == "go"
  2241  	}
  2242  	return false
  2243  }
  2244  
  2245  func TwoHash_XorXor_Shift503(name string) bool {
  2246  	if len(name) < 2 {
  2247  		return false
  2248  	}
  2249  	switch ((byte(len(name)) << 5) ^ (name[0] << 0)) ^ (name[1] << 3) {
  2250  	case 5:
  2251  		return name == "map"
  2252  	case 11:
  2253  		return name == "switch"
  2254  	case 14:
  2255  		return name == "fallthrough"
  2256  	case 19:
  2257  		return name == "struct"
  2258  	case 25:
  2259  		return name == "if"
  2260  	case 27:
  2261  		return name == "continue"
  2262  	case 30:
  2263  		return name == "var"
  2264  	case 57:
  2265  		return name == "interface"
  2266  	case 60:
  2267  		return name == "type"
  2268  	case 78:
  2269  		return name == "func"
  2270  	case 82:
  2271  		return name == "break"
  2272  	case 95:
  2273  		return name == "go"
  2274  	case 126:
  2275  		return name == "for"
  2276  	case 133:
  2277  		return name == "else"
  2278  	case 152:
  2279  		return name == "package"
  2280  	case 154:
  2281  		return name == "return"
  2282  	case 155:
  2283  		return name == "select"
  2284  	case 159:
  2285  		return name == "goto"
  2286  	case 163:
  2287  		return name == "chan"
  2288  	case 172:
  2289  		return name == "default"
  2290  	case 187:
  2291  		return name == "const"
  2292  	case 193:
  2293  		return name == "import"
  2294  	case 218:
  2295  		return name == "range"
  2296  	case 235:
  2297  		return name == "case"
  2298  	case 236:
  2299  		return name == "defer"
  2300  	}
  2301  	return false
  2302  }
  2303  
  2304  func TwoHash_XorXor_Shift505(name string) bool {
  2305  	if len(name) < 2 {
  2306  		return false
  2307  	}
  2308  	switch ((byte(len(name)) << 5) ^ (name[0] << 0)) ^ (name[1] << 5) {
  2309  	case 7:
  2310  		return name == "goto"
  2311  	case 9:
  2312  		return name == "import"
  2313  	case 18:
  2314  		return name == "return"
  2315  	case 19:
  2316  		return name == "select"
  2317  	case 35:
  2318  		return name == "const"
  2319  	case 36:
  2320  		return name == "default"
  2321  	case 38:
  2322  		return name == "fallthrough"
  2323  	case 45:
  2324  		return name == "map"
  2325  	case 51:
  2326  		return name == "struct"
  2327  	case 54:
  2328  		return name == "var"
  2329  	case 70:
  2330  		return name == "func"
  2331  	case 83:
  2332  		return name == "switch"
  2333  	case 100:
  2334  		return name == "defer"
  2335  	case 101:
  2336  		return name == "else"
  2337  	case 130:
  2338  		return name == "break"
  2339  	case 131:
  2340  		return name == "continue"
  2341  	case 137:
  2342  		return name == "interface"
  2343  	case 176:
  2344  		return name == "package"
  2345  	case 195:
  2346  		return name == "case"
  2347  	case 199:
  2348  		return name == "go"
  2349  	case 212:
  2350  		return name == "type"
  2351  	case 227:
  2352  		return name == "chan"
  2353  	case 230:
  2354  		return name == "for"
  2355  	case 233:
  2356  		return name == "if"
  2357  	case 242:
  2358  		return name == "range"
  2359  	}
  2360  	return false
  2361  }
  2362  
  2363  func TwoHash_XorXor_Shift510(name string) bool {
  2364  	if len(name) < 2 {
  2365  		return false
  2366  	}
  2367  	switch ((byte(len(name)) << 5) ^ (name[0] << 1)) ^ (name[1] << 0) {
  2368  	case 9:
  2369  		return name == "const"
  2370  	case 13:
  2371  		return name == "defer"
  2372  	case 17:
  2373  		return name == "type"
  2374  	case 22:
  2375  		return name == "break"
  2376  	case 33:
  2377  		return name == "goto"
  2378  	case 37:
  2379  		return name == "range"
  2380  	case 38:
  2381  		return name == "else"
  2382  	case 39:
  2383  		return name == "case"
  2384  	case 46:
  2385  		return name == "chan"
  2386  	case 57:
  2387  		return name == "func"
  2388  	case 65:
  2389  		return name == "return"
  2390  	case 67:
  2391  		return name == "select"
  2392  	case 77:
  2393  		return name == "default"
  2394  	case 81:
  2395  		return name == "switch"
  2396  	case 82:
  2397  		return name == "struct"
  2398  	case 97:
  2399  		return name == "package"
  2400  	case 127:
  2401  		return name == "import"
  2402  	case 156:
  2403  		return name == "interface"
  2404  	case 169:
  2405  		return name == "continue"
  2406  	case 195:
  2407  		return name == "for"
  2408  	case 205:
  2409  		return name == "fallthrough"
  2410  	case 219:
  2411  		return name == "map"
  2412  	case 225:
  2413  		return name == "go"
  2414  	case 237:
  2415  		return name == "var"
  2416  	case 244:
  2417  		return name == "if"
  2418  	}
  2419  	return false
  2420  }
  2421  
  2422  func TwoHash_XorXor_Shift513(name string) bool {
  2423  	if len(name) < 2 {
  2424  		return false
  2425  	}
  2426  	switch ((byte(len(name)) << 5) ^ (name[0] << 1)) ^ (name[1] << 3) {
  2427  	case 0:
  2428  		return name == "default"
  2429  	case 6:
  2430  		return name == "chan"
  2431  	case 8:
  2432  		return name == "package"
  2433  	case 12:
  2434  		return name == "return"
  2435  	case 14:
  2436  		return name == "select"
  2437  	case 30:
  2438  		return name == "const"
  2439  	case 42:
  2440  		return name == "else"
  2441  	case 54:
  2442  		return name == "goto"
  2443  	case 64:
  2444  		return name == "defer"
  2445  	case 76:
  2446  		return name == "range"
  2447  	case 78:
  2448  		return name == "case"
  2449  	case 122:
  2450  		return name == "import"
  2451  	case 130:
  2452  		return name == "interface"
  2453  	case 132:
  2454  		return name == "var"
  2455  	case 134:
  2456  		return name == "struct"
  2457  	case 158:
  2458  		return name == "switch"
  2459  	case 160:
  2460  		return name == "type"
  2461  	case 162:
  2462  		return name == "if"
  2463  	case 164:
  2464  		return name == "fallthrough"
  2465  	case 178:
  2466  		return name == "map"
  2467  	case 190:
  2468  		return name == "continue"
  2469  	case 212:
  2470  		return name == "for"
  2471  	case 228:
  2472  		return name == "func"
  2473  	case 244:
  2474  		return name == "break"
  2475  	case 246:
  2476  		return name == "go"
  2477  	}
  2478  	return false
  2479  }
  2480  
  2481  func TwoHash_XorXor_Shift525(name string) bool {
  2482  	if len(name) < 2 {
  2483  		return false
  2484  	}
  2485  	switch ((byte(len(name)) << 5) ^ (name[0] << 2)) ^ (name[1] << 5) {
  2486  	case 0:
  2487  		return name == "package"
  2488  	case 12:
  2489  		return name == "chan"
  2490  	case 24:
  2491  		return name == "for"
  2492  	case 36:
  2493  		return name == "if"
  2494  	case 44:
  2495  		return name == "case"
  2496  	case 60:
  2497  		return name == "go"
  2498  	case 68:
  2499  		return name == "interface"
  2500  	case 72:
  2501  		return name == "range"
  2502  	case 104:
  2503  		return name == "break"
  2504  	case 108:
  2505  		return name == "continue"
  2506  	case 112:
  2507  		return name == "type"
  2508  	case 140:
  2509  		return name == "struct"
  2510  	case 144:
  2511  		return name == "defer"
  2512  	case 148:
  2513  		return name == "else"
  2514  	case 152:
  2515  		return name == "var"
  2516  	case 168:
  2517  		return name == "return"
  2518  	case 172:
  2519  		return name == "select"
  2520  	case 184:
  2521  		return name == "func"
  2522  	case 196:
  2523  		return name == "import"
  2524  	case 204:
  2525  		return name == "const"
  2526  	case 208:
  2527  		return name == "default"
  2528  	case 216:
  2529  		return name == "fallthrough"
  2530  	case 236:
  2531  		return name == "switch"
  2532  	case 244:
  2533  		return name == "map"
  2534  	case 252:
  2535  		return name == "goto"
  2536  	}
  2537  	return false
  2538  }
  2539  
  2540  func TwoHash_XorXor_Shift602(name string) bool {
  2541  	if len(name) < 2 {
  2542  		return false
  2543  	}
  2544  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) ^ (name[1] << 2) {
  2545  	case 26:
  2546  		return name == "for"
  2547  	case 34:
  2548  		return name == "fallthrough"
  2549  	case 35:
  2550  		return name == "struct"
  2551  	case 41:
  2552  		return name == "map"
  2553  	case 47:
  2554  		return name == "switch"
  2555  	case 48:
  2556  		return name == "default"
  2557  	case 50:
  2558  		return name == "var"
  2559  	case 52:
  2560  		return name == "package"
  2561  	case 91:
  2562  		return name == "go"
  2563  	case 93:
  2564  		return name == "import"
  2565  	case 102:
  2566  		return name == "return"
  2567  	case 103:
  2568  		return name == "select"
  2569  	case 113:
  2570  		return name == "if"
  2571  	case 144:
  2572  		return name == "type"
  2573  	case 145:
  2574  		return name == "interface"
  2575  	case 159:
  2576  		return name == "const"
  2577  	case 176:
  2578  		return name == "defer"
  2579  	case 178:
  2580  		return name == "func"
  2581  	case 182:
  2582  		return name == "range"
  2583  	case 195:
  2584  		return name == "chan"
  2585  	case 213:
  2586  		return name == "else"
  2587  	case 219:
  2588  		return name == "goto"
  2589  	case 223:
  2590  		return name == "continue"
  2591  	case 231:
  2592  		return name == "case"
  2593  	case 234:
  2594  		return name == "break"
  2595  	}
  2596  	return false
  2597  }
  2598  
  2599  func TwoHash_XorXor_Shift603(name string) bool {
  2600  	if len(name) < 2 {
  2601  		return false
  2602  	}
  2603  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) ^ (name[1] << 3) {
  2604  	case 5:
  2605  		return name == "else"
  2606  	case 12:
  2607  		return name == "defer"
  2608  	case 27:
  2609  		return name == "continue"
  2610  	case 31:
  2611  		return name == "goto"
  2612  	case 35:
  2613  		return name == "chan"
  2614  	case 58:
  2615  		return name == "range"
  2616  	case 75:
  2617  		return name == "switch"
  2618  	case 83:
  2619  		return name == "struct"
  2620  	case 89:
  2621  		return name == "interface"
  2622  	case 91:
  2623  		return name == "const"
  2624  	case 107:
  2625  		return name == "case"
  2626  	case 129:
  2627  		return name == "import"
  2628  	case 140:
  2629  		return name == "default"
  2630  	case 159:
  2631  		return name == "go"
  2632  	case 165:
  2633  		return name == "map"
  2634  	case 174:
  2635  		return name == "fallthrough"
  2636  	case 178:
  2637  		return name == "break"
  2638  	case 184:
  2639  		return name == "package"
  2640  	case 188:
  2641  		return name == "type"
  2642  	case 190:
  2643  		return name == "var"
  2644  	case 206:
  2645  		return name == "func"
  2646  	case 217:
  2647  		return name == "if"
  2648  	case 218:
  2649  		return name == "return"
  2650  	case 219:
  2651  		return name == "select"
  2652  	case 222:
  2653  		return name == "for"
  2654  	}
  2655  	return false
  2656  }
  2657  
  2658  func TwoHash_XorXor_Shift604(name string) bool {
  2659  	if len(name) < 2 {
  2660  		return false
  2661  	}
  2662  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) ^ (name[1] << 4) {
  2663  	case 2:
  2664  		return name == "break"
  2665  	case 23:
  2666  		return name == "go"
  2667  	case 34:
  2668  		return name == "range"
  2669  	case 54:
  2670  		return name == "func"
  2671  	case 57:
  2672  		return name == "import"
  2673  	case 86:
  2674  		return name == "for"
  2675  	case 115:
  2676  		return name == "case"
  2677  	case 116:
  2678  		return name == "defer"
  2679  	case 131:
  2680  		return name == "switch"
  2681  	case 137:
  2682  		return name == "if"
  2683  	case 147:
  2684  		return name == "continue"
  2685  	case 151:
  2686  		return name == "goto"
  2687  	case 160:
  2688  		return name == "package"
  2689  	case 162:
  2690  		return name == "return"
  2691  	case 163:
  2692  		return name == "select"
  2693  	case 165:
  2694  		return name == "else"
  2695  	case 166:
  2696  		return name == "var"
  2697  	case 179:
  2698  		return name == "struct"
  2699  	case 182:
  2700  		return name == "fallthrough"
  2701  	case 189:
  2702  		return name == "map"
  2703  	case 201:
  2704  		return name == "interface"
  2705  	case 211:
  2706  		return name == "const"
  2707  	case 227:
  2708  		return name == "chan"
  2709  	case 228:
  2710  		return name == "type"
  2711  	case 244:
  2712  		return name == "default"
  2713  	}
  2714  	return false
  2715  }
  2716  
  2717  func TwoHash_XorXor_Shift605(name string) bool {
  2718  	if len(name) < 2 {
  2719  		return false
  2720  	}
  2721  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) ^ (name[1] << 5) {
  2722  	case 4:
  2723  		return name == "default"
  2724  	case 7:
  2725  		return name == "go"
  2726  	case 18:
  2727  		return name == "range"
  2728  	case 19:
  2729  		return name == "switch"
  2730  	case 41:
  2731  		return name == "if"
  2732  	case 67:
  2733  		return name == "case"
  2734  	case 70:
  2735  		return name == "for"
  2736  	case 73:
  2737  		return name == "import"
  2738  	case 82:
  2739  		return name == "return"
  2740  	case 83:
  2741  		return name == "select"
  2742  	case 84:
  2743  		return name == "type"
  2744  	case 98:
  2745  		return name == "break"
  2746  	case 99:
  2747  		return name == "chan"
  2748  	case 115:
  2749  		return name == "struct"
  2750  	case 131:
  2751  		return name == "continue"
  2752  	case 132:
  2753  		return name == "defer"
  2754  	case 134:
  2755  		return name == "fallthrough"
  2756  	case 135:
  2757  		return name == "goto"
  2758  	case 141:
  2759  		return name == "map"
  2760  	case 144:
  2761  		return name == "package"
  2762  	case 150:
  2763  		return name == "var"
  2764  	case 195:
  2765  		return name == "const"
  2766  	case 198:
  2767  		return name == "func"
  2768  	case 229:
  2769  		return name == "else"
  2770  	case 233:
  2771  		return name == "interface"
  2772  	}
  2773  	return false
  2774  }
  2775  
  2776  func TwoHash_XorXor_Shift630(name string) bool {
  2777  	if len(name) < 2 {
  2778  		return false
  2779  	}
  2780  	switch ((byte(len(name)) << 6) ^ (name[0] << 3)) ^ (name[1] << 0) {
  2781  	case 5:
  2782  		return name == "defer"
  2783  	case 17:
  2784  		return name == "var"
  2785  	case 33:
  2786  		return name == "package"
  2787  	case 34:
  2788  		return name == "break"
  2789  	case 55:
  2790  		return name == "const"
  2791  	case 68:
  2792  		return name == "else"
  2793  	case 69:
  2794  		return name == "func"
  2795  	case 87:
  2796  		return name == "goto"
  2797  	case 102:
  2798  		return name == "interface"
  2799  	case 108:
  2800  		return name == "struct"
  2801  	case 111:
  2802  		return name == "switch"
  2803  	case 112:
  2804  		return name == "chan"
  2805  	case 117:
  2806  		return name == "return"
  2807  	case 119:
  2808  		return name == "continue"
  2809  	case 121:
  2810  		return name == "case"
  2811  	case 125:
  2812  		return name == "select"
  2813  	case 133:
  2814  		return name == "default"
  2815  	case 145:
  2816  		return name == "fallthrough"
  2817  	case 159:
  2818  		return name == "for"
  2819  	case 165:
  2820  		return name == "import"
  2821  	case 174:
  2822  		return name == "if"
  2823  	case 177:
  2824  		return name == "range"
  2825  	case 201:
  2826  		return name == "map"
  2827  	case 215:
  2828  		return name == "go"
  2829  	case 217:
  2830  		return name == "type"
  2831  	}
  2832  	return false
  2833  }
  2834  
  2835  func TwoHash_XorAdd_Shift016(name string) bool {
  2836  	if len(name) < 2 {
  2837  		return false
  2838  	}
  2839  	switch ((byte(len(name)) << 0) ^ (name[0] << 1)) + (name[1] << 6) {
  2840  	case 2:
  2841  		return name == "case"
  2842  	case 7:
  2843  		return name == "fallthrough"
  2844  	case 8:
  2845  		return name == "func"
  2846  	case 13:
  2847  		return name == "defer"
  2848  	case 15:
  2849  		return name == "default"
  2850  	case 20:
  2851  		return name == "import"
  2852  	case 25:
  2853  		return name == "map"
  2854  	case 32:
  2855  		return name == "select"
  2856  	case 33:
  2857  		return name == "range"
  2858  	case 34:
  2859  		return name == "return"
  2860  	case 39:
  2861  		return name == "package"
  2862  	case 44:
  2863  		return name == "type"
  2864  	case 47:
  2865  		return name == "var"
  2866  	case 65:
  2867  		return name == "break"
  2868  	case 80:
  2869  		return name == "if"
  2870  	case 91:
  2871  		return name == "interface"
  2872  	case 131:
  2873  		return name == "const"
  2874  	case 138:
  2875  		return name == "goto"
  2876  	case 140:
  2877  		return name == "go"
  2878  	case 142:
  2879  		return name == "continue"
  2880  	case 143:
  2881  		return name == "for"
  2882  	case 160:
  2883  		return name == "switch"
  2884  	case 194:
  2885  		return name == "chan"
  2886  	case 206:
  2887  		return name == "else"
  2888  	case 224:
  2889  		return name == "struct"
  2890  	}
  2891  	return false
  2892  }
  2893  
  2894  func TwoHash_XorAdd_Shift024(name string) bool {
  2895  	if len(name) < 2 {
  2896  		return false
  2897  	}
  2898  	switch ((byte(len(name)) << 0) ^ (name[0] << 2)) + (name[1] << 4) {
  2899  	case 6:
  2900  		return name == "if"
  2901  	case 8:
  2902  		return name == "chan"
  2903  	case 10:
  2904  		return name == "struct"
  2905  	case 26:
  2906  		return name == "select"
  2907  	case 30:
  2908  		return name == "return"
  2909  	case 58:
  2910  		return name == "switch"
  2911  	case 80:
  2912  		return name == "else"
  2913  	case 100:
  2914  		return name == "type"
  2915  	case 114:
  2916  		return name == "import"
  2917  	case 116:
  2918  		return name == "continue"
  2919  	case 121:
  2920  		return name == "const"
  2921  	case 136:
  2922  		return name == "goto"
  2923  	case 139:
  2924  		return name == "for"
  2925  	case 141:
  2926  		return name == "interface"
  2927  	case 142:
  2928  		return name == "go"
  2929  	case 152:
  2930  		return name == "case"
  2931  	case 163:
  2932  		return name == "fallthrough"
  2933  	case 173:
  2934  		return name == "break"
  2935  	case 199:
  2936  		return name == "map"
  2937  	case 215:
  2938  		return name == "package"
  2939  	case 221:
  2940  		return name == "range"
  2941  	case 229:
  2942  		return name == "defer"
  2943  	case 231:
  2944  		return name == "default"
  2945  	case 235:
  2946  		return name == "var"
  2947  	case 236:
  2948  		return name == "func"
  2949  	}
  2950  	return false
  2951  }
  2952  
  2953  func TwoHash_XorAdd_Shift025(name string) bool {
  2954  	if len(name) < 2 {
  2955  		return false
  2956  	}
  2957  	switch ((byte(len(name)) << 0) ^ (name[0] << 2)) + (name[1] << 5) {
  2958  	case 16:
  2959  		return name == "else"
  2960  	case 53:
  2961  		return name == "defer"
  2962  	case 55:
  2963  		return name == "default"
  2964  	case 60:
  2965  		return name == "func"
  2966  	case 66:
  2967  		return name == "import"
  2968  	case 74:
  2969  		return name == "struct"
  2970  	case 100:
  2971  		return name == "continue"
  2972  	case 102:
  2973  		return name == "if"
  2974  	case 105:
  2975  		return name == "const"
  2976  	case 106:
  2977  		return name == "select"
  2978  	case 109:
  2979  		return name == "interface"
  2980  	case 110:
  2981  		return name == "return"
  2982  	case 120:
  2983  		return name == "goto"
  2984  	case 123:
  2985  		return name == "for"
  2986  	case 126:
  2987  		return name == "go"
  2988  	case 136:
  2989  		return name == "chan"
  2990  	case 168:
  2991  		return name == "case"
  2992  	case 170:
  2993  		return name == "switch"
  2994  	case 179:
  2995  		return name == "fallthrough"
  2996  	case 205:
  2997  		return name == "break"
  2998  	case 215:
  2999  		return name == "map"
  3000  	case 231:
  3001  		return name == "package"
  3002  	case 237:
  3003  		return name == "range"
  3004  	case 244:
  3005  		return name == "type"
  3006  	case 251:
  3007  		return name == "var"
  3008  	}
  3009  	return false
  3010  }
  3011  
  3012  func TwoHash_XorAdd_Shift031(name string) bool {
  3013  	if len(name) < 2 {
  3014  		return false
  3015  	}
  3016  	switch ((byte(len(name)) << 0) ^ (name[0] << 3)) + (name[1] << 1) {
  3017  	case 4:
  3018  		return name == "else"
  3019  	case 17:
  3020  		return name == "for"
  3021  	case 22:
  3022  		return name == "if"
  3023  	case 24:
  3024  		return name == "go"
  3025  	case 26:
  3026  		return name == "goto"
  3027  	case 29:
  3028  		return name == "interface"
  3029  	case 30:
  3030  		return name == "func"
  3031  	case 40:
  3032  		return name == "import"
  3033  	case 45:
  3034  		return name == "map"
  3035  	case 73:
  3036  		return name == "package"
  3037  	case 87:
  3038  		return name == "range"
  3039  	case 96:
  3040  		return name == "return"
  3041  	case 104:
  3042  		return name == "select"
  3043  	case 117:
  3044  		return name == "var"
  3045  	case 134:
  3046  		return name == "struct"
  3047  	case 140:
  3048  		return name == "switch"
  3049  	case 150:
  3050  		return name == "type"
  3051  	case 222:
  3052  		return name == "case"
  3053  	case 236:
  3054  		return name == "chan"
  3055  	case 238:
  3056  		return name == "continue"
  3057  	case 239:
  3058  		return name == "defer"
  3059  	case 241:
  3060  		return name == "default"
  3061  	case 249:
  3062  		return name == "break"
  3063  	case 251:
  3064  		return name == "const"
  3065  	case 253:
  3066  		return name == "fallthrough"
  3067  	}
  3068  	return false
  3069  }
  3070  
  3071  func TwoHash_XorAdd_Shift033(name string) bool {
  3072  	if len(name) < 2 {
  3073  		return false
  3074  	}
  3075  	switch ((byte(len(name)) << 0) ^ (name[0] << 3)) + (name[1] << 3) {
  3076  	case 36:
  3077  		return name == "case"
  3078  	case 62:
  3079  		return name == "struct"
  3080  	case 67:
  3081  		return name == "fallthrough"
  3082  	case 77:
  3083  		return name == "defer"
  3084  	case 79:
  3085  		return name == "default"
  3086  	case 86:
  3087  		return name == "switch"
  3088  	case 92:
  3089  		return name == "chan"
  3090  	case 108:
  3091  		return name == "type"
  3092  	case 115:
  3093  		return name == "map"
  3094  	case 122:
  3095  		return name == "if"
  3096  	case 136:
  3097  		return name == "continue"
  3098  	case 140:
  3099  		return name == "else"
  3100  	case 143:
  3101  		return name == "package"
  3102  	case 149:
  3103  		return name == "const"
  3104  	case 157:
  3105  		return name == "range"
  3106  	case 165:
  3107  		return name == "break"
  3108  	case 171:
  3109  		return name == "for"
  3110  	case 177:
  3111  		return name == "interface"
  3112  	case 178:
  3113  		return name == "go"
  3114  	case 180:
  3115  		return name == "goto"
  3116  	case 182:
  3117  		return name == "import"
  3118  	case 187:
  3119  		return name == "var"
  3120  	case 190:
  3121  		return name == "return"
  3122  	case 198:
  3123  		return name == "select"
  3124  	case 220:
  3125  		return name == "func"
  3126  	}
  3127  	return false
  3128  }
  3129  
  3130  func TwoHash_XorAdd_Shift041(name string) bool {
  3131  	if len(name) < 2 {
  3132  		return false
  3133  	}
  3134  	switch ((byte(len(name)) << 0) ^ (name[0] << 4)) + (name[1] << 1) {
  3135  	case 0:
  3136  		return name == "select"
  3137  	case 4:
  3138  		return name == "chan"
  3139  	case 9:
  3140  		return name == "break"
  3141  	case 15:
  3142  		return name == "defer"
  3143  	case 17:
  3144  		return name == "default"
  3145  	case 19:
  3146  		return name == "const"
  3147  	case 22:
  3148  		return name == "continue"
  3149  	case 30:
  3150  		return name == "struct"
  3151  	case 36:
  3152  		return name == "switch"
  3153  	case 37:
  3154  		return name == "var"
  3155  	case 44:
  3156  		return name == "else"
  3157  	case 45:
  3158  		return name == "fallthrough"
  3159  	case 54:
  3160  		return name == "type"
  3161  	case 65:
  3162  		return name == "for"
  3163  	case 78:
  3164  		return name == "func"
  3165  	case 80:
  3166  		return name == "go"
  3167  	case 82:
  3168  		return name == "goto"
  3169  	case 94:
  3170  		return name == "if"
  3171  	case 112:
  3172  		return name == "import"
  3173  	case 117:
  3174  		return name == "interface"
  3175  	case 149:
  3176  		return name == "map"
  3177  	case 201:
  3178  		return name == "package"
  3179  	case 231:
  3180  		return name == "range"
  3181  	case 240:
  3182  		return name == "return"
  3183  	case 246:
  3184  		return name == "case"
  3185  	}
  3186  	return false
  3187  }
  3188  
  3189  func TwoHash_XorAdd_Shift042(name string) bool {
  3190  	if len(name) < 2 {
  3191  		return false
  3192  	}
  3193  	switch ((byte(len(name)) << 0) ^ (name[0] << 4)) + (name[1] << 2) {
  3194  	case 4:
  3195  		return name == "else"
  3196  	case 6:
  3197  		return name == "struct"
  3198  	case 18:
  3199  		return name == "switch"
  3200  	case 31:
  3201  		return name == "for"
  3202  	case 40:
  3203  		return name == "type"
  3204  	case 42:
  3205  		return name == "if"
  3206  	case 46:
  3207  		return name == "go"
  3208  	case 48:
  3209  		return name == "goto"
  3210  	case 56:
  3211  		return name == "func"
  3212  	case 74:
  3213  		return name == "import"
  3214  	case 81:
  3215  		return name == "interface"
  3216  	case 87:
  3217  		return name == "map"
  3218  	case 139:
  3219  		return name == "package"
  3220  	case 169:
  3221  		return name == "range"
  3222  	case 184:
  3223  		return name == "case"
  3224  	case 186:
  3225  		return name == "return"
  3226  	case 202:
  3227  		return name == "select"
  3228  	case 212:
  3229  		return name == "chan"
  3230  	case 217:
  3231  		return name == "defer"
  3232  	case 219:
  3233  		return name == "default"
  3234  	case 231:
  3235  		return name == "var"
  3236  	case 237:
  3237  		return name == "break"
  3238  	case 239:
  3239  		return name == "fallthrough"
  3240  	case 241:
  3241  		return name == "const"
  3242  	case 244:
  3243  		return name == "continue"
  3244  	}
  3245  	return false
  3246  }
  3247  
  3248  func TwoHash_XorAdd_Shift050(name string) bool {
  3249  	if len(name) < 2 {
  3250  		return false
  3251  	}
  3252  	switch ((byte(len(name)) << 0) ^ (name[0] << 5)) + (name[1] << 0) {
  3253  	case 4:
  3254  		return name == "map"
  3255  	case 16:
  3256  		return name == "else"
  3257  	case 36:
  3258  		return name == "var"
  3259  	case 44:
  3260  		return name == "fallthrough"
  3261  	case 50:
  3262  		return name == "for"
  3263  	case 57:
  3264  		return name == "func"
  3265  	case 81:
  3266  		return name == "go"
  3267  	case 83:
  3268  		return name == "goto"
  3269  	case 104:
  3270  		return name == "package"
  3271  	case 136:
  3272  		return name == "if"
  3273  	case 147:
  3274  		return name == "import"
  3275  	case 151:
  3276  		return name == "interface"
  3277  	case 166:
  3278  		return name == "range"
  3279  	case 171:
  3280  		return name == "return"
  3281  	case 183:
  3282  		return name == "break"
  3283  	case 197:
  3284  		return name == "case"
  3285  	case 203:
  3286  		return name == "select"
  3287  	case 204:
  3288  		return name == "chan"
  3289  	case 212:
  3290  		return name == "const"
  3291  	case 215:
  3292  		return name == "continue"
  3293  	case 218:
  3294  		return name == "struct"
  3295  	case 221:
  3296  		return name == "switch"
  3297  	case 234:
  3298  		return name == "defer"
  3299  	case 236:
  3300  		return name == "default"
  3301  	case 253:
  3302  		return name == "type"
  3303  	}
  3304  	return false
  3305  }
  3306  
  3307  func TwoHash_XorAdd_Shift051(name string) bool {
  3308  	if len(name) < 2 {
  3309  		return false
  3310  	}
  3311  	switch ((byte(len(name)) << 0) ^ (name[0] << 5)) + (name[1] << 1) {
  3312  	case 0:
  3313  		return name == "import"
  3314  	case 5:
  3315  		return name == "interface"
  3316  	case 7:
  3317  		return name == "range"
  3318  	case 16:
  3319  		return name == "return"
  3320  	case 38:
  3321  		return name == "case"
  3322  	case 41:
  3323  		return name == "break"
  3324  	case 48:
  3325  		return name == "select"
  3326  	case 52:
  3327  		return name == "chan"
  3328  	case 67:
  3329  		return name == "const"
  3330  	case 70:
  3331  		return name == "continue"
  3332  	case 78:
  3333  		return name == "struct"
  3334  	case 79:
  3335  		return name == "defer"
  3336  	case 81:
  3337  		return name == "default"
  3338  	case 84:
  3339  		return name == "switch"
  3340  	case 101:
  3341  		return name == "map"
  3342  	case 118:
  3343  		return name == "type"
  3344  	case 124:
  3345  		return name == "else"
  3346  	case 133:
  3347  		return name == "var"
  3348  	case 141:
  3349  		return name == "fallthrough"
  3350  	case 161:
  3351  		return name == "for"
  3352  	case 174:
  3353  		return name == "func"
  3354  	case 192:
  3355  		return name == "go"
  3356  	case 194:
  3357  		return name == "goto"
  3358  	case 201:
  3359  		return name == "package"
  3360  	case 238:
  3361  		return name == "if"
  3362  	}
  3363  	return false
  3364  }
  3365  
  3366  func TwoHash_XorAdd_Shift060(name string) bool {
  3367  	if len(name) < 2 {
  3368  		return false
  3369  	}
  3370  	switch ((byte(len(name)) << 0) ^ (name[0] << 6)) + (name[1] << 0) {
  3371  	case 37:
  3372  		return name == "case"
  3373  	case 43:
  3374  		return name == "select"
  3375  	case 44:
  3376  		return name == "chan"
  3377  	case 49:
  3378  		return name == "go"
  3379  	case 51:
  3380  		return name == "goto"
  3381  	case 52:
  3382  		return name == "const"
  3383  	case 55:
  3384  		return name == "continue"
  3385  	case 58:
  3386  		return name == "struct"
  3387  	case 61:
  3388  		return name == "switch"
  3389  	case 104:
  3390  		return name == "package"
  3391  	case 106:
  3392  		return name == "defer"
  3393  	case 108:
  3394  		return name == "default"
  3395  	case 125:
  3396  		return name == "type"
  3397  	case 164:
  3398  		return name == "map"
  3399  	case 168:
  3400  		return name == "if"
  3401  	case 176:
  3402  		return name == "else"
  3403  	case 179:
  3404  		return name == "import"
  3405  	case 183:
  3406  		return name == "interface"
  3407  	case 228:
  3408  		return name == "var"
  3409  	case 230:
  3410  		return name == "range"
  3411  	case 235:
  3412  		return name == "return"
  3413  	case 236:
  3414  		return name == "fallthrough"
  3415  	case 242:
  3416  		return name == "for"
  3417  	case 247:
  3418  		return name == "break"
  3419  	case 249:
  3420  		return name == "func"
  3421  	}
  3422  	return false
  3423  }
  3424  
  3425  func TwoHash_XorAdd_Shift061(name string) bool {
  3426  	if len(name) < 2 {
  3427  		return false
  3428  	}
  3429  	switch ((byte(len(name)) << 0) ^ (name[0] << 6)) + (name[1] << 1) {
  3430  	case 5:
  3431  		return name == "map"
  3432  	case 14:
  3433  		return name == "if"
  3434  	case 28:
  3435  		return name == "else"
  3436  	case 32:
  3437  		return name == "import"
  3438  	case 37:
  3439  		return name == "interface"
  3440  	case 69:
  3441  		return name == "var"
  3442  	case 71:
  3443  		return name == "range"
  3444  	case 77:
  3445  		return name == "fallthrough"
  3446  	case 80:
  3447  		return name == "return"
  3448  	case 97:
  3449  		return name == "for"
  3450  	case 105:
  3451  		return name == "break"
  3452  	case 110:
  3453  		return name == "func"
  3454  	case 134:
  3455  		return name == "case"
  3456  	case 144:
  3457  		return name == "select"
  3458  	case 148:
  3459  		return name == "chan"
  3460  	case 160:
  3461  		return name == "go"
  3462  	case 162:
  3463  		return name == "goto"
  3464  	case 163:
  3465  		return name == "const"
  3466  	case 166:
  3467  		return name == "continue"
  3468  	case 174:
  3469  		return name == "struct"
  3470  	case 180:
  3471  		return name == "switch"
  3472  	case 201:
  3473  		return name == "package"
  3474  	case 207:
  3475  		return name == "defer"
  3476  	case 209:
  3477  		return name == "default"
  3478  	case 246:
  3479  		return name == "type"
  3480  	}
  3481  	return false
  3482  }
  3483  
  3484  func TwoHash_XorAdd_Shift062(name string) bool {
  3485  	if len(name) < 2 {
  3486  		return false
  3487  	}
  3488  	switch ((byte(len(name)) << 0) ^ (name[0] << 6)) + (name[1] << 2) {
  3489  	case 1:
  3490  		return name == "interface"
  3491  	case 7:
  3492  		return name == "var"
  3493  	case 9:
  3494  		return name == "range"
  3495  	case 15:
  3496  		return name == "fallthrough"
  3497  	case 26:
  3498  		return name == "return"
  3499  	case 63:
  3500  		return name == "for"
  3501  	case 72:
  3502  		return name == "case"
  3503  	case 77:
  3504  		return name == "break"
  3505  	case 88:
  3506  		return name == "func"
  3507  	case 90:
  3508  		return name == "select"
  3509  	case 100:
  3510  		return name == "chan"
  3511  	case 126:
  3512  		return name == "go"
  3513  	case 128:
  3514  		return name == "goto"
  3515  	case 129:
  3516  		return name == "const"
  3517  	case 132:
  3518  		return name == "continue"
  3519  	case 139:
  3520  		return name == "package"
  3521  	case 150:
  3522  		return name == "struct"
  3523  	case 153:
  3524  		return name == "defer"
  3525  	case 155:
  3526  		return name == "default"
  3527  	case 162:
  3528  		return name == "switch"
  3529  	case 199:
  3530  		return name == "map"
  3531  	case 218:
  3532  		return name == "if"
  3533  	case 232:
  3534  		return name == "type"
  3535  	case 244:
  3536  		return name == "else"
  3537  	case 250:
  3538  		return name == "import"
  3539  	}
  3540  	return false
  3541  }
  3542  
  3543  func TwoHash_XorAdd_Shift073(name string) bool {
  3544  	if len(name) < 2 {
  3545  		return false
  3546  	}
  3547  	switch ((byte(len(name)) << 0) ^ (name[0] << 7)) + (name[1] << 3) {
  3548  	case 0:
  3549  		return name == "continue"
  3550  	case 11:
  3551  		return name == "var"
  3552  	case 13:
  3553  		return name == "range"
  3554  	case 15:
  3555  		return name == "package"
  3556  	case 19:
  3557  		return name == "fallthrough"
  3558  	case 38:
  3559  		return name == "struct"
  3560  	case 45:
  3561  		return name == "defer"
  3562  	case 46:
  3563  		return name == "return"
  3564  	case 47:
  3565  		return name == "default"
  3566  	case 62:
  3567  		return name == "switch"
  3568  	case 123:
  3569  		return name == "for"
  3570  	case 139:
  3571  		return name == "map"
  3572  	case 140:
  3573  		return name == "case"
  3574  	case 149:
  3575  		return name == "break"
  3576  	case 172:
  3577  		return name == "func"
  3578  	case 174:
  3579  		return name == "select"
  3580  	case 178:
  3581  		return name == "if"
  3582  	case 196:
  3583  		return name == "chan"
  3584  	case 204:
  3585  		return name == "type"
  3586  	case 228:
  3587  		return name == "else"
  3588  	case 238:
  3589  		return name == "import"
  3590  	case 249:
  3591  		return name == "interface"
  3592  	case 250:
  3593  		return name == "go"
  3594  	case 252:
  3595  		return name == "goto"
  3596  	case 253:
  3597  		return name == "const"
  3598  	}
  3599  	return false
  3600  }
  3601  
  3602  func TwoHash_XorAdd_Shift150(name string) bool {
  3603  	if len(name) < 2 {
  3604  		return false
  3605  	}
  3606  	switch ((byte(len(name)) << 1) ^ (name[0] << 5)) + (name[1] << 0) {
  3607  	case 1:
  3608  		return name == "type"
  3609  	case 7:
  3610  		return name == "map"
  3611  	case 20:
  3612  		return name == "else"
  3613  	case 39:
  3614  		return name == "var"
  3615  	case 53:
  3616  		return name == "for"
  3617  	case 55:
  3618  		return name == "fallthrough"
  3619  	case 61:
  3620  		return name == "func"
  3621  	case 83:
  3622  		return name == "go"
  3623  	case 87:
  3624  		return name == "goto"
  3625  	case 111:
  3626  		return name == "package"
  3627  	case 138:
  3628  		return name == "if"
  3629  	case 153:
  3630  		return name == "import"
  3631  	case 160:
  3632  		return name == "interface"
  3633  	case 171:
  3634  		return name == "range"
  3635  	case 177:
  3636  		return name == "return"
  3637  	case 188:
  3638  		return name == "break"
  3639  	case 201:
  3640  		return name == "case"
  3641  	case 208:
  3642  		return name == "chan"
  3643  	case 209:
  3644  		return name == "select"
  3645  	case 217:
  3646  		return name == "const"
  3647  	case 223:
  3648  		return name == "continue"
  3649  	case 224:
  3650  		return name == "struct"
  3651  	case 227:
  3652  		return name == "switch"
  3653  	case 239:
  3654  		return name == "defer"
  3655  	case 243:
  3656  		return name == "default"
  3657  	}
  3658  	return false
  3659  }
  3660  
  3661  func TwoHash_XorAdd_Shift161(name string) bool {
  3662  	if len(name) < 2 {
  3663  		return false
  3664  	}
  3665  	switch ((byte(len(name)) << 1) ^ (name[0] << 6)) + (name[1] << 1) {
  3666  	case 8:
  3667  		return name == "map"
  3668  	case 16:
  3669  		return name == "if"
  3670  	case 32:
  3671  		return name == "else"
  3672  	case 38:
  3673  		return name == "import"
  3674  	case 46:
  3675  		return name == "interface"
  3676  	case 72:
  3677  		return name == "var"
  3678  	case 76:
  3679  		return name == "range"
  3680  	case 86:
  3681  		return name == "return"
  3682  	case 88:
  3683  		return name == "fallthrough"
  3684  	case 100:
  3685  		return name == "for"
  3686  	case 110:
  3687  		return name == "break"
  3688  	case 114:
  3689  		return name == "func"
  3690  	case 138:
  3691  		return name == "case"
  3692  	case 150:
  3693  		return name == "select"
  3694  	case 152:
  3695  		return name == "chan"
  3696  	case 162:
  3697  		return name == "go"
  3698  	case 166:
  3699  		return name == "goto"
  3700  	case 168:
  3701  		return name == "const"
  3702  	case 174:
  3703  		return name == "continue"
  3704  	case 180:
  3705  		return name == "struct"
  3706  	case 186:
  3707  		return name == "switch"
  3708  	case 208:
  3709  		return name == "package"
  3710  	case 212:
  3711  		return name == "defer"
  3712  	case 216:
  3713  		return name == "default"
  3714  	case 250:
  3715  		return name == "type"
  3716  	}
  3717  	return false
  3718  }
  3719  
  3720  func TwoHash_XorAdd_Shift240(name string) bool {
  3721  	if len(name) < 2 {
  3722  		return false
  3723  	}
  3724  	switch ((byte(len(name)) << 2) ^ (name[0] << 4)) + (name[1] << 0) {
  3725  	case 34:
  3726  		return name == "interface"
  3727  	case 61:
  3728  		return name == "map"
  3729  	case 125:
  3730  		return name == "package"
  3731  	case 127:
  3732  		return name == "continue"
  3733  	case 129:
  3734  		return name == "case"
  3735  	case 136:
  3736  		return name == "chan"
  3737  	case 141:
  3738  		return name == "select"
  3739  	case 147:
  3740  		return name == "const"
  3741  	case 149:
  3742  		return name == "range"
  3743  	case 156:
  3744  		return name == "struct"
  3745  	case 157:
  3746  		return name == "return"
  3747  	case 159:
  3748  		return name == "switch"
  3749  	case 166:
  3750  		return name == "break"
  3751  	case 172:
  3752  		return name == "else"
  3753  	case 173:
  3754  		return name == "fallthrough"
  3755  	case 185:
  3756  		return name == "defer"
  3757  	case 193:
  3758  		return name == "default"
  3759  	case 201:
  3760  		return name == "type"
  3761  	case 205:
  3762  		return name == "var"
  3763  	case 207:
  3764  		return name == "goto"
  3765  	case 219:
  3766  		return name == "for"
  3767  	case 229:
  3768  		return name == "func"
  3769  	case 231:
  3770  		return name == "go"
  3771  	case 245:
  3772  		return name == "import"
  3773  	case 254:
  3774  		return name == "if"
  3775  	}
  3776  	return false
  3777  }
  3778  
  3779  func TwoHash_XorAdd_Shift250(name string) bool {
  3780  	if len(name) < 2 {
  3781  		return false
  3782  	}
  3783  	switch ((byte(len(name)) << 2) ^ (name[0] << 5)) + (name[1] << 0) {
  3784  	case 1:
  3785  		return name == "default"
  3786  	case 9:
  3787  		return name == "type"
  3788  	case 13:
  3789  		return name == "map"
  3790  	case 28:
  3791  		return name == "else"
  3792  	case 45:
  3793  		return name == "var"
  3794  	case 59:
  3795  		return name == "for"
  3796  	case 69:
  3797  		return name == "func"
  3798  	case 77:
  3799  		return name == "fallthrough"
  3800  	case 87:
  3801  		return name == "go"
  3802  	case 95:
  3803  		return name == "goto"
  3804  	case 114:
  3805  		return name == "interface"
  3806  	case 125:
  3807  		return name == "package"
  3808  	case 142:
  3809  		return name == "if"
  3810  	case 165:
  3811  		return name == "import"
  3812  	case 175:
  3813  		return name == "continue"
  3814  	case 181:
  3815  		return name == "range"
  3816  	case 189:
  3817  		return name == "return"
  3818  	case 198:
  3819  		return name == "break"
  3820  	case 209:
  3821  		return name == "case"
  3822  	case 216:
  3823  		return name == "chan"
  3824  	case 221:
  3825  		return name == "select"
  3826  	case 227:
  3827  		return name == "const"
  3828  	case 236:
  3829  		return name == "struct"
  3830  	case 239:
  3831  		return name == "switch"
  3832  	case 249:
  3833  		return name == "defer"
  3834  	}
  3835  	return false
  3836  }
  3837  
  3838  func TwoHash_XorAdd_Shift302(name string) bool {
  3839  	if len(name) < 2 {
  3840  		return false
  3841  	}
  3842  	switch ((byte(len(name)) << 3) ^ (name[0] << 0)) + (name[1] << 2) {
  3843  	case 3:
  3844  		return name == "goto"
  3845  	case 7:
  3846  		return name == "const"
  3847  	case 13:
  3848  		return name == "import"
  3849  	case 17:
  3850  		return name == "if"
  3851  	case 18:
  3852  		return name == "break"
  3853  	case 19:
  3854  		return name == "struct"
  3855  	case 26:
  3856  		return name == "func"
  3857  	case 31:
  3858  		return name == "switch"
  3859  	case 51:
  3860  		return name == "go"
  3861  	case 56:
  3862  		return name == "type"
  3863  	case 58:
  3864  		return name == "for"
  3865  	case 194:
  3866  		return name == "fallthrough"
  3867  	case 199:
  3868  		return name == "case"
  3869  	case 204:
  3870  		return name == "package"
  3871  	case 214:
  3872  		return name == "return"
  3873  	case 215:
  3874  		return name == "select"
  3875  	case 217:
  3876  		return name == "interface"
  3877  	case 222:
  3878  		return name == "range"
  3879  	case 223:
  3880  		return name == "continue"
  3881  	case 224:
  3882  		return name == "defer"
  3883  	case 227:
  3884  		return name == "chan"
  3885  	case 240:
  3886  		return name == "default"
  3887  	case 242:
  3888  		return name == "var"
  3889  	case 245:
  3890  		return name == "else"
  3891  	case 249:
  3892  		return name == "map"
  3893  	}
  3894  	return false
  3895  }
  3896  
  3897  func TwoHash_XorAdd_Shift303(name string) bool {
  3898  	if len(name) < 2 {
  3899  		return false
  3900  	}
  3901  	switch ((byte(len(name)) << 3) ^ (name[0] << 0)) + (name[1] << 3) {
  3902  	case 28:
  3903  		return name == "type"
  3904  	case 70:
  3905  		return name == "fallthrough"
  3906  	case 75:
  3907  		return name == "case"
  3908  	case 80:
  3909  		return name == "package"
  3910  	case 98:
  3911  		return name == "range"
  3912  	case 106:
  3913  		return name == "return"
  3914  	case 107:
  3915  		return name == "select"
  3916  	case 116:
  3917  		return name == "defer"
  3918  	case 118:
  3919  		return name == "var"
  3920  	case 125:
  3921  		return name == "map"
  3922  	case 131:
  3923  		return name == "chan"
  3924  	case 132:
  3925  		return name == "default"
  3926  	case 145:
  3927  		return name == "interface"
  3928  	case 155:
  3929  		return name == "continue"
  3930  	case 165:
  3931  		return name == "else"
  3932  	case 169:
  3933  		return name == "if"
  3934  	case 191:
  3935  		return name == "goto"
  3936  	case 193:
  3937  		return name == "import"
  3938  	case 195:
  3939  		return name == "const"
  3940  	case 218:
  3941  		return name == "break"
  3942  	case 227:
  3943  		return name == "struct"
  3944  	case 238:
  3945  		return name == "func"
  3946  	case 239:
  3947  		return name == "go"
  3948  	case 246:
  3949  		return name == "for"
  3950  	case 251:
  3951  		return name == "switch"
  3952  	}
  3953  	return false
  3954  }
  3955  
  3956  func TwoHash_XorAdd_Shift351(name string) bool {
  3957  	if len(name) < 2 {
  3958  		return false
  3959  	}
  3960  	switch ((byte(len(name)) << 3) ^ (name[0] << 5)) + (name[1] << 1) {
  3961  	case 2:
  3962  		return name == "case"
  3963  	case 16:
  3964  		return name == "chan"
  3965  	case 26:
  3966  		return name == "select"
  3967  	case 38:
  3968  		return name == "const"
  3969  	case 42:
  3970  		return name == "range"
  3971  	case 56:
  3972  		return name == "struct"
  3973  	case 58:
  3974  		return name == "return"
  3975  	case 62:
  3976  		return name == "switch"
  3977  	case 68:
  3978  		return name == "interface"
  3979  	case 76:
  3980  		return name == "break"
  3981  	case 88:
  3982  		return name == "else"
  3983  	case 90:
  3984  		return name == "fallthrough"
  3985  	case 114:
  3986  		return name == "defer"
  3987  	case 122:
  3988  		return name == "map"
  3989  	case 130:
  3990  		return name == "default"
  3991  	case 146:
  3992  		return name == "type"
  3993  	case 154:
  3994  		return name == "var"
  3995  	case 158:
  3996  		return name == "goto"
  3997  	case 182:
  3998  		return name == "for"
  3999  	case 202:
  4000  		return name == "func"
  4001  	case 206:
  4002  		return name == "go"
  4003  	case 234:
  4004  		return name == "import"
  4005  	case 250:
  4006  		return name == "package"
  4007  	case 252:
  4008  		return name == "if"
  4009  	case 254:
  4010  		return name == "continue"
  4011  	}
  4012  	return false
  4013  }
  4014  
  4015  func TwoHash_XorAdd_Shift361(name string) bool {
  4016  	if len(name) < 2 {
  4017  		return false
  4018  	}
  4019  	switch ((byte(len(name)) << 3) ^ (name[0] << 6)) + (name[1] << 1) {
  4020  	case 2:
  4021  		return name == "default"
  4022  	case 18:
  4023  		return name == "type"
  4024  	case 26:
  4025  		return name == "map"
  4026  	case 28:
  4027  		return name == "if"
  4028  	case 56:
  4029  		return name == "else"
  4030  	case 74:
  4031  		return name == "import"
  4032  	case 90:
  4033  		return name == "var"
  4034  	case 94:
  4035  		return name == "continue"
  4036  	case 106:
  4037  		return name == "range"
  4038  	case 118:
  4039  		return name == "for"
  4040  	case 122:
  4041  		return name == "return"
  4042  	case 138:
  4043  		return name == "func"
  4044  	case 140:
  4045  		return name == "break"
  4046  	case 154:
  4047  		return name == "fallthrough"
  4048  	case 162:
  4049  		return name == "case"
  4050  	case 174:
  4051  		return name == "go"
  4052  	case 176:
  4053  		return name == "chan"
  4054  	case 186:
  4055  		return name == "select"
  4056  	case 190:
  4057  		return name == "goto"
  4058  	case 198:
  4059  		return name == "const"
  4060  	case 216:
  4061  		return name == "struct"
  4062  	case 222:
  4063  		return name == "switch"
  4064  	case 228:
  4065  		return name == "interface"
  4066  	case 242:
  4067  		return name == "defer"
  4068  	case 250:
  4069  		return name == "package"
  4070  	}
  4071  	return false
  4072  }
  4073  
  4074  func TwoHash_XorAdd_Shift400(name string) bool {
  4075  	if len(name) < 2 {
  4076  		return false
  4077  	}
  4078  	switch ((byte(len(name)) << 4) ^ (name[0] << 0)) + (name[1] << 0) {
  4079  	case 55:
  4080  		return name == "fallthrough"
  4081  	case 82:
  4082  		return name == "continue"
  4083  	case 97:
  4084  		return name == "package"
  4085  	case 103:
  4086  		return name == "interface"
  4087  	case 118:
  4088  		return name == "import"
  4089  	case 119:
  4090  		return name == "return"
  4091  	case 120:
  4092  		return name == "select"
  4093  	case 121:
  4094  		return name == "default"
  4095  	case 131:
  4096  		return name == "range"
  4097  	case 132:
  4098  		return name == "case"
  4099  	case 135:
  4100  		return name == "struct"
  4101  	case 138:
  4102  		return name == "switch"
  4103  	case 139:
  4104  		return name == "chan"
  4105  	case 145:
  4106  		return name == "else"
  4107  	case 150:
  4108  		return name == "goto"
  4109  	case 153:
  4110  		return name == "defer"
  4111  	case 155:
  4112  		return name == "func"
  4113  	case 162:
  4114  		return name == "const"
  4115  	case 164:
  4116  		return name == "break"
  4117  	case 167:
  4118  		return name == "var"
  4119  	case 173:
  4120  		return name == "type"
  4121  	case 175:
  4122  		return name == "if"
  4123  	case 182:
  4124  		return name == "go"
  4125  	case 190:
  4126  		return name == "map"
  4127  	case 197:
  4128  		return name == "for"
  4129  	}
  4130  	return false
  4131  }
  4132  
  4133  func TwoHash_XorAdd_Shift401(name string) bool {
  4134  	if len(name) < 2 {
  4135  		return false
  4136  	}
  4137  	switch ((byte(len(name)) << 4) ^ (name[0] << 0)) + (name[1] << 1) {
  4138  	case 1:
  4139  		return name == "switch"
  4140  	case 5:
  4141  		return name == "goto"
  4142  	case 8:
  4143  		return name == "var"
  4144  	case 16:
  4145  		return name == "func"
  4146  	case 17:
  4147  		return name == "const"
  4148  	case 21:
  4149  		return name == "if"
  4150  	case 22:
  4151  		return name == "break"
  4152  	case 31:
  4153  		return name == "map"
  4154  	case 37:
  4155  		return name == "go"
  4156  	case 38:
  4157  		return name == "type"
  4158  	case 52:
  4159  		return name == "for"
  4160  	case 152:
  4161  		return name == "fallthrough"
  4162  	case 193:
  4163  		return name == "continue"
  4164  	case 194:
  4165  		return name == "package"
  4166  	case 213:
  4167  		return name == "interface"
  4168  	case 220:
  4169  		return name == "return"
  4170  	case 221:
  4171  		return name == "select"
  4172  	case 222:
  4173  		return name == "default"
  4174  	case 227:
  4175  		return name == "import"
  4176  	case 228:
  4177  		return name == "range"
  4178  	case 229:
  4179  		return name == "case"
  4180  	case 243:
  4181  		return name == "chan"
  4182  	case 251:
  4183  		return name == "struct"
  4184  	case 253:
  4185  		return name == "else"
  4186  	case 254:
  4187  		return name == "defer"
  4188  	}
  4189  	return false
  4190  }
  4191  
  4192  func TwoHash_XorAdd_Shift405(name string) bool {
  4193  	if len(name) < 2 {
  4194  		return false
  4195  	}
  4196  	switch ((byte(len(name)) << 4) ^ (name[0] << 0)) + (name[1] << 5) {
  4197  	case 7:
  4198  		return name == "goto"
  4199  	case 9:
  4200  		return name == "if"
  4201  	case 19:
  4202  		return name == "const"
  4203  	case 32:
  4204  		return name == "package"
  4205  	case 35:
  4206  		return name == "chan"
  4207  	case 39:
  4208  		return name == "go"
  4209  	case 54:
  4210  		return name == "for"
  4211  	case 66:
  4212  		return name == "range"
  4213  	case 67:
  4214  		return name == "case"
  4215  	case 84:
  4216  		return name == "type"
  4217  	case 102:
  4218  		return name == "var"
  4219  	case 114:
  4220  		return name == "break"
  4221  	case 125:
  4222  		return name == "map"
  4223  	case 147:
  4224  		return name == "struct"
  4225  	case 165:
  4226  		return name == "else"
  4227  	case 169:
  4228  		return name == "import"
  4229  	case 178:
  4230  		return name == "return"
  4231  	case 179:
  4232  		return name == "select"
  4233  	case 180:
  4234  		return name == "default"
  4235  	case 185:
  4236  		return name == "interface"
  4237  	case 195:
  4238  		return name == "continue"
  4239  	case 198:
  4240  		return name == "func"
  4241  	case 212:
  4242  		return name == "defer"
  4243  	case 243:
  4244  		return name == "switch"
  4245  	case 246:
  4246  		return name == "fallthrough"
  4247  	}
  4248  	return false
  4249  }
  4250  
  4251  func TwoHash_XorAdd_Shift413(name string) bool {
  4252  	if len(name) < 2 {
  4253  		return false
  4254  	}
  4255  	switch ((byte(len(name)) << 4) ^ (name[0] << 1)) + (name[1] << 3) {
  4256  	case 6:
  4257  		return name == "goto"
  4258  	case 14:
  4259  		return name == "const"
  4260  	case 26:
  4261  		return name == "import"
  4262  	case 34:
  4263  		return name == "if"
  4264  	case 36:
  4265  		return name == "break"
  4266  	case 38:
  4267  		return name == "struct"
  4268  	case 52:
  4269  		return name == "func"
  4270  	case 62:
  4271  		return name == "switch"
  4272  	case 102:
  4273  		return name == "go"
  4274  	case 112:
  4275  		return name == "type"
  4276  	case 116:
  4277  		return name == "for"
  4278  	case 132:
  4279  		return name == "fallthrough"
  4280  	case 142:
  4281  		return name == "case"
  4282  	case 152:
  4283  		return name == "package"
  4284  	case 172:
  4285  		return name == "return"
  4286  	case 174:
  4287  		return name == "select"
  4288  	case 178:
  4289  		return name == "interface"
  4290  	case 188:
  4291  		return name == "range"
  4292  	case 190:
  4293  		return name == "continue"
  4294  	case 192:
  4295  		return name == "defer"
  4296  	case 198:
  4297  		return name == "chan"
  4298  	case 224:
  4299  		return name == "default"
  4300  	case 228:
  4301  		return name == "var"
  4302  	case 234:
  4303  		return name == "else"
  4304  	case 242:
  4305  		return name == "map"
  4306  	}
  4307  	return false
  4308  }
  4309  
  4310  func TwoHash_XorAdd_Shift500(name string) bool {
  4311  	if len(name) < 2 {
  4312  		return false
  4313  	}
  4314  	switch ((byte(len(name)) << 5) ^ (name[0] << 0)) + (name[1] << 0) {
  4315  	case 22:
  4316  		return name == "import"
  4317  	case 23:
  4318  		return name == "return"
  4319  	case 24:
  4320  		return name == "select"
  4321  	case 39:
  4322  		return name == "struct"
  4323  	case 41:
  4324  		return name == "defer"
  4325  	case 42:
  4326  		return name == "switch"
  4327  	case 50:
  4328  		return name == "const"
  4329  	case 51:
  4330  		return name == "range"
  4331  	case 52:
  4332  		return name == "break"
  4333  	case 68:
  4334  		return name == "case"
  4335  	case 75:
  4336  		return name == "chan"
  4337  	case 81:
  4338  		return name == "else"
  4339  	case 86:
  4340  		return name == "goto"
  4341  	case 91:
  4342  		return name == "func"
  4343  	case 103:
  4344  		return name == "fallthrough"
  4345  	case 109:
  4346  		return name == "type"
  4347  	case 110:
  4348  		return name == "map"
  4349  	case 117:
  4350  		return name == "for"
  4351  	case 119:
  4352  		return name == "var"
  4353  	case 143:
  4354  		return name == "if"
  4355  	case 150:
  4356  		return name == "go"
  4357  	case 183:
  4358  		return name == "interface"
  4359  	case 210:
  4360  		return name == "continue"
  4361  	case 233:
  4362  		return name == "default"
  4363  	case 241:
  4364  		return name == "package"
  4365  	}
  4366  	return false
  4367  }
  4368  
  4369  func TwoHash_XorAdd_Shift505(name string) bool {
  4370  	if len(name) < 2 {
  4371  		return false
  4372  	}
  4373  	switch ((byte(len(name)) << 5) ^ (name[0] << 0)) + (name[1] << 5) {
  4374  	case 2:
  4375  		return name == "break"
  4376  	case 3:
  4377  		return name == "case"
  4378  	case 7:
  4379  		return name == "go"
  4380  	case 9:
  4381  		return name == "interface"
  4382  	case 20:
  4383  		return name == "type"
  4384  	case 36:
  4385  		return name == "default"
  4386  	case 38:
  4387  		return name == "fallthrough"
  4388  	case 45:
  4389  		return name == "map"
  4390  	case 51:
  4391  		return name == "struct"
  4392  	case 54:
  4393  		return name == "var"
  4394  	case 67:
  4395  		return name == "continue"
  4396  	case 73:
  4397  		return name == "import"
  4398  	case 82:
  4399  		return name == "return"
  4400  	case 83:
  4401  		return name == "select"
  4402  	case 100:
  4403  		return name == "defer"
  4404  	case 101:
  4405  		return name == "else"
  4406  	case 134:
  4407  		return name == "func"
  4408  	case 147:
  4409  		return name == "switch"
  4410  	case 163:
  4411  		return name == "const"
  4412  	case 176:
  4413  		return name == "package"
  4414  	case 199:
  4415  		return name == "goto"
  4416  	case 227:
  4417  		return name == "chan"
  4418  	case 230:
  4419  		return name == "for"
  4420  	case 233:
  4421  		return name == "if"
  4422  	case 242:
  4423  		return name == "range"
  4424  	}
  4425  	return false
  4426  }
  4427  
  4428  func TwoHash_XorAdd_Shift511(name string) bool {
  4429  	if len(name) < 2 {
  4430  		return false
  4431  	}
  4432  	switch ((byte(len(name)) << 5) ^ (name[0] << 1)) + (name[1] << 1) {
  4433  	case 6:
  4434  		return name == "range"
  4435  	case 8:
  4436  		return name == "case"
  4437  	case 14:
  4438  		return name == "struct"
  4439  	case 20:
  4440  		return name == "switch"
  4441  	case 22:
  4442  		return name == "chan"
  4443  	case 34:
  4444  		return name == "else"
  4445  	case 44:
  4446  		return name == "goto"
  4447  	case 50:
  4448  		return name == "defer"
  4449  	case 54:
  4450  		return name == "func"
  4451  	case 68:
  4452  		return name == "const"
  4453  	case 72:
  4454  		return name == "break"
  4455  	case 78:
  4456  		return name == "var"
  4457  	case 90:
  4458  		return name == "type"
  4459  	case 94:
  4460  		return name == "if"
  4461  	case 108:
  4462  		return name == "go"
  4463  	case 110:
  4464  		return name == "fallthrough"
  4465  	case 124:
  4466  		return name == "map"
  4467  	case 138:
  4468  		return name == "for"
  4469  	case 164:
  4470  		return name == "continue"
  4471  	case 194:
  4472  		return name == "package"
  4473  	case 206:
  4474  		return name == "interface"
  4475  	case 236:
  4476  		return name == "import"
  4477  	case 238:
  4478  		return name == "return"
  4479  	case 240:
  4480  		return name == "select"
  4481  	case 242:
  4482  		return name == "default"
  4483  	}
  4484  	return false
  4485  }
  4486  
  4487  func TwoHash_XorAdd_Shift512(name string) bool {
  4488  	if len(name) < 2 {
  4489  		return false
  4490  	}
  4491  	switch ((byte(len(name)) << 5) ^ (name[0] << 1)) + (name[1] << 2) {
  4492  	case 2:
  4493  		return name == "switch"
  4494  	case 10:
  4495  		return name == "goto"
  4496  	case 16:
  4497  		return name == "var"
  4498  	case 32:
  4499  		return name == "func"
  4500  	case 34:
  4501  		return name == "const"
  4502  	case 42:
  4503  		return name == "if"
  4504  	case 44:
  4505  		return name == "break"
  4506  	case 48:
  4507  		return name == "fallthrough"
  4508  	case 62:
  4509  		return name == "map"
  4510  	case 74:
  4511  		return name == "go"
  4512  	case 76:
  4513  		return name == "type"
  4514  	case 104:
  4515  		return name == "for"
  4516  	case 130:
  4517  		return name == "continue"
  4518  	case 132:
  4519  		return name == "package"
  4520  	case 170:
  4521  		return name == "interface"
  4522  	case 184:
  4523  		return name == "return"
  4524  	case 186:
  4525  		return name == "select"
  4526  	case 188:
  4527  		return name == "default"
  4528  	case 198:
  4529  		return name == "import"
  4530  	case 200:
  4531  		return name == "range"
  4532  	case 202:
  4533  		return name == "case"
  4534  	case 230:
  4535  		return name == "chan"
  4536  	case 246:
  4537  		return name == "struct"
  4538  	case 250:
  4539  		return name == "else"
  4540  	case 252:
  4541  		return name == "defer"
  4542  	}
  4543  	return false
  4544  }
  4545  
  4546  func TwoHash_XorAdd_Shift601(name string) bool {
  4547  	if len(name) < 2 {
  4548  		return false
  4549  	}
  4550  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) + (name[1] << 1) {
  4551  	case 1:
  4552  		return name == "const"
  4553  	case 5:
  4554  		return name == "interface"
  4555  	case 6:
  4556  		return name == "break"
  4557  	case 37:
  4558  		return name == "case"
  4559  	case 51:
  4560  		return name == "chan"
  4561  	case 61:
  4562  		return name == "else"
  4563  	case 65:
  4564  		return name == "continue"
  4565  	case 69:
  4566  		return name == "goto"
  4567  	case 80:
  4568  		return name == "func"
  4569  	case 102:
  4570  		return name == "type"
  4571  	case 104:
  4572  		return name == "fallthrough"
  4573  	case 110:
  4574  		return name == "default"
  4575  	case 111:
  4576  		return name == "map"
  4577  	case 114:
  4578  		return name == "package"
  4579  	case 120:
  4580  		return name == "var"
  4581  	case 132:
  4582  		return name == "for"
  4583  	case 181:
  4584  		return name == "if"
  4585  	case 188:
  4586  		return name == "return"
  4587  	case 189:
  4588  		return name == "select"
  4589  	case 195:
  4590  		return name == "import"
  4591  	case 197:
  4592  		return name == "go"
  4593  	case 219:
  4594  		return name == "struct"
  4595  	case 225:
  4596  		return name == "switch"
  4597  	case 238:
  4598  		return name == "defer"
  4599  	case 244:
  4600  		return name == "range"
  4601  	}
  4602  	return false
  4603  }
  4604  
  4605  func TwoHash_XorAdd_Shift603(name string) bool {
  4606  	if len(name) < 2 {
  4607  		return false
  4608  	}
  4609  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) + (name[1] << 3) {
  4610  	case 14:
  4611  		return name == "func"
  4612  	case 25:
  4613  		return name == "if"
  4614  	case 26:
  4615  		return name == "return"
  4616  	case 27:
  4617  		return name == "select"
  4618  	case 30:
  4619  		return name == "for"
  4620  	case 58:
  4621  		return name == "range"
  4622  	case 60:
  4623  		return name == "type"
  4624  	case 76:
  4625  		return name == "defer"
  4626  	case 81:
  4627  		return name == "import"
  4628  	case 95:
  4629  		return name == "go"
  4630  	case 107:
  4631  		return name == "case"
  4632  	case 147:
  4633  		return name == "struct"
  4634  	case 153:
  4635  		return name == "interface"
  4636  	case 155:
  4637  		return name == "const"
  4638  	case 163:
  4639  		return name == "chan"
  4640  	case 171:
  4641  		return name == "switch"
  4642  	case 174:
  4643  		return name == "fallthrough"
  4644  	case 178:
  4645  		return name == "break"
  4646  	case 181:
  4647  		return name == "map"
  4648  	case 184:
  4649  		return name == "package"
  4650  	case 190:
  4651  		return name == "var"
  4652  	case 197:
  4653  		return name == "else"
  4654  	case 204:
  4655  		return name == "default"
  4656  	case 219:
  4657  		return name == "continue"
  4658  	case 223:
  4659  		return name == "goto"
  4660  	}
  4661  	return false
  4662  }
  4663  
  4664  func TwoHash_XorAdd_Shift605(name string) bool {
  4665  	if len(name) < 2 {
  4666  		return false
  4667  	}
  4668  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) + (name[1] << 5) {
  4669  	case 3:
  4670  		return name == "const"
  4671  	case 6:
  4672  		return name == "func"
  4673  	case 67:
  4674  		return name == "continue"
  4675  	case 68:
  4676  		return name == "default"
  4677  	case 71:
  4678  		return name == "goto"
  4679  	case 82:
  4680  		return name == "range"
  4681  	case 98:
  4682  		return name == "break"
  4683  	case 99:
  4684  		return name == "chan"
  4685  	case 115:
  4686  		return name == "struct"
  4687  	case 131:
  4688  		return name == "case"
  4689  	case 134:
  4690  		return name == "for"
  4691  	case 137:
  4692  		return name == "import"
  4693  	case 146:
  4694  		return name == "return"
  4695  	case 147:
  4696  		return name == "select"
  4697  	case 148:
  4698  		return name == "type"
  4699  	case 169:
  4700  		return name == "if"
  4701  	case 196:
  4702  		return name == "defer"
  4703  	case 198:
  4704  		return name == "fallthrough"
  4705  	case 199:
  4706  		return name == "go"
  4707  	case 205:
  4708  		return name == "map"
  4709  	case 208:
  4710  		return name == "package"
  4711  	case 211:
  4712  		return name == "switch"
  4713  	case 214:
  4714  		return name == "var"
  4715  	case 229:
  4716  		return name == "else"
  4717  	case 233:
  4718  		return name == "interface"
  4719  	}
  4720  	return false
  4721  }
  4722  
  4723  func TwoHash_XorAdd_Shift606(name string) bool {
  4724  	if len(name) < 2 {
  4725  		return false
  4726  	}
  4727  	switch ((byte(len(name)) << 6) ^ (name[0] << 0)) + (name[1] << 6) {
  4728  	case 35:
  4729  		return name == "continue"
  4730  	case 39:
  4731  		return name == "goto"
  4732  	case 41:
  4733  		return name == "import"
  4734  	case 50:
  4735  		return name == "return"
  4736  	case 51:
  4737  		return name == "select"
  4738  	case 99:
  4739  		return name == "chan"
  4740  	case 100:
  4741  		return name == "defer"
  4742  	case 101:
  4743  		return name == "else"
  4744  	case 102:
  4745  		return name == "for"
  4746  	case 105:
  4747  		return name == "if"
  4748  	case 114:
  4749  		return name == "range"
  4750  	case 162:
  4751  		return name == "break"
  4752  	case 163:
  4753  		return name == "case"
  4754  	case 166:
  4755  		return name == "func"
  4756  	case 167:
  4757  		return name == "go"
  4758  	case 169:
  4759  		return name == "interface"
  4760  	case 179:
  4761  		return name == "switch"
  4762  	case 180:
  4763  		return name == "type"
  4764  	case 227:
  4765  		return name == "const"
  4766  	case 228:
  4767  		return name == "default"
  4768  	case 230:
  4769  		return name == "fallthrough"
  4770  	case 237:
  4771  		return name == "map"
  4772  	case 240:
  4773  		return name == "package"
  4774  	case 243:
  4775  		return name == "struct"
  4776  	case 246:
  4777  		return name == "var"
  4778  	}
  4779  	return false
  4780  }
  4781  
  4782  func TwoHash_XorAdd_Shift616(name string) bool {
  4783  	if len(name) < 2 {
  4784  		return false
  4785  	}
  4786  	switch ((byte(len(name)) << 6) ^ (name[0] << 1)) + (name[1] << 6) {
  4787  	case 4:
  4788  		return name == "break"
  4789  	case 6:
  4790  		return name == "case"
  4791  	case 12:
  4792  		return name == "func"
  4793  	case 14:
  4794  		return name == "go"
  4795  	case 18:
  4796  		return name == "interface"
  4797  	case 38:
  4798  		return name == "switch"
  4799  	case 40:
  4800  		return name == "type"
  4801  	case 70:
  4802  		return name == "const"
  4803  	case 72:
  4804  		return name == "default"
  4805  	case 76:
  4806  		return name == "fallthrough"
  4807  	case 90:
  4808  		return name == "map"
  4809  	case 96:
  4810  		return name == "package"
  4811  	case 102:
  4812  		return name == "struct"
  4813  	case 108:
  4814  		return name == "var"
  4815  	case 134:
  4816  		return name == "continue"
  4817  	case 142:
  4818  		return name == "goto"
  4819  	case 146:
  4820  		return name == "import"
  4821  	case 164:
  4822  		return name == "return"
  4823  	case 166:
  4824  		return name == "select"
  4825  	case 198:
  4826  		return name == "chan"
  4827  	case 200:
  4828  		return name == "defer"
  4829  	case 202:
  4830  		return name == "else"
  4831  	case 204:
  4832  		return name == "for"
  4833  	case 210:
  4834  		return name == "if"
  4835  	case 228:
  4836  		return name == "range"
  4837  	}
  4838  	return false
  4839  }
  4840  
  4841  func TwoHash_XorAdd_Shift620(name string) bool {
  4842  	if len(name) < 2 {
  4843  		return false
  4844  	}
  4845  	switch ((byte(len(name)) << 6) ^ (name[0] << 2)) + (name[1] << 0) {
  4846  	case 0:
  4847  		return name == "else"
  4848  	case 11:
  4849  		return name == "goto"
  4850  	case 13:
  4851  		return name == "func"
  4852  	case 53:
  4853  		return name == "defer"
  4854  	case 58:
  4855  		return name == "break"
  4856  	case 59:
  4857  		return name == "const"
  4858  	case 73:
  4859  		return name == "type"
  4860  	case 82:
  4861  		return name == "interface"
  4862  	case 97:
  4863  		return name == "package"
  4864  	case 121:
  4865  		return name == "var"
  4866  	case 138:
  4867  		return name == "if"
  4868  	case 139:
  4869  		return name == "go"
  4870  	case 145:
  4871  		return name == "import"
  4872  	case 173:
  4873  		return name == "return"
  4874  	case 177:
  4875  		return name == "select"
  4876  	case 181:
  4877  		return name == "default"
  4878  	case 185:
  4879  		return name == "fallthrough"
  4880  	case 192:
  4881  		return name == "struct"
  4882  	case 195:
  4883  		return name == "switch"
  4884  	case 199:
  4885  		return name == "for"
  4886  	case 213:
  4887  		return name == "map"
  4888  	case 233:
  4889  		return name == "range"
  4890  	case 237:
  4891  		return name == "case"
  4892  	case 244:
  4893  		return name == "chan"
  4894  	case 251:
  4895  		return name == "continue"
  4896  	}
  4897  	return false
  4898  }
  4899  
  4900  func TwoHash_XorAdd_Shift630(name string) bool {
  4901  	if len(name) < 2 {
  4902  		return false
  4903  	}
  4904  	switch ((byte(len(name)) << 6) ^ (name[0] << 3)) + (name[1] << 0) {
  4905  	case 9:
  4906  		return name == "map"
  4907  	case 25:
  4908  		return name == "type"
  4909  	case 39:
  4910  		return name == "go"
  4911  	case 46:
  4912  		return name == "if"
  4913  	case 49:
  4914  		return name == "range"
  4915  	case 53:
  4916  		return name == "import"
  4917  	case 69:
  4918  		return name == "default"
  4919  	case 81:
  4920  		return name == "fallthrough"
  4921  	case 95:
  4922  		return name == "for"
  4923  	case 117:
  4924  		return name == "return"
  4925  	case 118:
  4926  		return name == "interface"
  4927  	case 121:
  4928  		return name == "case"
  4929  	case 125:
  4930  		return name == "select"
  4931  	case 128:
  4932  		return name == "chan"
  4933  	case 135:
  4934  		return name == "continue"
  4935  	case 140:
  4936  		return name == "struct"
  4937  	case 143:
  4938  		return name == "switch"
  4939  	case 148:
  4940  		return name == "else"
  4941  	case 161:
  4942  		return name == "package"
  4943  	case 165:
  4944  		return name == "func"
  4945  	case 167:
  4946  		return name == "goto"
  4947  	case 194:
  4948  		return name == "break"
  4949  	case 197:
  4950  		return name == "defer"
  4951  	case 199:
  4952  		return name == "const"
  4953  	case 209:
  4954  		return name == "var"
  4955  	}
  4956  	return false
  4957  }
  4958  
  4959  func TwoHash_AddXor_Shift015(name string) bool {
  4960  	if len(name) < 2 {
  4961  		return false
  4962  	}
  4963  	switch ((byte(len(name)) << 0) + (name[0] << 1)) ^ (name[1] << 5) {
  4964  	case 12:
  4965  		return name == "switch"
  4966  	case 20:
  4967  		return name == "if"
  4968  	case 27:
  4969  		return name == "interface"
  4970  	case 43:
  4971  		return name == "const"
  4972  	case 46:
  4973  		return name == "continue"
  4974  	case 47:
  4975  		return name == "for"
  4976  	case 48:
  4977  		return name == "go"
  4978  	case 50:
  4979  		return name == "goto"
  4980  	case 74:
  4981  		return name == "return"
  4982  	case 76:
  4983  		return name == "select"
  4984  	case 78:
  4985  		return name == "else"
  4986  	case 108:
  4987  		return name == "struct"
  4988  	case 109:
  4989  		return name == "defer"
  4990  	case 111:
  4991  		return name == "default"
  4992  	case 112:
  4993  		return name == "func"
  4994  	case 120:
  4995  		return name == "import"
  4996  	case 137:
  4997  		return name == "break"
  4998  	case 199:
  4999  		return name == "package"
  5000  	case 201:
  5001  		return name == "range"
  5002  	case 202:
  5003  		return name == "chan"
  5004  	case 204:
  5005  		return name == "type"
  5006  	case 207:
  5007  		return name == "var"
  5008  	case 234:
  5009  		return name == "case"
  5010  	case 247:
  5011  		return name == "fallthrough"
  5012  	case 253:
  5013  		return name == "map"
  5014  	}
  5015  	return false
  5016  }
  5017  
  5018  func TwoHash_AddXor_Shift024(name string) bool {
  5019  	if len(name) < 2 {
  5020  		return false
  5021  	}
  5022  	switch ((byte(len(name)) << 0) + (name[0] << 2)) ^ (name[1] << 4) {
  5023  	case 16:
  5024  		return name == "chan"
  5025  	case 68:
  5026  		return name == "type"
  5027  	case 77:
  5028  		return name == "interface"
  5029  	case 80:
  5030  		return name == "goto"
  5031  	case 88:
  5032  		return name == "else"
  5033  	case 97:
  5034  		return name == "const"
  5035  	case 100:
  5036  		return name == "continue"
  5037  	case 107:
  5038  		return name == "for"
  5039  	case 110:
  5040  		return name == "go"
  5041  	case 122:
  5042  		return name == "import"
  5043  	case 128:
  5044  		return name == "case"
  5045  	case 130:
  5046  		return name == "select"
  5047  	case 146:
  5048  		return name == "struct"
  5049  	case 158:
  5050  		return name == "return"
  5051  	case 162:
  5052  		return name == "switch"
  5053  	case 167:
  5054  		return name == "map"
  5055  	case 173:
  5056  		return name == "break"
  5057  	case 179:
  5058  		return name == "fallthrough"
  5059  	case 197:
  5060  		return name == "defer"
  5061  	case 198:
  5062  		return name == "if"
  5063  	case 199:
  5064  		return name == "default"
  5065  	case 203:
  5066  		return name == "var"
  5067  	case 204:
  5068  		return name == "func"
  5069  	case 215:
  5070  		return name == "package"
  5071  	case 221:
  5072  		return name == "range"
  5073  	}
  5074  	return false
  5075  }
  5076  
  5077  func TwoHash_AddXor_Shift025(name string) bool {
  5078  	if len(name) < 2 {
  5079  		return false
  5080  	}
  5081  	switch ((byte(len(name)) << 0) + (name[0] << 2)) ^ (name[1] << 5) {
  5082  	case 10:
  5083  		return name == "import"
  5084  	case 24:
  5085  		return name == "else"
  5086  	case 50:
  5087  		return name == "switch"
  5088  	case 53:
  5089  		return name == "defer"
  5090  	case 55:
  5091  		return name == "default"
  5092  	case 60:
  5093  		return name == "func"
  5094  	case 64:
  5095  		return name == "goto"
  5096  	case 82:
  5097  		return name == "struct"
  5098  	case 102:
  5099  		return name == "if"
  5100  	case 109:
  5101  		return name == "interface"
  5102  	case 110:
  5103  		return name == "return"
  5104  	case 113:
  5105  		return name == "const"
  5106  	case 114:
  5107  		return name == "select"
  5108  	case 116:
  5109  		return name == "continue"
  5110  	case 123:
  5111  		return name == "for"
  5112  	case 126:
  5113  		return name == "go"
  5114  	case 131:
  5115  		return name == "fallthrough"
  5116  	case 144:
  5117  		return name == "chan"
  5118  	case 151:
  5119  		return name == "map"
  5120  	case 176:
  5121  		return name == "case"
  5122  	case 205:
  5123  		return name == "break"
  5124  	case 231:
  5125  		return name == "package"
  5126  	case 237:
  5127  		return name == "range"
  5128  	case 244:
  5129  		return name == "type"
  5130  	case 251:
  5131  		return name == "var"
  5132  	}
  5133  	return false
  5134  }
  5135  
  5136  func TwoHash_AddXor_Shift026(name string) bool {
  5137  	if len(name) < 2 {
  5138  		return false
  5139  	}
  5140  	switch ((byte(len(name)) << 0) + (name[0] << 2)) ^ (name[1] << 6) {
  5141  	case 13:
  5142  		return name == "break"
  5143  	case 18:
  5144  		return name == "switch"
  5145  	case 38:
  5146  		return name == "if"
  5147  	case 45:
  5148  		return name == "interface"
  5149  	case 81:
  5150  		return name == "const"
  5151  	case 84:
  5152  		return name == "continue"
  5153  	case 91:
  5154  		return name == "for"
  5155  	case 94:
  5156  		return name == "go"
  5157  	case 96:
  5158  		return name == "goto"
  5159  	case 135:
  5160  		return name == "package"
  5161  	case 141:
  5162  		return name == "range"
  5163  	case 142:
  5164  		return name == "return"
  5165  	case 144:
  5166  		return name == "chan"
  5167  	case 146:
  5168  		return name == "select"
  5169  	case 148:
  5170  		return name == "type"
  5171  	case 152:
  5172  		return name == "else"
  5173  	case 155:
  5174  		return name == "var"
  5175  	case 208:
  5176  		return name == "case"
  5177  	case 210:
  5178  		return name == "struct"
  5179  	case 213:
  5180  		return name == "defer"
  5181  	case 215:
  5182  		return name == "default"
  5183  	case 220:
  5184  		return name == "func"
  5185  	case 227:
  5186  		return name == "fallthrough"
  5187  	case 234:
  5188  		return name == "import"
  5189  	case 247:
  5190  		return name == "map"
  5191  	}
  5192  	return false
  5193  }
  5194  
  5195  func TwoHash_AddXor_Shift034(name string) bool {
  5196  	if len(name) < 2 {
  5197  		return false
  5198  	}
  5199  	switch ((byte(len(name)) << 0) + (name[0] << 3)) ^ (name[1] << 4) {
  5200  	case 12:
  5201  		return name == "case"
  5202  	case 42:
  5203  		return name == "if"
  5204  	case 43:
  5205  		return name == "fallthrough"
  5206  	case 52:
  5207  		return name == "type"
  5208  	case 53:
  5209  		return name == "break"
  5210  	case 100:
  5211  		return name == "func"
  5212  	case 117:
  5213  		return name == "defer"
  5214  	case 119:
  5215  		return name == "default"
  5216  	case 123:
  5217  		return name == "map"
  5218  	case 133:
  5219  		return name == "range"
  5220  	case 151:
  5221  		return name == "package"
  5222  	case 156:
  5223  		return name == "chan"
  5224  	case 158:
  5225  		return name == "import"
  5226  	case 163:
  5227  		return name == "var"
  5228  	case 177:
  5229  		return name == "interface"
  5230  	case 195:
  5231  		return name == "for"
  5232  	case 198:
  5233  		return name == "return"
  5234  	case 202:
  5235  		return name == "go"
  5236  	case 204:
  5237  		return name == "goto"
  5238  	case 206:
  5239  		return name == "select"
  5240  	case 208:
  5241  		return name == "continue"
  5242  	case 222:
  5243  		return name == "struct"
  5244  	case 236:
  5245  		return name == "else"
  5246  	case 237:
  5247  		return name == "const"
  5248  	case 238:
  5249  		return name == "switch"
  5250  	}
  5251  	return false
  5252  }
  5253  
  5254  func TwoHash_AddXor_Shift035(name string) bool {
  5255  	if len(name) < 2 {
  5256  		return false
  5257  	}
  5258  	switch ((byte(len(name)) << 0) + (name[0] << 3)) ^ (name[1] << 5) {
  5259  	case 27:
  5260  		return name == "fallthrough"
  5261  	case 28:
  5262  		return name == "chan"
  5263  	case 30:
  5264  		return name == "struct"
  5265  	case 54:
  5266  		return name == "return"
  5267  	case 60:
  5268  		return name == "case"
  5269  	case 62:
  5270  		return name == "select"
  5271  	case 75:
  5272  		return name == "map"
  5273  	case 85:
  5274  		return name == "break"
  5275  	case 126:
  5276  		return name == "switch"
  5277  	case 132:
  5278  		return name == "type"
  5279  	case 133:
  5280  		return name == "defer"
  5281  	case 135:
  5282  		return name == "default"
  5283  	case 138:
  5284  		return name == "if"
  5285  	case 145:
  5286  		return name == "interface"
  5287  	case 147:
  5288  		return name == "var"
  5289  	case 148:
  5290  		return name == "func"
  5291  	case 167:
  5292  		return name == "package"
  5293  	case 172:
  5294  		return name == "else"
  5295  	case 181:
  5296  		return name == "range"
  5297  	case 192:
  5298  		return name == "continue"
  5299  	case 211:
  5300  		return name == "for"
  5301  	case 218:
  5302  		return name == "go"
  5303  	case 220:
  5304  		return name == "goto"
  5305  	case 238:
  5306  		return name == "import"
  5307  	case 253:
  5308  		return name == "const"
  5309  	}
  5310  	return false
  5311  }
  5312  
  5313  func TwoHash_AddXor_Shift041(name string) bool {
  5314  	if len(name) < 2 {
  5315  		return false
  5316  	}
  5317  	switch ((byte(len(name)) << 0) + (name[0] << 4)) ^ (name[1] << 1) {
  5318  	case 17:
  5319  		return name == "map"
  5320  	case 69:
  5321  		return name == "interface"
  5322  	case 76:
  5323  		return name == "import"
  5324  	case 94:
  5325  		return name == "if"
  5326  	case 140:
  5327  		return name == "else"
  5328  	case 141:
  5329  		return name == "default"
  5330  	case 142:
  5331  		return name == "func"
  5332  	case 143:
  5333  		return name == "defer"
  5334  	case 161:
  5335  		return name == "var"
  5336  	case 169:
  5337  		return name == "fallthrough"
  5338  	case 170:
  5339  		return name == "goto"
  5340  	case 172:
  5341  		return name == "go"
  5342  	case 182:
  5343  		return name == "type"
  5344  	case 189:
  5345  		return name == "for"
  5346  	case 193:
  5347  		return name == "break"
  5348  	case 197:
  5349  		return name == "package"
  5350  	case 216:
  5351  		return name == "switch"
  5352  	case 222:
  5353  		return name == "struct"
  5354  	case 228:
  5355  		return name == "chan"
  5356  	case 230:
  5357  		return name == "continue"
  5358  	case 231:
  5359  		return name == "range"
  5360  	case 235:
  5361  		return name == "const"
  5362  	case 236:
  5363  		return name == "return"
  5364  	case 246:
  5365  		return name == "case"
  5366  	case 252:
  5367  		return name == "select"
  5368  	}
  5369  	return false
  5370  }
  5371  
  5372  func TwoHash_AddXor_Shift043(name string) bool {
  5373  	if len(name) < 2 {
  5374  		return false
  5375  	}
  5376  	switch ((byte(len(name)) << 0) + (name[0] << 4)) ^ (name[1] << 3) {
  5377  	case 10:
  5378  		return name == "go"
  5379  	case 12:
  5380  		return name == "goto"
  5381  	case 14:
  5382  		return name == "return"
  5383  	case 15:
  5384  		return name == "package"
  5385  	case 27:
  5386  		return name == "for"
  5387  	case 30:
  5388  		return name == "select"
  5389  	case 45:
  5390  		return name == "range"
  5391  	case 52:
  5392  		return name == "else"
  5393  	case 60:
  5394  		return name == "case"
  5395  	case 64:
  5396  		return name == "continue"
  5397  	case 77:
  5398  		return name == "const"
  5399  	case 99:
  5400  		return name == "fallthrough"
  5401  	case 107:
  5402  		return name == "var"
  5403  	case 109:
  5404  		return name == "defer"
  5405  	case 111:
  5406  		return name == "default"
  5407  	case 116:
  5408  		return name == "chan"
  5409  	case 140:
  5410  		return name == "type"
  5411  	case 142:
  5412  		return name == "switch"
  5413  	case 150:
  5414  		return name == "struct"
  5415  	case 162:
  5416  		return name == "if"
  5417  	case 181:
  5418  		return name == "break"
  5419  	case 204:
  5420  		return name == "func"
  5421  	case 219:
  5422  		return name == "map"
  5423  	case 233:
  5424  		return name == "interface"
  5425  	case 254:
  5426  		return name == "import"
  5427  	}
  5428  	return false
  5429  }
  5430  
  5431  func TwoHash_AddXor_Shift045(name string) bool {
  5432  	if len(name) < 2 {
  5433  		return false
  5434  	}
  5435  	switch ((byte(len(name)) << 0) + (name[0] << 4)) ^ (name[1] << 5) {
  5436  	case 5:
  5437  		return name == "range"
  5438  	case 20:
  5439  		return name == "case"
  5440  	case 39:
  5441  		return name == "package"
  5442  	case 52:
  5443  		return name == "chan"
  5444  	case 54:
  5445  		return name == "import"
  5446  	case 67:
  5447  		return name == "var"
  5448  	case 75:
  5449  		return name == "fallthrough"
  5450  	case 82:
  5451  		return name == "if"
  5452  	case 89:
  5453  		return name == "interface"
  5454  	case 100:
  5455  		return name == "type"
  5456  	case 101:
  5457  		return name == "break"
  5458  	case 131:
  5459  		return name == "for"
  5460  	case 134:
  5461  		return name == "return"
  5462  	case 146:
  5463  		return name == "go"
  5464  	case 148:
  5465  		return name == "goto"
  5466  	case 150:
  5467  		return name == "select"
  5468  	case 182:
  5469  		return name == "struct"
  5470  	case 196:
  5471  		return name == "func"
  5472  	case 212:
  5473  		return name == "else"
  5474  	case 213:
  5475  		return name == "const"
  5476  	case 214:
  5477  		return name == "switch"
  5478  	case 216:
  5479  		return name == "continue"
  5480  	case 229:
  5481  		return name == "defer"
  5482  	case 231:
  5483  		return name == "default"
  5484  	case 243:
  5485  		return name == "map"
  5486  	}
  5487  	return false
  5488  }
  5489  
  5490  func TwoHash_AddXor_Shift046(name string) bool {
  5491  	if len(name) < 2 {
  5492  		return false
  5493  	}
  5494  	switch ((byte(len(name)) << 0) + (name[0] << 4)) ^ (name[1] << 6) {
  5495  	case 4:
  5496  		return name == "type"
  5497  	case 5:
  5498  		return name == "defer"
  5499  	case 7:
  5500  		return name == "default"
  5501  	case 18:
  5502  		return name == "if"
  5503  	case 25:
  5504  		return name == "interface"
  5505  	case 35:
  5506  		return name == "var"
  5507  	case 36:
  5508  		return name == "func"
  5509  	case 43:
  5510  		return name == "fallthrough"
  5511  	case 52:
  5512  		return name == "chan"
  5513  	case 54:
  5514  		return name == "struct"
  5515  	case 71:
  5516  		return name == "package"
  5517  	case 84:
  5518  		return name == "else"
  5519  	case 101:
  5520  		return name == "range"
  5521  	case 102:
  5522  		return name == "return"
  5523  	case 116:
  5524  		return name == "case"
  5525  	case 118:
  5526  		return name == "select"
  5527  	case 147:
  5528  		return name == "map"
  5529  	case 163:
  5530  		return name == "for"
  5531  	case 165:
  5532  		return name == "break"
  5533  	case 178:
  5534  		return name == "go"
  5535  	case 180:
  5536  		return name == "goto"
  5537  	case 214:
  5538  		return name == "import"
  5539  	case 245:
  5540  		return name == "const"
  5541  	case 246:
  5542  		return name == "switch"
  5543  	case 248:
  5544  		return name == "continue"
  5545  	}
  5546  	return false
  5547  }
  5548  
  5549  func TwoHash_AddXor_Shift050(name string) bool {
  5550  	if len(name) < 2 {
  5551  		return false
  5552  	}
  5553  	switch ((byte(len(name)) << 0) + (name[0] << 5)) ^ (name[1] << 0) {
  5554  	case 3:
  5555  		return name == "select"
  5556  	case 5:
  5557  		return name == "case"
  5558  	case 7:
  5559  		return name == "continue"
  5560  	case 10:
  5561  		return name == "const"
  5562  	case 12:
  5563  		return name == "chan"
  5564  	case 17:
  5565  		return name == "switch"
  5566  	case 18:
  5567  		return name == "struct"
  5568  	case 35:
  5569  		return name == "return"
  5570  	case 36:
  5571  		return name == "range"
  5572  	case 55:
  5573  		return name == "break"
  5574  	case 68:
  5575  		return name == "if"
  5576  	case 71:
  5577  		return name == "interface"
  5578  	case 75:
  5579  		return name == "import"
  5580  	case 102:
  5581  		return name == "package"
  5582  	case 139:
  5583  		return name == "goto"
  5584  	case 141:
  5585  		return name == "go"
  5586  	case 162:
  5587  		return name == "var"
  5588  	case 170:
  5589  		return name == "fallthrough"
  5590  	case 172:
  5591  		return name == "for"
  5592  	case 177:
  5593  		return name == "func"
  5594  	case 194:
  5595  		return name == "map"
  5596  	case 200:
  5597  		return name == "else"
  5598  	case 224:
  5599  		return name == "defer"
  5600  	case 226:
  5601  		return name == "default"
  5602  	case 253:
  5603  		return name == "type"
  5604  	}
  5605  	return false
  5606  }
  5607  
  5608  func TwoHash_AddXor_Shift051(name string) bool {
  5609  	if len(name) < 2 {
  5610  		return false
  5611  	}
  5612  	switch ((byte(len(name)) << 0) + (name[0] << 5)) ^ (name[1] << 1) {
  5613  	case 1:
  5614  		return name == "var"
  5615  	case 9:
  5616  		return name == "fallthrough"
  5617  	case 29:
  5618  		return name == "for"
  5619  	case 46:
  5620  		return name == "func"
  5621  	case 58:
  5622  		return name == "goto"
  5623  	case 60:
  5624  		return name == "go"
  5625  	case 77:
  5626  		return name == "default"
  5627  	case 79:
  5628  		return name == "defer"
  5629  	case 97:
  5630  		return name == "map"
  5631  	case 118:
  5632  		return name == "type"
  5633  	case 124:
  5634  		return name == "else"
  5635  	case 135:
  5636  		return name == "range"
  5637  	case 136:
  5638  		return name == "switch"
  5639  	case 140:
  5640  		return name == "return"
  5641  	case 142:
  5642  		return name == "struct"
  5643  	case 161:
  5644  		return name == "break"
  5645  	case 166:
  5646  		return name == "case"
  5647  	case 172:
  5648  		return name == "select"
  5649  	case 180:
  5650  		return name == "chan"
  5651  	case 182:
  5652  		return name == "continue"
  5653  	case 187:
  5654  		return name == "const"
  5655  	case 197:
  5656  		return name == "package"
  5657  	case 238:
  5658  		return name == "if"
  5659  	case 245:
  5660  		return name == "interface"
  5661  	case 252:
  5662  		return name == "import"
  5663  	}
  5664  	return false
  5665  }
  5666  
  5667  func TwoHash_AddXor_Shift060(name string) bool {
  5668  	if len(name) < 2 {
  5669  		return false
  5670  	}
  5671  	switch ((byte(len(name)) << 0) + (name[0] << 6)) ^ (name[1] << 0) {
  5672  	case 34:
  5673  		return name == "map"
  5674  	case 36:
  5675  		return name == "if"
  5676  	case 39:
  5677  		return name == "interface"
  5678  	case 40:
  5679  		return name == "else"
  5680  	case 43:
  5681  		return name == "import"
  5682  	case 96:
  5683  		return name == "defer"
  5684  	case 98:
  5685  		return name == "default"
  5686  	case 102:
  5687  		return name == "package"
  5688  	case 125:
  5689  		return name == "type"
  5690  	case 163:
  5691  		return name == "select"
  5692  	case 165:
  5693  		return name == "case"
  5694  	case 167:
  5695  		return name == "continue"
  5696  	case 170:
  5697  		return name == "const"
  5698  	case 171:
  5699  		return name == "goto"
  5700  	case 172:
  5701  		return name == "chan"
  5702  	case 173:
  5703  		return name == "go"
  5704  	case 177:
  5705  		return name == "switch"
  5706  	case 178:
  5707  		return name == "struct"
  5708  	case 226:
  5709  		return name == "var"
  5710  	case 227:
  5711  		return name == "return"
  5712  	case 228:
  5713  		return name == "range"
  5714  	case 234:
  5715  		return name == "fallthrough"
  5716  	case 236:
  5717  		return name == "for"
  5718  	case 241:
  5719  		return name == "func"
  5720  	case 247:
  5721  		return name == "break"
  5722  	}
  5723  	return false
  5724  }
  5725  
  5726  func TwoHash_AddXor_Shift062(name string) bool {
  5727  	if len(name) < 2 {
  5728  		return false
  5729  	}
  5730  	switch ((byte(len(name)) << 0) + (name[0] << 6)) ^ (name[1] << 2) {
  5731  	case 1:
  5732  		return name == "range"
  5733  	case 7:
  5734  		return name == "var"
  5735  	case 15:
  5736  		return name == "fallthrough"
  5737  	case 18:
  5738  		return name == "return"
  5739  	case 22:
  5740  		return name == "struct"
  5741  	case 26:
  5742  		return name == "switch"
  5743  	case 63:
  5744  		return name == "for"
  5745  	case 64:
  5746  		return name == "case"
  5747  	case 77:
  5748  		return name == "break"
  5749  	case 80:
  5750  		return name == "func"
  5751  	case 82:
  5752  		return name == "select"
  5753  	case 100:
  5754  		return name == "chan"
  5755  	case 116:
  5756  		return name == "continue"
  5757  	case 120:
  5758  		return name == "goto"
  5759  	case 121:
  5760  		return name == "const"
  5761  	case 126:
  5762  		return name == "go"
  5763  	case 131:
  5764  		return name == "package"
  5765  	case 145:
  5766  		return name == "defer"
  5767  	case 147:
  5768  		return name == "default"
  5769  	case 199:
  5770  		return name == "map"
  5771  	case 218:
  5772  		return name == "if"
  5773  	case 224:
  5774  		return name == "type"
  5775  	case 241:
  5776  		return name == "interface"
  5777  	case 242:
  5778  		return name == "import"
  5779  	case 244:
  5780  		return name == "else"
  5781  	}
  5782  	return false
  5783  }
  5784  
  5785  func TwoHash_AddXor_Shift073(name string) bool {
  5786  	if len(name) < 2 {
  5787  		return false
  5788  	}
  5789  	switch ((byte(len(name)) << 0) + (name[0] << 7)) ^ (name[1] << 3) {
  5790  	case 3:
  5791  		return name == "fallthrough"
  5792  	case 11:
  5793  		return name == "var"
  5794  	case 13:
  5795  		return name == "range"
  5796  	case 15:
  5797  		return name == "package"
  5798  	case 38:
  5799  		return name == "struct"
  5800  	case 45:
  5801  		return name == "defer"
  5802  	case 46:
  5803  		return name == "return"
  5804  	case 47:
  5805  		return name == "default"
  5806  	case 62:
  5807  		return name == "switch"
  5808  	case 123:
  5809  		return name == "for"
  5810  	case 139:
  5811  		return name == "map"
  5812  	case 140:
  5813  		return name == "case"
  5814  	case 149:
  5815  		return name == "break"
  5816  	case 172:
  5817  		return name == "func"
  5818  	case 174:
  5819  		return name == "select"
  5820  	case 178:
  5821  		return name == "if"
  5822  	case 196:
  5823  		return name == "chan"
  5824  	case 204:
  5825  		return name == "type"
  5826  	case 228:
  5827  		return name == "else"
  5828  	case 238:
  5829  		return name == "import"
  5830  	case 240:
  5831  		return name == "continue"
  5832  	case 249:
  5833  		return name == "interface"
  5834  	case 250:
  5835  		return name == "go"
  5836  	case 252:
  5837  		return name == "goto"
  5838  	case 253:
  5839  		return name == "const"
  5840  	}
  5841  	return false
  5842  }
  5843  
  5844  func TwoHash_AddXor_Shift135(name string) bool {
  5845  	if len(name) < 2 {
  5846  		return false
  5847  	}
  5848  	switch ((byte(len(name)) << 1) + (name[0] << 3)) ^ (name[1] << 5) {
  5849  	case 0:
  5850  		return name == "case"
  5851  	case 4:
  5852  		return name == "select"
  5853  	case 32:
  5854  		return name == "chan"
  5855  	case 36:
  5856  		return name == "struct"
  5857  	case 60:
  5858  		return name == "return"
  5859  	case 68:
  5860  		return name == "switch"
  5861  	case 78:
  5862  		return name == "map"
  5863  	case 90:
  5864  		return name == "break"
  5865  	case 102:
  5866  		return name == "fallthrough"
  5867  	case 136:
  5868  		return name == "type"
  5869  	case 138:
  5870  		return name == "defer"
  5871  	case 140:
  5872  		return name == "if"
  5873  	case 142:
  5874  		return name == "default"
  5875  	case 150:
  5876  		return name == "var"
  5877  	case 152:
  5878  		return name == "func"
  5879  	case 154:
  5880  		return name == "interface"
  5881  	case 160:
  5882  		return name == "goto"
  5883  	case 174:
  5884  		return name == "package"
  5885  	case 176:
  5886  		return name == "else"
  5887  	case 186:
  5888  		return name == "range"
  5889  	case 194:
  5890  		return name == "const"
  5891  	case 200:
  5892  		return name == "continue"
  5893  	case 214:
  5894  		return name == "for"
  5895  	case 220:
  5896  		return name == "go"
  5897  	case 244:
  5898  		return name == "import"
  5899  	}
  5900  	return false
  5901  }
  5902  
  5903  func TwoHash_AddXor_Shift145(name string) bool {
  5904  	if len(name) < 2 {
  5905  		return false
  5906  	}
  5907  	switch ((byte(len(name)) << 1) + (name[0] << 4)) ^ (name[1] << 5) {
  5908  	case 10:
  5909  		return name == "range"
  5910  	case 24:
  5911  		return name == "case"
  5912  	case 46:
  5913  		return name == "package"
  5914  	case 56:
  5915  		return name == "chan"
  5916  	case 60:
  5917  		return name == "import"
  5918  	case 70:
  5919  		return name == "var"
  5920  	case 84:
  5921  		return name == "if"
  5922  	case 86:
  5923  		return name == "fallthrough"
  5924  	case 98:
  5925  		return name == "interface"
  5926  	case 104:
  5927  		return name == "type"
  5928  	case 106:
  5929  		return name == "break"
  5930  	case 134:
  5931  		return name == "for"
  5932  	case 140:
  5933  		return name == "return"
  5934  	case 148:
  5935  		return name == "go"
  5936  	case 152:
  5937  		return name == "goto"
  5938  	case 156:
  5939  		return name == "select"
  5940  	case 160:
  5941  		return name == "continue"
  5942  	case 188:
  5943  		return name == "struct"
  5944  	case 200:
  5945  		return name == "func"
  5946  	case 216:
  5947  		return name == "else"
  5948  	case 218:
  5949  		return name == "const"
  5950  	case 220:
  5951  		return name == "switch"
  5952  	case 234:
  5953  		return name == "defer"
  5954  	case 238:
  5955  		return name == "default"
  5956  	case 246:
  5957  		return name == "map"
  5958  	}
  5959  	return false
  5960  }
  5961  
  5962  func TwoHash_AddXor_Shift146(name string) bool {
  5963  	if len(name) < 2 {
  5964  		return false
  5965  	}
  5966  	switch ((byte(len(name)) << 1) + (name[0] << 4)) ^ (name[1] << 6) {
  5967  	case 8:
  5968  		return name == "type"
  5969  	case 10:
  5970  		return name == "defer"
  5971  	case 14:
  5972  		return name == "default"
  5973  	case 20:
  5974  		return name == "if"
  5975  	case 34:
  5976  		return name == "interface"
  5977  	case 38:
  5978  		return name == "var"
  5979  	case 40:
  5980  		return name == "func"
  5981  	case 54:
  5982  		return name == "fallthrough"
  5983  	case 56:
  5984  		return name == "chan"
  5985  	case 60:
  5986  		return name == "struct"
  5987  	case 78:
  5988  		return name == "package"
  5989  	case 88:
  5990  		return name == "else"
  5991  	case 106:
  5992  		return name == "range"
  5993  	case 108:
  5994  		return name == "return"
  5995  	case 120:
  5996  		return name == "case"
  5997  	case 124:
  5998  		return name == "select"
  5999  	case 128:
  6000  		return name == "continue"
  6001  	case 150:
  6002  		return name == "map"
  6003  	case 166:
  6004  		return name == "for"
  6005  	case 170:
  6006  		return name == "break"
  6007  	case 180:
  6008  		return name == "go"
  6009  	case 184:
  6010  		return name == "goto"
  6011  	case 220:
  6012  		return name == "import"
  6013  	case 250:
  6014  		return name == "const"
  6015  	case 252:
  6016  		return name == "switch"
  6017  	}
  6018  	return false
  6019  }
  6020  
  6021  func TwoHash_AddXor_Shift161(name string) bool {
  6022  	if len(name) < 2 {
  6023  		return false
  6024  	}
  6025  	switch ((byte(len(name)) << 1) + (name[0] << 6)) ^ (name[1] << 1) {
  6026  	case 6:
  6027  		return name == "select"
  6028  	case 10:
  6029  		return name == "case"
  6030  	case 14:
  6031  		return name == "continue"
  6032  	case 20:
  6033  		return name == "const"
  6034  	case 22:
  6035  		return name == "goto"
  6036  	case 24:
  6037  		return name == "chan"
  6038  	case 26:
  6039  		return name == "go"
  6040  	case 34:
  6041  		return name == "switch"
  6042  	case 36:
  6043  		return name == "struct"
  6044  	case 68:
  6045  		return name == "var"
  6046  	case 70:
  6047  		return name == "return"
  6048  	case 72:
  6049  		return name == "range"
  6050  	case 84:
  6051  		return name == "fallthrough"
  6052  	case 88:
  6053  		return name == "for"
  6054  	case 98:
  6055  		return name == "func"
  6056  	case 110:
  6057  		return name == "break"
  6058  	case 132:
  6059  		return name == "map"
  6060  	case 136:
  6061  		return name == "if"
  6062  	case 142:
  6063  		return name == "interface"
  6064  	case 144:
  6065  		return name == "else"
  6066  	case 150:
  6067  		return name == "import"
  6068  	case 192:
  6069  		return name == "defer"
  6070  	case 196:
  6071  		return name == "default"
  6072  	case 204:
  6073  		return name == "package"
  6074  	case 250:
  6075  		return name == "type"
  6076  	}
  6077  	return false
  6078  }
  6079  
  6080  func TwoHash_AddXor_Shift230(name string) bool {
  6081  	if len(name) < 2 {
  6082  		return false
  6083  	}
  6084  	switch ((byte(len(name)) << 2) + (name[0] << 3)) ^ (name[1] << 0) {
  6085  	case 2:
  6086  		return name == "interface"
  6087  	case 13:
  6088  		return name == "import"
  6089  	case 21:
  6090  		return name == "map"
  6091  	case 39:
  6092  		return name == "goto"
  6093  	case 47:
  6094  		return name == "go"
  6095  	case 53:
  6096  		return name == "func"
  6097  	case 54:
  6098  		return name == "if"
  6099  	case 61:
  6100  		return name == "fallthrough"
  6101  	case 64:
  6102  		return name == "chan"
  6103  	case 67:
  6104  		return name == "const"
  6105  	case 73:
  6106  		return name == "case"
  6107  	case 81:
  6108  		return name == "defer"
  6109  	case 83:
  6110  		return name == "for"
  6111  	case 84:
  6112  		return name == "else"
  6113  	case 86:
  6114  		return name == "break"
  6115  	case 87:
  6116  		return name == "continue"
  6117  	case 89:
  6118  		return name == "default"
  6119  	case 196:
  6120  		return name == "struct"
  6121  	case 197:
  6122  		return name == "range"
  6123  	case 199:
  6124  		return name == "switch"
  6125  	case 201:
  6126  		return name == "type"
  6127  	case 205:
  6128  		return name == "return"
  6129  	case 213:
  6130  		return name == "select"
  6131  	case 221:
  6132  		return name == "var"
  6133  	case 253:
  6134  		return name == "package"
  6135  	}
  6136  	return false
  6137  }
  6138  
  6139  func TwoHash_AddXor_Shift250(name string) bool {
  6140  	if len(name) < 2 {
  6141  		return false
  6142  	}
  6143  	switch ((byte(len(name)) << 2) + (name[0] << 5)) ^ (name[1] << 0) {
  6144  	case 12:
  6145  		return name == "struct"
  6146  	case 15:
  6147  		return name == "switch"
  6148  	case 17:
  6149  		return name == "case"
  6150  	case 24:
  6151  		return name == "chan"
  6152  	case 27:
  6153  		return name == "const"
  6154  	case 29:
  6155  		return name == "select"
  6156  	case 38:
  6157  		return name == "break"
  6158  	case 42:
  6159  		return name == "interface"
  6160  	case 53:
  6161  		return name == "range"
  6162  	case 61:
  6163  		return name == "return"
  6164  	case 78:
  6165  		return name == "if"
  6166  	case 85:
  6167  		return name == "import"
  6168  	case 125:
  6169  		return name == "package"
  6170  	case 135:
  6171  		return name == "go"
  6172  	case 141:
  6173  		return name == "fallthrough"
  6174  	case 159:
  6175  		return name == "goto"
  6176  	case 163:
  6177  		return name == "for"
  6178  	case 165:
  6179  		return name == "func"
  6180  	case 173:
  6181  		return name == "var"
  6182  	case 205:
  6183  		return name == "map"
  6184  	case 220:
  6185  		return name == "else"
  6186  	case 233:
  6187  		return name == "type"
  6188  	case 239:
  6189  		return name == "continue"
  6190  	case 241:
  6191  		return name == "defer"
  6192  	case 249:
  6193  		return name == "default"
  6194  	}
  6195  	return false
  6196  }
  6197  
  6198  func TwoHash_AddXor_Shift260(name string) bool {
  6199  	if len(name) < 2 {
  6200  		return false
  6201  	}
  6202  	switch ((byte(len(name)) << 2) + (name[0] << 6)) ^ (name[1] << 0) {
  6203  	case 10:
  6204  		return name == "interface"
  6205  	case 45:
  6206  		return name == "map"
  6207  	case 46:
  6208  		return name == "if"
  6209  	case 53:
  6210  		return name == "import"
  6211  	case 60:
  6212  		return name == "else"
  6213  	case 105:
  6214  		return name == "type"
  6215  	case 113:
  6216  		return name == "defer"
  6217  	case 121:
  6218  		return name == "default"
  6219  	case 125:
  6220  		return name == "package"
  6221  	case 143:
  6222  		return name == "continue"
  6223  	case 167:
  6224  		return name == "go"
  6225  	case 172:
  6226  		return name == "struct"
  6227  	case 175:
  6228  		return name == "switch"
  6229  	case 177:
  6230  		return name == "case"
  6231  	case 184:
  6232  		return name == "chan"
  6233  	case 187:
  6234  		return name == "const"
  6235  	case 189:
  6236  		return name == "select"
  6237  	case 191:
  6238  		return name == "goto"
  6239  	case 205:
  6240  		return name == "fallthrough"
  6241  	case 227:
  6242  		return name == "for"
  6243  	case 229:
  6244  		return name == "func"
  6245  	case 230:
  6246  		return name == "break"
  6247  	case 237:
  6248  		return name == "var"
  6249  	case 245:
  6250  		return name == "range"
  6251  	case 253:
  6252  		return name == "return"
  6253  	}
  6254  	return false
  6255  }
  6256  
  6257  func TwoHash_AddXor_Shift301(name string) bool {
  6258  	if len(name) < 2 {
  6259  		return false
  6260  	}
  6261  	switch ((byte(len(name)) << 3) + (name[0] << 0)) ^ (name[1] << 1) {
  6262  	case 65:
  6263  		return name == "case"
  6264  	case 67:
  6265  		return name == "import"
  6266  	case 70:
  6267  		return name == "defer"
  6268  	case 71:
  6269  		return name == "map"
  6270  	case 75:
  6271  		return name == "struct"
  6272  	case 76:
  6273  		return name == "var"
  6274  	case 77:
  6275  		return name == "switch"
  6276  	case 83:
  6277  		return name == "chan"
  6278  	case 85:
  6279  		return name == "const"
  6280  	case 86:
  6281  		return name == "default"
  6282  	case 88:
  6283  		return name == "range"
  6284  	case 89:
  6285  		return name == "goto"
  6286  	case 93:
  6287  		return name == "else"
  6288  	case 102:
  6289  		return name == "type"
  6290  	case 104:
  6291  		return name == "return"
  6292  	case 105:
  6293  		return name == "select"
  6294  	case 106:
  6295  		return name == "package"
  6296  	case 108:
  6297  		return name == "func"
  6298  	case 109:
  6299  		return name == "interface"
  6300  	case 110:
  6301  		return name == "break"
  6302  	case 124:
  6303  		return name == "fallthrough"
  6304  	case 125:
  6305  		return name == "continue"
  6306  	case 160:
  6307  		return name == "for"
  6308  	case 169:
  6309  		return name == "go"
  6310  	case 181:
  6311  		return name == "if"
  6312  	}
  6313  	return false
  6314  }
  6315  
  6316  func TwoHash_AddXor_Shift304(name string) bool {
  6317  	if len(name) < 2 {
  6318  		return false
  6319  	}
  6320  	switch ((byte(len(name)) << 3) + (name[0] << 0)) ^ (name[1] << 4) {
  6321  	case 3:
  6322  		return name == "chan"
  6323  	case 4:
  6324  		return name == "type"
  6325  	case 25:
  6326  		return name == "if"
  6327  	case 69:
  6328  		return name == "else"
  6329  	case 73:
  6330  		return name == "import"
  6331  	case 81:
  6332  		return name == "interface"
  6333  	case 83:
  6334  		return name == "continue"
  6335  	case 119:
  6336  		return name == "goto"
  6337  	case 123:
  6338  		return name == "const"
  6339  	case 135:
  6340  		return name == "go"
  6341  	case 138:
  6342  		return name == "range"
  6343  	case 142:
  6344  		return name == "for"
  6345  	case 147:
  6346  		return name == "case"
  6347  	case 149:
  6348  		return name == "map"
  6349  	case 158:
  6350  		return name == "var"
  6351  	case 170:
  6352  		return name == "break"
  6353  	case 174:
  6354  		return name == "fallthrough"
  6355  	case 184:
  6356  		return name == "package"
  6357  	case 204:
  6358  		return name == "default"
  6359  	case 211:
  6360  		return name == "switch"
  6361  	case 214:
  6362  		return name == "func"
  6363  	case 220:
  6364  		return name == "defer"
  6365  	case 227:
  6366  		return name == "struct"
  6367  	case 242:
  6368  		return name == "return"
  6369  	case 243:
  6370  		return name == "select"
  6371  	}
  6372  	return false
  6373  }
  6374  
  6375  func TwoHash_AddXor_Shift361(name string) bool {
  6376  	if len(name) < 2 {
  6377  		return false
  6378  	}
  6379  	switch ((byte(len(name)) << 3) + (name[0] << 6)) ^ (name[1] << 1) {
  6380  	case 14:
  6381  		return name == "go"
  6382  	case 24:
  6383  		return name == "struct"
  6384  	case 26:
  6385  		return name == "fallthrough"
  6386  	case 30:
  6387  		return name == "switch"
  6388  	case 34:
  6389  		return name == "case"
  6390  	case 48:
  6391  		return name == "chan"
  6392  	case 54:
  6393  		return name == "const"
  6394  	case 58:
  6395  		return name == "select"
  6396  	case 62:
  6397  		return name == "goto"
  6398  	case 70:
  6399  		return name == "for"
  6400  	case 74:
  6401  		return name == "func"
  6402  	case 76:
  6403  		return name == "break"
  6404  	case 84:
  6405  		return name == "interface"
  6406  	case 90:
  6407  		return name == "var"
  6408  	case 106:
  6409  		return name == "range"
  6410  	case 122:
  6411  		return name == "return"
  6412  	case 154:
  6413  		return name == "map"
  6414  	case 156:
  6415  		return name == "if"
  6416  	case 170:
  6417  		return name == "import"
  6418  	case 184:
  6419  		return name == "else"
  6420  	case 210:
  6421  		return name == "type"
  6422  	case 222:
  6423  		return name == "continue"
  6424  	case 226:
  6425  		return name == "defer"
  6426  	case 242:
  6427  		return name == "default"
  6428  	case 250:
  6429  		return name == "package"
  6430  	}
  6431  	return false
  6432  }
  6433  
  6434  func TwoHash_AddXor_Shift403(name string) bool {
  6435  	if len(name) < 2 {
  6436  		return false
  6437  	}
  6438  	switch ((byte(len(name)) << 4) + (name[0] << 0)) ^ (name[1] << 3) {
  6439  	case 14:
  6440  		return name == "func"
  6441  	case 30:
  6442  		return name == "fallthrough"
  6443  	case 34:
  6444  		return name == "break"
  6445  	case 107:
  6446  		return name == "switch"
  6447  	case 115:
  6448  		return name == "struct"
  6449  	case 124:
  6450  		return name == "type"
  6451  	case 137:
  6452  		return name == "interface"
  6453  	case 149:
  6454  		return name == "map"
  6455  	case 155:
  6456  		return name == "continue"
  6457  	case 156:
  6458  		return name == "defer"
  6459  	case 161:
  6460  		return name == "import"
  6461  	case 171:
  6462  		return name == "case"
  6463  	case 174:
  6464  		return name == "var"
  6465  	case 185:
  6466  		return name == "if"
  6467  	case 197:
  6468  		return name == "else"
  6469  	case 202:
  6470  		return name == "range"
  6471  	case 203:
  6472  		return name == "const"
  6473  	case 223:
  6474  		return name == "goto"
  6475  	case 227:
  6476  		return name == "chan"
  6477  	case 232:
  6478  		return name == "package"
  6479  	case 238:
  6480  		return name == "for"
  6481  	case 250:
  6482  		return name == "return"
  6483  	case 251:
  6484  		return name == "select"
  6485  	case 252:
  6486  		return name == "default"
  6487  	case 255:
  6488  		return name == "go"
  6489  	}
  6490  	return false
  6491  }
  6492  
  6493  func TwoHash_AddXor_Shift412(name string) bool {
  6494  	if len(name) < 2 {
  6495  		return false
  6496  	}
  6497  	switch ((byte(len(name)) << 4) + (name[0] << 1)) ^ (name[1] << 2) {
  6498  	case 64:
  6499  		return name == "for"
  6500  	case 82:
  6501  		return name == "go"
  6502  	case 106:
  6503  		return name == "if"
  6504  	case 130:
  6505  		return name == "case"
  6506  	case 134:
  6507  		return name == "import"
  6508  	case 140:
  6509  		return name == "defer"
  6510  	case 142:
  6511  		return name == "map"
  6512  	case 150:
  6513  		return name == "struct"
  6514  	case 152:
  6515  		return name == "var"
  6516  	case 154:
  6517  		return name == "switch"
  6518  	case 166:
  6519  		return name == "chan"
  6520  	case 170:
  6521  		return name == "const"
  6522  	case 172:
  6523  		return name == "default"
  6524  	case 176:
  6525  		return name == "range"
  6526  	case 178:
  6527  		return name == "goto"
  6528  	case 186:
  6529  		return name == "else"
  6530  	case 204:
  6531  		return name == "type"
  6532  	case 208:
  6533  		return name == "return"
  6534  	case 210:
  6535  		return name == "select"
  6536  	case 212:
  6537  		return name == "package"
  6538  	case 216:
  6539  		return name == "func"
  6540  	case 218:
  6541  		return name == "interface"
  6542  	case 220:
  6543  		return name == "break"
  6544  	case 248:
  6545  		return name == "fallthrough"
  6546  	case 250:
  6547  		return name == "continue"
  6548  	}
  6549  	return false
  6550  }
  6551  
  6552  func TwoHash_AddXor_Shift510(name string) bool {
  6553  	if len(name) < 2 {
  6554  		return false
  6555  	}
  6556  	switch ((byte(len(name)) << 5) + (name[0] << 1)) ^ (name[1] << 0) {
  6557  	case 9:
  6558  		return name == "const"
  6559  	case 13:
  6560  		return name == "defer"
  6561  	case 17:
  6562  		return name == "type"
  6563  	case 22:
  6564  		return name == "break"
  6565  	case 33:
  6566  		return name == "goto"
  6567  	case 38:
  6568  		return name == "else"
  6569  	case 39:
  6570  		return name == "case"
  6571  	case 45:
  6572  		return name == "var"
  6573  	case 46:
  6574  		return name == "chan"
  6575  	case 57:
  6576  		return name == "func"
  6577  	case 67:
  6578  		return name == "for"
  6579  	case 77:
  6580  		return name == "fallthrough"
  6581  	case 91:
  6582  		return name == "map"
  6583  	case 97:
  6584  		return name == "go"
  6585  	case 116:
  6586  		return name == "if"
  6587  	case 156:
  6588  		return name == "interface"
  6589  	case 161:
  6590  		return name == "package"
  6591  	case 169:
  6592  		return name == "continue"
  6593  	case 193:
  6594  		return name == "return"
  6595  	case 195:
  6596  		return name == "select"
  6597  	case 205:
  6598  		return name == "default"
  6599  	case 209:
  6600  		return name == "switch"
  6601  	case 210:
  6602  		return name == "struct"
  6603  	case 229:
  6604  		return name == "range"
  6605  	case 255:
  6606  		return name == "import"
  6607  	}
  6608  	return false
  6609  }
  6610  
  6611  func TwoHash_AddXor_Shift630(name string) bool {
  6612  	if len(name) < 2 {
  6613  		return false
  6614  	}
  6615  	switch ((byte(len(name)) << 6) + (name[0] << 3)) ^ (name[1] << 0) {
  6616  	case 5:
  6617  		return name == "defer"
  6618  	case 17:
  6619  		return name == "var"
  6620  	case 33:
  6621  		return name == "package"
  6622  	case 34:
  6623  		return name == "break"
  6624  	case 55:
  6625  		return name == "const"
  6626  	case 68:
  6627  		return name == "else"
  6628  	case 69:
  6629  		return name == "func"
  6630  	case 73:
  6631  		return name == "map"
  6632  	case 87:
  6633  		return name == "goto"
  6634  	case 108:
  6635  		return name == "struct"
  6636  	case 111:
  6637  		return name == "switch"
  6638  	case 112:
  6639  		return name == "chan"
  6640  	case 117:
  6641  		return name == "return"
  6642  	case 119:
  6643  		return name == "continue"
  6644  	case 121:
  6645  		return name == "case"
  6646  	case 125:
  6647  		return name == "select"
  6648  	case 133:
  6649  		return name == "default"
  6650  	case 145:
  6651  		return name == "fallthrough"
  6652  	case 159:
  6653  		return name == "for"
  6654  	case 165:
  6655  		return name == "import"
  6656  	case 174:
  6657  		return name == "if"
  6658  	case 177:
  6659  		return name == "range"
  6660  	case 215:
  6661  		return name == "go"
  6662  	case 217:
  6663  		return name == "type"
  6664  	case 230:
  6665  		return name == "interface"
  6666  	}
  6667  	return false
  6668  }
  6669  
  6670  func TwoHash_AddAdd_Shift022(name string) bool {
  6671  	if len(name) < 2 {
  6672  		return false
  6673  	}
  6674  	switch ((byte(len(name)) << 0) + (name[0] << 2)) + (name[1] << 2) {
  6675  	case 20:
  6676  		return name == "case"
  6677  	case 39:
  6678  		return name == "fallthrough"
  6679  	case 41:
  6680  		return name == "defer"
  6681  	case 43:
  6682  		return name == "default"
  6683  	case 48:
  6684  		return name == "chan"
  6685  	case 59:
  6686  		return name == "map"
  6687  	case 62:
  6688  		return name == "if"
  6689  	case 72:
  6690  		return name == "else"
  6691  	case 75:
  6692  		return name == "package"
  6693  	case 77:
  6694  		return name == "const"
  6695  	case 80:
  6696  		return name == "continue"
  6697  	case 81:
  6698  		return name == "range"
  6699  	case 85:
  6700  		return name == "break"
  6701  	case 87:
  6702  		return name == "for"
  6703  	case 90:
  6704  		return name == "go"
  6705  	case 92:
  6706  		return name == "goto"
  6707  	case 94:
  6708  		return name == "import"
  6709  	case 95:
  6710  		return name == "var"
  6711  	case 98:
  6712  		return name == "return"
  6713  	case 101:
  6714  		return name == "interface"
  6715  	case 102:
  6716  		return name == "select"
  6717  	case 112:
  6718  		return name == "func"
  6719  	case 162:
  6720  		return name == "struct"
  6721  	case 174:
  6722  		return name == "switch"
  6723  	case 184:
  6724  		return name == "type"
  6725  	}
  6726  	return false
  6727  }
  6728  
  6729  func TwoHash_AddAdd_Shift024(name string) bool {
  6730  	if len(name) < 2 {
  6731  		return false
  6732  	}
  6733  	switch ((byte(len(name)) << 0) + (name[0] << 2)) + (name[1] << 4) {
  6734  	case 6:
  6735  		return name == "if"
  6736  	case 16:
  6737  		return name == "chan"
  6738  	case 18:
  6739  		return name == "struct"
  6740  	case 30:
  6741  		return name == "return"
  6742  	case 34:
  6743  		return name == "select"
  6744  	case 66:
  6745  		return name == "switch"
  6746  	case 88:
  6747  		return name == "else"
  6748  	case 100:
  6749  		return name == "type"
  6750  	case 122:
  6751  		return name == "import"
  6752  	case 129:
  6753  		return name == "const"
  6754  	case 132:
  6755  		return name == "continue"
  6756  	case 139:
  6757  		return name == "for"
  6758  	case 141:
  6759  		return name == "interface"
  6760  	case 142:
  6761  		return name == "go"
  6762  	case 144:
  6763  		return name == "goto"
  6764  	case 160:
  6765  		return name == "case"
  6766  	case 173:
  6767  		return name == "break"
  6768  	case 179:
  6769  		return name == "fallthrough"
  6770  	case 199:
  6771  		return name == "map"
  6772  	case 215:
  6773  		return name == "package"
  6774  	case 221:
  6775  		return name == "range"
  6776  	case 229:
  6777  		return name == "defer"
  6778  	case 231:
  6779  		return name == "default"
  6780  	case 235:
  6781  		return name == "var"
  6782  	case 236:
  6783  		return name == "func"
  6784  	}
  6785  	return false
  6786  }
  6787  
  6788  func TwoHash_AddAdd_Shift025(name string) bool {
  6789  	if len(name) < 2 {
  6790  		return false
  6791  	}
  6792  	switch ((byte(len(name)) << 0) + (name[0] << 2)) + (name[1] << 5) {
  6793  	case 24:
  6794  		return name == "else"
  6795  	case 53:
  6796  		return name == "defer"
  6797  	case 55:
  6798  		return name == "default"
  6799  	case 60:
  6800  		return name == "func"
  6801  	case 74:
  6802  		return name == "import"
  6803  	case 82:
  6804  		return name == "struct"
  6805  	case 102:
  6806  		return name == "if"
  6807  	case 109:
  6808  		return name == "interface"
  6809  	case 110:
  6810  		return name == "return"
  6811  	case 113:
  6812  		return name == "const"
  6813  	case 114:
  6814  		return name == "select"
  6815  	case 116:
  6816  		return name == "continue"
  6817  	case 123:
  6818  		return name == "for"
  6819  	case 126:
  6820  		return name == "go"
  6821  	case 128:
  6822  		return name == "goto"
  6823  	case 144:
  6824  		return name == "chan"
  6825  	case 176:
  6826  		return name == "case"
  6827  	case 178:
  6828  		return name == "switch"
  6829  	case 195:
  6830  		return name == "fallthrough"
  6831  	case 205:
  6832  		return name == "break"
  6833  	case 215:
  6834  		return name == "map"
  6835  	case 231:
  6836  		return name == "package"
  6837  	case 237:
  6838  		return name == "range"
  6839  	case 244:
  6840  		return name == "type"
  6841  	case 251:
  6842  		return name == "var"
  6843  	}
  6844  	return false
  6845  }
  6846  
  6847  func TwoHash_AddAdd_Shift033(name string) bool {
  6848  	if len(name) < 2 {
  6849  		return false
  6850  	}
  6851  	switch ((byte(len(name)) << 0) + (name[0] << 3)) + (name[1] << 3) {
  6852  	case 36:
  6853  		return name == "case"
  6854  	case 62:
  6855  		return name == "struct"
  6856  	case 67:
  6857  		return name == "fallthrough"
  6858  	case 77:
  6859  		return name == "defer"
  6860  	case 79:
  6861  		return name == "default"
  6862  	case 86:
  6863  		return name == "switch"
  6864  	case 92:
  6865  		return name == "chan"
  6866  	case 108:
  6867  		return name == "type"
  6868  	case 115:
  6869  		return name == "map"
  6870  	case 122:
  6871  		return name == "if"
  6872  	case 140:
  6873  		return name == "else"
  6874  	case 143:
  6875  		return name == "package"
  6876  	case 149:
  6877  		return name == "const"
  6878  	case 152:
  6879  		return name == "continue"
  6880  	case 157:
  6881  		return name == "range"
  6882  	case 165:
  6883  		return name == "break"
  6884  	case 171:
  6885  		return name == "for"
  6886  	case 178:
  6887  		return name == "go"
  6888  	case 180:
  6889  		return name == "goto"
  6890  	case 182:
  6891  		return name == "import"
  6892  	case 187:
  6893  		return name == "var"
  6894  	case 190:
  6895  		return name == "return"
  6896  	case 193:
  6897  		return name == "interface"
  6898  	case 198:
  6899  		return name == "select"
  6900  	case 220:
  6901  		return name == "func"
  6902  	}
  6903  	return false
  6904  }
  6905  
  6906  func TwoHash_AddAdd_Shift041(name string) bool {
  6907  	if len(name) < 2 {
  6908  		return false
  6909  	}
  6910  	switch ((byte(len(name)) << 0) + (name[0] << 4)) + (name[1] << 1) {
  6911  	case 0:
  6912  		return name == "select"
  6913  	case 4:
  6914  		return name == "chan"
  6915  	case 9:
  6916  		return name == "break"
  6917  	case 15:
  6918  		return name == "defer"
  6919  	case 17:
  6920  		return name == "default"
  6921  	case 19:
  6922  		return name == "const"
  6923  	case 22:
  6924  		return name == "continue"
  6925  	case 30:
  6926  		return name == "struct"
  6927  	case 36:
  6928  		return name == "switch"
  6929  	case 37:
  6930  		return name == "var"
  6931  	case 44:
  6932  		return name == "else"
  6933  	case 45:
  6934  		return name == "fallthrough"
  6935  	case 54:
  6936  		return name == "type"
  6937  	case 65:
  6938  		return name == "for"
  6939  	case 78:
  6940  		return name == "func"
  6941  	case 80:
  6942  		return name == "go"
  6943  	case 82:
  6944  		return name == "goto"
  6945  	case 94:
  6946  		return name == "if"
  6947  	case 112:
  6948  		return name == "import"
  6949  	case 117:
  6950  		return name == "interface"
  6951  	case 149:
  6952  		return name == "map"
  6953  	case 201:
  6954  		return name == "package"
  6955  	case 231:
  6956  		return name == "range"
  6957  	case 240:
  6958  		return name == "return"
  6959  	case 246:
  6960  		return name == "case"
  6961  	}
  6962  	return false
  6963  }
  6964  
  6965  func TwoHash_AddAdd_Shift042(name string) bool {
  6966  	if len(name) < 2 {
  6967  		return false
  6968  	}
  6969  	switch ((byte(len(name)) << 0) + (name[0] << 4)) + (name[1] << 2) {
  6970  	case 4:
  6971  		return name == "else"
  6972  	case 6:
  6973  		return name == "struct"
  6974  	case 18:
  6975  		return name == "switch"
  6976  	case 31:
  6977  		return name == "for"
  6978  	case 40:
  6979  		return name == "type"
  6980  	case 42:
  6981  		return name == "if"
  6982  	case 46:
  6983  		return name == "go"
  6984  	case 48:
  6985  		return name == "goto"
  6986  	case 56:
  6987  		return name == "func"
  6988  	case 74:
  6989  		return name == "import"
  6990  	case 81:
  6991  		return name == "interface"
  6992  	case 87:
  6993  		return name == "map"
  6994  	case 139:
  6995  		return name == "package"
  6996  	case 169:
  6997  		return name == "range"
  6998  	case 184:
  6999  		return name == "case"
  7000  	case 186:
  7001  		return name == "return"
  7002  	case 202:
  7003  		return name == "select"
  7004  	case 212:
  7005  		return name == "chan"
  7006  	case 217:
  7007  		return name == "defer"
  7008  	case 219:
  7009  		return name == "default"
  7010  	case 231:
  7011  		return name == "var"
  7012  	case 237:
  7013  		return name == "break"
  7014  	case 239:
  7015  		return name == "fallthrough"
  7016  	case 241:
  7017  		return name == "const"
  7018  	case 244:
  7019  		return name == "continue"
  7020  	}
  7021  	return false
  7022  }
  7023  
  7024  func TwoHash_AddAdd_Shift050(name string) bool {
  7025  	if len(name) < 2 {
  7026  		return false
  7027  	}
  7028  	switch ((byte(len(name)) << 0) + (name[0] << 5)) + (name[1] << 0) {
  7029  	case 4:
  7030  		return name == "map"
  7031  	case 16:
  7032  		return name == "else"
  7033  	case 36:
  7034  		return name == "var"
  7035  	case 44:
  7036  		return name == "fallthrough"
  7037  	case 50:
  7038  		return name == "for"
  7039  	case 57:
  7040  		return name == "func"
  7041  	case 81:
  7042  		return name == "go"
  7043  	case 83:
  7044  		return name == "goto"
  7045  	case 104:
  7046  		return name == "package"
  7047  	case 136:
  7048  		return name == "if"
  7049  	case 147:
  7050  		return name == "import"
  7051  	case 151:
  7052  		return name == "interface"
  7053  	case 166:
  7054  		return name == "range"
  7055  	case 171:
  7056  		return name == "return"
  7057  	case 183:
  7058  		return name == "break"
  7059  	case 197:
  7060  		return name == "case"
  7061  	case 203:
  7062  		return name == "select"
  7063  	case 204:
  7064  		return name == "chan"
  7065  	case 212:
  7066  		return name == "const"
  7067  	case 215:
  7068  		return name == "continue"
  7069  	case 218:
  7070  		return name == "struct"
  7071  	case 221:
  7072  		return name == "switch"
  7073  	case 234:
  7074  		return name == "defer"
  7075  	case 236:
  7076  		return name == "default"
  7077  	case 253:
  7078  		return name == "type"
  7079  	}
  7080  	return false
  7081  }
  7082  
  7083  func TwoHash_AddAdd_Shift051(name string) bool {
  7084  	if len(name) < 2 {
  7085  		return false
  7086  	}
  7087  	switch ((byte(len(name)) << 0) + (name[0] << 5)) + (name[1] << 1) {
  7088  	case 0:
  7089  		return name == "import"
  7090  	case 5:
  7091  		return name == "interface"
  7092  	case 7:
  7093  		return name == "range"
  7094  	case 16:
  7095  		return name == "return"
  7096  	case 38:
  7097  		return name == "case"
  7098  	case 41:
  7099  		return name == "break"
  7100  	case 48:
  7101  		return name == "select"
  7102  	case 52:
  7103  		return name == "chan"
  7104  	case 67:
  7105  		return name == "const"
  7106  	case 70:
  7107  		return name == "continue"
  7108  	case 78:
  7109  		return name == "struct"
  7110  	case 79:
  7111  		return name == "defer"
  7112  	case 81:
  7113  		return name == "default"
  7114  	case 84:
  7115  		return name == "switch"
  7116  	case 101:
  7117  		return name == "map"
  7118  	case 118:
  7119  		return name == "type"
  7120  	case 124:
  7121  		return name == "else"
  7122  	case 133:
  7123  		return name == "var"
  7124  	case 141:
  7125  		return name == "fallthrough"
  7126  	case 161:
  7127  		return name == "for"
  7128  	case 174:
  7129  		return name == "func"
  7130  	case 192:
  7131  		return name == "go"
  7132  	case 194:
  7133  		return name == "goto"
  7134  	case 201:
  7135  		return name == "package"
  7136  	case 238:
  7137  		return name == "if"
  7138  	}
  7139  	return false
  7140  }
  7141  
  7142  func TwoHash_AddAdd_Shift060(name string) bool {
  7143  	if len(name) < 2 {
  7144  		return false
  7145  	}
  7146  	switch ((byte(len(name)) << 0) + (name[0] << 6)) + (name[1] << 0) {
  7147  	case 37:
  7148  		return name == "case"
  7149  	case 43:
  7150  		return name == "select"
  7151  	case 44:
  7152  		return name == "chan"
  7153  	case 49:
  7154  		return name == "go"
  7155  	case 51:
  7156  		return name == "goto"
  7157  	case 52:
  7158  		return name == "const"
  7159  	case 55:
  7160  		return name == "continue"
  7161  	case 58:
  7162  		return name == "struct"
  7163  	case 61:
  7164  		return name == "switch"
  7165  	case 104:
  7166  		return name == "package"
  7167  	case 106:
  7168  		return name == "defer"
  7169  	case 108:
  7170  		return name == "default"
  7171  	case 125:
  7172  		return name == "type"
  7173  	case 164:
  7174  		return name == "map"
  7175  	case 168:
  7176  		return name == "if"
  7177  	case 176:
  7178  		return name == "else"
  7179  	case 179:
  7180  		return name == "import"
  7181  	case 183:
  7182  		return name == "interface"
  7183  	case 228:
  7184  		return name == "var"
  7185  	case 230:
  7186  		return name == "range"
  7187  	case 235:
  7188  		return name == "return"
  7189  	case 236:
  7190  		return name == "fallthrough"
  7191  	case 242:
  7192  		return name == "for"
  7193  	case 247:
  7194  		return name == "break"
  7195  	case 249:
  7196  		return name == "func"
  7197  	}
  7198  	return false
  7199  }
  7200  
  7201  func TwoHash_AddAdd_Shift061(name string) bool {
  7202  	if len(name) < 2 {
  7203  		return false
  7204  	}
  7205  	switch ((byte(len(name)) << 0) + (name[0] << 6)) + (name[1] << 1) {
  7206  	case 5:
  7207  		return name == "map"
  7208  	case 14:
  7209  		return name == "if"
  7210  	case 28:
  7211  		return name == "else"
  7212  	case 32:
  7213  		return name == "import"
  7214  	case 37:
  7215  		return name == "interface"
  7216  	case 69:
  7217  		return name == "var"
  7218  	case 71:
  7219  		return name == "range"
  7220  	case 77:
  7221  		return name == "fallthrough"
  7222  	case 80:
  7223  		return name == "return"
  7224  	case 97:
  7225  		return name == "for"
  7226  	case 105:
  7227  		return name == "break"
  7228  	case 110:
  7229  		return name == "func"
  7230  	case 134:
  7231  		return name == "case"
  7232  	case 144:
  7233  		return name == "select"
  7234  	case 148:
  7235  		return name == "chan"
  7236  	case 160:
  7237  		return name == "go"
  7238  	case 162:
  7239  		return name == "goto"
  7240  	case 163:
  7241  		return name == "const"
  7242  	case 166:
  7243  		return name == "continue"
  7244  	case 174:
  7245  		return name == "struct"
  7246  	case 180:
  7247  		return name == "switch"
  7248  	case 201:
  7249  		return name == "package"
  7250  	case 207:
  7251  		return name == "defer"
  7252  	case 209:
  7253  		return name == "default"
  7254  	case 246:
  7255  		return name == "type"
  7256  	}
  7257  	return false
  7258  }
  7259  
  7260  func TwoHash_AddAdd_Shift062(name string) bool {
  7261  	if len(name) < 2 {
  7262  		return false
  7263  	}
  7264  	switch ((byte(len(name)) << 0) + (name[0] << 6)) + (name[1] << 2) {
  7265  	case 1:
  7266  		return name == "interface"
  7267  	case 7:
  7268  		return name == "var"
  7269  	case 9:
  7270  		return name == "range"
  7271  	case 15:
  7272  		return name == "fallthrough"
  7273  	case 26:
  7274  		return name == "return"
  7275  	case 63:
  7276  		return name == "for"
  7277  	case 72:
  7278  		return name == "case"
  7279  	case 77:
  7280  		return name == "break"
  7281  	case 88:
  7282  		return name == "func"
  7283  	case 90:
  7284  		return name == "select"
  7285  	case 100:
  7286  		return name == "chan"
  7287  	case 126:
  7288  		return name == "go"
  7289  	case 128:
  7290  		return name == "goto"
  7291  	case 129:
  7292  		return name == "const"
  7293  	case 132:
  7294  		return name == "continue"
  7295  	case 139:
  7296  		return name == "package"
  7297  	case 150:
  7298  		return name == "struct"
  7299  	case 153:
  7300  		return name == "defer"
  7301  	case 155:
  7302  		return name == "default"
  7303  	case 162:
  7304  		return name == "switch"
  7305  	case 199:
  7306  		return name == "map"
  7307  	case 218:
  7308  		return name == "if"
  7309  	case 232:
  7310  		return name == "type"
  7311  	case 244:
  7312  		return name == "else"
  7313  	case 250:
  7314  		return name == "import"
  7315  	}
  7316  	return false
  7317  }
  7318  
  7319  func TwoHash_AddAdd_Shift073(name string) bool {
  7320  	if len(name) < 2 {
  7321  		return false
  7322  	}
  7323  	switch ((byte(len(name)) << 0) + (name[0] << 7)) + (name[1] << 3) {
  7324  	case 0:
  7325  		return name == "continue"
  7326  	case 11:
  7327  		return name == "var"
  7328  	case 13:
  7329  		return name == "range"
  7330  	case 15:
  7331  		return name == "package"
  7332  	case 19:
  7333  		return name == "fallthrough"
  7334  	case 38:
  7335  		return name == "struct"
  7336  	case 45:
  7337  		return name == "defer"
  7338  	case 46:
  7339  		return name == "return"
  7340  	case 47:
  7341  		return name == "default"
  7342  	case 62:
  7343  		return name == "switch"
  7344  	case 123:
  7345  		return name == "for"
  7346  	case 139:
  7347  		return name == "map"
  7348  	case 140:
  7349  		return name == "case"
  7350  	case 149:
  7351  		return name == "break"
  7352  	case 172:
  7353  		return name == "func"
  7354  	case 174:
  7355  		return name == "select"
  7356  	case 178:
  7357  		return name == "if"
  7358  	case 196:
  7359  		return name == "chan"
  7360  	case 204:
  7361  		return name == "type"
  7362  	case 228:
  7363  		return name == "else"
  7364  	case 238:
  7365  		return name == "import"
  7366  	case 249:
  7367  		return name == "interface"
  7368  	case 250:
  7369  		return name == "go"
  7370  	case 252:
  7371  		return name == "goto"
  7372  	case 253:
  7373  		return name == "const"
  7374  	}
  7375  	return false
  7376  }
  7377  
  7378  func TwoHash_AddAdd_Shift130(name string) bool {
  7379  	if len(name) < 2 {
  7380  		return false
  7381  	}
  7382  	switch ((byte(len(name)) << 1) + (name[0] << 3)) + (name[1] << 0) {
  7383  	case 1:
  7384  		return name == "return"
  7385  	case 9:
  7386  		return name == "select"
  7387  	case 23:
  7388  		return name == "var"
  7389  	case 24:
  7390  		return name == "struct"
  7391  	case 27:
  7392  		return name == "switch"
  7393  	case 33:
  7394  		return name == "type"
  7395  	case 129:
  7396  		return name == "case"
  7397  	case 136:
  7398  		return name == "chan"
  7399  	case 140:
  7400  		return name == "break"
  7401  	case 143:
  7402  		return name == "defer"
  7403  	case 145:
  7404  		return name == "const"
  7405  	case 147:
  7406  		return name == "default"
  7407  	case 151:
  7408  		return name == "continue"
  7409  	case 156:
  7410  		return name == "else"
  7411  	case 165:
  7412  		return name == "for"
  7413  	case 167:
  7414  		return name == "fallthrough"
  7415  	case 171:
  7416  		return name == "go"
  7417  	case 173:
  7418  		return name == "func"
  7419  	case 175:
  7420  		return name == "goto"
  7421  	case 178:
  7422  		return name == "if"
  7423  	case 193:
  7424  		return name == "import"
  7425  	case 200:
  7426  		return name == "interface"
  7427  	case 207:
  7428  		return name == "map"
  7429  	case 239:
  7430  		return name == "package"
  7431  	case 251:
  7432  		return name == "range"
  7433  	}
  7434  	return false
  7435  }
  7436  
  7437  func TwoHash_AddAdd_Shift133(name string) bool {
  7438  	if len(name) < 2 {
  7439  		return false
  7440  	}
  7441  	switch ((byte(len(name)) << 1) + (name[0] << 3)) + (name[1] << 3) {
  7442  	case 40:
  7443  		return name == "case"
  7444  	case 68:
  7445  		return name == "struct"
  7446  	case 78:
  7447  		return name == "fallthrough"
  7448  	case 82:
  7449  		return name == "defer"
  7450  	case 86:
  7451  		return name == "default"
  7452  	case 92:
  7453  		return name == "switch"
  7454  	case 96:
  7455  		return name == "chan"
  7456  	case 112:
  7457  		return name == "type"
  7458  	case 118:
  7459  		return name == "map"
  7460  	case 124:
  7461  		return name == "if"
  7462  	case 144:
  7463  		return name == "else"
  7464  	case 150:
  7465  		return name == "package"
  7466  	case 154:
  7467  		return name == "const"
  7468  	case 160:
  7469  		return name == "continue"
  7470  	case 162:
  7471  		return name == "range"
  7472  	case 170:
  7473  		return name == "break"
  7474  	case 174:
  7475  		return name == "for"
  7476  	case 180:
  7477  		return name == "go"
  7478  	case 184:
  7479  		return name == "goto"
  7480  	case 188:
  7481  		return name == "import"
  7482  	case 190:
  7483  		return name == "var"
  7484  	case 196:
  7485  		return name == "return"
  7486  	case 202:
  7487  		return name == "interface"
  7488  	case 204:
  7489  		return name == "select"
  7490  	case 224:
  7491  		return name == "func"
  7492  	}
  7493  	return false
  7494  }
  7495  
  7496  func TwoHash_AddAdd_Shift150(name string) bool {
  7497  	if len(name) < 2 {
  7498  		return false
  7499  	}
  7500  	switch ((byte(len(name)) << 1) + (name[0] << 5)) + (name[1] << 0) {
  7501  	case 1:
  7502  		return name == "type"
  7503  	case 7:
  7504  		return name == "map"
  7505  	case 20:
  7506  		return name == "else"
  7507  	case 39:
  7508  		return name == "var"
  7509  	case 53:
  7510  		return name == "for"
  7511  	case 55:
  7512  		return name == "fallthrough"
  7513  	case 61:
  7514  		return name == "func"
  7515  	case 83:
  7516  		return name == "go"
  7517  	case 87:
  7518  		return name == "goto"
  7519  	case 111:
  7520  		return name == "package"
  7521  	case 138:
  7522  		return name == "if"
  7523  	case 153:
  7524  		return name == "import"
  7525  	case 160:
  7526  		return name == "interface"
  7527  	case 171:
  7528  		return name == "range"
  7529  	case 177:
  7530  		return name == "return"
  7531  	case 188:
  7532  		return name == "break"
  7533  	case 201:
  7534  		return name == "case"
  7535  	case 208:
  7536  		return name == "chan"
  7537  	case 209:
  7538  		return name == "select"
  7539  	case 217:
  7540  		return name == "const"
  7541  	case 223:
  7542  		return name == "continue"
  7543  	case 224:
  7544  		return name == "struct"
  7545  	case 227:
  7546  		return name == "switch"
  7547  	case 239:
  7548  		return name == "defer"
  7549  	case 243:
  7550  		return name == "default"
  7551  	}
  7552  	return false
  7553  }
  7554  
  7555  func TwoHash_AddAdd_Shift161(name string) bool {
  7556  	if len(name) < 2 {
  7557  		return false
  7558  	}
  7559  	switch ((byte(len(name)) << 1) + (name[0] << 6)) + (name[1] << 1) {
  7560  	case 8:
  7561  		return name == "map"
  7562  	case 16:
  7563  		return name == "if"
  7564  	case 32:
  7565  		return name == "else"
  7566  	case 38:
  7567  		return name == "import"
  7568  	case 46:
  7569  		return name == "interface"
  7570  	case 72:
  7571  		return name == "var"
  7572  	case 76:
  7573  		return name == "range"
  7574  	case 86:
  7575  		return name == "return"
  7576  	case 88:
  7577  		return name == "fallthrough"
  7578  	case 100:
  7579  		return name == "for"
  7580  	case 110:
  7581  		return name == "break"
  7582  	case 114:
  7583  		return name == "func"
  7584  	case 138:
  7585  		return name == "case"
  7586  	case 150:
  7587  		return name == "select"
  7588  	case 152:
  7589  		return name == "chan"
  7590  	case 162:
  7591  		return name == "go"
  7592  	case 166:
  7593  		return name == "goto"
  7594  	case 168:
  7595  		return name == "const"
  7596  	case 174:
  7597  		return name == "continue"
  7598  	case 180:
  7599  		return name == "struct"
  7600  	case 186:
  7601  		return name == "switch"
  7602  	case 208:
  7603  		return name == "package"
  7604  	case 212:
  7605  		return name == "defer"
  7606  	case 216:
  7607  		return name == "default"
  7608  	case 250:
  7609  		return name == "type"
  7610  	}
  7611  	return false
  7612  }
  7613  
  7614  func TwoHash_AddAdd_Shift230(name string) bool {
  7615  	if len(name) < 2 {
  7616  		return false
  7617  	}
  7618  	switch ((byte(len(name)) << 2) + (name[0] << 3)) + (name[1] << 0) {
  7619  	case 5:
  7620  		return name == "range"
  7621  	case 13:
  7622  		return name == "return"
  7623  	case 21:
  7624  		return name == "select"
  7625  	case 29:
  7626  		return name == "var"
  7627  	case 36:
  7628  		return name == "struct"
  7629  	case 39:
  7630  		return name == "switch"
  7631  	case 41:
  7632  		return name == "type"
  7633  	case 137:
  7634  		return name == "case"
  7635  	case 144:
  7636  		return name == "chan"
  7637  	case 150:
  7638  		return name == "break"
  7639  	case 153:
  7640  		return name == "defer"
  7641  	case 155:
  7642  		return name == "const"
  7643  	case 161:
  7644  		return name == "default"
  7645  	case 164:
  7646  		return name == "else"
  7647  	case 167:
  7648  		return name == "continue"
  7649  	case 171:
  7650  		return name == "for"
  7651  	case 175:
  7652  		return name == "go"
  7653  	case 181:
  7654  		return name == "func"
  7655  	case 182:
  7656  		return name == "if"
  7657  	case 183:
  7658  		return name == "goto"
  7659  	case 189:
  7660  		return name == "fallthrough"
  7661  	case 205:
  7662  		return name == "import"
  7663  	case 213:
  7664  		return name == "map"
  7665  	case 218:
  7666  		return name == "interface"
  7667  	case 253:
  7668  		return name == "package"
  7669  	}
  7670  	return false
  7671  }
  7672  
  7673  func TwoHash_AddAdd_Shift302(name string) bool {
  7674  	if len(name) < 2 {
  7675  		return false
  7676  	}
  7677  	switch ((byte(len(name)) << 3) + (name[0] << 0)) + (name[1] << 2) {
  7678  	case 7:
  7679  		return name == "case"
  7680  	case 9:
  7681  		return name == "map"
  7682  	case 17:
  7683  		return name == "if"
  7684  	case 18:
  7685  		return name == "var"
  7686  	case 30:
  7687  		return name == "range"
  7688  	case 32:
  7689  		return name == "defer"
  7690  	case 35:
  7691  		return name == "chan"
  7692  	case 44:
  7693  		return name == "package"
  7694  	case 48:
  7695  		return name == "default"
  7696  	case 51:
  7697  		return name == "go"
  7698  	case 53:
  7699  		return name == "else"
  7700  	case 54:
  7701  		return name == "return"
  7702  	case 55:
  7703  		return name == "select"
  7704  	case 58:
  7705  		return name == "for"
  7706  	case 66:
  7707  		return name == "fallthrough"
  7708  	case 67:
  7709  		return name == "goto"
  7710  	case 71:
  7711  		return name == "const"
  7712  	case 77:
  7713  		return name == "import"
  7714  	case 82:
  7715  		return name == "break"
  7716  	case 90:
  7717  		return name == "func"
  7718  	case 95:
  7719  		return name == "continue"
  7720  	case 105:
  7721  		return name == "interface"
  7722  	case 115:
  7723  		return name == "struct"
  7724  	case 120:
  7725  		return name == "type"
  7726  	case 127:
  7727  		return name == "switch"
  7728  	}
  7729  	return false
  7730  }
  7731  
  7732  func TwoHash_AddAdd_Shift303(name string) bool {
  7733  	if len(name) < 2 {
  7734  		return false
  7735  	}
  7736  	switch ((byte(len(name)) << 3) + (name[0] << 0)) + (name[1] << 3) {
  7737  	case 1:
  7738  		return name == "import"
  7739  	case 3:
  7740  		return name == "const"
  7741  	case 26:
  7742  		return name == "break"
  7743  	case 27:
  7744  		return name == "continue"
  7745  	case 33:
  7746  		return name == "interface"
  7747  	case 46:
  7748  		return name == "func"
  7749  	case 67:
  7750  		return name == "struct"
  7751  	case 91:
  7752  		return name == "switch"
  7753  	case 92:
  7754  		return name == "type"
  7755  	case 139:
  7756  		return name == "case"
  7757  	case 141:
  7758  		return name == "map"
  7759  	case 150:
  7760  		return name == "var"
  7761  	case 162:
  7762  		return name == "range"
  7763  	case 169:
  7764  		return name == "if"
  7765  	case 176:
  7766  		return name == "package"
  7767  	case 180:
  7768  		return name == "defer"
  7769  	case 195:
  7770  		return name == "chan"
  7771  	case 196:
  7772  		return name == "default"
  7773  	case 198:
  7774  		return name == "fallthrough"
  7775  	case 202:
  7776  		return name == "return"
  7777  	case 203:
  7778  		return name == "select"
  7779  	case 229:
  7780  		return name == "else"
  7781  	case 239:
  7782  		return name == "go"
  7783  	case 246:
  7784  		return name == "for"
  7785  	case 255:
  7786  		return name == "goto"
  7787  	}
  7788  	return false
  7789  }
  7790  
  7791  func TwoHash_AddAdd_Shift400(name string) bool {
  7792  	if len(name) < 2 {
  7793  		return false
  7794  	}
  7795  	switch ((byte(len(name)) << 4) + (name[0] << 0)) + (name[1] << 0) {
  7796  	case 4:
  7797  		return name == "case"
  7798  	case 5:
  7799  		return name == "for"
  7800  	case 7:
  7801  		return name == "var"
  7802  	case 11:
  7803  		return name == "chan"
  7804  	case 17:
  7805  		return name == "else"
  7806  	case 22:
  7807  		return name == "goto"
  7808  	case 25:
  7809  		return name == "defer"
  7810  	case 27:
  7811  		return name == "func"
  7812  	case 34:
  7813  		return name == "const"
  7814  	case 35:
  7815  		return name == "range"
  7816  	case 36:
  7817  		return name == "break"
  7818  	case 45:
  7819  		return name == "type"
  7820  	case 54:
  7821  		return name == "import"
  7822  	case 55:
  7823  		return name == "return"
  7824  	case 56:
  7825  		return name == "select"
  7826  	case 57:
  7827  		return name == "default"
  7828  	case 65:
  7829  		return name == "package"
  7830  	case 71:
  7831  		return name == "struct"
  7832  	case 74:
  7833  		return name == "switch"
  7834  	case 82:
  7835  		return name == "continue"
  7836  	case 103:
  7837  		return name == "interface"
  7838  	case 119:
  7839  		return name == "fallthrough"
  7840  	case 239:
  7841  		return name == "if"
  7842  	case 246:
  7843  		return name == "go"
  7844  	case 254:
  7845  		return name == "map"
  7846  	}
  7847  	return false
  7848  }
  7849  
  7850  func TwoHash_AddAdd_Shift403(name string) bool {
  7851  	if len(name) < 2 {
  7852  		return false
  7853  	}
  7854  	switch ((byte(len(name)) << 4) + (name[0] << 0)) + (name[1] << 3) {
  7855  	case 5:
  7856  		return name == "else"
  7857  	case 14:
  7858  		return name == "for"
  7859  	case 30:
  7860  		return name == "fallthrough"
  7861  	case 31:
  7862  		return name == "goto"
  7863  	case 43:
  7864  		return name == "const"
  7865  	case 49:
  7866  		return name == "import"
  7867  	case 66:
  7868  		return name == "break"
  7869  	case 78:
  7870  		return name == "func"
  7871  	case 91:
  7872  		return name == "continue"
  7873  	case 105:
  7874  		return name == "interface"
  7875  	case 115:
  7876  		return name == "struct"
  7877  	case 124:
  7878  		return name == "type"
  7879  	case 139:
  7880  		return name == "switch"
  7881  	case 165:
  7882  		return name == "map"
  7883  	case 171:
  7884  		return name == "case"
  7885  	case 174:
  7886  		return name == "var"
  7887  	case 185:
  7888  		return name == "if"
  7889  	case 202:
  7890  		return name == "range"
  7891  	case 220:
  7892  		return name == "defer"
  7893  	case 227:
  7894  		return name == "chan"
  7895  	case 232:
  7896  		return name == "package"
  7897  	case 250:
  7898  		return name == "return"
  7899  	case 251:
  7900  		return name == "select"
  7901  	case 252:
  7902  		return name == "default"
  7903  	case 255:
  7904  		return name == "go"
  7905  	}
  7906  	return false
  7907  }
  7908  
  7909  func TwoHash_AddAdd_Shift413(name string) bool {
  7910  	if len(name) < 2 {
  7911  		return false
  7912  	}
  7913  	switch ((byte(len(name)) << 4) + (name[0] << 1)) + (name[1] << 3) {
  7914  	case 14:
  7915  		return name == "case"
  7916  	case 18:
  7917  		return name == "map"
  7918  	case 34:
  7919  		return name == "if"
  7920  	case 36:
  7921  		return name == "var"
  7922  	case 60:
  7923  		return name == "range"
  7924  	case 64:
  7925  		return name == "defer"
  7926  	case 70:
  7927  		return name == "chan"
  7928  	case 88:
  7929  		return name == "package"
  7930  	case 96:
  7931  		return name == "default"
  7932  	case 102:
  7933  		return name == "go"
  7934  	case 106:
  7935  		return name == "else"
  7936  	case 108:
  7937  		return name == "return"
  7938  	case 110:
  7939  		return name == "select"
  7940  	case 116:
  7941  		return name == "for"
  7942  	case 132:
  7943  		return name == "fallthrough"
  7944  	case 134:
  7945  		return name == "goto"
  7946  	case 142:
  7947  		return name == "const"
  7948  	case 154:
  7949  		return name == "import"
  7950  	case 164:
  7951  		return name == "break"
  7952  	case 180:
  7953  		return name == "func"
  7954  	case 190:
  7955  		return name == "continue"
  7956  	case 210:
  7957  		return name == "interface"
  7958  	case 230:
  7959  		return name == "struct"
  7960  	case 240:
  7961  		return name == "type"
  7962  	case 254:
  7963  		return name == "switch"
  7964  	}
  7965  	return false
  7966  }
  7967  
  7968  func TwoHash_AddAdd_Shift500(name string) bool {
  7969  	if len(name) < 2 {
  7970  		return false
  7971  	}
  7972  	switch ((byte(len(name)) << 5) + (name[0] << 0)) + (name[1] << 0) {
  7973  	case 15:
  7974  		return name == "if"
  7975  	case 22:
  7976  		return name == "go"
  7977  	case 39:
  7978  		return name == "fallthrough"
  7979  	case 46:
  7980  		return name == "map"
  7981  	case 53:
  7982  		return name == "for"
  7983  	case 55:
  7984  		return name == "var"
  7985  	case 68:
  7986  		return name == "case"
  7987  	case 75:
  7988  		return name == "chan"
  7989  	case 81:
  7990  		return name == "else"
  7991  	case 86:
  7992  		return name == "goto"
  7993  	case 91:
  7994  		return name == "func"
  7995  	case 105:
  7996  		return name == "defer"
  7997  	case 109:
  7998  		return name == "type"
  7999  	case 114:
  8000  		return name == "const"
  8001  	case 115:
  8002  		return name == "range"
  8003  	case 116:
  8004  		return name == "break"
  8005  	case 150:
  8006  		return name == "import"
  8007  	case 151:
  8008  		return name == "return"
  8009  	case 152:
  8010  		return name == "select"
  8011  	case 167:
  8012  		return name == "struct"
  8013  	case 169:
  8014  		return name == "default"
  8015  	case 170:
  8016  		return name == "switch"
  8017  	case 177:
  8018  		return name == "package"
  8019  	case 210:
  8020  		return name == "continue"
  8021  	case 247:
  8022  		return name == "interface"
  8023  	}
  8024  	return false
  8025  }
  8026  
  8027  func TwoHash_AddAdd_Shift511(name string) bool {
  8028  	if len(name) < 2 {
  8029  		return false
  8030  	}
  8031  	switch ((byte(len(name)) << 5) + (name[0] << 1)) + (name[1] << 1) {
  8032  	case 8:
  8033  		return name == "case"
  8034  	case 10:
  8035  		return name == "for"
  8036  	case 14:
  8037  		return name == "var"
  8038  	case 22:
  8039  		return name == "chan"
  8040  	case 34:
  8041  		return name == "else"
  8042  	case 44:
  8043  		return name == "goto"
  8044  	case 50:
  8045  		return name == "defer"
  8046  	case 54:
  8047  		return name == "func"
  8048  	case 68:
  8049  		return name == "const"
  8050  	case 70:
  8051  		return name == "range"
  8052  	case 72:
  8053  		return name == "break"
  8054  	case 90:
  8055  		return name == "type"
  8056  	case 108:
  8057  		return name == "import"
  8058  	case 110:
  8059  		return name == "return"
  8060  	case 112:
  8061  		return name == "select"
  8062  	case 114:
  8063  		return name == "default"
  8064  	case 130:
  8065  		return name == "package"
  8066  	case 142:
  8067  		return name == "struct"
  8068  	case 148:
  8069  		return name == "switch"
  8070  	case 164:
  8071  		return name == "continue"
  8072  	case 206:
  8073  		return name == "interface"
  8074  	case 222:
  8075  		return name == "if"
  8076  	case 236:
  8077  		return name == "go"
  8078  	case 238:
  8079  		return name == "fallthrough"
  8080  	case 252:
  8081  		return name == "map"
  8082  	}
  8083  	return false
  8084  }
  8085  
  8086  func TwoHash_AddAdd_Shift601(name string) bool {
  8087  	if len(name) < 2 {
  8088  		return false
  8089  	}
  8090  	switch ((byte(len(name)) << 6) + (name[0] << 0)) + (name[1] << 1) {
  8091  	case 4:
  8092  		return name == "for"
  8093  	case 37:
  8094  		return name == "case"
  8095  	case 51:
  8096  		return name == "chan"
  8097  	case 61:
  8098  		return name == "else"
  8099  	case 65:
  8100  		return name == "continue"
  8101  	case 69:
  8102  		return name == "goto"
  8103  	case 80:
  8104  		return name == "func"
  8105  	case 102:
  8106  		return name == "type"
  8107  	case 110:
  8108  		return name == "defer"
  8109  	case 116:
  8110  		return name == "range"
  8111  	case 129:
  8112  		return name == "const"
  8113  	case 133:
  8114  		return name == "interface"
  8115  	case 134:
  8116  		return name == "break"
  8117  	case 181:
  8118  		return name == "if"
  8119  	case 188:
  8120  		return name == "return"
  8121  	case 189:
  8122  		return name == "select"
  8123  	case 195:
  8124  		return name == "import"
  8125  	case 197:
  8126  		return name == "go"
  8127  	case 219:
  8128  		return name == "struct"
  8129  	case 225:
  8130  		return name == "switch"
  8131  	case 232:
  8132  		return name == "fallthrough"
  8133  	case 238:
  8134  		return name == "default"
  8135  	case 239:
  8136  		return name == "map"
  8137  	case 242:
  8138  		return name == "package"
  8139  	case 248:
  8140  		return name == "var"
  8141  	}
  8142  	return false
  8143  }
  8144  
  8145  func TwoHash_AddAdd_Shift602(name string) bool {
  8146  	if len(name) < 2 {
  8147  		return false
  8148  	}
  8149  	switch ((byte(len(name)) << 6) + (name[0] << 0)) + (name[1] << 2) {
  8150  	case 3:
  8151  		return name == "chan"
  8152  	case 21:
  8153  		return name == "else"
  8154  	case 31:
  8155  		return name == "continue"
  8156  	case 35:
  8157  		return name == "goto"
  8158  	case 54:
  8159  		return name == "range"
  8160  	case 56:
  8161  		return name == "defer"
  8162  	case 58:
  8163  		return name == "func"
  8164  	case 88:
  8165  		return name == "type"
  8166  	case 95:
  8167  		return name == "const"
  8168  	case 97:
  8169  		return name == "interface"
  8170  	case 106:
  8171  		return name == "break"
  8172  	case 129:
  8173  		return name == "if"
  8174  	case 134:
  8175  		return name == "return"
  8176  	case 135:
  8177  		return name == "select"
  8178  	case 157:
  8179  		return name == "import"
  8180  	case 163:
  8181  		return name == "go"
  8182  	case 170:
  8183  		return name == "fallthrough"
  8184  	case 177:
  8185  		return name == "map"
  8186  	case 180:
  8187  		return name == "package"
  8188  	case 184:
  8189  		return name == "default"
  8190  	case 186:
  8191  		return name == "var"
  8192  	case 195:
  8193  		return name == "struct"
  8194  	case 207:
  8195  		return name == "switch"
  8196  	case 226:
  8197  		return name == "for"
  8198  	case 231:
  8199  		return name == "case"
  8200  	}
  8201  	return false
  8202  }
  8203  
  8204  func TwoHash_AddAdd_Shift620(name string) bool {
  8205  	if len(name) < 2 {
  8206  		return false
  8207  	}
  8208  	switch ((byte(len(name)) << 6) + (name[0] << 2)) + (name[1] << 0) {
  8209  	case 0:
  8210  		return name == "else"
  8211  	case 11:
  8212  		return name == "goto"
  8213  	case 13:
  8214  		return name == "func"
  8215  	case 53:
  8216  		return name == "defer"
  8217  	case 58:
  8218  		return name == "break"
  8219  	case 59:
  8220  		return name == "const"
  8221  	case 73:
  8222  		return name == "type"
  8223  	case 82:
  8224  		return name == "interface"
  8225  	case 105:
  8226  		return name == "range"
  8227  	case 138:
  8228  		return name == "if"
  8229  	case 139:
  8230  		return name == "go"
  8231  	case 145:
  8232  		return name == "import"
  8233  	case 173:
  8234  		return name == "return"
  8235  	case 177:
  8236  		return name == "select"
  8237  	case 181:
  8238  		return name == "default"
  8239  	case 185:
  8240  		return name == "fallthrough"
  8241  	case 192:
  8242  		return name == "struct"
  8243  	case 195:
  8244  		return name == "switch"
  8245  	case 199:
  8246  		return name == "for"
  8247  	case 213:
  8248  		return name == "map"
  8249  	case 225:
  8250  		return name == "package"
  8251  	case 237:
  8252  		return name == "case"
  8253  	case 244:
  8254  		return name == "chan"
  8255  	case 249:
  8256  		return name == "var"
  8257  	case 251:
  8258  		return name == "continue"
  8259  	}
  8260  	return false
  8261  }
  8262  
  8263  func TwoHash_AddAdd_Shift630(name string) bool {
  8264  	if len(name) < 2 {
  8265  		return false
  8266  	}
  8267  	switch ((byte(len(name)) << 6) + (name[0] << 3)) + (name[1] << 0) {
  8268  	case 25:
  8269  		return name == "type"
  8270  	case 39:
  8271  		return name == "go"
  8272  	case 46:
  8273  		return name == "if"
  8274  	case 49:
  8275  		return name == "range"
  8276  	case 53:
  8277  		return name == "import"
  8278  	case 69:
  8279  		return name == "default"
  8280  	case 81:
  8281  		return name == "fallthrough"
  8282  	case 95:
  8283  		return name == "for"
  8284  	case 117:
  8285  		return name == "return"
  8286  	case 121:
  8287  		return name == "case"
  8288  	case 125:
  8289  		return name == "select"
  8290  	case 128:
  8291  		return name == "chan"
  8292  	case 135:
  8293  		return name == "continue"
  8294  	case 137:
  8295  		return name == "map"
  8296  	case 140:
  8297  		return name == "struct"
  8298  	case 143:
  8299  		return name == "switch"
  8300  	case 148:
  8301  		return name == "else"
  8302  	case 161:
  8303  		return name == "package"
  8304  	case 165:
  8305  		return name == "func"
  8306  	case 167:
  8307  		return name == "goto"
  8308  	case 194:
  8309  		return name == "break"
  8310  	case 197:
  8311  		return name == "defer"
  8312  	case 199:
  8313  		return name == "const"
  8314  	case 209:
  8315  		return name == "var"
  8316  	case 246:
  8317  		return name == "interface"
  8318  	}
  8319  	return false
  8320  }
  8321  
  8322  func TwoHash_OrXor_Shift032(name string) bool {
  8323  	if len(name) < 2 {
  8324  		return false
  8325  	}
  8326  	switch ((byte(len(name)) << 0) | (name[0] << 3)) ^ (name[1] << 2) {
  8327  	case 2:
  8328  		return name == "return"
  8329  	case 3:
  8330  		return name == "package"
  8331  	case 10:
  8332  		return name == "select"
  8333  	case 17:
  8334  		return name == "range"
  8335  	case 55:
  8336  		return name == "var"
  8337  	case 64:
  8338  		return name == "type"
  8339  	case 66:
  8340  		return name == "switch"
  8341  	case 78:
  8342  		return name == "struct"
  8343  	case 128:
  8344  		return name == "goto"
  8345  	case 134:
  8346  		return name == "go"
  8347  	case 143:
  8348  		return name == "for"
  8349  	case 152:
  8350  		return name == "case"
  8351  	case 156:
  8352  		return name == "else"
  8353  	case 161:
  8354  		return name == "const"
  8355  	case 164:
  8356  		return name == "continue"
  8357  	case 177:
  8358  		return name == "defer"
  8359  	case 179:
  8360  		return name == "default"
  8361  	case 188:
  8362  		return name == "chan"
  8363  	case 191:
  8364  		return name == "fallthrough"
  8365  	case 210:
  8366  		return name == "if"
  8367  	case 221:
  8368  		return name == "break"
  8369  	case 224:
  8370  		return name == "func"
  8371  	case 239:
  8372  		return name == "map"
  8373  	case 241:
  8374  		return name == "interface"
  8375  	case 250:
  8376  		return name == "import"
  8377  	}
  8378  	return false
  8379  }
  8380  
  8381  func TwoHash_OrXor_Shift034(name string) bool {
  8382  	if len(name) < 2 {
  8383  		return false
  8384  	}
  8385  	switch ((byte(len(name)) << 0) | (name[0] << 3)) ^ (name[1] << 4) {
  8386  	case 12:
  8387  		return name == "case"
  8388  	case 42:
  8389  		return name == "if"
  8390  	case 43:
  8391  		return name == "fallthrough"
  8392  	case 52:
  8393  		return name == "type"
  8394  	case 53:
  8395  		return name == "break"
  8396  	case 100:
  8397  		return name == "func"
  8398  	case 117:
  8399  		return name == "defer"
  8400  	case 119:
  8401  		return name == "default"
  8402  	case 123:
  8403  		return name == "map"
  8404  	case 133:
  8405  		return name == "range"
  8406  	case 151:
  8407  		return name == "package"
  8408  	case 156:
  8409  		return name == "chan"
  8410  	case 158:
  8411  		return name == "import"
  8412  	case 163:
  8413  		return name == "var"
  8414  	case 169:
  8415  		return name == "interface"
  8416  	case 195:
  8417  		return name == "for"
  8418  	case 198:
  8419  		return name == "return"
  8420  	case 202:
  8421  		return name == "go"
  8422  	case 204:
  8423  		return name == "goto"
  8424  	case 206:
  8425  		return name == "select"
  8426  	case 222:
  8427  		return name == "struct"
  8428  	case 232:
  8429  		return name == "continue"
  8430  	case 236:
  8431  		return name == "else"
  8432  	case 237:
  8433  		return name == "const"
  8434  	case 238:
  8435  		return name == "switch"
  8436  	}
  8437  	return false
  8438  }
  8439  
  8440  func TwoHash_OrXor_Shift035(name string) bool {
  8441  	if len(name) < 2 {
  8442  		return false
  8443  	}
  8444  	switch ((byte(len(name)) << 0) | (name[0] << 3)) ^ (name[1] << 5) {
  8445  	case 27:
  8446  		return name == "fallthrough"
  8447  	case 28:
  8448  		return name == "chan"
  8449  	case 30:
  8450  		return name == "struct"
  8451  	case 54:
  8452  		return name == "return"
  8453  	case 60:
  8454  		return name == "case"
  8455  	case 62:
  8456  		return name == "select"
  8457  	case 75:
  8458  		return name == "map"
  8459  	case 85:
  8460  		return name == "break"
  8461  	case 126:
  8462  		return name == "switch"
  8463  	case 132:
  8464  		return name == "type"
  8465  	case 133:
  8466  		return name == "defer"
  8467  	case 135:
  8468  		return name == "default"
  8469  	case 137:
  8470  		return name == "interface"
  8471  	case 138:
  8472  		return name == "if"
  8473  	case 147:
  8474  		return name == "var"
  8475  	case 148:
  8476  		return name == "func"
  8477  	case 167:
  8478  		return name == "package"
  8479  	case 172:
  8480  		return name == "else"
  8481  	case 181:
  8482  		return name == "range"
  8483  	case 211:
  8484  		return name == "for"
  8485  	case 218:
  8486  		return name == "go"
  8487  	case 220:
  8488  		return name == "goto"
  8489  	case 238:
  8490  		return name == "import"
  8491  	case 248:
  8492  		return name == "continue"
  8493  	case 253:
  8494  		return name == "const"
  8495  	}
  8496  	return false
  8497  }
  8498  
  8499  func TwoHash_OrXor_Shift041(name string) bool {
  8500  	if len(name) < 2 {
  8501  		return false
  8502  	}
  8503  	switch ((byte(len(name)) << 0) | (name[0] << 4)) ^ (name[1] << 1) {
  8504  	case 17:
  8505  		return name == "map"
  8506  	case 69:
  8507  		return name == "interface"
  8508  	case 76:
  8509  		return name == "import"
  8510  	case 94:
  8511  		return name == "if"
  8512  	case 140:
  8513  		return name == "else"
  8514  	case 141:
  8515  		return name == "default"
  8516  	case 142:
  8517  		return name == "func"
  8518  	case 143:
  8519  		return name == "defer"
  8520  	case 161:
  8521  		return name == "var"
  8522  	case 169:
  8523  		return name == "fallthrough"
  8524  	case 170:
  8525  		return name == "goto"
  8526  	case 172:
  8527  		return name == "go"
  8528  	case 182:
  8529  		return name == "type"
  8530  	case 189:
  8531  		return name == "for"
  8532  	case 193:
  8533  		return name == "break"
  8534  	case 197:
  8535  		return name == "package"
  8536  	case 216:
  8537  		return name == "switch"
  8538  	case 222:
  8539  		return name == "struct"
  8540  	case 228:
  8541  		return name == "chan"
  8542  	case 230:
  8543  		return name == "continue"
  8544  	case 231:
  8545  		return name == "range"
  8546  	case 235:
  8547  		return name == "const"
  8548  	case 236:
  8549  		return name == "return"
  8550  	case 246:
  8551  		return name == "case"
  8552  	case 252:
  8553  		return name == "select"
  8554  	}
  8555  	return false
  8556  }
  8557  
  8558  func TwoHash_OrXor_Shift043(name string) bool {
  8559  	if len(name) < 2 {
  8560  		return false
  8561  	}
  8562  	switch ((byte(len(name)) << 0) | (name[0] << 4)) ^ (name[1] << 3) {
  8563  	case 10:
  8564  		return name == "go"
  8565  	case 12:
  8566  		return name == "goto"
  8567  	case 14:
  8568  		return name == "return"
  8569  	case 15:
  8570  		return name == "package"
  8571  	case 27:
  8572  		return name == "for"
  8573  	case 30:
  8574  		return name == "select"
  8575  	case 45:
  8576  		return name == "range"
  8577  	case 52:
  8578  		return name == "else"
  8579  	case 60:
  8580  		return name == "case"
  8581  	case 64:
  8582  		return name == "continue"
  8583  	case 77:
  8584  		return name == "const"
  8585  	case 99:
  8586  		return name == "fallthrough"
  8587  	case 107:
  8588  		return name == "var"
  8589  	case 109:
  8590  		return name == "defer"
  8591  	case 111:
  8592  		return name == "default"
  8593  	case 116:
  8594  		return name == "chan"
  8595  	case 140:
  8596  		return name == "type"
  8597  	case 142:
  8598  		return name == "switch"
  8599  	case 150:
  8600  		return name == "struct"
  8601  	case 162:
  8602  		return name == "if"
  8603  	case 181:
  8604  		return name == "break"
  8605  	case 204:
  8606  		return name == "func"
  8607  	case 219:
  8608  		return name == "map"
  8609  	case 233:
  8610  		return name == "interface"
  8611  	case 254:
  8612  		return name == "import"
  8613  	}
  8614  	return false
  8615  }
  8616  
  8617  func TwoHash_OrXor_Shift045(name string) bool {
  8618  	if len(name) < 2 {
  8619  		return false
  8620  	}
  8621  	switch ((byte(len(name)) << 0) | (name[0] << 4)) ^ (name[1] << 5) {
  8622  	case 5:
  8623  		return name == "range"
  8624  	case 20:
  8625  		return name == "case"
  8626  	case 39:
  8627  		return name == "package"
  8628  	case 52:
  8629  		return name == "chan"
  8630  	case 54:
  8631  		return name == "import"
  8632  	case 67:
  8633  		return name == "var"
  8634  	case 75:
  8635  		return name == "fallthrough"
  8636  	case 82:
  8637  		return name == "if"
  8638  	case 89:
  8639  		return name == "interface"
  8640  	case 100:
  8641  		return name == "type"
  8642  	case 101:
  8643  		return name == "break"
  8644  	case 131:
  8645  		return name == "for"
  8646  	case 134:
  8647  		return name == "return"
  8648  	case 146:
  8649  		return name == "go"
  8650  	case 148:
  8651  		return name == "goto"
  8652  	case 150:
  8653  		return name == "select"
  8654  	case 182:
  8655  		return name == "struct"
  8656  	case 196:
  8657  		return name == "func"
  8658  	case 212:
  8659  		return name == "else"
  8660  	case 213:
  8661  		return name == "const"
  8662  	case 214:
  8663  		return name == "switch"
  8664  	case 216:
  8665  		return name == "continue"
  8666  	case 229:
  8667  		return name == "defer"
  8668  	case 231:
  8669  		return name == "default"
  8670  	case 243:
  8671  		return name == "map"
  8672  	}
  8673  	return false
  8674  }
  8675  
  8676  func TwoHash_OrXor_Shift046(name string) bool {
  8677  	if len(name) < 2 {
  8678  		return false
  8679  	}
  8680  	switch ((byte(len(name)) << 0) | (name[0] << 4)) ^ (name[1] << 6) {
  8681  	case 4:
  8682  		return name == "type"
  8683  	case 5:
  8684  		return name == "defer"
  8685  	case 7:
  8686  		return name == "default"
  8687  	case 18:
  8688  		return name == "if"
  8689  	case 25:
  8690  		return name == "interface"
  8691  	case 35:
  8692  		return name == "var"
  8693  	case 36:
  8694  		return name == "func"
  8695  	case 43:
  8696  		return name == "fallthrough"
  8697  	case 52:
  8698  		return name == "chan"
  8699  	case 54:
  8700  		return name == "struct"
  8701  	case 71:
  8702  		return name == "package"
  8703  	case 84:
  8704  		return name == "else"
  8705  	case 101:
  8706  		return name == "range"
  8707  	case 102:
  8708  		return name == "return"
  8709  	case 116:
  8710  		return name == "case"
  8711  	case 118:
  8712  		return name == "select"
  8713  	case 147:
  8714  		return name == "map"
  8715  	case 163:
  8716  		return name == "for"
  8717  	case 165:
  8718  		return name == "break"
  8719  	case 178:
  8720  		return name == "go"
  8721  	case 180:
  8722  		return name == "goto"
  8723  	case 214:
  8724  		return name == "import"
  8725  	case 245:
  8726  		return name == "const"
  8727  	case 246:
  8728  		return name == "switch"
  8729  	case 248:
  8730  		return name == "continue"
  8731  	}
  8732  	return false
  8733  }
  8734  
  8735  func TwoHash_OrXor_Shift050(name string) bool {
  8736  	if len(name) < 2 {
  8737  		return false
  8738  	}
  8739  	switch ((byte(len(name)) << 0) | (name[0] << 5)) ^ (name[1] << 0) {
  8740  	case 3:
  8741  		return name == "select"
  8742  	case 5:
  8743  		return name == "case"
  8744  	case 7:
  8745  		return name == "continue"
  8746  	case 10:
  8747  		return name == "const"
  8748  	case 12:
  8749  		return name == "chan"
  8750  	case 17:
  8751  		return name == "switch"
  8752  	case 18:
  8753  		return name == "struct"
  8754  	case 35:
  8755  		return name == "return"
  8756  	case 36:
  8757  		return name == "range"
  8758  	case 55:
  8759  		return name == "break"
  8760  	case 68:
  8761  		return name == "if"
  8762  	case 71:
  8763  		return name == "interface"
  8764  	case 75:
  8765  		return name == "import"
  8766  	case 102:
  8767  		return name == "package"
  8768  	case 139:
  8769  		return name == "goto"
  8770  	case 141:
  8771  		return name == "go"
  8772  	case 162:
  8773  		return name == "var"
  8774  	case 170:
  8775  		return name == "fallthrough"
  8776  	case 172:
  8777  		return name == "for"
  8778  	case 177:
  8779  		return name == "func"
  8780  	case 194:
  8781  		return name == "map"
  8782  	case 200:
  8783  		return name == "else"
  8784  	case 224:
  8785  		return name == "defer"
  8786  	case 226:
  8787  		return name == "default"
  8788  	case 253:
  8789  		return name == "type"
  8790  	}
  8791  	return false
  8792  }
  8793  
  8794  func TwoHash_OrXor_Shift051(name string) bool {
  8795  	if len(name) < 2 {
  8796  		return false
  8797  	}
  8798  	switch ((byte(len(name)) << 0) | (name[0] << 5)) ^ (name[1] << 1) {
  8799  	case 1:
  8800  		return name == "var"
  8801  	case 9:
  8802  		return name == "fallthrough"
  8803  	case 29:
  8804  		return name == "for"
  8805  	case 46:
  8806  		return name == "func"
  8807  	case 58:
  8808  		return name == "goto"
  8809  	case 60:
  8810  		return name == "go"
  8811  	case 77:
  8812  		return name == "default"
  8813  	case 79:
  8814  		return name == "defer"
  8815  	case 97:
  8816  		return name == "map"
  8817  	case 118:
  8818  		return name == "type"
  8819  	case 124:
  8820  		return name == "else"
  8821  	case 135:
  8822  		return name == "range"
  8823  	case 136:
  8824  		return name == "switch"
  8825  	case 140:
  8826  		return name == "return"
  8827  	case 142:
  8828  		return name == "struct"
  8829  	case 161:
  8830  		return name == "break"
  8831  	case 166:
  8832  		return name == "case"
  8833  	case 172:
  8834  		return name == "select"
  8835  	case 180:
  8836  		return name == "chan"
  8837  	case 182:
  8838  		return name == "continue"
  8839  	case 187:
  8840  		return name == "const"
  8841  	case 197:
  8842  		return name == "package"
  8843  	case 238:
  8844  		return name == "if"
  8845  	case 245:
  8846  		return name == "interface"
  8847  	case 252:
  8848  		return name == "import"
  8849  	}
  8850  	return false
  8851  }
  8852  
  8853  func TwoHash_OrXor_Shift060(name string) bool {
  8854  	if len(name) < 2 {
  8855  		return false
  8856  	}
  8857  	switch ((byte(len(name)) << 0) | (name[0] << 6)) ^ (name[1] << 0) {
  8858  	case 34:
  8859  		return name == "map"
  8860  	case 36:
  8861  		return name == "if"
  8862  	case 39:
  8863  		return name == "interface"
  8864  	case 40:
  8865  		return name == "else"
  8866  	case 43:
  8867  		return name == "import"
  8868  	case 96:
  8869  		return name == "defer"
  8870  	case 98:
  8871  		return name == "default"
  8872  	case 102:
  8873  		return name == "package"
  8874  	case 125:
  8875  		return name == "type"
  8876  	case 163:
  8877  		return name == "select"
  8878  	case 165:
  8879  		return name == "case"
  8880  	case 167:
  8881  		return name == "continue"
  8882  	case 170:
  8883  		return name == "const"
  8884  	case 171:
  8885  		return name == "goto"
  8886  	case 172:
  8887  		return name == "chan"
  8888  	case 173:
  8889  		return name == "go"
  8890  	case 177:
  8891  		return name == "switch"
  8892  	case 178:
  8893  		return name == "struct"
  8894  	case 226:
  8895  		return name == "var"
  8896  	case 227:
  8897  		return name == "return"
  8898  	case 228:
  8899  		return name == "range"
  8900  	case 234:
  8901  		return name == "fallthrough"
  8902  	case 236:
  8903  		return name == "for"
  8904  	case 241:
  8905  		return name == "func"
  8906  	case 247:
  8907  		return name == "break"
  8908  	}
  8909  	return false
  8910  }
  8911  
  8912  func TwoHash_OrXor_Shift062(name string) bool {
  8913  	if len(name) < 2 {
  8914  		return false
  8915  	}
  8916  	switch ((byte(len(name)) << 0) | (name[0] << 6)) ^ (name[1] << 2) {
  8917  	case 1:
  8918  		return name == "range"
  8919  	case 7:
  8920  		return name == "var"
  8921  	case 15:
  8922  		return name == "fallthrough"
  8923  	case 18:
  8924  		return name == "return"
  8925  	case 22:
  8926  		return name == "struct"
  8927  	case 26:
  8928  		return name == "switch"
  8929  	case 63:
  8930  		return name == "for"
  8931  	case 64:
  8932  		return name == "case"
  8933  	case 77:
  8934  		return name == "break"
  8935  	case 80:
  8936  		return name == "func"
  8937  	case 82:
  8938  		return name == "select"
  8939  	case 100:
  8940  		return name == "chan"
  8941  	case 116:
  8942  		return name == "continue"
  8943  	case 120:
  8944  		return name == "goto"
  8945  	case 121:
  8946  		return name == "const"
  8947  	case 126:
  8948  		return name == "go"
  8949  	case 131:
  8950  		return name == "package"
  8951  	case 145:
  8952  		return name == "defer"
  8953  	case 147:
  8954  		return name == "default"
  8955  	case 199:
  8956  		return name == "map"
  8957  	case 218:
  8958  		return name == "if"
  8959  	case 224:
  8960  		return name == "type"
  8961  	case 241:
  8962  		return name == "interface"
  8963  	case 242:
  8964  		return name == "import"
  8965  	case 244:
  8966  		return name == "else"
  8967  	}
  8968  	return false
  8969  }
  8970  
  8971  func TwoHash_OrXor_Shift073(name string) bool {
  8972  	if len(name) < 2 {
  8973  		return false
  8974  	}
  8975  	switch ((byte(len(name)) << 0) | (name[0] << 7)) ^ (name[1] << 3) {
  8976  	case 3:
  8977  		return name == "fallthrough"
  8978  	case 11:
  8979  		return name == "var"
  8980  	case 13:
  8981  		return name == "range"
  8982  	case 15:
  8983  		return name == "package"
  8984  	case 38:
  8985  		return name == "struct"
  8986  	case 45:
  8987  		return name == "defer"
  8988  	case 46:
  8989  		return name == "return"
  8990  	case 47:
  8991  		return name == "default"
  8992  	case 62:
  8993  		return name == "switch"
  8994  	case 123:
  8995  		return name == "for"
  8996  	case 139:
  8997  		return name == "map"
  8998  	case 140:
  8999  		return name == "case"
  9000  	case 149:
  9001  		return name == "break"
  9002  	case 172:
  9003  		return name == "func"
  9004  	case 174:
  9005  		return name == "select"
  9006  	case 178:
  9007  		return name == "if"
  9008  	case 196:
  9009  		return name == "chan"
  9010  	case 204:
  9011  		return name == "type"
  9012  	case 228:
  9013  		return name == "else"
  9014  	case 238:
  9015  		return name == "import"
  9016  	case 240:
  9017  		return name == "continue"
  9018  	case 249:
  9019  		return name == "interface"
  9020  	case 250:
  9021  		return name == "go"
  9022  	case 252:
  9023  		return name == "goto"
  9024  	case 253:
  9025  		return name == "const"
  9026  	}
  9027  	return false
  9028  }
  9029  
  9030  func TwoHash_OrXor_Shift143(name string) bool {
  9031  	if len(name) < 2 {
  9032  		return false
  9033  	}
  9034  	switch ((byte(len(name)) << 1) | (name[0] << 4)) ^ (name[1] << 3) {
  9035  	case 0:
  9036  		return name == "goto"
  9037  	case 4:
  9038  		return name == "return"
  9039  	case 6:
  9040  		return name == "package"
  9041  	case 12:
  9042  		return name == "go"
  9043  	case 20:
  9044  		return name == "select"
  9045  	case 30:
  9046  		return name == "for"
  9047  	case 34:
  9048  		return name == "range"
  9049  	case 48:
  9050  		return name == "case"
  9051  	case 56:
  9052  		return name == "else"
  9053  	case 66:
  9054  		return name == "const"
  9055  	case 72:
  9056  		return name == "continue"
  9057  	case 98:
  9058  		return name == "defer"
  9059  	case 102:
  9060  		return name == "default"
  9061  	case 110:
  9062  		return name == "var"
  9063  	case 120:
  9064  		return name == "chan"
  9065  	case 126:
  9066  		return name == "fallthrough"
  9067  	case 128:
  9068  		return name == "type"
  9069  	case 132:
  9070  		return name == "switch"
  9071  	case 156:
  9072  		return name == "struct"
  9073  	case 164:
  9074  		return name == "if"
  9075  	case 186:
  9076  		return name == "break"
  9077  	case 192:
  9078  		return name == "func"
  9079  	case 222:
  9080  		return name == "map"
  9081  	case 226:
  9082  		return name == "interface"
  9083  	case 244:
  9084  		return name == "import"
  9085  	}
  9086  	return false
  9087  }
  9088  
  9089  func TwoHash_OrXor_Shift145(name string) bool {
  9090  	if len(name) < 2 {
  9091  		return false
  9092  	}
  9093  	switch ((byte(len(name)) << 1) | (name[0] << 4)) ^ (name[1] << 5) {
  9094  	case 10:
  9095  		return name == "range"
  9096  	case 24:
  9097  		return name == "case"
  9098  	case 46:
  9099  		return name == "package"
  9100  	case 56:
  9101  		return name == "chan"
  9102  	case 60:
  9103  		return name == "import"
  9104  	case 70:
  9105  		return name == "var"
  9106  	case 82:
  9107  		return name == "interface"
  9108  	case 84:
  9109  		return name == "if"
  9110  	case 86:
  9111  		return name == "fallthrough"
  9112  	case 104:
  9113  		return name == "type"
  9114  	case 106:
  9115  		return name == "break"
  9116  	case 134:
  9117  		return name == "for"
  9118  	case 140:
  9119  		return name == "return"
  9120  	case 148:
  9121  		return name == "go"
  9122  	case 152:
  9123  		return name == "goto"
  9124  	case 156:
  9125  		return name == "select"
  9126  	case 188:
  9127  		return name == "struct"
  9128  	case 200:
  9129  		return name == "func"
  9130  	case 208:
  9131  		return name == "continue"
  9132  	case 216:
  9133  		return name == "else"
  9134  	case 218:
  9135  		return name == "const"
  9136  	case 220:
  9137  		return name == "switch"
  9138  	case 234:
  9139  		return name == "defer"
  9140  	case 238:
  9141  		return name == "default"
  9142  	case 246:
  9143  		return name == "map"
  9144  	}
  9145  	return false
  9146  }
  9147  
  9148  func TwoHash_OrXor_Shift146(name string) bool {
  9149  	if len(name) < 2 {
  9150  		return false
  9151  	}
  9152  	switch ((byte(len(name)) << 1) | (name[0] << 4)) ^ (name[1] << 6) {
  9153  	case 8:
  9154  		return name == "type"
  9155  	case 10:
  9156  		return name == "defer"
  9157  	case 14:
  9158  		return name == "default"
  9159  	case 18:
  9160  		return name == "interface"
  9161  	case 20:
  9162  		return name == "if"
  9163  	case 38:
  9164  		return name == "var"
  9165  	case 40:
  9166  		return name == "func"
  9167  	case 54:
  9168  		return name == "fallthrough"
  9169  	case 56:
  9170  		return name == "chan"
  9171  	case 60:
  9172  		return name == "struct"
  9173  	case 78:
  9174  		return name == "package"
  9175  	case 88:
  9176  		return name == "else"
  9177  	case 106:
  9178  		return name == "range"
  9179  	case 108:
  9180  		return name == "return"
  9181  	case 120:
  9182  		return name == "case"
  9183  	case 124:
  9184  		return name == "select"
  9185  	case 150:
  9186  		return name == "map"
  9187  	case 166:
  9188  		return name == "for"
  9189  	case 170:
  9190  		return name == "break"
  9191  	case 180:
  9192  		return name == "go"
  9193  	case 184:
  9194  		return name == "goto"
  9195  	case 220:
  9196  		return name == "import"
  9197  	case 240:
  9198  		return name == "continue"
  9199  	case 250:
  9200  		return name == "const"
  9201  	case 252:
  9202  		return name == "switch"
  9203  	}
  9204  	return false
  9205  }
  9206  
  9207  func TwoHash_OrXor_Shift161(name string) bool {
  9208  	if len(name) < 2 {
  9209  		return false
  9210  	}
  9211  	switch ((byte(len(name)) << 1) | (name[0] << 6)) ^ (name[1] << 1) {
  9212  	case 6:
  9213  		return name == "select"
  9214  	case 10:
  9215  		return name == "case"
  9216  	case 14:
  9217  		return name == "continue"
  9218  	case 20:
  9219  		return name == "const"
  9220  	case 22:
  9221  		return name == "goto"
  9222  	case 24:
  9223  		return name == "chan"
  9224  	case 26:
  9225  		return name == "go"
  9226  	case 34:
  9227  		return name == "switch"
  9228  	case 36:
  9229  		return name == "struct"
  9230  	case 68:
  9231  		return name == "var"
  9232  	case 70:
  9233  		return name == "return"
  9234  	case 72:
  9235  		return name == "range"
  9236  	case 84:
  9237  		return name == "fallthrough"
  9238  	case 88:
  9239  		return name == "for"
  9240  	case 98:
  9241  		return name == "func"
  9242  	case 110:
  9243  		return name == "break"
  9244  	case 132:
  9245  		return name == "map"
  9246  	case 136:
  9247  		return name == "if"
  9248  	case 142:
  9249  		return name == "interface"
  9250  	case 144:
  9251  		return name == "else"
  9252  	case 150:
  9253  		return name == "import"
  9254  	case 192:
  9255  		return name == "defer"
  9256  	case 196:
  9257  		return name == "default"
  9258  	case 204:
  9259  		return name == "package"
  9260  	case 250:
  9261  		return name == "type"
  9262  	}
  9263  	return false
  9264  }
  9265  
  9266  func TwoHash_OrXor_Shift260(name string) bool {
  9267  	if len(name) < 2 {
  9268  		return false
  9269  	}
  9270  	switch ((byte(len(name)) << 2) | (name[0] << 6)) ^ (name[1] << 0) {
  9271  	case 10:
  9272  		return name == "interface"
  9273  	case 45:
  9274  		return name == "map"
  9275  	case 46:
  9276  		return name == "if"
  9277  	case 53:
  9278  		return name == "import"
  9279  	case 60:
  9280  		return name == "else"
  9281  	case 105:
  9282  		return name == "type"
  9283  	case 113:
  9284  		return name == "defer"
  9285  	case 121:
  9286  		return name == "default"
  9287  	case 125:
  9288  		return name == "package"
  9289  	case 143:
  9290  		return name == "continue"
  9291  	case 167:
  9292  		return name == "go"
  9293  	case 172:
  9294  		return name == "struct"
  9295  	case 175:
  9296  		return name == "switch"
  9297  	case 177:
  9298  		return name == "case"
  9299  	case 184:
  9300  		return name == "chan"
  9301  	case 187:
  9302  		return name == "const"
  9303  	case 189:
  9304  		return name == "select"
  9305  	case 191:
  9306  		return name == "goto"
  9307  	case 205:
  9308  		return name == "fallthrough"
  9309  	case 227:
  9310  		return name == "for"
  9311  	case 229:
  9312  		return name == "func"
  9313  	case 230:
  9314  		return name == "break"
  9315  	case 237:
  9316  		return name == "var"
  9317  	case 245:
  9318  		return name == "range"
  9319  	case 253:
  9320  		return name == "return"
  9321  	}
  9322  	return false
  9323  }
  9324  
  9325  func TwoHash_OrAdd_Shift031(name string) bool {
  9326  	if len(name) < 2 {
  9327  		return false
  9328  	}
  9329  	switch ((byte(len(name)) << 0) | (name[0] << 3)) + (name[1] << 1) {
  9330  	case 4:
  9331  		return name == "else"
  9332  	case 17:
  9333  		return name == "for"
  9334  	case 22:
  9335  		return name == "if"
  9336  	case 24:
  9337  		return name == "go"
  9338  	case 26:
  9339  		return name == "goto"
  9340  	case 30:
  9341  		return name == "func"
  9342  	case 37:
  9343  		return name == "interface"
  9344  	case 40:
  9345  		return name == "import"
  9346  	case 45:
  9347  		return name == "map"
  9348  	case 73:
  9349  		return name == "package"
  9350  	case 87:
  9351  		return name == "range"
  9352  	case 96:
  9353  		return name == "return"
  9354  	case 104:
  9355  		return name == "select"
  9356  	case 117:
  9357  		return name == "var"
  9358  	case 134:
  9359  		return name == "struct"
  9360  	case 140:
  9361  		return name == "switch"
  9362  	case 150:
  9363  		return name == "type"
  9364  	case 222:
  9365  		return name == "case"
  9366  	case 236:
  9367  		return name == "chan"
  9368  	case 239:
  9369  		return name == "defer"
  9370  	case 241:
  9371  		return name == "default"
  9372  	case 246:
  9373  		return name == "continue"
  9374  	case 249:
  9375  		return name == "break"
  9376  	case 251:
  9377  		return name == "const"
  9378  	case 253:
  9379  		return name == "fallthrough"
  9380  	}
  9381  	return false
  9382  }
  9383  
  9384  func TwoHash_OrAdd_Shift033(name string) bool {
  9385  	if len(name) < 2 {
  9386  		return false
  9387  	}
  9388  	switch ((byte(len(name)) << 0) | (name[0] << 3)) + (name[1] << 3) {
  9389  	case 36:
  9390  		return name == "case"
  9391  	case 62:
  9392  		return name == "struct"
  9393  	case 67:
  9394  		return name == "fallthrough"
  9395  	case 77:
  9396  		return name == "defer"
  9397  	case 79:
  9398  		return name == "default"
  9399  	case 86:
  9400  		return name == "switch"
  9401  	case 92:
  9402  		return name == "chan"
  9403  	case 108:
  9404  		return name == "type"
  9405  	case 115:
  9406  		return name == "map"
  9407  	case 122:
  9408  		return name == "if"
  9409  	case 140:
  9410  		return name == "else"
  9411  	case 143:
  9412  		return name == "package"
  9413  	case 144:
  9414  		return name == "continue"
  9415  	case 149:
  9416  		return name == "const"
  9417  	case 157:
  9418  		return name == "range"
  9419  	case 165:
  9420  		return name == "break"
  9421  	case 171:
  9422  		return name == "for"
  9423  	case 178:
  9424  		return name == "go"
  9425  	case 180:
  9426  		return name == "goto"
  9427  	case 182:
  9428  		return name == "import"
  9429  	case 185:
  9430  		return name == "interface"
  9431  	case 187:
  9432  		return name == "var"
  9433  	case 190:
  9434  		return name == "return"
  9435  	case 198:
  9436  		return name == "select"
  9437  	case 220:
  9438  		return name == "func"
  9439  	}
  9440  	return false
  9441  }
  9442  
  9443  func TwoHash_OrAdd_Shift041(name string) bool {
  9444  	if len(name) < 2 {
  9445  		return false
  9446  	}
  9447  	switch ((byte(len(name)) << 0) | (name[0] << 4)) + (name[1] << 1) {
  9448  	case 0:
  9449  		return name == "select"
  9450  	case 4:
  9451  		return name == "chan"
  9452  	case 9:
  9453  		return name == "break"
  9454  	case 15:
  9455  		return name == "defer"
  9456  	case 17:
  9457  		return name == "default"
  9458  	case 19:
  9459  		return name == "const"
  9460  	case 22:
  9461  		return name == "continue"
  9462  	case 30:
  9463  		return name == "struct"
  9464  	case 36:
  9465  		return name == "switch"
  9466  	case 37:
  9467  		return name == "var"
  9468  	case 44:
  9469  		return name == "else"
  9470  	case 45:
  9471  		return name == "fallthrough"
  9472  	case 54:
  9473  		return name == "type"
  9474  	case 65:
  9475  		return name == "for"
  9476  	case 78:
  9477  		return name == "func"
  9478  	case 80:
  9479  		return name == "go"
  9480  	case 82:
  9481  		return name == "goto"
  9482  	case 94:
  9483  		return name == "if"
  9484  	case 112:
  9485  		return name == "import"
  9486  	case 117:
  9487  		return name == "interface"
  9488  	case 149:
  9489  		return name == "map"
  9490  	case 201:
  9491  		return name == "package"
  9492  	case 231:
  9493  		return name == "range"
  9494  	case 240:
  9495  		return name == "return"
  9496  	case 246:
  9497  		return name == "case"
  9498  	}
  9499  	return false
  9500  }
  9501  
  9502  func TwoHash_OrAdd_Shift042(name string) bool {
  9503  	if len(name) < 2 {
  9504  		return false
  9505  	}
  9506  	switch ((byte(len(name)) << 0) | (name[0] << 4)) + (name[1] << 2) {
  9507  	case 4:
  9508  		return name == "else"
  9509  	case 6:
  9510  		return name == "struct"
  9511  	case 18:
  9512  		return name == "switch"
  9513  	case 31:
  9514  		return name == "for"
  9515  	case 40:
  9516  		return name == "type"
  9517  	case 42:
  9518  		return name == "if"
  9519  	case 46:
  9520  		return name == "go"
  9521  	case 48:
  9522  		return name == "goto"
  9523  	case 56:
  9524  		return name == "func"
  9525  	case 74:
  9526  		return name == "import"
  9527  	case 81:
  9528  		return name == "interface"
  9529  	case 87:
  9530  		return name == "map"
  9531  	case 139:
  9532  		return name == "package"
  9533  	case 169:
  9534  		return name == "range"
  9535  	case 184:
  9536  		return name == "case"
  9537  	case 186:
  9538  		return name == "return"
  9539  	case 202:
  9540  		return name == "select"
  9541  	case 212:
  9542  		return name == "chan"
  9543  	case 217:
  9544  		return name == "defer"
  9545  	case 219:
  9546  		return name == "default"
  9547  	case 231:
  9548  		return name == "var"
  9549  	case 237:
  9550  		return name == "break"
  9551  	case 239:
  9552  		return name == "fallthrough"
  9553  	case 241:
  9554  		return name == "const"
  9555  	case 244:
  9556  		return name == "continue"
  9557  	}
  9558  	return false
  9559  }
  9560  
  9561  func TwoHash_OrAdd_Shift050(name string) bool {
  9562  	if len(name) < 2 {
  9563  		return false
  9564  	}
  9565  	switch ((byte(len(name)) << 0) | (name[0] << 5)) + (name[1] << 0) {
  9566  	case 4:
  9567  		return name == "map"
  9568  	case 16:
  9569  		return name == "else"
  9570  	case 36:
  9571  		return name == "var"
  9572  	case 44:
  9573  		return name == "fallthrough"
  9574  	case 50:
  9575  		return name == "for"
  9576  	case 57:
  9577  		return name == "func"
  9578  	case 81:
  9579  		return name == "go"
  9580  	case 83:
  9581  		return name == "goto"
  9582  	case 104:
  9583  		return name == "package"
  9584  	case 136:
  9585  		return name == "if"
  9586  	case 147:
  9587  		return name == "import"
  9588  	case 151:
  9589  		return name == "interface"
  9590  	case 166:
  9591  		return name == "range"
  9592  	case 171:
  9593  		return name == "return"
  9594  	case 183:
  9595  		return name == "break"
  9596  	case 197:
  9597  		return name == "case"
  9598  	case 203:
  9599  		return name == "select"
  9600  	case 204:
  9601  		return name == "chan"
  9602  	case 212:
  9603  		return name == "const"
  9604  	case 215:
  9605  		return name == "continue"
  9606  	case 218:
  9607  		return name == "struct"
  9608  	case 221:
  9609  		return name == "switch"
  9610  	case 234:
  9611  		return name == "defer"
  9612  	case 236:
  9613  		return name == "default"
  9614  	case 253:
  9615  		return name == "type"
  9616  	}
  9617  	return false
  9618  }
  9619  
  9620  func TwoHash_OrAdd_Shift051(name string) bool {
  9621  	if len(name) < 2 {
  9622  		return false
  9623  	}
  9624  	switch ((byte(len(name)) << 0) | (name[0] << 5)) + (name[1] << 1) {
  9625  	case 0:
  9626  		return name == "import"
  9627  	case 5:
  9628  		return name == "interface"
  9629  	case 7:
  9630  		return name == "range"
  9631  	case 16:
  9632  		return name == "return"
  9633  	case 38:
  9634  		return name == "case"
  9635  	case 41:
  9636  		return name == "break"
  9637  	case 48:
  9638  		return name == "select"
  9639  	case 52:
  9640  		return name == "chan"
  9641  	case 67:
  9642  		return name == "const"
  9643  	case 70:
  9644  		return name == "continue"
  9645  	case 78:
  9646  		return name == "struct"
  9647  	case 79:
  9648  		return name == "defer"
  9649  	case 81:
  9650  		return name == "default"
  9651  	case 84:
  9652  		return name == "switch"
  9653  	case 101:
  9654  		return name == "map"
  9655  	case 118:
  9656  		return name == "type"
  9657  	case 124:
  9658  		return name == "else"
  9659  	case 133:
  9660  		return name == "var"
  9661  	case 141:
  9662  		return name == "fallthrough"
  9663  	case 161:
  9664  		return name == "for"
  9665  	case 174:
  9666  		return name == "func"
  9667  	case 192:
  9668  		return name == "go"
  9669  	case 194:
  9670  		return name == "goto"
  9671  	case 201:
  9672  		return name == "package"
  9673  	case 238:
  9674  		return name == "if"
  9675  	}
  9676  	return false
  9677  }
  9678  
  9679  func TwoHash_OrAdd_Shift060(name string) bool {
  9680  	if len(name) < 2 {
  9681  		return false
  9682  	}
  9683  	switch ((byte(len(name)) << 0) | (name[0] << 6)) + (name[1] << 0) {
  9684  	case 37:
  9685  		return name == "case"
  9686  	case 43:
  9687  		return name == "select"
  9688  	case 44:
  9689  		return name == "chan"
  9690  	case 49:
  9691  		return name == "go"
  9692  	case 51:
  9693  		return name == "goto"
  9694  	case 52:
  9695  		return name == "const"
  9696  	case 55:
  9697  		return name == "continue"
  9698  	case 58:
  9699  		return name == "struct"
  9700  	case 61:
  9701  		return name == "switch"
  9702  	case 104:
  9703  		return name == "package"
  9704  	case 106:
  9705  		return name == "defer"
  9706  	case 108:
  9707  		return name == "default"
  9708  	case 125:
  9709  		return name == "type"
  9710  	case 164:
  9711  		return name == "map"
  9712  	case 168:
  9713  		return name == "if"
  9714  	case 176:
  9715  		return name == "else"
  9716  	case 179:
  9717  		return name == "import"
  9718  	case 183:
  9719  		return name == "interface"
  9720  	case 228:
  9721  		return name == "var"
  9722  	case 230:
  9723  		return name == "range"
  9724  	case 235:
  9725  		return name == "return"
  9726  	case 236:
  9727  		return name == "fallthrough"
  9728  	case 242:
  9729  		return name == "for"
  9730  	case 247:
  9731  		return name == "break"
  9732  	case 249:
  9733  		return name == "func"
  9734  	}
  9735  	return false
  9736  }
  9737  
  9738  func TwoHash_OrAdd_Shift061(name string) bool {
  9739  	if len(name) < 2 {
  9740  		return false
  9741  	}
  9742  	switch ((byte(len(name)) << 0) | (name[0] << 6)) + (name[1] << 1) {
  9743  	case 5:
  9744  		return name == "map"
  9745  	case 14:
  9746  		return name == "if"
  9747  	case 28:
  9748  		return name == "else"
  9749  	case 32:
  9750  		return name == "import"
  9751  	case 37:
  9752  		return name == "interface"
  9753  	case 69:
  9754  		return name == "var"
  9755  	case 71:
  9756  		return name == "range"
  9757  	case 77:
  9758  		return name == "fallthrough"
  9759  	case 80:
  9760  		return name == "return"
  9761  	case 97:
  9762  		return name == "for"
  9763  	case 105:
  9764  		return name == "break"
  9765  	case 110:
  9766  		return name == "func"
  9767  	case 134:
  9768  		return name == "case"
  9769  	case 144:
  9770  		return name == "select"
  9771  	case 148:
  9772  		return name == "chan"
  9773  	case 160:
  9774  		return name == "go"
  9775  	case 162:
  9776  		return name == "goto"
  9777  	case 163:
  9778  		return name == "const"
  9779  	case 166:
  9780  		return name == "continue"
  9781  	case 174:
  9782  		return name == "struct"
  9783  	case 180:
  9784  		return name == "switch"
  9785  	case 201:
  9786  		return name == "package"
  9787  	case 207:
  9788  		return name == "defer"
  9789  	case 209:
  9790  		return name == "default"
  9791  	case 246:
  9792  		return name == "type"
  9793  	}
  9794  	return false
  9795  }
  9796  
  9797  func TwoHash_OrAdd_Shift062(name string) bool {
  9798  	if len(name) < 2 {
  9799  		return false
  9800  	}
  9801  	switch ((byte(len(name)) << 0) | (name[0] << 6)) + (name[1] << 2) {
  9802  	case 1:
  9803  		return name == "interface"
  9804  	case 7:
  9805  		return name == "var"
  9806  	case 9:
  9807  		return name == "range"
  9808  	case 15:
  9809  		return name == "fallthrough"
  9810  	case 26:
  9811  		return name == "return"
  9812  	case 63:
  9813  		return name == "for"
  9814  	case 72:
  9815  		return name == "case"
  9816  	case 77:
  9817  		return name == "break"
  9818  	case 88:
  9819  		return name == "func"
  9820  	case 90:
  9821  		return name == "select"
  9822  	case 100:
  9823  		return name == "chan"
  9824  	case 126:
  9825  		return name == "go"
  9826  	case 128:
  9827  		return name == "goto"
  9828  	case 129:
  9829  		return name == "const"
  9830  	case 132:
  9831  		return name == "continue"
  9832  	case 139:
  9833  		return name == "package"
  9834  	case 150:
  9835  		return name == "struct"
  9836  	case 153:
  9837  		return name == "defer"
  9838  	case 155:
  9839  		return name == "default"
  9840  	case 162:
  9841  		return name == "switch"
  9842  	case 199:
  9843  		return name == "map"
  9844  	case 218:
  9845  		return name == "if"
  9846  	case 232:
  9847  		return name == "type"
  9848  	case 244:
  9849  		return name == "else"
  9850  	case 250:
  9851  		return name == "import"
  9852  	}
  9853  	return false
  9854  }
  9855  
  9856  func TwoHash_OrAdd_Shift073(name string) bool {
  9857  	if len(name) < 2 {
  9858  		return false
  9859  	}
  9860  	switch ((byte(len(name)) << 0) | (name[0] << 7)) + (name[1] << 3) {
  9861  	case 0:
  9862  		return name == "continue"
  9863  	case 11:
  9864  		return name == "var"
  9865  	case 13:
  9866  		return name == "range"
  9867  	case 15:
  9868  		return name == "package"
  9869  	case 19:
  9870  		return name == "fallthrough"
  9871  	case 38:
  9872  		return name == "struct"
  9873  	case 45:
  9874  		return name == "defer"
  9875  	case 46:
  9876  		return name == "return"
  9877  	case 47:
  9878  		return name == "default"
  9879  	case 62:
  9880  		return name == "switch"
  9881  	case 123:
  9882  		return name == "for"
  9883  	case 139:
  9884  		return name == "map"
  9885  	case 140:
  9886  		return name == "case"
  9887  	case 149:
  9888  		return name == "break"
  9889  	case 172:
  9890  		return name == "func"
  9891  	case 174:
  9892  		return name == "select"
  9893  	case 178:
  9894  		return name == "if"
  9895  	case 196:
  9896  		return name == "chan"
  9897  	case 204:
  9898  		return name == "type"
  9899  	case 228:
  9900  		return name == "else"
  9901  	case 238:
  9902  		return name == "import"
  9903  	case 249:
  9904  		return name == "interface"
  9905  	case 250:
  9906  		return name == "go"
  9907  	case 252:
  9908  		return name == "goto"
  9909  	case 253:
  9910  		return name == "const"
  9911  	}
  9912  	return false
  9913  }
  9914  
  9915  func TwoHash_OrAdd_Shift150(name string) bool {
  9916  	if len(name) < 2 {
  9917  		return false
  9918  	}
  9919  	switch ((byte(len(name)) << 1) | (name[0] << 5)) + (name[1] << 0) {
  9920  	case 1:
  9921  		return name == "type"
  9922  	case 7:
  9923  		return name == "map"
  9924  	case 20:
  9925  		return name == "else"
  9926  	case 39:
  9927  		return name == "var"
  9928  	case 53:
  9929  		return name == "for"
  9930  	case 55:
  9931  		return name == "fallthrough"
  9932  	case 61:
  9933  		return name == "func"
  9934  	case 83:
  9935  		return name == "go"
  9936  	case 87:
  9937  		return name == "goto"
  9938  	case 111:
  9939  		return name == "package"
  9940  	case 138:
  9941  		return name == "if"
  9942  	case 153:
  9943  		return name == "import"
  9944  	case 160:
  9945  		return name == "interface"
  9946  	case 171:
  9947  		return name == "range"
  9948  	case 177:
  9949  		return name == "return"
  9950  	case 188:
  9951  		return name == "break"
  9952  	case 201:
  9953  		return name == "case"
  9954  	case 208:
  9955  		return name == "chan"
  9956  	case 209:
  9957  		return name == "select"
  9958  	case 217:
  9959  		return name == "const"
  9960  	case 223:
  9961  		return name == "continue"
  9962  	case 224:
  9963  		return name == "struct"
  9964  	case 227:
  9965  		return name == "switch"
  9966  	case 239:
  9967  		return name == "defer"
  9968  	case 243:
  9969  		return name == "default"
  9970  	}
  9971  	return false
  9972  }
  9973  
  9974  func TwoHash_OrAdd_Shift161(name string) bool {
  9975  	if len(name) < 2 {
  9976  		return false
  9977  	}
  9978  	switch ((byte(len(name)) << 1) | (name[0] << 6)) + (name[1] << 1) {
  9979  	case 8:
  9980  		return name == "map"
  9981  	case 16:
  9982  		return name == "if"
  9983  	case 32:
  9984  		return name == "else"
  9985  	case 38:
  9986  		return name == "import"
  9987  	case 46:
  9988  		return name == "interface"
  9989  	case 72:
  9990  		return name == "var"
  9991  	case 76:
  9992  		return name == "range"
  9993  	case 86:
  9994  		return name == "return"
  9995  	case 88:
  9996  		return name == "fallthrough"
  9997  	case 100:
  9998  		return name == "for"
  9999  	case 110:
 10000  		return name == "break"
 10001  	case 114:
 10002  		return name == "func"
 10003  	case 138:
 10004  		return name == "case"
 10005  	case 150:
 10006  		return name == "select"
 10007  	case 152:
 10008  		return name == "chan"
 10009  	case 162:
 10010  		return name == "go"
 10011  	case 166:
 10012  		return name == "goto"
 10013  	case 168:
 10014  		return name == "const"
 10015  	case 174:
 10016  		return name == "continue"
 10017  	case 180:
 10018  		return name == "struct"
 10019  	case 186:
 10020  		return name == "switch"
 10021  	case 208:
 10022  		return name == "package"
 10023  	case 212:
 10024  		return name == "defer"
 10025  	case 216:
 10026  		return name == "default"
 10027  	case 250:
 10028  		return name == "type"
 10029  	}
 10030  	return false
 10031  }
 10032  
 10033  func TwoHash_OrAdd_Shift250(name string) bool {
 10034  	if len(name) < 2 {
 10035  		return false
 10036  	}
 10037  	switch ((byte(len(name)) << 2) | (name[0] << 5)) + (name[1] << 0) {
 10038  	case 1:
 10039  		return name == "default"
 10040  	case 9:
 10041  		return name == "type"
 10042  	case 13:
 10043  		return name == "map"
 10044  	case 28:
 10045  		return name == "else"
 10046  	case 45:
 10047  		return name == "var"
 10048  	case 59:
 10049  		return name == "for"
 10050  	case 69:
 10051  		return name == "func"
 10052  	case 77:
 10053  		return name == "fallthrough"
 10054  	case 87:
 10055  		return name == "go"
 10056  	case 95:
 10057  		return name == "goto"
 10058  	case 125:
 10059  		return name == "package"
 10060  	case 142:
 10061  		return name == "if"
 10062  	case 146:
 10063  		return name == "interface"
 10064  	case 165:
 10065  		return name == "import"
 10066  	case 181:
 10067  		return name == "range"
 10068  	case 189:
 10069  		return name == "return"
 10070  	case 198:
 10071  		return name == "break"
 10072  	case 207:
 10073  		return name == "continue"
 10074  	case 209:
 10075  		return name == "case"
 10076  	case 216:
 10077  		return name == "chan"
 10078  	case 221:
 10079  		return name == "select"
 10080  	case 227:
 10081  		return name == "const"
 10082  	case 236:
 10083  		return name == "struct"
 10084  	case 239:
 10085  		return name == "switch"
 10086  	case 249:
 10087  		return name == "defer"
 10088  	}
 10089  	return false
 10090  }
 10091  
 10092  func TwoHash_OrAdd_Shift361(name string) bool {
 10093  	if len(name) < 2 {
 10094  		return false
 10095  	}
 10096  	switch ((byte(len(name)) << 3) | (name[0] << 6)) + (name[1] << 1) {
 10097  	case 2:
 10098  		return name == "default"
 10099  	case 18:
 10100  		return name == "type"
 10101  	case 26:
 10102  		return name == "map"
 10103  	case 28:
 10104  		return name == "if"
 10105  	case 36:
 10106  		return name == "interface"
 10107  	case 56:
 10108  		return name == "else"
 10109  	case 74:
 10110  		return name == "import"
 10111  	case 90:
 10112  		return name == "var"
 10113  	case 106:
 10114  		return name == "range"
 10115  	case 118:
 10116  		return name == "for"
 10117  	case 122:
 10118  		return name == "return"
 10119  	case 138:
 10120  		return name == "func"
 10121  	case 140:
 10122  		return name == "break"
 10123  	case 154:
 10124  		return name == "fallthrough"
 10125  	case 158:
 10126  		return name == "continue"
 10127  	case 162:
 10128  		return name == "case"
 10129  	case 174:
 10130  		return name == "go"
 10131  	case 176:
 10132  		return name == "chan"
 10133  	case 186:
 10134  		return name == "select"
 10135  	case 190:
 10136  		return name == "goto"
 10137  	case 198:
 10138  		return name == "const"
 10139  	case 216:
 10140  		return name == "struct"
 10141  	case 222:
 10142  		return name == "switch"
 10143  	case 242:
 10144  		return name == "defer"
 10145  	case 250:
 10146  		return name == "package"
 10147  	}
 10148  	return false
 10149  }