github.com/hikaru7719/go@v0.0.0-20181025140707-c8b2ac68906a/src/cmd/compile/internal/ssa/rewritegeneric.go (about)

     1  // Code generated from gen/generic.rules; DO NOT EDIT.
     2  // generated with: cd gen; go run *.go
     3  
     4  package ssa
     5  
     6  import "math"
     7  import "cmd/internal/obj"
     8  import "cmd/internal/objabi"
     9  import "cmd/compile/internal/types"
    10  
    11  var _ = math.MinInt8  // in case not otherwise used
    12  var _ = obj.ANOP      // in case not otherwise used
    13  var _ = objabi.GOROOT // in case not otherwise used
    14  var _ = types.TypeMem // in case not otherwise used
    15  
    16  func rewriteValuegeneric(v *Value) bool {
    17  	switch v.Op {
    18  	case OpAdd16:
    19  		return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v) || rewriteValuegeneric_OpAdd16_30(v)
    20  	case OpAdd32:
    21  		return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v) || rewriteValuegeneric_OpAdd32_30(v)
    22  	case OpAdd32F:
    23  		return rewriteValuegeneric_OpAdd32F_0(v)
    24  	case OpAdd64:
    25  		return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v) || rewriteValuegeneric_OpAdd64_30(v)
    26  	case OpAdd64F:
    27  		return rewriteValuegeneric_OpAdd64F_0(v)
    28  	case OpAdd8:
    29  		return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v) || rewriteValuegeneric_OpAdd8_30(v)
    30  	case OpAddPtr:
    31  		return rewriteValuegeneric_OpAddPtr_0(v)
    32  	case OpAnd16:
    33  		return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v) || rewriteValuegeneric_OpAnd16_20(v)
    34  	case OpAnd32:
    35  		return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v) || rewriteValuegeneric_OpAnd32_20(v)
    36  	case OpAnd64:
    37  		return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v)
    38  	case OpAnd8:
    39  		return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v) || rewriteValuegeneric_OpAnd8_20(v)
    40  	case OpArg:
    41  		return rewriteValuegeneric_OpArg_0(v) || rewriteValuegeneric_OpArg_10(v)
    42  	case OpArraySelect:
    43  		return rewriteValuegeneric_OpArraySelect_0(v)
    44  	case OpCom16:
    45  		return rewriteValuegeneric_OpCom16_0(v)
    46  	case OpCom32:
    47  		return rewriteValuegeneric_OpCom32_0(v)
    48  	case OpCom64:
    49  		return rewriteValuegeneric_OpCom64_0(v)
    50  	case OpCom8:
    51  		return rewriteValuegeneric_OpCom8_0(v)
    52  	case OpConstInterface:
    53  		return rewriteValuegeneric_OpConstInterface_0(v)
    54  	case OpConstSlice:
    55  		return rewriteValuegeneric_OpConstSlice_0(v)
    56  	case OpConstString:
    57  		return rewriteValuegeneric_OpConstString_0(v)
    58  	case OpConvert:
    59  		return rewriteValuegeneric_OpConvert_0(v)
    60  	case OpCvt32Fto32:
    61  		return rewriteValuegeneric_OpCvt32Fto32_0(v)
    62  	case OpCvt32Fto64:
    63  		return rewriteValuegeneric_OpCvt32Fto64_0(v)
    64  	case OpCvt32Fto64F:
    65  		return rewriteValuegeneric_OpCvt32Fto64F_0(v)
    66  	case OpCvt32to32F:
    67  		return rewriteValuegeneric_OpCvt32to32F_0(v)
    68  	case OpCvt32to64F:
    69  		return rewriteValuegeneric_OpCvt32to64F_0(v)
    70  	case OpCvt64Fto32:
    71  		return rewriteValuegeneric_OpCvt64Fto32_0(v)
    72  	case OpCvt64Fto32F:
    73  		return rewriteValuegeneric_OpCvt64Fto32F_0(v)
    74  	case OpCvt64Fto64:
    75  		return rewriteValuegeneric_OpCvt64Fto64_0(v)
    76  	case OpCvt64to32F:
    77  		return rewriteValuegeneric_OpCvt64to32F_0(v)
    78  	case OpCvt64to64F:
    79  		return rewriteValuegeneric_OpCvt64to64F_0(v)
    80  	case OpDiv16:
    81  		return rewriteValuegeneric_OpDiv16_0(v)
    82  	case OpDiv16u:
    83  		return rewriteValuegeneric_OpDiv16u_0(v)
    84  	case OpDiv32:
    85  		return rewriteValuegeneric_OpDiv32_0(v)
    86  	case OpDiv32F:
    87  		return rewriteValuegeneric_OpDiv32F_0(v)
    88  	case OpDiv32u:
    89  		return rewriteValuegeneric_OpDiv32u_0(v)
    90  	case OpDiv64:
    91  		return rewriteValuegeneric_OpDiv64_0(v)
    92  	case OpDiv64F:
    93  		return rewriteValuegeneric_OpDiv64F_0(v)
    94  	case OpDiv64u:
    95  		return rewriteValuegeneric_OpDiv64u_0(v)
    96  	case OpDiv8:
    97  		return rewriteValuegeneric_OpDiv8_0(v)
    98  	case OpDiv8u:
    99  		return rewriteValuegeneric_OpDiv8u_0(v)
   100  	case OpEq16:
   101  		return rewriteValuegeneric_OpEq16_0(v)
   102  	case OpEq32:
   103  		return rewriteValuegeneric_OpEq32_0(v)
   104  	case OpEq32F:
   105  		return rewriteValuegeneric_OpEq32F_0(v)
   106  	case OpEq64:
   107  		return rewriteValuegeneric_OpEq64_0(v)
   108  	case OpEq64F:
   109  		return rewriteValuegeneric_OpEq64F_0(v)
   110  	case OpEq8:
   111  		return rewriteValuegeneric_OpEq8_0(v)
   112  	case OpEqB:
   113  		return rewriteValuegeneric_OpEqB_0(v)
   114  	case OpEqInter:
   115  		return rewriteValuegeneric_OpEqInter_0(v)
   116  	case OpEqPtr:
   117  		return rewriteValuegeneric_OpEqPtr_0(v) || rewriteValuegeneric_OpEqPtr_10(v) || rewriteValuegeneric_OpEqPtr_20(v)
   118  	case OpEqSlice:
   119  		return rewriteValuegeneric_OpEqSlice_0(v)
   120  	case OpGeq16:
   121  		return rewriteValuegeneric_OpGeq16_0(v)
   122  	case OpGeq16U:
   123  		return rewriteValuegeneric_OpGeq16U_0(v)
   124  	case OpGeq32:
   125  		return rewriteValuegeneric_OpGeq32_0(v)
   126  	case OpGeq32F:
   127  		return rewriteValuegeneric_OpGeq32F_0(v)
   128  	case OpGeq32U:
   129  		return rewriteValuegeneric_OpGeq32U_0(v)
   130  	case OpGeq64:
   131  		return rewriteValuegeneric_OpGeq64_0(v)
   132  	case OpGeq64F:
   133  		return rewriteValuegeneric_OpGeq64F_0(v)
   134  	case OpGeq64U:
   135  		return rewriteValuegeneric_OpGeq64U_0(v)
   136  	case OpGeq8:
   137  		return rewriteValuegeneric_OpGeq8_0(v)
   138  	case OpGeq8U:
   139  		return rewriteValuegeneric_OpGeq8U_0(v)
   140  	case OpGreater16:
   141  		return rewriteValuegeneric_OpGreater16_0(v)
   142  	case OpGreater16U:
   143  		return rewriteValuegeneric_OpGreater16U_0(v)
   144  	case OpGreater32:
   145  		return rewriteValuegeneric_OpGreater32_0(v)
   146  	case OpGreater32F:
   147  		return rewriteValuegeneric_OpGreater32F_0(v)
   148  	case OpGreater32U:
   149  		return rewriteValuegeneric_OpGreater32U_0(v)
   150  	case OpGreater64:
   151  		return rewriteValuegeneric_OpGreater64_0(v)
   152  	case OpGreater64F:
   153  		return rewriteValuegeneric_OpGreater64F_0(v)
   154  	case OpGreater64U:
   155  		return rewriteValuegeneric_OpGreater64U_0(v)
   156  	case OpGreater8:
   157  		return rewriteValuegeneric_OpGreater8_0(v)
   158  	case OpGreater8U:
   159  		return rewriteValuegeneric_OpGreater8U_0(v)
   160  	case OpIMake:
   161  		return rewriteValuegeneric_OpIMake_0(v)
   162  	case OpInterCall:
   163  		return rewriteValuegeneric_OpInterCall_0(v)
   164  	case OpIsInBounds:
   165  		return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v) || rewriteValuegeneric_OpIsInBounds_30(v)
   166  	case OpIsNonNil:
   167  		return rewriteValuegeneric_OpIsNonNil_0(v)
   168  	case OpIsSliceInBounds:
   169  		return rewriteValuegeneric_OpIsSliceInBounds_0(v)
   170  	case OpLeq16:
   171  		return rewriteValuegeneric_OpLeq16_0(v)
   172  	case OpLeq16U:
   173  		return rewriteValuegeneric_OpLeq16U_0(v)
   174  	case OpLeq32:
   175  		return rewriteValuegeneric_OpLeq32_0(v)
   176  	case OpLeq32F:
   177  		return rewriteValuegeneric_OpLeq32F_0(v)
   178  	case OpLeq32U:
   179  		return rewriteValuegeneric_OpLeq32U_0(v)
   180  	case OpLeq64:
   181  		return rewriteValuegeneric_OpLeq64_0(v)
   182  	case OpLeq64F:
   183  		return rewriteValuegeneric_OpLeq64F_0(v)
   184  	case OpLeq64U:
   185  		return rewriteValuegeneric_OpLeq64U_0(v)
   186  	case OpLeq8:
   187  		return rewriteValuegeneric_OpLeq8_0(v)
   188  	case OpLeq8U:
   189  		return rewriteValuegeneric_OpLeq8U_0(v)
   190  	case OpLess16:
   191  		return rewriteValuegeneric_OpLess16_0(v)
   192  	case OpLess16U:
   193  		return rewriteValuegeneric_OpLess16U_0(v)
   194  	case OpLess32:
   195  		return rewriteValuegeneric_OpLess32_0(v)
   196  	case OpLess32F:
   197  		return rewriteValuegeneric_OpLess32F_0(v)
   198  	case OpLess32U:
   199  		return rewriteValuegeneric_OpLess32U_0(v)
   200  	case OpLess64:
   201  		return rewriteValuegeneric_OpLess64_0(v)
   202  	case OpLess64F:
   203  		return rewriteValuegeneric_OpLess64F_0(v)
   204  	case OpLess64U:
   205  		return rewriteValuegeneric_OpLess64U_0(v)
   206  	case OpLess8:
   207  		return rewriteValuegeneric_OpLess8_0(v)
   208  	case OpLess8U:
   209  		return rewriteValuegeneric_OpLess8U_0(v)
   210  	case OpLoad:
   211  		return rewriteValuegeneric_OpLoad_0(v) || rewriteValuegeneric_OpLoad_10(v) || rewriteValuegeneric_OpLoad_20(v)
   212  	case OpLsh16x16:
   213  		return rewriteValuegeneric_OpLsh16x16_0(v)
   214  	case OpLsh16x32:
   215  		return rewriteValuegeneric_OpLsh16x32_0(v)
   216  	case OpLsh16x64:
   217  		return rewriteValuegeneric_OpLsh16x64_0(v)
   218  	case OpLsh16x8:
   219  		return rewriteValuegeneric_OpLsh16x8_0(v)
   220  	case OpLsh32x16:
   221  		return rewriteValuegeneric_OpLsh32x16_0(v)
   222  	case OpLsh32x32:
   223  		return rewriteValuegeneric_OpLsh32x32_0(v)
   224  	case OpLsh32x64:
   225  		return rewriteValuegeneric_OpLsh32x64_0(v)
   226  	case OpLsh32x8:
   227  		return rewriteValuegeneric_OpLsh32x8_0(v)
   228  	case OpLsh64x16:
   229  		return rewriteValuegeneric_OpLsh64x16_0(v)
   230  	case OpLsh64x32:
   231  		return rewriteValuegeneric_OpLsh64x32_0(v)
   232  	case OpLsh64x64:
   233  		return rewriteValuegeneric_OpLsh64x64_0(v)
   234  	case OpLsh64x8:
   235  		return rewriteValuegeneric_OpLsh64x8_0(v)
   236  	case OpLsh8x16:
   237  		return rewriteValuegeneric_OpLsh8x16_0(v)
   238  	case OpLsh8x32:
   239  		return rewriteValuegeneric_OpLsh8x32_0(v)
   240  	case OpLsh8x64:
   241  		return rewriteValuegeneric_OpLsh8x64_0(v)
   242  	case OpLsh8x8:
   243  		return rewriteValuegeneric_OpLsh8x8_0(v)
   244  	case OpMod16:
   245  		return rewriteValuegeneric_OpMod16_0(v)
   246  	case OpMod16u:
   247  		return rewriteValuegeneric_OpMod16u_0(v)
   248  	case OpMod32:
   249  		return rewriteValuegeneric_OpMod32_0(v)
   250  	case OpMod32u:
   251  		return rewriteValuegeneric_OpMod32u_0(v)
   252  	case OpMod64:
   253  		return rewriteValuegeneric_OpMod64_0(v)
   254  	case OpMod64u:
   255  		return rewriteValuegeneric_OpMod64u_0(v)
   256  	case OpMod8:
   257  		return rewriteValuegeneric_OpMod8_0(v)
   258  	case OpMod8u:
   259  		return rewriteValuegeneric_OpMod8u_0(v)
   260  	case OpMove:
   261  		return rewriteValuegeneric_OpMove_0(v) || rewriteValuegeneric_OpMove_10(v) || rewriteValuegeneric_OpMove_20(v)
   262  	case OpMul16:
   263  		return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v)
   264  	case OpMul32:
   265  		return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v)
   266  	case OpMul32F:
   267  		return rewriteValuegeneric_OpMul32F_0(v)
   268  	case OpMul64:
   269  		return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v)
   270  	case OpMul64F:
   271  		return rewriteValuegeneric_OpMul64F_0(v)
   272  	case OpMul8:
   273  		return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v)
   274  	case OpNeg16:
   275  		return rewriteValuegeneric_OpNeg16_0(v)
   276  	case OpNeg32:
   277  		return rewriteValuegeneric_OpNeg32_0(v)
   278  	case OpNeg32F:
   279  		return rewriteValuegeneric_OpNeg32F_0(v)
   280  	case OpNeg64:
   281  		return rewriteValuegeneric_OpNeg64_0(v)
   282  	case OpNeg64F:
   283  		return rewriteValuegeneric_OpNeg64F_0(v)
   284  	case OpNeg8:
   285  		return rewriteValuegeneric_OpNeg8_0(v)
   286  	case OpNeq16:
   287  		return rewriteValuegeneric_OpNeq16_0(v)
   288  	case OpNeq32:
   289  		return rewriteValuegeneric_OpNeq32_0(v)
   290  	case OpNeq32F:
   291  		return rewriteValuegeneric_OpNeq32F_0(v)
   292  	case OpNeq64:
   293  		return rewriteValuegeneric_OpNeq64_0(v)
   294  	case OpNeq64F:
   295  		return rewriteValuegeneric_OpNeq64F_0(v)
   296  	case OpNeq8:
   297  		return rewriteValuegeneric_OpNeq8_0(v)
   298  	case OpNeqB:
   299  		return rewriteValuegeneric_OpNeqB_0(v)
   300  	case OpNeqInter:
   301  		return rewriteValuegeneric_OpNeqInter_0(v)
   302  	case OpNeqPtr:
   303  		return rewriteValuegeneric_OpNeqPtr_0(v) || rewriteValuegeneric_OpNeqPtr_10(v) || rewriteValuegeneric_OpNeqPtr_20(v)
   304  	case OpNeqSlice:
   305  		return rewriteValuegeneric_OpNeqSlice_0(v)
   306  	case OpNilCheck:
   307  		return rewriteValuegeneric_OpNilCheck_0(v)
   308  	case OpNot:
   309  		return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v)
   310  	case OpOffPtr:
   311  		return rewriteValuegeneric_OpOffPtr_0(v)
   312  	case OpOr16:
   313  		return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v) || rewriteValuegeneric_OpOr16_20(v)
   314  	case OpOr32:
   315  		return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v) || rewriteValuegeneric_OpOr32_20(v)
   316  	case OpOr64:
   317  		return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v) || rewriteValuegeneric_OpOr64_20(v)
   318  	case OpOr8:
   319  		return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v) || rewriteValuegeneric_OpOr8_20(v)
   320  	case OpPhi:
   321  		return rewriteValuegeneric_OpPhi_0(v)
   322  	case OpPtrIndex:
   323  		return rewriteValuegeneric_OpPtrIndex_0(v)
   324  	case OpRound32F:
   325  		return rewriteValuegeneric_OpRound32F_0(v)
   326  	case OpRound64F:
   327  		return rewriteValuegeneric_OpRound64F_0(v)
   328  	case OpRsh16Ux16:
   329  		return rewriteValuegeneric_OpRsh16Ux16_0(v)
   330  	case OpRsh16Ux32:
   331  		return rewriteValuegeneric_OpRsh16Ux32_0(v)
   332  	case OpRsh16Ux64:
   333  		return rewriteValuegeneric_OpRsh16Ux64_0(v)
   334  	case OpRsh16Ux8:
   335  		return rewriteValuegeneric_OpRsh16Ux8_0(v)
   336  	case OpRsh16x16:
   337  		return rewriteValuegeneric_OpRsh16x16_0(v)
   338  	case OpRsh16x32:
   339  		return rewriteValuegeneric_OpRsh16x32_0(v)
   340  	case OpRsh16x64:
   341  		return rewriteValuegeneric_OpRsh16x64_0(v)
   342  	case OpRsh16x8:
   343  		return rewriteValuegeneric_OpRsh16x8_0(v)
   344  	case OpRsh32Ux16:
   345  		return rewriteValuegeneric_OpRsh32Ux16_0(v)
   346  	case OpRsh32Ux32:
   347  		return rewriteValuegeneric_OpRsh32Ux32_0(v)
   348  	case OpRsh32Ux64:
   349  		return rewriteValuegeneric_OpRsh32Ux64_0(v)
   350  	case OpRsh32Ux8:
   351  		return rewriteValuegeneric_OpRsh32Ux8_0(v)
   352  	case OpRsh32x16:
   353  		return rewriteValuegeneric_OpRsh32x16_0(v)
   354  	case OpRsh32x32:
   355  		return rewriteValuegeneric_OpRsh32x32_0(v)
   356  	case OpRsh32x64:
   357  		return rewriteValuegeneric_OpRsh32x64_0(v)
   358  	case OpRsh32x8:
   359  		return rewriteValuegeneric_OpRsh32x8_0(v)
   360  	case OpRsh64Ux16:
   361  		return rewriteValuegeneric_OpRsh64Ux16_0(v)
   362  	case OpRsh64Ux32:
   363  		return rewriteValuegeneric_OpRsh64Ux32_0(v)
   364  	case OpRsh64Ux64:
   365  		return rewriteValuegeneric_OpRsh64Ux64_0(v)
   366  	case OpRsh64Ux8:
   367  		return rewriteValuegeneric_OpRsh64Ux8_0(v)
   368  	case OpRsh64x16:
   369  		return rewriteValuegeneric_OpRsh64x16_0(v)
   370  	case OpRsh64x32:
   371  		return rewriteValuegeneric_OpRsh64x32_0(v)
   372  	case OpRsh64x64:
   373  		return rewriteValuegeneric_OpRsh64x64_0(v)
   374  	case OpRsh64x8:
   375  		return rewriteValuegeneric_OpRsh64x8_0(v)
   376  	case OpRsh8Ux16:
   377  		return rewriteValuegeneric_OpRsh8Ux16_0(v)
   378  	case OpRsh8Ux32:
   379  		return rewriteValuegeneric_OpRsh8Ux32_0(v)
   380  	case OpRsh8Ux64:
   381  		return rewriteValuegeneric_OpRsh8Ux64_0(v)
   382  	case OpRsh8Ux8:
   383  		return rewriteValuegeneric_OpRsh8Ux8_0(v)
   384  	case OpRsh8x16:
   385  		return rewriteValuegeneric_OpRsh8x16_0(v)
   386  	case OpRsh8x32:
   387  		return rewriteValuegeneric_OpRsh8x32_0(v)
   388  	case OpRsh8x64:
   389  		return rewriteValuegeneric_OpRsh8x64_0(v)
   390  	case OpRsh8x8:
   391  		return rewriteValuegeneric_OpRsh8x8_0(v)
   392  	case OpSignExt16to32:
   393  		return rewriteValuegeneric_OpSignExt16to32_0(v)
   394  	case OpSignExt16to64:
   395  		return rewriteValuegeneric_OpSignExt16to64_0(v)
   396  	case OpSignExt32to64:
   397  		return rewriteValuegeneric_OpSignExt32to64_0(v)
   398  	case OpSignExt8to16:
   399  		return rewriteValuegeneric_OpSignExt8to16_0(v)
   400  	case OpSignExt8to32:
   401  		return rewriteValuegeneric_OpSignExt8to32_0(v)
   402  	case OpSignExt8to64:
   403  		return rewriteValuegeneric_OpSignExt8to64_0(v)
   404  	case OpSliceCap:
   405  		return rewriteValuegeneric_OpSliceCap_0(v)
   406  	case OpSliceLen:
   407  		return rewriteValuegeneric_OpSliceLen_0(v)
   408  	case OpSlicePtr:
   409  		return rewriteValuegeneric_OpSlicePtr_0(v)
   410  	case OpSlicemask:
   411  		return rewriteValuegeneric_OpSlicemask_0(v)
   412  	case OpSqrt:
   413  		return rewriteValuegeneric_OpSqrt_0(v)
   414  	case OpStaticCall:
   415  		return rewriteValuegeneric_OpStaticCall_0(v)
   416  	case OpStore:
   417  		return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) || rewriteValuegeneric_OpStore_20(v)
   418  	case OpStringLen:
   419  		return rewriteValuegeneric_OpStringLen_0(v)
   420  	case OpStringPtr:
   421  		return rewriteValuegeneric_OpStringPtr_0(v)
   422  	case OpStructSelect:
   423  		return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v)
   424  	case OpSub16:
   425  		return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v)
   426  	case OpSub32:
   427  		return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v)
   428  	case OpSub32F:
   429  		return rewriteValuegeneric_OpSub32F_0(v)
   430  	case OpSub64:
   431  		return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v)
   432  	case OpSub64F:
   433  		return rewriteValuegeneric_OpSub64F_0(v)
   434  	case OpSub8:
   435  		return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v)
   436  	case OpTrunc16to8:
   437  		return rewriteValuegeneric_OpTrunc16to8_0(v)
   438  	case OpTrunc32to16:
   439  		return rewriteValuegeneric_OpTrunc32to16_0(v)
   440  	case OpTrunc32to8:
   441  		return rewriteValuegeneric_OpTrunc32to8_0(v)
   442  	case OpTrunc64to16:
   443  		return rewriteValuegeneric_OpTrunc64to16_0(v)
   444  	case OpTrunc64to32:
   445  		return rewriteValuegeneric_OpTrunc64to32_0(v)
   446  	case OpTrunc64to8:
   447  		return rewriteValuegeneric_OpTrunc64to8_0(v)
   448  	case OpXor16:
   449  		return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v)
   450  	case OpXor32:
   451  		return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v)
   452  	case OpXor64:
   453  		return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v)
   454  	case OpXor8:
   455  		return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v)
   456  	case OpZero:
   457  		return rewriteValuegeneric_OpZero_0(v)
   458  	case OpZeroExt16to32:
   459  		return rewriteValuegeneric_OpZeroExt16to32_0(v)
   460  	case OpZeroExt16to64:
   461  		return rewriteValuegeneric_OpZeroExt16to64_0(v)
   462  	case OpZeroExt32to64:
   463  		return rewriteValuegeneric_OpZeroExt32to64_0(v)
   464  	case OpZeroExt8to16:
   465  		return rewriteValuegeneric_OpZeroExt8to16_0(v)
   466  	case OpZeroExt8to32:
   467  		return rewriteValuegeneric_OpZeroExt8to32_0(v)
   468  	case OpZeroExt8to64:
   469  		return rewriteValuegeneric_OpZeroExt8to64_0(v)
   470  	}
   471  	return false
   472  }
   473  func rewriteValuegeneric_OpAdd16_0(v *Value) bool {
   474  	b := v.Block
   475  	_ = b
   476  	// match: (Add16 (Const16 [c]) (Const16 [d]))
   477  	// cond:
   478  	// result: (Const16 [int64(int16(c+d))])
   479  	for {
   480  		_ = v.Args[1]
   481  		v_0 := v.Args[0]
   482  		if v_0.Op != OpConst16 {
   483  			break
   484  		}
   485  		c := v_0.AuxInt
   486  		v_1 := v.Args[1]
   487  		if v_1.Op != OpConst16 {
   488  			break
   489  		}
   490  		d := v_1.AuxInt
   491  		v.reset(OpConst16)
   492  		v.AuxInt = int64(int16(c + d))
   493  		return true
   494  	}
   495  	// match: (Add16 (Const16 [d]) (Const16 [c]))
   496  	// cond:
   497  	// result: (Const16 [int64(int16(c+d))])
   498  	for {
   499  		_ = v.Args[1]
   500  		v_0 := v.Args[0]
   501  		if v_0.Op != OpConst16 {
   502  			break
   503  		}
   504  		d := v_0.AuxInt
   505  		v_1 := v.Args[1]
   506  		if v_1.Op != OpConst16 {
   507  			break
   508  		}
   509  		c := v_1.AuxInt
   510  		v.reset(OpConst16)
   511  		v.AuxInt = int64(int16(c + d))
   512  		return true
   513  	}
   514  	// match: (Add16 <t> (Mul16 x y) (Mul16 x z))
   515  	// cond:
   516  	// result: (Mul16 x (Add16 <t> y z))
   517  	for {
   518  		t := v.Type
   519  		_ = v.Args[1]
   520  		v_0 := v.Args[0]
   521  		if v_0.Op != OpMul16 {
   522  			break
   523  		}
   524  		_ = v_0.Args[1]
   525  		x := v_0.Args[0]
   526  		y := v_0.Args[1]
   527  		v_1 := v.Args[1]
   528  		if v_1.Op != OpMul16 {
   529  			break
   530  		}
   531  		_ = v_1.Args[1]
   532  		if x != v_1.Args[0] {
   533  			break
   534  		}
   535  		z := v_1.Args[1]
   536  		v.reset(OpMul16)
   537  		v.AddArg(x)
   538  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   539  		v0.AddArg(y)
   540  		v0.AddArg(z)
   541  		v.AddArg(v0)
   542  		return true
   543  	}
   544  	// match: (Add16 <t> (Mul16 y x) (Mul16 x z))
   545  	// cond:
   546  	// result: (Mul16 x (Add16 <t> y z))
   547  	for {
   548  		t := v.Type
   549  		_ = v.Args[1]
   550  		v_0 := v.Args[0]
   551  		if v_0.Op != OpMul16 {
   552  			break
   553  		}
   554  		_ = v_0.Args[1]
   555  		y := v_0.Args[0]
   556  		x := v_0.Args[1]
   557  		v_1 := v.Args[1]
   558  		if v_1.Op != OpMul16 {
   559  			break
   560  		}
   561  		_ = v_1.Args[1]
   562  		if x != v_1.Args[0] {
   563  			break
   564  		}
   565  		z := v_1.Args[1]
   566  		v.reset(OpMul16)
   567  		v.AddArg(x)
   568  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   569  		v0.AddArg(y)
   570  		v0.AddArg(z)
   571  		v.AddArg(v0)
   572  		return true
   573  	}
   574  	// match: (Add16 <t> (Mul16 x y) (Mul16 z x))
   575  	// cond:
   576  	// result: (Mul16 x (Add16 <t> y z))
   577  	for {
   578  		t := v.Type
   579  		_ = v.Args[1]
   580  		v_0 := v.Args[0]
   581  		if v_0.Op != OpMul16 {
   582  			break
   583  		}
   584  		_ = v_0.Args[1]
   585  		x := v_0.Args[0]
   586  		y := v_0.Args[1]
   587  		v_1 := v.Args[1]
   588  		if v_1.Op != OpMul16 {
   589  			break
   590  		}
   591  		_ = v_1.Args[1]
   592  		z := v_1.Args[0]
   593  		if x != v_1.Args[1] {
   594  			break
   595  		}
   596  		v.reset(OpMul16)
   597  		v.AddArg(x)
   598  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   599  		v0.AddArg(y)
   600  		v0.AddArg(z)
   601  		v.AddArg(v0)
   602  		return true
   603  	}
   604  	// match: (Add16 <t> (Mul16 y x) (Mul16 z x))
   605  	// cond:
   606  	// result: (Mul16 x (Add16 <t> y z))
   607  	for {
   608  		t := v.Type
   609  		_ = v.Args[1]
   610  		v_0 := v.Args[0]
   611  		if v_0.Op != OpMul16 {
   612  			break
   613  		}
   614  		_ = v_0.Args[1]
   615  		y := v_0.Args[0]
   616  		x := v_0.Args[1]
   617  		v_1 := v.Args[1]
   618  		if v_1.Op != OpMul16 {
   619  			break
   620  		}
   621  		_ = v_1.Args[1]
   622  		z := v_1.Args[0]
   623  		if x != v_1.Args[1] {
   624  			break
   625  		}
   626  		v.reset(OpMul16)
   627  		v.AddArg(x)
   628  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   629  		v0.AddArg(y)
   630  		v0.AddArg(z)
   631  		v.AddArg(v0)
   632  		return true
   633  	}
   634  	// match: (Add16 <t> (Mul16 x z) (Mul16 x y))
   635  	// cond:
   636  	// result: (Mul16 x (Add16 <t> y z))
   637  	for {
   638  		t := v.Type
   639  		_ = v.Args[1]
   640  		v_0 := v.Args[0]
   641  		if v_0.Op != OpMul16 {
   642  			break
   643  		}
   644  		_ = v_0.Args[1]
   645  		x := v_0.Args[0]
   646  		z := v_0.Args[1]
   647  		v_1 := v.Args[1]
   648  		if v_1.Op != OpMul16 {
   649  			break
   650  		}
   651  		_ = v_1.Args[1]
   652  		if x != v_1.Args[0] {
   653  			break
   654  		}
   655  		y := v_1.Args[1]
   656  		v.reset(OpMul16)
   657  		v.AddArg(x)
   658  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   659  		v0.AddArg(y)
   660  		v0.AddArg(z)
   661  		v.AddArg(v0)
   662  		return true
   663  	}
   664  	// match: (Add16 <t> (Mul16 z x) (Mul16 x y))
   665  	// cond:
   666  	// result: (Mul16 x (Add16 <t> y z))
   667  	for {
   668  		t := v.Type
   669  		_ = v.Args[1]
   670  		v_0 := v.Args[0]
   671  		if v_0.Op != OpMul16 {
   672  			break
   673  		}
   674  		_ = v_0.Args[1]
   675  		z := v_0.Args[0]
   676  		x := v_0.Args[1]
   677  		v_1 := v.Args[1]
   678  		if v_1.Op != OpMul16 {
   679  			break
   680  		}
   681  		_ = v_1.Args[1]
   682  		if x != v_1.Args[0] {
   683  			break
   684  		}
   685  		y := v_1.Args[1]
   686  		v.reset(OpMul16)
   687  		v.AddArg(x)
   688  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   689  		v0.AddArg(y)
   690  		v0.AddArg(z)
   691  		v.AddArg(v0)
   692  		return true
   693  	}
   694  	// match: (Add16 <t> (Mul16 x z) (Mul16 y x))
   695  	// cond:
   696  	// result: (Mul16 x (Add16 <t> y z))
   697  	for {
   698  		t := v.Type
   699  		_ = v.Args[1]
   700  		v_0 := v.Args[0]
   701  		if v_0.Op != OpMul16 {
   702  			break
   703  		}
   704  		_ = v_0.Args[1]
   705  		x := v_0.Args[0]
   706  		z := v_0.Args[1]
   707  		v_1 := v.Args[1]
   708  		if v_1.Op != OpMul16 {
   709  			break
   710  		}
   711  		_ = v_1.Args[1]
   712  		y := v_1.Args[0]
   713  		if x != v_1.Args[1] {
   714  			break
   715  		}
   716  		v.reset(OpMul16)
   717  		v.AddArg(x)
   718  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   719  		v0.AddArg(y)
   720  		v0.AddArg(z)
   721  		v.AddArg(v0)
   722  		return true
   723  	}
   724  	// match: (Add16 <t> (Mul16 z x) (Mul16 y x))
   725  	// cond:
   726  	// result: (Mul16 x (Add16 <t> y z))
   727  	for {
   728  		t := v.Type
   729  		_ = v.Args[1]
   730  		v_0 := v.Args[0]
   731  		if v_0.Op != OpMul16 {
   732  			break
   733  		}
   734  		_ = v_0.Args[1]
   735  		z := v_0.Args[0]
   736  		x := v_0.Args[1]
   737  		v_1 := v.Args[1]
   738  		if v_1.Op != OpMul16 {
   739  			break
   740  		}
   741  		_ = v_1.Args[1]
   742  		y := v_1.Args[0]
   743  		if x != v_1.Args[1] {
   744  			break
   745  		}
   746  		v.reset(OpMul16)
   747  		v.AddArg(x)
   748  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   749  		v0.AddArg(y)
   750  		v0.AddArg(z)
   751  		v.AddArg(v0)
   752  		return true
   753  	}
   754  	return false
   755  }
   756  func rewriteValuegeneric_OpAdd16_10(v *Value) bool {
   757  	b := v.Block
   758  	_ = b
   759  	// match: (Add16 (Const16 [0]) x)
   760  	// cond:
   761  	// result: x
   762  	for {
   763  		_ = v.Args[1]
   764  		v_0 := v.Args[0]
   765  		if v_0.Op != OpConst16 {
   766  			break
   767  		}
   768  		if v_0.AuxInt != 0 {
   769  			break
   770  		}
   771  		x := v.Args[1]
   772  		v.reset(OpCopy)
   773  		v.Type = x.Type
   774  		v.AddArg(x)
   775  		return true
   776  	}
   777  	// match: (Add16 x (Const16 [0]))
   778  	// cond:
   779  	// result: x
   780  	for {
   781  		_ = v.Args[1]
   782  		x := v.Args[0]
   783  		v_1 := v.Args[1]
   784  		if v_1.Op != OpConst16 {
   785  			break
   786  		}
   787  		if v_1.AuxInt != 0 {
   788  			break
   789  		}
   790  		v.reset(OpCopy)
   791  		v.Type = x.Type
   792  		v.AddArg(x)
   793  		return true
   794  	}
   795  	// match: (Add16 (Const16 [1]) (Com16 x))
   796  	// cond:
   797  	// result: (Neg16 x)
   798  	for {
   799  		_ = v.Args[1]
   800  		v_0 := v.Args[0]
   801  		if v_0.Op != OpConst16 {
   802  			break
   803  		}
   804  		if v_0.AuxInt != 1 {
   805  			break
   806  		}
   807  		v_1 := v.Args[1]
   808  		if v_1.Op != OpCom16 {
   809  			break
   810  		}
   811  		x := v_1.Args[0]
   812  		v.reset(OpNeg16)
   813  		v.AddArg(x)
   814  		return true
   815  	}
   816  	// match: (Add16 (Com16 x) (Const16 [1]))
   817  	// cond:
   818  	// result: (Neg16 x)
   819  	for {
   820  		_ = v.Args[1]
   821  		v_0 := v.Args[0]
   822  		if v_0.Op != OpCom16 {
   823  			break
   824  		}
   825  		x := v_0.Args[0]
   826  		v_1 := v.Args[1]
   827  		if v_1.Op != OpConst16 {
   828  			break
   829  		}
   830  		if v_1.AuxInt != 1 {
   831  			break
   832  		}
   833  		v.reset(OpNeg16)
   834  		v.AddArg(x)
   835  		return true
   836  	}
   837  	// match: (Add16 (Add16 i:(Const16 <t>) z) x)
   838  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   839  	// result: (Add16 i (Add16 <t> z x))
   840  	for {
   841  		_ = v.Args[1]
   842  		v_0 := v.Args[0]
   843  		if v_0.Op != OpAdd16 {
   844  			break
   845  		}
   846  		_ = v_0.Args[1]
   847  		i := v_0.Args[0]
   848  		if i.Op != OpConst16 {
   849  			break
   850  		}
   851  		t := i.Type
   852  		z := v_0.Args[1]
   853  		x := v.Args[1]
   854  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
   855  			break
   856  		}
   857  		v.reset(OpAdd16)
   858  		v.AddArg(i)
   859  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   860  		v0.AddArg(z)
   861  		v0.AddArg(x)
   862  		v.AddArg(v0)
   863  		return true
   864  	}
   865  	// match: (Add16 (Add16 z i:(Const16 <t>)) x)
   866  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   867  	// result: (Add16 i (Add16 <t> z x))
   868  	for {
   869  		_ = v.Args[1]
   870  		v_0 := v.Args[0]
   871  		if v_0.Op != OpAdd16 {
   872  			break
   873  		}
   874  		_ = v_0.Args[1]
   875  		z := v_0.Args[0]
   876  		i := v_0.Args[1]
   877  		if i.Op != OpConst16 {
   878  			break
   879  		}
   880  		t := i.Type
   881  		x := v.Args[1]
   882  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
   883  			break
   884  		}
   885  		v.reset(OpAdd16)
   886  		v.AddArg(i)
   887  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   888  		v0.AddArg(z)
   889  		v0.AddArg(x)
   890  		v.AddArg(v0)
   891  		return true
   892  	}
   893  	// match: (Add16 x (Add16 i:(Const16 <t>) z))
   894  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   895  	// result: (Add16 i (Add16 <t> z x))
   896  	for {
   897  		_ = v.Args[1]
   898  		x := v.Args[0]
   899  		v_1 := v.Args[1]
   900  		if v_1.Op != OpAdd16 {
   901  			break
   902  		}
   903  		_ = v_1.Args[1]
   904  		i := v_1.Args[0]
   905  		if i.Op != OpConst16 {
   906  			break
   907  		}
   908  		t := i.Type
   909  		z := v_1.Args[1]
   910  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
   911  			break
   912  		}
   913  		v.reset(OpAdd16)
   914  		v.AddArg(i)
   915  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   916  		v0.AddArg(z)
   917  		v0.AddArg(x)
   918  		v.AddArg(v0)
   919  		return true
   920  	}
   921  	// match: (Add16 x (Add16 z i:(Const16 <t>)))
   922  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   923  	// result: (Add16 i (Add16 <t> z x))
   924  	for {
   925  		_ = v.Args[1]
   926  		x := v.Args[0]
   927  		v_1 := v.Args[1]
   928  		if v_1.Op != OpAdd16 {
   929  			break
   930  		}
   931  		_ = v_1.Args[1]
   932  		z := v_1.Args[0]
   933  		i := v_1.Args[1]
   934  		if i.Op != OpConst16 {
   935  			break
   936  		}
   937  		t := i.Type
   938  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
   939  			break
   940  		}
   941  		v.reset(OpAdd16)
   942  		v.AddArg(i)
   943  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
   944  		v0.AddArg(z)
   945  		v0.AddArg(x)
   946  		v.AddArg(v0)
   947  		return true
   948  	}
   949  	// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
   950  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   951  	// result: (Add16 i (Sub16 <t> x z))
   952  	for {
   953  		_ = v.Args[1]
   954  		v_0 := v.Args[0]
   955  		if v_0.Op != OpSub16 {
   956  			break
   957  		}
   958  		_ = v_0.Args[1]
   959  		i := v_0.Args[0]
   960  		if i.Op != OpConst16 {
   961  			break
   962  		}
   963  		t := i.Type
   964  		z := v_0.Args[1]
   965  		x := v.Args[1]
   966  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
   967  			break
   968  		}
   969  		v.reset(OpAdd16)
   970  		v.AddArg(i)
   971  		v0 := b.NewValue0(v.Pos, OpSub16, t)
   972  		v0.AddArg(x)
   973  		v0.AddArg(z)
   974  		v.AddArg(v0)
   975  		return true
   976  	}
   977  	// match: (Add16 x (Sub16 i:(Const16 <t>) z))
   978  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
   979  	// result: (Add16 i (Sub16 <t> x z))
   980  	for {
   981  		_ = v.Args[1]
   982  		x := v.Args[0]
   983  		v_1 := v.Args[1]
   984  		if v_1.Op != OpSub16 {
   985  			break
   986  		}
   987  		_ = v_1.Args[1]
   988  		i := v_1.Args[0]
   989  		if i.Op != OpConst16 {
   990  			break
   991  		}
   992  		t := i.Type
   993  		z := v_1.Args[1]
   994  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
   995  			break
   996  		}
   997  		v.reset(OpAdd16)
   998  		v.AddArg(i)
   999  		v0 := b.NewValue0(v.Pos, OpSub16, t)
  1000  		v0.AddArg(x)
  1001  		v0.AddArg(z)
  1002  		v.AddArg(v0)
  1003  		return true
  1004  	}
  1005  	return false
  1006  }
  1007  func rewriteValuegeneric_OpAdd16_20(v *Value) bool {
  1008  	b := v.Block
  1009  	_ = b
  1010  	// match: (Add16 x (Sub16 i:(Const16 <t>) z))
  1011  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1012  	// result: (Add16 i (Sub16 <t> x z))
  1013  	for {
  1014  		_ = v.Args[1]
  1015  		x := v.Args[0]
  1016  		v_1 := v.Args[1]
  1017  		if v_1.Op != OpSub16 {
  1018  			break
  1019  		}
  1020  		_ = v_1.Args[1]
  1021  		i := v_1.Args[0]
  1022  		if i.Op != OpConst16 {
  1023  			break
  1024  		}
  1025  		t := i.Type
  1026  		z := v_1.Args[1]
  1027  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1028  			break
  1029  		}
  1030  		v.reset(OpAdd16)
  1031  		v.AddArg(i)
  1032  		v0 := b.NewValue0(v.Pos, OpSub16, t)
  1033  		v0.AddArg(x)
  1034  		v0.AddArg(z)
  1035  		v.AddArg(v0)
  1036  		return true
  1037  	}
  1038  	// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
  1039  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1040  	// result: (Add16 i (Sub16 <t> x z))
  1041  	for {
  1042  		_ = v.Args[1]
  1043  		v_0 := v.Args[0]
  1044  		if v_0.Op != OpSub16 {
  1045  			break
  1046  		}
  1047  		_ = v_0.Args[1]
  1048  		i := v_0.Args[0]
  1049  		if i.Op != OpConst16 {
  1050  			break
  1051  		}
  1052  		t := i.Type
  1053  		z := v_0.Args[1]
  1054  		x := v.Args[1]
  1055  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1056  			break
  1057  		}
  1058  		v.reset(OpAdd16)
  1059  		v.AddArg(i)
  1060  		v0 := b.NewValue0(v.Pos, OpSub16, t)
  1061  		v0.AddArg(x)
  1062  		v0.AddArg(z)
  1063  		v.AddArg(v0)
  1064  		return true
  1065  	}
  1066  	// match: (Add16 (Sub16 z i:(Const16 <t>)) x)
  1067  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1068  	// result: (Sub16 (Add16 <t> x z) i)
  1069  	for {
  1070  		_ = v.Args[1]
  1071  		v_0 := v.Args[0]
  1072  		if v_0.Op != OpSub16 {
  1073  			break
  1074  		}
  1075  		_ = v_0.Args[1]
  1076  		z := v_0.Args[0]
  1077  		i := v_0.Args[1]
  1078  		if i.Op != OpConst16 {
  1079  			break
  1080  		}
  1081  		t := i.Type
  1082  		x := v.Args[1]
  1083  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1084  			break
  1085  		}
  1086  		v.reset(OpSub16)
  1087  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1088  		v0.AddArg(x)
  1089  		v0.AddArg(z)
  1090  		v.AddArg(v0)
  1091  		v.AddArg(i)
  1092  		return true
  1093  	}
  1094  	// match: (Add16 x (Sub16 z i:(Const16 <t>)))
  1095  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1096  	// result: (Sub16 (Add16 <t> x z) i)
  1097  	for {
  1098  		_ = v.Args[1]
  1099  		x := v.Args[0]
  1100  		v_1 := v.Args[1]
  1101  		if v_1.Op != OpSub16 {
  1102  			break
  1103  		}
  1104  		_ = v_1.Args[1]
  1105  		z := v_1.Args[0]
  1106  		i := v_1.Args[1]
  1107  		if i.Op != OpConst16 {
  1108  			break
  1109  		}
  1110  		t := i.Type
  1111  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1112  			break
  1113  		}
  1114  		v.reset(OpSub16)
  1115  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1116  		v0.AddArg(x)
  1117  		v0.AddArg(z)
  1118  		v.AddArg(v0)
  1119  		v.AddArg(i)
  1120  		return true
  1121  	}
  1122  	// match: (Add16 x (Sub16 z i:(Const16 <t>)))
  1123  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1124  	// result: (Sub16 (Add16 <t> x z) i)
  1125  	for {
  1126  		_ = v.Args[1]
  1127  		x := v.Args[0]
  1128  		v_1 := v.Args[1]
  1129  		if v_1.Op != OpSub16 {
  1130  			break
  1131  		}
  1132  		_ = v_1.Args[1]
  1133  		z := v_1.Args[0]
  1134  		i := v_1.Args[1]
  1135  		if i.Op != OpConst16 {
  1136  			break
  1137  		}
  1138  		t := i.Type
  1139  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1140  			break
  1141  		}
  1142  		v.reset(OpSub16)
  1143  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1144  		v0.AddArg(x)
  1145  		v0.AddArg(z)
  1146  		v.AddArg(v0)
  1147  		v.AddArg(i)
  1148  		return true
  1149  	}
  1150  	// match: (Add16 (Sub16 z i:(Const16 <t>)) x)
  1151  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  1152  	// result: (Sub16 (Add16 <t> x z) i)
  1153  	for {
  1154  		_ = v.Args[1]
  1155  		v_0 := v.Args[0]
  1156  		if v_0.Op != OpSub16 {
  1157  			break
  1158  		}
  1159  		_ = v_0.Args[1]
  1160  		z := v_0.Args[0]
  1161  		i := v_0.Args[1]
  1162  		if i.Op != OpConst16 {
  1163  			break
  1164  		}
  1165  		t := i.Type
  1166  		x := v.Args[1]
  1167  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  1168  			break
  1169  		}
  1170  		v.reset(OpSub16)
  1171  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
  1172  		v0.AddArg(x)
  1173  		v0.AddArg(z)
  1174  		v.AddArg(v0)
  1175  		v.AddArg(i)
  1176  		return true
  1177  	}
  1178  	// match: (Add16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
  1179  	// cond:
  1180  	// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1181  	for {
  1182  		_ = v.Args[1]
  1183  		v_0 := v.Args[0]
  1184  		if v_0.Op != OpConst16 {
  1185  			break
  1186  		}
  1187  		t := v_0.Type
  1188  		c := v_0.AuxInt
  1189  		v_1 := v.Args[1]
  1190  		if v_1.Op != OpAdd16 {
  1191  			break
  1192  		}
  1193  		_ = v_1.Args[1]
  1194  		v_1_0 := v_1.Args[0]
  1195  		if v_1_0.Op != OpConst16 {
  1196  			break
  1197  		}
  1198  		if v_1_0.Type != t {
  1199  			break
  1200  		}
  1201  		d := v_1_0.AuxInt
  1202  		x := v_1.Args[1]
  1203  		v.reset(OpAdd16)
  1204  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1205  		v0.AuxInt = int64(int16(c + d))
  1206  		v.AddArg(v0)
  1207  		v.AddArg(x)
  1208  		return true
  1209  	}
  1210  	// match: (Add16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d])))
  1211  	// cond:
  1212  	// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1213  	for {
  1214  		_ = v.Args[1]
  1215  		v_0 := v.Args[0]
  1216  		if v_0.Op != OpConst16 {
  1217  			break
  1218  		}
  1219  		t := v_0.Type
  1220  		c := v_0.AuxInt
  1221  		v_1 := v.Args[1]
  1222  		if v_1.Op != OpAdd16 {
  1223  			break
  1224  		}
  1225  		_ = v_1.Args[1]
  1226  		x := v_1.Args[0]
  1227  		v_1_1 := v_1.Args[1]
  1228  		if v_1_1.Op != OpConst16 {
  1229  			break
  1230  		}
  1231  		if v_1_1.Type != t {
  1232  			break
  1233  		}
  1234  		d := v_1_1.AuxInt
  1235  		v.reset(OpAdd16)
  1236  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1237  		v0.AuxInt = int64(int16(c + d))
  1238  		v.AddArg(v0)
  1239  		v.AddArg(x)
  1240  		return true
  1241  	}
  1242  	// match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  1243  	// cond:
  1244  	// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1245  	for {
  1246  		_ = v.Args[1]
  1247  		v_0 := v.Args[0]
  1248  		if v_0.Op != OpAdd16 {
  1249  			break
  1250  		}
  1251  		_ = v_0.Args[1]
  1252  		v_0_0 := v_0.Args[0]
  1253  		if v_0_0.Op != OpConst16 {
  1254  			break
  1255  		}
  1256  		t := v_0_0.Type
  1257  		d := v_0_0.AuxInt
  1258  		x := v_0.Args[1]
  1259  		v_1 := v.Args[1]
  1260  		if v_1.Op != OpConst16 {
  1261  			break
  1262  		}
  1263  		if v_1.Type != t {
  1264  			break
  1265  		}
  1266  		c := v_1.AuxInt
  1267  		v.reset(OpAdd16)
  1268  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1269  		v0.AuxInt = int64(int16(c + d))
  1270  		v.AddArg(v0)
  1271  		v.AddArg(x)
  1272  		return true
  1273  	}
  1274  	// match: (Add16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c]))
  1275  	// cond:
  1276  	// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
  1277  	for {
  1278  		_ = v.Args[1]
  1279  		v_0 := v.Args[0]
  1280  		if v_0.Op != OpAdd16 {
  1281  			break
  1282  		}
  1283  		_ = v_0.Args[1]
  1284  		x := v_0.Args[0]
  1285  		v_0_1 := v_0.Args[1]
  1286  		if v_0_1.Op != OpConst16 {
  1287  			break
  1288  		}
  1289  		t := v_0_1.Type
  1290  		d := v_0_1.AuxInt
  1291  		v_1 := v.Args[1]
  1292  		if v_1.Op != OpConst16 {
  1293  			break
  1294  		}
  1295  		if v_1.Type != t {
  1296  			break
  1297  		}
  1298  		c := v_1.AuxInt
  1299  		v.reset(OpAdd16)
  1300  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1301  		v0.AuxInt = int64(int16(c + d))
  1302  		v.AddArg(v0)
  1303  		v.AddArg(x)
  1304  		return true
  1305  	}
  1306  	return false
  1307  }
  1308  func rewriteValuegeneric_OpAdd16_30(v *Value) bool {
  1309  	b := v.Block
  1310  	_ = b
  1311  	// match: (Add16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
  1312  	// cond:
  1313  	// result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x)
  1314  	for {
  1315  		_ = v.Args[1]
  1316  		v_0 := v.Args[0]
  1317  		if v_0.Op != OpConst16 {
  1318  			break
  1319  		}
  1320  		t := v_0.Type
  1321  		c := v_0.AuxInt
  1322  		v_1 := v.Args[1]
  1323  		if v_1.Op != OpSub16 {
  1324  			break
  1325  		}
  1326  		_ = v_1.Args[1]
  1327  		v_1_0 := v_1.Args[0]
  1328  		if v_1_0.Op != OpConst16 {
  1329  			break
  1330  		}
  1331  		if v_1_0.Type != t {
  1332  			break
  1333  		}
  1334  		d := v_1_0.AuxInt
  1335  		x := v_1.Args[1]
  1336  		v.reset(OpSub16)
  1337  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1338  		v0.AuxInt = int64(int16(c + d))
  1339  		v.AddArg(v0)
  1340  		v.AddArg(x)
  1341  		return true
  1342  	}
  1343  	// match: (Add16 (Sub16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  1344  	// cond:
  1345  	// result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x)
  1346  	for {
  1347  		_ = v.Args[1]
  1348  		v_0 := v.Args[0]
  1349  		if v_0.Op != OpSub16 {
  1350  			break
  1351  		}
  1352  		_ = v_0.Args[1]
  1353  		v_0_0 := v_0.Args[0]
  1354  		if v_0_0.Op != OpConst16 {
  1355  			break
  1356  		}
  1357  		t := v_0_0.Type
  1358  		d := v_0_0.AuxInt
  1359  		x := v_0.Args[1]
  1360  		v_1 := v.Args[1]
  1361  		if v_1.Op != OpConst16 {
  1362  			break
  1363  		}
  1364  		if v_1.Type != t {
  1365  			break
  1366  		}
  1367  		c := v_1.AuxInt
  1368  		v.reset(OpSub16)
  1369  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1370  		v0.AuxInt = int64(int16(c + d))
  1371  		v.AddArg(v0)
  1372  		v.AddArg(x)
  1373  		return true
  1374  	}
  1375  	// match: (Add16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d])))
  1376  	// cond:
  1377  	// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
  1378  	for {
  1379  		_ = v.Args[1]
  1380  		v_0 := v.Args[0]
  1381  		if v_0.Op != OpConst16 {
  1382  			break
  1383  		}
  1384  		t := v_0.Type
  1385  		c := v_0.AuxInt
  1386  		v_1 := v.Args[1]
  1387  		if v_1.Op != OpSub16 {
  1388  			break
  1389  		}
  1390  		_ = v_1.Args[1]
  1391  		x := v_1.Args[0]
  1392  		v_1_1 := v_1.Args[1]
  1393  		if v_1_1.Op != OpConst16 {
  1394  			break
  1395  		}
  1396  		if v_1_1.Type != t {
  1397  			break
  1398  		}
  1399  		d := v_1_1.AuxInt
  1400  		v.reset(OpAdd16)
  1401  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1402  		v0.AuxInt = int64(int16(c - d))
  1403  		v.AddArg(v0)
  1404  		v.AddArg(x)
  1405  		return true
  1406  	}
  1407  	// match: (Add16 (Sub16 x (Const16 <t> [d])) (Const16 <t> [c]))
  1408  	// cond:
  1409  	// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
  1410  	for {
  1411  		_ = v.Args[1]
  1412  		v_0 := v.Args[0]
  1413  		if v_0.Op != OpSub16 {
  1414  			break
  1415  		}
  1416  		_ = v_0.Args[1]
  1417  		x := v_0.Args[0]
  1418  		v_0_1 := v_0.Args[1]
  1419  		if v_0_1.Op != OpConst16 {
  1420  			break
  1421  		}
  1422  		t := v_0_1.Type
  1423  		d := v_0_1.AuxInt
  1424  		v_1 := v.Args[1]
  1425  		if v_1.Op != OpConst16 {
  1426  			break
  1427  		}
  1428  		if v_1.Type != t {
  1429  			break
  1430  		}
  1431  		c := v_1.AuxInt
  1432  		v.reset(OpAdd16)
  1433  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  1434  		v0.AuxInt = int64(int16(c - d))
  1435  		v.AddArg(v0)
  1436  		v.AddArg(x)
  1437  		return true
  1438  	}
  1439  	return false
  1440  }
  1441  func rewriteValuegeneric_OpAdd32_0(v *Value) bool {
  1442  	b := v.Block
  1443  	_ = b
  1444  	// match: (Add32 (Const32 [c]) (Const32 [d]))
  1445  	// cond:
  1446  	// result: (Const32 [int64(int32(c+d))])
  1447  	for {
  1448  		_ = v.Args[1]
  1449  		v_0 := v.Args[0]
  1450  		if v_0.Op != OpConst32 {
  1451  			break
  1452  		}
  1453  		c := v_0.AuxInt
  1454  		v_1 := v.Args[1]
  1455  		if v_1.Op != OpConst32 {
  1456  			break
  1457  		}
  1458  		d := v_1.AuxInt
  1459  		v.reset(OpConst32)
  1460  		v.AuxInt = int64(int32(c + d))
  1461  		return true
  1462  	}
  1463  	// match: (Add32 (Const32 [d]) (Const32 [c]))
  1464  	// cond:
  1465  	// result: (Const32 [int64(int32(c+d))])
  1466  	for {
  1467  		_ = v.Args[1]
  1468  		v_0 := v.Args[0]
  1469  		if v_0.Op != OpConst32 {
  1470  			break
  1471  		}
  1472  		d := v_0.AuxInt
  1473  		v_1 := v.Args[1]
  1474  		if v_1.Op != OpConst32 {
  1475  			break
  1476  		}
  1477  		c := v_1.AuxInt
  1478  		v.reset(OpConst32)
  1479  		v.AuxInt = int64(int32(c + d))
  1480  		return true
  1481  	}
  1482  	// match: (Add32 <t> (Mul32 x y) (Mul32 x z))
  1483  	// cond:
  1484  	// result: (Mul32 x (Add32 <t> y z))
  1485  	for {
  1486  		t := v.Type
  1487  		_ = v.Args[1]
  1488  		v_0 := v.Args[0]
  1489  		if v_0.Op != OpMul32 {
  1490  			break
  1491  		}
  1492  		_ = v_0.Args[1]
  1493  		x := v_0.Args[0]
  1494  		y := v_0.Args[1]
  1495  		v_1 := v.Args[1]
  1496  		if v_1.Op != OpMul32 {
  1497  			break
  1498  		}
  1499  		_ = v_1.Args[1]
  1500  		if x != v_1.Args[0] {
  1501  			break
  1502  		}
  1503  		z := v_1.Args[1]
  1504  		v.reset(OpMul32)
  1505  		v.AddArg(x)
  1506  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1507  		v0.AddArg(y)
  1508  		v0.AddArg(z)
  1509  		v.AddArg(v0)
  1510  		return true
  1511  	}
  1512  	// match: (Add32 <t> (Mul32 y x) (Mul32 x z))
  1513  	// cond:
  1514  	// result: (Mul32 x (Add32 <t> y z))
  1515  	for {
  1516  		t := v.Type
  1517  		_ = v.Args[1]
  1518  		v_0 := v.Args[0]
  1519  		if v_0.Op != OpMul32 {
  1520  			break
  1521  		}
  1522  		_ = v_0.Args[1]
  1523  		y := v_0.Args[0]
  1524  		x := v_0.Args[1]
  1525  		v_1 := v.Args[1]
  1526  		if v_1.Op != OpMul32 {
  1527  			break
  1528  		}
  1529  		_ = v_1.Args[1]
  1530  		if x != v_1.Args[0] {
  1531  			break
  1532  		}
  1533  		z := v_1.Args[1]
  1534  		v.reset(OpMul32)
  1535  		v.AddArg(x)
  1536  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1537  		v0.AddArg(y)
  1538  		v0.AddArg(z)
  1539  		v.AddArg(v0)
  1540  		return true
  1541  	}
  1542  	// match: (Add32 <t> (Mul32 x y) (Mul32 z x))
  1543  	// cond:
  1544  	// result: (Mul32 x (Add32 <t> y z))
  1545  	for {
  1546  		t := v.Type
  1547  		_ = v.Args[1]
  1548  		v_0 := v.Args[0]
  1549  		if v_0.Op != OpMul32 {
  1550  			break
  1551  		}
  1552  		_ = v_0.Args[1]
  1553  		x := v_0.Args[0]
  1554  		y := v_0.Args[1]
  1555  		v_1 := v.Args[1]
  1556  		if v_1.Op != OpMul32 {
  1557  			break
  1558  		}
  1559  		_ = v_1.Args[1]
  1560  		z := v_1.Args[0]
  1561  		if x != v_1.Args[1] {
  1562  			break
  1563  		}
  1564  		v.reset(OpMul32)
  1565  		v.AddArg(x)
  1566  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1567  		v0.AddArg(y)
  1568  		v0.AddArg(z)
  1569  		v.AddArg(v0)
  1570  		return true
  1571  	}
  1572  	// match: (Add32 <t> (Mul32 y x) (Mul32 z x))
  1573  	// cond:
  1574  	// result: (Mul32 x (Add32 <t> y z))
  1575  	for {
  1576  		t := v.Type
  1577  		_ = v.Args[1]
  1578  		v_0 := v.Args[0]
  1579  		if v_0.Op != OpMul32 {
  1580  			break
  1581  		}
  1582  		_ = v_0.Args[1]
  1583  		y := v_0.Args[0]
  1584  		x := v_0.Args[1]
  1585  		v_1 := v.Args[1]
  1586  		if v_1.Op != OpMul32 {
  1587  			break
  1588  		}
  1589  		_ = v_1.Args[1]
  1590  		z := v_1.Args[0]
  1591  		if x != v_1.Args[1] {
  1592  			break
  1593  		}
  1594  		v.reset(OpMul32)
  1595  		v.AddArg(x)
  1596  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1597  		v0.AddArg(y)
  1598  		v0.AddArg(z)
  1599  		v.AddArg(v0)
  1600  		return true
  1601  	}
  1602  	// match: (Add32 <t> (Mul32 x z) (Mul32 x y))
  1603  	// cond:
  1604  	// result: (Mul32 x (Add32 <t> y z))
  1605  	for {
  1606  		t := v.Type
  1607  		_ = v.Args[1]
  1608  		v_0 := v.Args[0]
  1609  		if v_0.Op != OpMul32 {
  1610  			break
  1611  		}
  1612  		_ = v_0.Args[1]
  1613  		x := v_0.Args[0]
  1614  		z := v_0.Args[1]
  1615  		v_1 := v.Args[1]
  1616  		if v_1.Op != OpMul32 {
  1617  			break
  1618  		}
  1619  		_ = v_1.Args[1]
  1620  		if x != v_1.Args[0] {
  1621  			break
  1622  		}
  1623  		y := v_1.Args[1]
  1624  		v.reset(OpMul32)
  1625  		v.AddArg(x)
  1626  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1627  		v0.AddArg(y)
  1628  		v0.AddArg(z)
  1629  		v.AddArg(v0)
  1630  		return true
  1631  	}
  1632  	// match: (Add32 <t> (Mul32 z x) (Mul32 x y))
  1633  	// cond:
  1634  	// result: (Mul32 x (Add32 <t> y z))
  1635  	for {
  1636  		t := v.Type
  1637  		_ = v.Args[1]
  1638  		v_0 := v.Args[0]
  1639  		if v_0.Op != OpMul32 {
  1640  			break
  1641  		}
  1642  		_ = v_0.Args[1]
  1643  		z := v_0.Args[0]
  1644  		x := v_0.Args[1]
  1645  		v_1 := v.Args[1]
  1646  		if v_1.Op != OpMul32 {
  1647  			break
  1648  		}
  1649  		_ = v_1.Args[1]
  1650  		if x != v_1.Args[0] {
  1651  			break
  1652  		}
  1653  		y := v_1.Args[1]
  1654  		v.reset(OpMul32)
  1655  		v.AddArg(x)
  1656  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1657  		v0.AddArg(y)
  1658  		v0.AddArg(z)
  1659  		v.AddArg(v0)
  1660  		return true
  1661  	}
  1662  	// match: (Add32 <t> (Mul32 x z) (Mul32 y x))
  1663  	// cond:
  1664  	// result: (Mul32 x (Add32 <t> y z))
  1665  	for {
  1666  		t := v.Type
  1667  		_ = v.Args[1]
  1668  		v_0 := v.Args[0]
  1669  		if v_0.Op != OpMul32 {
  1670  			break
  1671  		}
  1672  		_ = v_0.Args[1]
  1673  		x := v_0.Args[0]
  1674  		z := v_0.Args[1]
  1675  		v_1 := v.Args[1]
  1676  		if v_1.Op != OpMul32 {
  1677  			break
  1678  		}
  1679  		_ = v_1.Args[1]
  1680  		y := v_1.Args[0]
  1681  		if x != v_1.Args[1] {
  1682  			break
  1683  		}
  1684  		v.reset(OpMul32)
  1685  		v.AddArg(x)
  1686  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1687  		v0.AddArg(y)
  1688  		v0.AddArg(z)
  1689  		v.AddArg(v0)
  1690  		return true
  1691  	}
  1692  	// match: (Add32 <t> (Mul32 z x) (Mul32 y x))
  1693  	// cond:
  1694  	// result: (Mul32 x (Add32 <t> y z))
  1695  	for {
  1696  		t := v.Type
  1697  		_ = v.Args[1]
  1698  		v_0 := v.Args[0]
  1699  		if v_0.Op != OpMul32 {
  1700  			break
  1701  		}
  1702  		_ = v_0.Args[1]
  1703  		z := v_0.Args[0]
  1704  		x := v_0.Args[1]
  1705  		v_1 := v.Args[1]
  1706  		if v_1.Op != OpMul32 {
  1707  			break
  1708  		}
  1709  		_ = v_1.Args[1]
  1710  		y := v_1.Args[0]
  1711  		if x != v_1.Args[1] {
  1712  			break
  1713  		}
  1714  		v.reset(OpMul32)
  1715  		v.AddArg(x)
  1716  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1717  		v0.AddArg(y)
  1718  		v0.AddArg(z)
  1719  		v.AddArg(v0)
  1720  		return true
  1721  	}
  1722  	return false
  1723  }
  1724  func rewriteValuegeneric_OpAdd32_10(v *Value) bool {
  1725  	b := v.Block
  1726  	_ = b
  1727  	// match: (Add32 (Const32 [0]) x)
  1728  	// cond:
  1729  	// result: x
  1730  	for {
  1731  		_ = v.Args[1]
  1732  		v_0 := v.Args[0]
  1733  		if v_0.Op != OpConst32 {
  1734  			break
  1735  		}
  1736  		if v_0.AuxInt != 0 {
  1737  			break
  1738  		}
  1739  		x := v.Args[1]
  1740  		v.reset(OpCopy)
  1741  		v.Type = x.Type
  1742  		v.AddArg(x)
  1743  		return true
  1744  	}
  1745  	// match: (Add32 x (Const32 [0]))
  1746  	// cond:
  1747  	// result: x
  1748  	for {
  1749  		_ = v.Args[1]
  1750  		x := v.Args[0]
  1751  		v_1 := v.Args[1]
  1752  		if v_1.Op != OpConst32 {
  1753  			break
  1754  		}
  1755  		if v_1.AuxInt != 0 {
  1756  			break
  1757  		}
  1758  		v.reset(OpCopy)
  1759  		v.Type = x.Type
  1760  		v.AddArg(x)
  1761  		return true
  1762  	}
  1763  	// match: (Add32 (Const32 [1]) (Com32 x))
  1764  	// cond:
  1765  	// result: (Neg32 x)
  1766  	for {
  1767  		_ = v.Args[1]
  1768  		v_0 := v.Args[0]
  1769  		if v_0.Op != OpConst32 {
  1770  			break
  1771  		}
  1772  		if v_0.AuxInt != 1 {
  1773  			break
  1774  		}
  1775  		v_1 := v.Args[1]
  1776  		if v_1.Op != OpCom32 {
  1777  			break
  1778  		}
  1779  		x := v_1.Args[0]
  1780  		v.reset(OpNeg32)
  1781  		v.AddArg(x)
  1782  		return true
  1783  	}
  1784  	// match: (Add32 (Com32 x) (Const32 [1]))
  1785  	// cond:
  1786  	// result: (Neg32 x)
  1787  	for {
  1788  		_ = v.Args[1]
  1789  		v_0 := v.Args[0]
  1790  		if v_0.Op != OpCom32 {
  1791  			break
  1792  		}
  1793  		x := v_0.Args[0]
  1794  		v_1 := v.Args[1]
  1795  		if v_1.Op != OpConst32 {
  1796  			break
  1797  		}
  1798  		if v_1.AuxInt != 1 {
  1799  			break
  1800  		}
  1801  		v.reset(OpNeg32)
  1802  		v.AddArg(x)
  1803  		return true
  1804  	}
  1805  	// match: (Add32 (Add32 i:(Const32 <t>) z) x)
  1806  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1807  	// result: (Add32 i (Add32 <t> z x))
  1808  	for {
  1809  		_ = v.Args[1]
  1810  		v_0 := v.Args[0]
  1811  		if v_0.Op != OpAdd32 {
  1812  			break
  1813  		}
  1814  		_ = v_0.Args[1]
  1815  		i := v_0.Args[0]
  1816  		if i.Op != OpConst32 {
  1817  			break
  1818  		}
  1819  		t := i.Type
  1820  		z := v_0.Args[1]
  1821  		x := v.Args[1]
  1822  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1823  			break
  1824  		}
  1825  		v.reset(OpAdd32)
  1826  		v.AddArg(i)
  1827  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1828  		v0.AddArg(z)
  1829  		v0.AddArg(x)
  1830  		v.AddArg(v0)
  1831  		return true
  1832  	}
  1833  	// match: (Add32 (Add32 z i:(Const32 <t>)) x)
  1834  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1835  	// result: (Add32 i (Add32 <t> z x))
  1836  	for {
  1837  		_ = v.Args[1]
  1838  		v_0 := v.Args[0]
  1839  		if v_0.Op != OpAdd32 {
  1840  			break
  1841  		}
  1842  		_ = v_0.Args[1]
  1843  		z := v_0.Args[0]
  1844  		i := v_0.Args[1]
  1845  		if i.Op != OpConst32 {
  1846  			break
  1847  		}
  1848  		t := i.Type
  1849  		x := v.Args[1]
  1850  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1851  			break
  1852  		}
  1853  		v.reset(OpAdd32)
  1854  		v.AddArg(i)
  1855  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1856  		v0.AddArg(z)
  1857  		v0.AddArg(x)
  1858  		v.AddArg(v0)
  1859  		return true
  1860  	}
  1861  	// match: (Add32 x (Add32 i:(Const32 <t>) z))
  1862  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1863  	// result: (Add32 i (Add32 <t> z x))
  1864  	for {
  1865  		_ = v.Args[1]
  1866  		x := v.Args[0]
  1867  		v_1 := v.Args[1]
  1868  		if v_1.Op != OpAdd32 {
  1869  			break
  1870  		}
  1871  		_ = v_1.Args[1]
  1872  		i := v_1.Args[0]
  1873  		if i.Op != OpConst32 {
  1874  			break
  1875  		}
  1876  		t := i.Type
  1877  		z := v_1.Args[1]
  1878  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1879  			break
  1880  		}
  1881  		v.reset(OpAdd32)
  1882  		v.AddArg(i)
  1883  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1884  		v0.AddArg(z)
  1885  		v0.AddArg(x)
  1886  		v.AddArg(v0)
  1887  		return true
  1888  	}
  1889  	// match: (Add32 x (Add32 z i:(Const32 <t>)))
  1890  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1891  	// result: (Add32 i (Add32 <t> z x))
  1892  	for {
  1893  		_ = v.Args[1]
  1894  		x := v.Args[0]
  1895  		v_1 := v.Args[1]
  1896  		if v_1.Op != OpAdd32 {
  1897  			break
  1898  		}
  1899  		_ = v_1.Args[1]
  1900  		z := v_1.Args[0]
  1901  		i := v_1.Args[1]
  1902  		if i.Op != OpConst32 {
  1903  			break
  1904  		}
  1905  		t := i.Type
  1906  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1907  			break
  1908  		}
  1909  		v.reset(OpAdd32)
  1910  		v.AddArg(i)
  1911  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  1912  		v0.AddArg(z)
  1913  		v0.AddArg(x)
  1914  		v.AddArg(v0)
  1915  		return true
  1916  	}
  1917  	// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
  1918  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1919  	// result: (Add32 i (Sub32 <t> x z))
  1920  	for {
  1921  		_ = v.Args[1]
  1922  		v_0 := v.Args[0]
  1923  		if v_0.Op != OpSub32 {
  1924  			break
  1925  		}
  1926  		_ = v_0.Args[1]
  1927  		i := v_0.Args[0]
  1928  		if i.Op != OpConst32 {
  1929  			break
  1930  		}
  1931  		t := i.Type
  1932  		z := v_0.Args[1]
  1933  		x := v.Args[1]
  1934  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1935  			break
  1936  		}
  1937  		v.reset(OpAdd32)
  1938  		v.AddArg(i)
  1939  		v0 := b.NewValue0(v.Pos, OpSub32, t)
  1940  		v0.AddArg(x)
  1941  		v0.AddArg(z)
  1942  		v.AddArg(v0)
  1943  		return true
  1944  	}
  1945  	// match: (Add32 x (Sub32 i:(Const32 <t>) z))
  1946  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1947  	// result: (Add32 i (Sub32 <t> x z))
  1948  	for {
  1949  		_ = v.Args[1]
  1950  		x := v.Args[0]
  1951  		v_1 := v.Args[1]
  1952  		if v_1.Op != OpSub32 {
  1953  			break
  1954  		}
  1955  		_ = v_1.Args[1]
  1956  		i := v_1.Args[0]
  1957  		if i.Op != OpConst32 {
  1958  			break
  1959  		}
  1960  		t := i.Type
  1961  		z := v_1.Args[1]
  1962  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1963  			break
  1964  		}
  1965  		v.reset(OpAdd32)
  1966  		v.AddArg(i)
  1967  		v0 := b.NewValue0(v.Pos, OpSub32, t)
  1968  		v0.AddArg(x)
  1969  		v0.AddArg(z)
  1970  		v.AddArg(v0)
  1971  		return true
  1972  	}
  1973  	return false
  1974  }
  1975  func rewriteValuegeneric_OpAdd32_20(v *Value) bool {
  1976  	b := v.Block
  1977  	_ = b
  1978  	// match: (Add32 x (Sub32 i:(Const32 <t>) z))
  1979  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  1980  	// result: (Add32 i (Sub32 <t> x z))
  1981  	for {
  1982  		_ = v.Args[1]
  1983  		x := v.Args[0]
  1984  		v_1 := v.Args[1]
  1985  		if v_1.Op != OpSub32 {
  1986  			break
  1987  		}
  1988  		_ = v_1.Args[1]
  1989  		i := v_1.Args[0]
  1990  		if i.Op != OpConst32 {
  1991  			break
  1992  		}
  1993  		t := i.Type
  1994  		z := v_1.Args[1]
  1995  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  1996  			break
  1997  		}
  1998  		v.reset(OpAdd32)
  1999  		v.AddArg(i)
  2000  		v0 := b.NewValue0(v.Pos, OpSub32, t)
  2001  		v0.AddArg(x)
  2002  		v0.AddArg(z)
  2003  		v.AddArg(v0)
  2004  		return true
  2005  	}
  2006  	// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
  2007  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2008  	// result: (Add32 i (Sub32 <t> x z))
  2009  	for {
  2010  		_ = v.Args[1]
  2011  		v_0 := v.Args[0]
  2012  		if v_0.Op != OpSub32 {
  2013  			break
  2014  		}
  2015  		_ = v_0.Args[1]
  2016  		i := v_0.Args[0]
  2017  		if i.Op != OpConst32 {
  2018  			break
  2019  		}
  2020  		t := i.Type
  2021  		z := v_0.Args[1]
  2022  		x := v.Args[1]
  2023  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2024  			break
  2025  		}
  2026  		v.reset(OpAdd32)
  2027  		v.AddArg(i)
  2028  		v0 := b.NewValue0(v.Pos, OpSub32, t)
  2029  		v0.AddArg(x)
  2030  		v0.AddArg(z)
  2031  		v.AddArg(v0)
  2032  		return true
  2033  	}
  2034  	// match: (Add32 (Sub32 z i:(Const32 <t>)) x)
  2035  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2036  	// result: (Sub32 (Add32 <t> x z) i)
  2037  	for {
  2038  		_ = v.Args[1]
  2039  		v_0 := v.Args[0]
  2040  		if v_0.Op != OpSub32 {
  2041  			break
  2042  		}
  2043  		_ = v_0.Args[1]
  2044  		z := v_0.Args[0]
  2045  		i := v_0.Args[1]
  2046  		if i.Op != OpConst32 {
  2047  			break
  2048  		}
  2049  		t := i.Type
  2050  		x := v.Args[1]
  2051  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2052  			break
  2053  		}
  2054  		v.reset(OpSub32)
  2055  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2056  		v0.AddArg(x)
  2057  		v0.AddArg(z)
  2058  		v.AddArg(v0)
  2059  		v.AddArg(i)
  2060  		return true
  2061  	}
  2062  	// match: (Add32 x (Sub32 z i:(Const32 <t>)))
  2063  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2064  	// result: (Sub32 (Add32 <t> x z) i)
  2065  	for {
  2066  		_ = v.Args[1]
  2067  		x := v.Args[0]
  2068  		v_1 := v.Args[1]
  2069  		if v_1.Op != OpSub32 {
  2070  			break
  2071  		}
  2072  		_ = v_1.Args[1]
  2073  		z := v_1.Args[0]
  2074  		i := v_1.Args[1]
  2075  		if i.Op != OpConst32 {
  2076  			break
  2077  		}
  2078  		t := i.Type
  2079  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2080  			break
  2081  		}
  2082  		v.reset(OpSub32)
  2083  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2084  		v0.AddArg(x)
  2085  		v0.AddArg(z)
  2086  		v.AddArg(v0)
  2087  		v.AddArg(i)
  2088  		return true
  2089  	}
  2090  	// match: (Add32 x (Sub32 z i:(Const32 <t>)))
  2091  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2092  	// result: (Sub32 (Add32 <t> x z) i)
  2093  	for {
  2094  		_ = v.Args[1]
  2095  		x := v.Args[0]
  2096  		v_1 := v.Args[1]
  2097  		if v_1.Op != OpSub32 {
  2098  			break
  2099  		}
  2100  		_ = v_1.Args[1]
  2101  		z := v_1.Args[0]
  2102  		i := v_1.Args[1]
  2103  		if i.Op != OpConst32 {
  2104  			break
  2105  		}
  2106  		t := i.Type
  2107  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2108  			break
  2109  		}
  2110  		v.reset(OpSub32)
  2111  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2112  		v0.AddArg(x)
  2113  		v0.AddArg(z)
  2114  		v.AddArg(v0)
  2115  		v.AddArg(i)
  2116  		return true
  2117  	}
  2118  	// match: (Add32 (Sub32 z i:(Const32 <t>)) x)
  2119  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  2120  	// result: (Sub32 (Add32 <t> x z) i)
  2121  	for {
  2122  		_ = v.Args[1]
  2123  		v_0 := v.Args[0]
  2124  		if v_0.Op != OpSub32 {
  2125  			break
  2126  		}
  2127  		_ = v_0.Args[1]
  2128  		z := v_0.Args[0]
  2129  		i := v_0.Args[1]
  2130  		if i.Op != OpConst32 {
  2131  			break
  2132  		}
  2133  		t := i.Type
  2134  		x := v.Args[1]
  2135  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  2136  			break
  2137  		}
  2138  		v.reset(OpSub32)
  2139  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  2140  		v0.AddArg(x)
  2141  		v0.AddArg(z)
  2142  		v.AddArg(v0)
  2143  		v.AddArg(i)
  2144  		return true
  2145  	}
  2146  	// match: (Add32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
  2147  	// cond:
  2148  	// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2149  	for {
  2150  		_ = v.Args[1]
  2151  		v_0 := v.Args[0]
  2152  		if v_0.Op != OpConst32 {
  2153  			break
  2154  		}
  2155  		t := v_0.Type
  2156  		c := v_0.AuxInt
  2157  		v_1 := v.Args[1]
  2158  		if v_1.Op != OpAdd32 {
  2159  			break
  2160  		}
  2161  		_ = v_1.Args[1]
  2162  		v_1_0 := v_1.Args[0]
  2163  		if v_1_0.Op != OpConst32 {
  2164  			break
  2165  		}
  2166  		if v_1_0.Type != t {
  2167  			break
  2168  		}
  2169  		d := v_1_0.AuxInt
  2170  		x := v_1.Args[1]
  2171  		v.reset(OpAdd32)
  2172  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2173  		v0.AuxInt = int64(int32(c + d))
  2174  		v.AddArg(v0)
  2175  		v.AddArg(x)
  2176  		return true
  2177  	}
  2178  	// match: (Add32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d])))
  2179  	// cond:
  2180  	// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2181  	for {
  2182  		_ = v.Args[1]
  2183  		v_0 := v.Args[0]
  2184  		if v_0.Op != OpConst32 {
  2185  			break
  2186  		}
  2187  		t := v_0.Type
  2188  		c := v_0.AuxInt
  2189  		v_1 := v.Args[1]
  2190  		if v_1.Op != OpAdd32 {
  2191  			break
  2192  		}
  2193  		_ = v_1.Args[1]
  2194  		x := v_1.Args[0]
  2195  		v_1_1 := v_1.Args[1]
  2196  		if v_1_1.Op != OpConst32 {
  2197  			break
  2198  		}
  2199  		if v_1_1.Type != t {
  2200  			break
  2201  		}
  2202  		d := v_1_1.AuxInt
  2203  		v.reset(OpAdd32)
  2204  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2205  		v0.AuxInt = int64(int32(c + d))
  2206  		v.AddArg(v0)
  2207  		v.AddArg(x)
  2208  		return true
  2209  	}
  2210  	// match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  2211  	// cond:
  2212  	// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2213  	for {
  2214  		_ = v.Args[1]
  2215  		v_0 := v.Args[0]
  2216  		if v_0.Op != OpAdd32 {
  2217  			break
  2218  		}
  2219  		_ = v_0.Args[1]
  2220  		v_0_0 := v_0.Args[0]
  2221  		if v_0_0.Op != OpConst32 {
  2222  			break
  2223  		}
  2224  		t := v_0_0.Type
  2225  		d := v_0_0.AuxInt
  2226  		x := v_0.Args[1]
  2227  		v_1 := v.Args[1]
  2228  		if v_1.Op != OpConst32 {
  2229  			break
  2230  		}
  2231  		if v_1.Type != t {
  2232  			break
  2233  		}
  2234  		c := v_1.AuxInt
  2235  		v.reset(OpAdd32)
  2236  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2237  		v0.AuxInt = int64(int32(c + d))
  2238  		v.AddArg(v0)
  2239  		v.AddArg(x)
  2240  		return true
  2241  	}
  2242  	// match: (Add32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c]))
  2243  	// cond:
  2244  	// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
  2245  	for {
  2246  		_ = v.Args[1]
  2247  		v_0 := v.Args[0]
  2248  		if v_0.Op != OpAdd32 {
  2249  			break
  2250  		}
  2251  		_ = v_0.Args[1]
  2252  		x := v_0.Args[0]
  2253  		v_0_1 := v_0.Args[1]
  2254  		if v_0_1.Op != OpConst32 {
  2255  			break
  2256  		}
  2257  		t := v_0_1.Type
  2258  		d := v_0_1.AuxInt
  2259  		v_1 := v.Args[1]
  2260  		if v_1.Op != OpConst32 {
  2261  			break
  2262  		}
  2263  		if v_1.Type != t {
  2264  			break
  2265  		}
  2266  		c := v_1.AuxInt
  2267  		v.reset(OpAdd32)
  2268  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2269  		v0.AuxInt = int64(int32(c + d))
  2270  		v.AddArg(v0)
  2271  		v.AddArg(x)
  2272  		return true
  2273  	}
  2274  	return false
  2275  }
  2276  func rewriteValuegeneric_OpAdd32_30(v *Value) bool {
  2277  	b := v.Block
  2278  	_ = b
  2279  	// match: (Add32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
  2280  	// cond:
  2281  	// result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x)
  2282  	for {
  2283  		_ = v.Args[1]
  2284  		v_0 := v.Args[0]
  2285  		if v_0.Op != OpConst32 {
  2286  			break
  2287  		}
  2288  		t := v_0.Type
  2289  		c := v_0.AuxInt
  2290  		v_1 := v.Args[1]
  2291  		if v_1.Op != OpSub32 {
  2292  			break
  2293  		}
  2294  		_ = v_1.Args[1]
  2295  		v_1_0 := v_1.Args[0]
  2296  		if v_1_0.Op != OpConst32 {
  2297  			break
  2298  		}
  2299  		if v_1_0.Type != t {
  2300  			break
  2301  		}
  2302  		d := v_1_0.AuxInt
  2303  		x := v_1.Args[1]
  2304  		v.reset(OpSub32)
  2305  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2306  		v0.AuxInt = int64(int32(c + d))
  2307  		v.AddArg(v0)
  2308  		v.AddArg(x)
  2309  		return true
  2310  	}
  2311  	// match: (Add32 (Sub32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  2312  	// cond:
  2313  	// result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x)
  2314  	for {
  2315  		_ = v.Args[1]
  2316  		v_0 := v.Args[0]
  2317  		if v_0.Op != OpSub32 {
  2318  			break
  2319  		}
  2320  		_ = v_0.Args[1]
  2321  		v_0_0 := v_0.Args[0]
  2322  		if v_0_0.Op != OpConst32 {
  2323  			break
  2324  		}
  2325  		t := v_0_0.Type
  2326  		d := v_0_0.AuxInt
  2327  		x := v_0.Args[1]
  2328  		v_1 := v.Args[1]
  2329  		if v_1.Op != OpConst32 {
  2330  			break
  2331  		}
  2332  		if v_1.Type != t {
  2333  			break
  2334  		}
  2335  		c := v_1.AuxInt
  2336  		v.reset(OpSub32)
  2337  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2338  		v0.AuxInt = int64(int32(c + d))
  2339  		v.AddArg(v0)
  2340  		v.AddArg(x)
  2341  		return true
  2342  	}
  2343  	// match: (Add32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d])))
  2344  	// cond:
  2345  	// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
  2346  	for {
  2347  		_ = v.Args[1]
  2348  		v_0 := v.Args[0]
  2349  		if v_0.Op != OpConst32 {
  2350  			break
  2351  		}
  2352  		t := v_0.Type
  2353  		c := v_0.AuxInt
  2354  		v_1 := v.Args[1]
  2355  		if v_1.Op != OpSub32 {
  2356  			break
  2357  		}
  2358  		_ = v_1.Args[1]
  2359  		x := v_1.Args[0]
  2360  		v_1_1 := v_1.Args[1]
  2361  		if v_1_1.Op != OpConst32 {
  2362  			break
  2363  		}
  2364  		if v_1_1.Type != t {
  2365  			break
  2366  		}
  2367  		d := v_1_1.AuxInt
  2368  		v.reset(OpAdd32)
  2369  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2370  		v0.AuxInt = int64(int32(c - d))
  2371  		v.AddArg(v0)
  2372  		v.AddArg(x)
  2373  		return true
  2374  	}
  2375  	// match: (Add32 (Sub32 x (Const32 <t> [d])) (Const32 <t> [c]))
  2376  	// cond:
  2377  	// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
  2378  	for {
  2379  		_ = v.Args[1]
  2380  		v_0 := v.Args[0]
  2381  		if v_0.Op != OpSub32 {
  2382  			break
  2383  		}
  2384  		_ = v_0.Args[1]
  2385  		x := v_0.Args[0]
  2386  		v_0_1 := v_0.Args[1]
  2387  		if v_0_1.Op != OpConst32 {
  2388  			break
  2389  		}
  2390  		t := v_0_1.Type
  2391  		d := v_0_1.AuxInt
  2392  		v_1 := v.Args[1]
  2393  		if v_1.Op != OpConst32 {
  2394  			break
  2395  		}
  2396  		if v_1.Type != t {
  2397  			break
  2398  		}
  2399  		c := v_1.AuxInt
  2400  		v.reset(OpAdd32)
  2401  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  2402  		v0.AuxInt = int64(int32(c - d))
  2403  		v.AddArg(v0)
  2404  		v.AddArg(x)
  2405  		return true
  2406  	}
  2407  	return false
  2408  }
  2409  func rewriteValuegeneric_OpAdd32F_0(v *Value) bool {
  2410  	// match: (Add32F (Const32F [c]) (Const32F [d]))
  2411  	// cond:
  2412  	// result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))])
  2413  	for {
  2414  		_ = v.Args[1]
  2415  		v_0 := v.Args[0]
  2416  		if v_0.Op != OpConst32F {
  2417  			break
  2418  		}
  2419  		c := v_0.AuxInt
  2420  		v_1 := v.Args[1]
  2421  		if v_1.Op != OpConst32F {
  2422  			break
  2423  		}
  2424  		d := v_1.AuxInt
  2425  		v.reset(OpConst32F)
  2426  		v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d))
  2427  		return true
  2428  	}
  2429  	// match: (Add32F (Const32F [d]) (Const32F [c]))
  2430  	// cond:
  2431  	// result: (Const32F [auxFrom32F(auxTo32F(c) + auxTo32F(d))])
  2432  	for {
  2433  		_ = v.Args[1]
  2434  		v_0 := v.Args[0]
  2435  		if v_0.Op != OpConst32F {
  2436  			break
  2437  		}
  2438  		d := v_0.AuxInt
  2439  		v_1 := v.Args[1]
  2440  		if v_1.Op != OpConst32F {
  2441  			break
  2442  		}
  2443  		c := v_1.AuxInt
  2444  		v.reset(OpConst32F)
  2445  		v.AuxInt = auxFrom32F(auxTo32F(c) + auxTo32F(d))
  2446  		return true
  2447  	}
  2448  	return false
  2449  }
  2450  func rewriteValuegeneric_OpAdd64_0(v *Value) bool {
  2451  	b := v.Block
  2452  	_ = b
  2453  	// match: (Add64 (Const64 [c]) (Const64 [d]))
  2454  	// cond:
  2455  	// result: (Const64 [c+d])
  2456  	for {
  2457  		_ = v.Args[1]
  2458  		v_0 := v.Args[0]
  2459  		if v_0.Op != OpConst64 {
  2460  			break
  2461  		}
  2462  		c := v_0.AuxInt
  2463  		v_1 := v.Args[1]
  2464  		if v_1.Op != OpConst64 {
  2465  			break
  2466  		}
  2467  		d := v_1.AuxInt
  2468  		v.reset(OpConst64)
  2469  		v.AuxInt = c + d
  2470  		return true
  2471  	}
  2472  	// match: (Add64 (Const64 [d]) (Const64 [c]))
  2473  	// cond:
  2474  	// result: (Const64 [c+d])
  2475  	for {
  2476  		_ = v.Args[1]
  2477  		v_0 := v.Args[0]
  2478  		if v_0.Op != OpConst64 {
  2479  			break
  2480  		}
  2481  		d := v_0.AuxInt
  2482  		v_1 := v.Args[1]
  2483  		if v_1.Op != OpConst64 {
  2484  			break
  2485  		}
  2486  		c := v_1.AuxInt
  2487  		v.reset(OpConst64)
  2488  		v.AuxInt = c + d
  2489  		return true
  2490  	}
  2491  	// match: (Add64 <t> (Mul64 x y) (Mul64 x z))
  2492  	// cond:
  2493  	// result: (Mul64 x (Add64 <t> y z))
  2494  	for {
  2495  		t := v.Type
  2496  		_ = v.Args[1]
  2497  		v_0 := v.Args[0]
  2498  		if v_0.Op != OpMul64 {
  2499  			break
  2500  		}
  2501  		_ = v_0.Args[1]
  2502  		x := v_0.Args[0]
  2503  		y := v_0.Args[1]
  2504  		v_1 := v.Args[1]
  2505  		if v_1.Op != OpMul64 {
  2506  			break
  2507  		}
  2508  		_ = v_1.Args[1]
  2509  		if x != v_1.Args[0] {
  2510  			break
  2511  		}
  2512  		z := v_1.Args[1]
  2513  		v.reset(OpMul64)
  2514  		v.AddArg(x)
  2515  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2516  		v0.AddArg(y)
  2517  		v0.AddArg(z)
  2518  		v.AddArg(v0)
  2519  		return true
  2520  	}
  2521  	// match: (Add64 <t> (Mul64 y x) (Mul64 x z))
  2522  	// cond:
  2523  	// result: (Mul64 x (Add64 <t> y z))
  2524  	for {
  2525  		t := v.Type
  2526  		_ = v.Args[1]
  2527  		v_0 := v.Args[0]
  2528  		if v_0.Op != OpMul64 {
  2529  			break
  2530  		}
  2531  		_ = v_0.Args[1]
  2532  		y := v_0.Args[0]
  2533  		x := v_0.Args[1]
  2534  		v_1 := v.Args[1]
  2535  		if v_1.Op != OpMul64 {
  2536  			break
  2537  		}
  2538  		_ = v_1.Args[1]
  2539  		if x != v_1.Args[0] {
  2540  			break
  2541  		}
  2542  		z := v_1.Args[1]
  2543  		v.reset(OpMul64)
  2544  		v.AddArg(x)
  2545  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2546  		v0.AddArg(y)
  2547  		v0.AddArg(z)
  2548  		v.AddArg(v0)
  2549  		return true
  2550  	}
  2551  	// match: (Add64 <t> (Mul64 x y) (Mul64 z x))
  2552  	// cond:
  2553  	// result: (Mul64 x (Add64 <t> y z))
  2554  	for {
  2555  		t := v.Type
  2556  		_ = v.Args[1]
  2557  		v_0 := v.Args[0]
  2558  		if v_0.Op != OpMul64 {
  2559  			break
  2560  		}
  2561  		_ = v_0.Args[1]
  2562  		x := v_0.Args[0]
  2563  		y := v_0.Args[1]
  2564  		v_1 := v.Args[1]
  2565  		if v_1.Op != OpMul64 {
  2566  			break
  2567  		}
  2568  		_ = v_1.Args[1]
  2569  		z := v_1.Args[0]
  2570  		if x != v_1.Args[1] {
  2571  			break
  2572  		}
  2573  		v.reset(OpMul64)
  2574  		v.AddArg(x)
  2575  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2576  		v0.AddArg(y)
  2577  		v0.AddArg(z)
  2578  		v.AddArg(v0)
  2579  		return true
  2580  	}
  2581  	// match: (Add64 <t> (Mul64 y x) (Mul64 z x))
  2582  	// cond:
  2583  	// result: (Mul64 x (Add64 <t> y z))
  2584  	for {
  2585  		t := v.Type
  2586  		_ = v.Args[1]
  2587  		v_0 := v.Args[0]
  2588  		if v_0.Op != OpMul64 {
  2589  			break
  2590  		}
  2591  		_ = v_0.Args[1]
  2592  		y := v_0.Args[0]
  2593  		x := v_0.Args[1]
  2594  		v_1 := v.Args[1]
  2595  		if v_1.Op != OpMul64 {
  2596  			break
  2597  		}
  2598  		_ = v_1.Args[1]
  2599  		z := v_1.Args[0]
  2600  		if x != v_1.Args[1] {
  2601  			break
  2602  		}
  2603  		v.reset(OpMul64)
  2604  		v.AddArg(x)
  2605  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2606  		v0.AddArg(y)
  2607  		v0.AddArg(z)
  2608  		v.AddArg(v0)
  2609  		return true
  2610  	}
  2611  	// match: (Add64 <t> (Mul64 x z) (Mul64 x y))
  2612  	// cond:
  2613  	// result: (Mul64 x (Add64 <t> y z))
  2614  	for {
  2615  		t := v.Type
  2616  		_ = v.Args[1]
  2617  		v_0 := v.Args[0]
  2618  		if v_0.Op != OpMul64 {
  2619  			break
  2620  		}
  2621  		_ = v_0.Args[1]
  2622  		x := v_0.Args[0]
  2623  		z := v_0.Args[1]
  2624  		v_1 := v.Args[1]
  2625  		if v_1.Op != OpMul64 {
  2626  			break
  2627  		}
  2628  		_ = v_1.Args[1]
  2629  		if x != v_1.Args[0] {
  2630  			break
  2631  		}
  2632  		y := v_1.Args[1]
  2633  		v.reset(OpMul64)
  2634  		v.AddArg(x)
  2635  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2636  		v0.AddArg(y)
  2637  		v0.AddArg(z)
  2638  		v.AddArg(v0)
  2639  		return true
  2640  	}
  2641  	// match: (Add64 <t> (Mul64 z x) (Mul64 x y))
  2642  	// cond:
  2643  	// result: (Mul64 x (Add64 <t> y z))
  2644  	for {
  2645  		t := v.Type
  2646  		_ = v.Args[1]
  2647  		v_0 := v.Args[0]
  2648  		if v_0.Op != OpMul64 {
  2649  			break
  2650  		}
  2651  		_ = v_0.Args[1]
  2652  		z := v_0.Args[0]
  2653  		x := v_0.Args[1]
  2654  		v_1 := v.Args[1]
  2655  		if v_1.Op != OpMul64 {
  2656  			break
  2657  		}
  2658  		_ = v_1.Args[1]
  2659  		if x != v_1.Args[0] {
  2660  			break
  2661  		}
  2662  		y := v_1.Args[1]
  2663  		v.reset(OpMul64)
  2664  		v.AddArg(x)
  2665  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2666  		v0.AddArg(y)
  2667  		v0.AddArg(z)
  2668  		v.AddArg(v0)
  2669  		return true
  2670  	}
  2671  	// match: (Add64 <t> (Mul64 x z) (Mul64 y x))
  2672  	// cond:
  2673  	// result: (Mul64 x (Add64 <t> y z))
  2674  	for {
  2675  		t := v.Type
  2676  		_ = v.Args[1]
  2677  		v_0 := v.Args[0]
  2678  		if v_0.Op != OpMul64 {
  2679  			break
  2680  		}
  2681  		_ = v_0.Args[1]
  2682  		x := v_0.Args[0]
  2683  		z := v_0.Args[1]
  2684  		v_1 := v.Args[1]
  2685  		if v_1.Op != OpMul64 {
  2686  			break
  2687  		}
  2688  		_ = v_1.Args[1]
  2689  		y := v_1.Args[0]
  2690  		if x != v_1.Args[1] {
  2691  			break
  2692  		}
  2693  		v.reset(OpMul64)
  2694  		v.AddArg(x)
  2695  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2696  		v0.AddArg(y)
  2697  		v0.AddArg(z)
  2698  		v.AddArg(v0)
  2699  		return true
  2700  	}
  2701  	// match: (Add64 <t> (Mul64 z x) (Mul64 y x))
  2702  	// cond:
  2703  	// result: (Mul64 x (Add64 <t> y z))
  2704  	for {
  2705  		t := v.Type
  2706  		_ = v.Args[1]
  2707  		v_0 := v.Args[0]
  2708  		if v_0.Op != OpMul64 {
  2709  			break
  2710  		}
  2711  		_ = v_0.Args[1]
  2712  		z := v_0.Args[0]
  2713  		x := v_0.Args[1]
  2714  		v_1 := v.Args[1]
  2715  		if v_1.Op != OpMul64 {
  2716  			break
  2717  		}
  2718  		_ = v_1.Args[1]
  2719  		y := v_1.Args[0]
  2720  		if x != v_1.Args[1] {
  2721  			break
  2722  		}
  2723  		v.reset(OpMul64)
  2724  		v.AddArg(x)
  2725  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2726  		v0.AddArg(y)
  2727  		v0.AddArg(z)
  2728  		v.AddArg(v0)
  2729  		return true
  2730  	}
  2731  	return false
  2732  }
  2733  func rewriteValuegeneric_OpAdd64_10(v *Value) bool {
  2734  	b := v.Block
  2735  	_ = b
  2736  	// match: (Add64 (Const64 [0]) x)
  2737  	// cond:
  2738  	// result: x
  2739  	for {
  2740  		_ = v.Args[1]
  2741  		v_0 := v.Args[0]
  2742  		if v_0.Op != OpConst64 {
  2743  			break
  2744  		}
  2745  		if v_0.AuxInt != 0 {
  2746  			break
  2747  		}
  2748  		x := v.Args[1]
  2749  		v.reset(OpCopy)
  2750  		v.Type = x.Type
  2751  		v.AddArg(x)
  2752  		return true
  2753  	}
  2754  	// match: (Add64 x (Const64 [0]))
  2755  	// cond:
  2756  	// result: x
  2757  	for {
  2758  		_ = v.Args[1]
  2759  		x := v.Args[0]
  2760  		v_1 := v.Args[1]
  2761  		if v_1.Op != OpConst64 {
  2762  			break
  2763  		}
  2764  		if v_1.AuxInt != 0 {
  2765  			break
  2766  		}
  2767  		v.reset(OpCopy)
  2768  		v.Type = x.Type
  2769  		v.AddArg(x)
  2770  		return true
  2771  	}
  2772  	// match: (Add64 (Const64 [1]) (Com64 x))
  2773  	// cond:
  2774  	// result: (Neg64 x)
  2775  	for {
  2776  		_ = v.Args[1]
  2777  		v_0 := v.Args[0]
  2778  		if v_0.Op != OpConst64 {
  2779  			break
  2780  		}
  2781  		if v_0.AuxInt != 1 {
  2782  			break
  2783  		}
  2784  		v_1 := v.Args[1]
  2785  		if v_1.Op != OpCom64 {
  2786  			break
  2787  		}
  2788  		x := v_1.Args[0]
  2789  		v.reset(OpNeg64)
  2790  		v.AddArg(x)
  2791  		return true
  2792  	}
  2793  	// match: (Add64 (Com64 x) (Const64 [1]))
  2794  	// cond:
  2795  	// result: (Neg64 x)
  2796  	for {
  2797  		_ = v.Args[1]
  2798  		v_0 := v.Args[0]
  2799  		if v_0.Op != OpCom64 {
  2800  			break
  2801  		}
  2802  		x := v_0.Args[0]
  2803  		v_1 := v.Args[1]
  2804  		if v_1.Op != OpConst64 {
  2805  			break
  2806  		}
  2807  		if v_1.AuxInt != 1 {
  2808  			break
  2809  		}
  2810  		v.reset(OpNeg64)
  2811  		v.AddArg(x)
  2812  		return true
  2813  	}
  2814  	// match: (Add64 (Add64 i:(Const64 <t>) z) x)
  2815  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2816  	// result: (Add64 i (Add64 <t> z x))
  2817  	for {
  2818  		_ = v.Args[1]
  2819  		v_0 := v.Args[0]
  2820  		if v_0.Op != OpAdd64 {
  2821  			break
  2822  		}
  2823  		_ = v_0.Args[1]
  2824  		i := v_0.Args[0]
  2825  		if i.Op != OpConst64 {
  2826  			break
  2827  		}
  2828  		t := i.Type
  2829  		z := v_0.Args[1]
  2830  		x := v.Args[1]
  2831  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2832  			break
  2833  		}
  2834  		v.reset(OpAdd64)
  2835  		v.AddArg(i)
  2836  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2837  		v0.AddArg(z)
  2838  		v0.AddArg(x)
  2839  		v.AddArg(v0)
  2840  		return true
  2841  	}
  2842  	// match: (Add64 (Add64 z i:(Const64 <t>)) x)
  2843  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2844  	// result: (Add64 i (Add64 <t> z x))
  2845  	for {
  2846  		_ = v.Args[1]
  2847  		v_0 := v.Args[0]
  2848  		if v_0.Op != OpAdd64 {
  2849  			break
  2850  		}
  2851  		_ = v_0.Args[1]
  2852  		z := v_0.Args[0]
  2853  		i := v_0.Args[1]
  2854  		if i.Op != OpConst64 {
  2855  			break
  2856  		}
  2857  		t := i.Type
  2858  		x := v.Args[1]
  2859  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2860  			break
  2861  		}
  2862  		v.reset(OpAdd64)
  2863  		v.AddArg(i)
  2864  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2865  		v0.AddArg(z)
  2866  		v0.AddArg(x)
  2867  		v.AddArg(v0)
  2868  		return true
  2869  	}
  2870  	// match: (Add64 x (Add64 i:(Const64 <t>) z))
  2871  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2872  	// result: (Add64 i (Add64 <t> z x))
  2873  	for {
  2874  		_ = v.Args[1]
  2875  		x := v.Args[0]
  2876  		v_1 := v.Args[1]
  2877  		if v_1.Op != OpAdd64 {
  2878  			break
  2879  		}
  2880  		_ = v_1.Args[1]
  2881  		i := v_1.Args[0]
  2882  		if i.Op != OpConst64 {
  2883  			break
  2884  		}
  2885  		t := i.Type
  2886  		z := v_1.Args[1]
  2887  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2888  			break
  2889  		}
  2890  		v.reset(OpAdd64)
  2891  		v.AddArg(i)
  2892  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2893  		v0.AddArg(z)
  2894  		v0.AddArg(x)
  2895  		v.AddArg(v0)
  2896  		return true
  2897  	}
  2898  	// match: (Add64 x (Add64 z i:(Const64 <t>)))
  2899  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2900  	// result: (Add64 i (Add64 <t> z x))
  2901  	for {
  2902  		_ = v.Args[1]
  2903  		x := v.Args[0]
  2904  		v_1 := v.Args[1]
  2905  		if v_1.Op != OpAdd64 {
  2906  			break
  2907  		}
  2908  		_ = v_1.Args[1]
  2909  		z := v_1.Args[0]
  2910  		i := v_1.Args[1]
  2911  		if i.Op != OpConst64 {
  2912  			break
  2913  		}
  2914  		t := i.Type
  2915  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2916  			break
  2917  		}
  2918  		v.reset(OpAdd64)
  2919  		v.AddArg(i)
  2920  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  2921  		v0.AddArg(z)
  2922  		v0.AddArg(x)
  2923  		v.AddArg(v0)
  2924  		return true
  2925  	}
  2926  	// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
  2927  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2928  	// result: (Add64 i (Sub64 <t> x z))
  2929  	for {
  2930  		_ = v.Args[1]
  2931  		v_0 := v.Args[0]
  2932  		if v_0.Op != OpSub64 {
  2933  			break
  2934  		}
  2935  		_ = v_0.Args[1]
  2936  		i := v_0.Args[0]
  2937  		if i.Op != OpConst64 {
  2938  			break
  2939  		}
  2940  		t := i.Type
  2941  		z := v_0.Args[1]
  2942  		x := v.Args[1]
  2943  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2944  			break
  2945  		}
  2946  		v.reset(OpAdd64)
  2947  		v.AddArg(i)
  2948  		v0 := b.NewValue0(v.Pos, OpSub64, t)
  2949  		v0.AddArg(x)
  2950  		v0.AddArg(z)
  2951  		v.AddArg(v0)
  2952  		return true
  2953  	}
  2954  	// match: (Add64 x (Sub64 i:(Const64 <t>) z))
  2955  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2956  	// result: (Add64 i (Sub64 <t> x z))
  2957  	for {
  2958  		_ = v.Args[1]
  2959  		x := v.Args[0]
  2960  		v_1 := v.Args[1]
  2961  		if v_1.Op != OpSub64 {
  2962  			break
  2963  		}
  2964  		_ = v_1.Args[1]
  2965  		i := v_1.Args[0]
  2966  		if i.Op != OpConst64 {
  2967  			break
  2968  		}
  2969  		t := i.Type
  2970  		z := v_1.Args[1]
  2971  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  2972  			break
  2973  		}
  2974  		v.reset(OpAdd64)
  2975  		v.AddArg(i)
  2976  		v0 := b.NewValue0(v.Pos, OpSub64, t)
  2977  		v0.AddArg(x)
  2978  		v0.AddArg(z)
  2979  		v.AddArg(v0)
  2980  		return true
  2981  	}
  2982  	return false
  2983  }
  2984  func rewriteValuegeneric_OpAdd64_20(v *Value) bool {
  2985  	b := v.Block
  2986  	_ = b
  2987  	// match: (Add64 x (Sub64 i:(Const64 <t>) z))
  2988  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  2989  	// result: (Add64 i (Sub64 <t> x z))
  2990  	for {
  2991  		_ = v.Args[1]
  2992  		x := v.Args[0]
  2993  		v_1 := v.Args[1]
  2994  		if v_1.Op != OpSub64 {
  2995  			break
  2996  		}
  2997  		_ = v_1.Args[1]
  2998  		i := v_1.Args[0]
  2999  		if i.Op != OpConst64 {
  3000  			break
  3001  		}
  3002  		t := i.Type
  3003  		z := v_1.Args[1]
  3004  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3005  			break
  3006  		}
  3007  		v.reset(OpAdd64)
  3008  		v.AddArg(i)
  3009  		v0 := b.NewValue0(v.Pos, OpSub64, t)
  3010  		v0.AddArg(x)
  3011  		v0.AddArg(z)
  3012  		v.AddArg(v0)
  3013  		return true
  3014  	}
  3015  	// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
  3016  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3017  	// result: (Add64 i (Sub64 <t> x z))
  3018  	for {
  3019  		_ = v.Args[1]
  3020  		v_0 := v.Args[0]
  3021  		if v_0.Op != OpSub64 {
  3022  			break
  3023  		}
  3024  		_ = v_0.Args[1]
  3025  		i := v_0.Args[0]
  3026  		if i.Op != OpConst64 {
  3027  			break
  3028  		}
  3029  		t := i.Type
  3030  		z := v_0.Args[1]
  3031  		x := v.Args[1]
  3032  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3033  			break
  3034  		}
  3035  		v.reset(OpAdd64)
  3036  		v.AddArg(i)
  3037  		v0 := b.NewValue0(v.Pos, OpSub64, t)
  3038  		v0.AddArg(x)
  3039  		v0.AddArg(z)
  3040  		v.AddArg(v0)
  3041  		return true
  3042  	}
  3043  	// match: (Add64 (Sub64 z i:(Const64 <t>)) x)
  3044  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3045  	// result: (Sub64 (Add64 <t> x z) i)
  3046  	for {
  3047  		_ = v.Args[1]
  3048  		v_0 := v.Args[0]
  3049  		if v_0.Op != OpSub64 {
  3050  			break
  3051  		}
  3052  		_ = v_0.Args[1]
  3053  		z := v_0.Args[0]
  3054  		i := v_0.Args[1]
  3055  		if i.Op != OpConst64 {
  3056  			break
  3057  		}
  3058  		t := i.Type
  3059  		x := v.Args[1]
  3060  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3061  			break
  3062  		}
  3063  		v.reset(OpSub64)
  3064  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3065  		v0.AddArg(x)
  3066  		v0.AddArg(z)
  3067  		v.AddArg(v0)
  3068  		v.AddArg(i)
  3069  		return true
  3070  	}
  3071  	// match: (Add64 x (Sub64 z i:(Const64 <t>)))
  3072  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3073  	// result: (Sub64 (Add64 <t> x z) i)
  3074  	for {
  3075  		_ = v.Args[1]
  3076  		x := v.Args[0]
  3077  		v_1 := v.Args[1]
  3078  		if v_1.Op != OpSub64 {
  3079  			break
  3080  		}
  3081  		_ = v_1.Args[1]
  3082  		z := v_1.Args[0]
  3083  		i := v_1.Args[1]
  3084  		if i.Op != OpConst64 {
  3085  			break
  3086  		}
  3087  		t := i.Type
  3088  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3089  			break
  3090  		}
  3091  		v.reset(OpSub64)
  3092  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3093  		v0.AddArg(x)
  3094  		v0.AddArg(z)
  3095  		v.AddArg(v0)
  3096  		v.AddArg(i)
  3097  		return true
  3098  	}
  3099  	// match: (Add64 x (Sub64 z i:(Const64 <t>)))
  3100  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3101  	// result: (Sub64 (Add64 <t> x z) i)
  3102  	for {
  3103  		_ = v.Args[1]
  3104  		x := v.Args[0]
  3105  		v_1 := v.Args[1]
  3106  		if v_1.Op != OpSub64 {
  3107  			break
  3108  		}
  3109  		_ = v_1.Args[1]
  3110  		z := v_1.Args[0]
  3111  		i := v_1.Args[1]
  3112  		if i.Op != OpConst64 {
  3113  			break
  3114  		}
  3115  		t := i.Type
  3116  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3117  			break
  3118  		}
  3119  		v.reset(OpSub64)
  3120  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3121  		v0.AddArg(x)
  3122  		v0.AddArg(z)
  3123  		v.AddArg(v0)
  3124  		v.AddArg(i)
  3125  		return true
  3126  	}
  3127  	// match: (Add64 (Sub64 z i:(Const64 <t>)) x)
  3128  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  3129  	// result: (Sub64 (Add64 <t> x z) i)
  3130  	for {
  3131  		_ = v.Args[1]
  3132  		v_0 := v.Args[0]
  3133  		if v_0.Op != OpSub64 {
  3134  			break
  3135  		}
  3136  		_ = v_0.Args[1]
  3137  		z := v_0.Args[0]
  3138  		i := v_0.Args[1]
  3139  		if i.Op != OpConst64 {
  3140  			break
  3141  		}
  3142  		t := i.Type
  3143  		x := v.Args[1]
  3144  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  3145  			break
  3146  		}
  3147  		v.reset(OpSub64)
  3148  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  3149  		v0.AddArg(x)
  3150  		v0.AddArg(z)
  3151  		v.AddArg(v0)
  3152  		v.AddArg(i)
  3153  		return true
  3154  	}
  3155  	// match: (Add64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
  3156  	// cond:
  3157  	// result: (Add64 (Const64 <t> [c+d]) x)
  3158  	for {
  3159  		_ = v.Args[1]
  3160  		v_0 := v.Args[0]
  3161  		if v_0.Op != OpConst64 {
  3162  			break
  3163  		}
  3164  		t := v_0.Type
  3165  		c := v_0.AuxInt
  3166  		v_1 := v.Args[1]
  3167  		if v_1.Op != OpAdd64 {
  3168  			break
  3169  		}
  3170  		_ = v_1.Args[1]
  3171  		v_1_0 := v_1.Args[0]
  3172  		if v_1_0.Op != OpConst64 {
  3173  			break
  3174  		}
  3175  		if v_1_0.Type != t {
  3176  			break
  3177  		}
  3178  		d := v_1_0.AuxInt
  3179  		x := v_1.Args[1]
  3180  		v.reset(OpAdd64)
  3181  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3182  		v0.AuxInt = c + d
  3183  		v.AddArg(v0)
  3184  		v.AddArg(x)
  3185  		return true
  3186  	}
  3187  	// match: (Add64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d])))
  3188  	// cond:
  3189  	// result: (Add64 (Const64 <t> [c+d]) x)
  3190  	for {
  3191  		_ = v.Args[1]
  3192  		v_0 := v.Args[0]
  3193  		if v_0.Op != OpConst64 {
  3194  			break
  3195  		}
  3196  		t := v_0.Type
  3197  		c := v_0.AuxInt
  3198  		v_1 := v.Args[1]
  3199  		if v_1.Op != OpAdd64 {
  3200  			break
  3201  		}
  3202  		_ = v_1.Args[1]
  3203  		x := v_1.Args[0]
  3204  		v_1_1 := v_1.Args[1]
  3205  		if v_1_1.Op != OpConst64 {
  3206  			break
  3207  		}
  3208  		if v_1_1.Type != t {
  3209  			break
  3210  		}
  3211  		d := v_1_1.AuxInt
  3212  		v.reset(OpAdd64)
  3213  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3214  		v0.AuxInt = c + d
  3215  		v.AddArg(v0)
  3216  		v.AddArg(x)
  3217  		return true
  3218  	}
  3219  	// match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  3220  	// cond:
  3221  	// result: (Add64 (Const64 <t> [c+d]) x)
  3222  	for {
  3223  		_ = v.Args[1]
  3224  		v_0 := v.Args[0]
  3225  		if v_0.Op != OpAdd64 {
  3226  			break
  3227  		}
  3228  		_ = v_0.Args[1]
  3229  		v_0_0 := v_0.Args[0]
  3230  		if v_0_0.Op != OpConst64 {
  3231  			break
  3232  		}
  3233  		t := v_0_0.Type
  3234  		d := v_0_0.AuxInt
  3235  		x := v_0.Args[1]
  3236  		v_1 := v.Args[1]
  3237  		if v_1.Op != OpConst64 {
  3238  			break
  3239  		}
  3240  		if v_1.Type != t {
  3241  			break
  3242  		}
  3243  		c := v_1.AuxInt
  3244  		v.reset(OpAdd64)
  3245  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3246  		v0.AuxInt = c + d
  3247  		v.AddArg(v0)
  3248  		v.AddArg(x)
  3249  		return true
  3250  	}
  3251  	// match: (Add64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c]))
  3252  	// cond:
  3253  	// result: (Add64 (Const64 <t> [c+d]) x)
  3254  	for {
  3255  		_ = v.Args[1]
  3256  		v_0 := v.Args[0]
  3257  		if v_0.Op != OpAdd64 {
  3258  			break
  3259  		}
  3260  		_ = v_0.Args[1]
  3261  		x := v_0.Args[0]
  3262  		v_0_1 := v_0.Args[1]
  3263  		if v_0_1.Op != OpConst64 {
  3264  			break
  3265  		}
  3266  		t := v_0_1.Type
  3267  		d := v_0_1.AuxInt
  3268  		v_1 := v.Args[1]
  3269  		if v_1.Op != OpConst64 {
  3270  			break
  3271  		}
  3272  		if v_1.Type != t {
  3273  			break
  3274  		}
  3275  		c := v_1.AuxInt
  3276  		v.reset(OpAdd64)
  3277  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3278  		v0.AuxInt = c + d
  3279  		v.AddArg(v0)
  3280  		v.AddArg(x)
  3281  		return true
  3282  	}
  3283  	return false
  3284  }
  3285  func rewriteValuegeneric_OpAdd64_30(v *Value) bool {
  3286  	b := v.Block
  3287  	_ = b
  3288  	// match: (Add64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
  3289  	// cond:
  3290  	// result: (Sub64 (Const64 <t> [c+d]) x)
  3291  	for {
  3292  		_ = v.Args[1]
  3293  		v_0 := v.Args[0]
  3294  		if v_0.Op != OpConst64 {
  3295  			break
  3296  		}
  3297  		t := v_0.Type
  3298  		c := v_0.AuxInt
  3299  		v_1 := v.Args[1]
  3300  		if v_1.Op != OpSub64 {
  3301  			break
  3302  		}
  3303  		_ = v_1.Args[1]
  3304  		v_1_0 := v_1.Args[0]
  3305  		if v_1_0.Op != OpConst64 {
  3306  			break
  3307  		}
  3308  		if v_1_0.Type != t {
  3309  			break
  3310  		}
  3311  		d := v_1_0.AuxInt
  3312  		x := v_1.Args[1]
  3313  		v.reset(OpSub64)
  3314  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3315  		v0.AuxInt = c + d
  3316  		v.AddArg(v0)
  3317  		v.AddArg(x)
  3318  		return true
  3319  	}
  3320  	// match: (Add64 (Sub64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  3321  	// cond:
  3322  	// result: (Sub64 (Const64 <t> [c+d]) x)
  3323  	for {
  3324  		_ = v.Args[1]
  3325  		v_0 := v.Args[0]
  3326  		if v_0.Op != OpSub64 {
  3327  			break
  3328  		}
  3329  		_ = v_0.Args[1]
  3330  		v_0_0 := v_0.Args[0]
  3331  		if v_0_0.Op != OpConst64 {
  3332  			break
  3333  		}
  3334  		t := v_0_0.Type
  3335  		d := v_0_0.AuxInt
  3336  		x := v_0.Args[1]
  3337  		v_1 := v.Args[1]
  3338  		if v_1.Op != OpConst64 {
  3339  			break
  3340  		}
  3341  		if v_1.Type != t {
  3342  			break
  3343  		}
  3344  		c := v_1.AuxInt
  3345  		v.reset(OpSub64)
  3346  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3347  		v0.AuxInt = c + d
  3348  		v.AddArg(v0)
  3349  		v.AddArg(x)
  3350  		return true
  3351  	}
  3352  	// match: (Add64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d])))
  3353  	// cond:
  3354  	// result: (Add64 (Const64 <t> [c-d]) x)
  3355  	for {
  3356  		_ = v.Args[1]
  3357  		v_0 := v.Args[0]
  3358  		if v_0.Op != OpConst64 {
  3359  			break
  3360  		}
  3361  		t := v_0.Type
  3362  		c := v_0.AuxInt
  3363  		v_1 := v.Args[1]
  3364  		if v_1.Op != OpSub64 {
  3365  			break
  3366  		}
  3367  		_ = v_1.Args[1]
  3368  		x := v_1.Args[0]
  3369  		v_1_1 := v_1.Args[1]
  3370  		if v_1_1.Op != OpConst64 {
  3371  			break
  3372  		}
  3373  		if v_1_1.Type != t {
  3374  			break
  3375  		}
  3376  		d := v_1_1.AuxInt
  3377  		v.reset(OpAdd64)
  3378  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3379  		v0.AuxInt = c - d
  3380  		v.AddArg(v0)
  3381  		v.AddArg(x)
  3382  		return true
  3383  	}
  3384  	// match: (Add64 (Sub64 x (Const64 <t> [d])) (Const64 <t> [c]))
  3385  	// cond:
  3386  	// result: (Add64 (Const64 <t> [c-d]) x)
  3387  	for {
  3388  		_ = v.Args[1]
  3389  		v_0 := v.Args[0]
  3390  		if v_0.Op != OpSub64 {
  3391  			break
  3392  		}
  3393  		_ = v_0.Args[1]
  3394  		x := v_0.Args[0]
  3395  		v_0_1 := v_0.Args[1]
  3396  		if v_0_1.Op != OpConst64 {
  3397  			break
  3398  		}
  3399  		t := v_0_1.Type
  3400  		d := v_0_1.AuxInt
  3401  		v_1 := v.Args[1]
  3402  		if v_1.Op != OpConst64 {
  3403  			break
  3404  		}
  3405  		if v_1.Type != t {
  3406  			break
  3407  		}
  3408  		c := v_1.AuxInt
  3409  		v.reset(OpAdd64)
  3410  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  3411  		v0.AuxInt = c - d
  3412  		v.AddArg(v0)
  3413  		v.AddArg(x)
  3414  		return true
  3415  	}
  3416  	return false
  3417  }
  3418  func rewriteValuegeneric_OpAdd64F_0(v *Value) bool {
  3419  	// match: (Add64F (Const64F [c]) (Const64F [d]))
  3420  	// cond:
  3421  	// result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))])
  3422  	for {
  3423  		_ = v.Args[1]
  3424  		v_0 := v.Args[0]
  3425  		if v_0.Op != OpConst64F {
  3426  			break
  3427  		}
  3428  		c := v_0.AuxInt
  3429  		v_1 := v.Args[1]
  3430  		if v_1.Op != OpConst64F {
  3431  			break
  3432  		}
  3433  		d := v_1.AuxInt
  3434  		v.reset(OpConst64F)
  3435  		v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d))
  3436  		return true
  3437  	}
  3438  	// match: (Add64F (Const64F [d]) (Const64F [c]))
  3439  	// cond:
  3440  	// result: (Const64F [auxFrom64F(auxTo64F(c) + auxTo64F(d))])
  3441  	for {
  3442  		_ = v.Args[1]
  3443  		v_0 := v.Args[0]
  3444  		if v_0.Op != OpConst64F {
  3445  			break
  3446  		}
  3447  		d := v_0.AuxInt
  3448  		v_1 := v.Args[1]
  3449  		if v_1.Op != OpConst64F {
  3450  			break
  3451  		}
  3452  		c := v_1.AuxInt
  3453  		v.reset(OpConst64F)
  3454  		v.AuxInt = auxFrom64F(auxTo64F(c) + auxTo64F(d))
  3455  		return true
  3456  	}
  3457  	return false
  3458  }
  3459  func rewriteValuegeneric_OpAdd8_0(v *Value) bool {
  3460  	b := v.Block
  3461  	_ = b
  3462  	// match: (Add8 (Const8 [c]) (Const8 [d]))
  3463  	// cond:
  3464  	// result: (Const8 [int64(int8(c+d))])
  3465  	for {
  3466  		_ = v.Args[1]
  3467  		v_0 := v.Args[0]
  3468  		if v_0.Op != OpConst8 {
  3469  			break
  3470  		}
  3471  		c := v_0.AuxInt
  3472  		v_1 := v.Args[1]
  3473  		if v_1.Op != OpConst8 {
  3474  			break
  3475  		}
  3476  		d := v_1.AuxInt
  3477  		v.reset(OpConst8)
  3478  		v.AuxInt = int64(int8(c + d))
  3479  		return true
  3480  	}
  3481  	// match: (Add8 (Const8 [d]) (Const8 [c]))
  3482  	// cond:
  3483  	// result: (Const8 [int64(int8(c+d))])
  3484  	for {
  3485  		_ = v.Args[1]
  3486  		v_0 := v.Args[0]
  3487  		if v_0.Op != OpConst8 {
  3488  			break
  3489  		}
  3490  		d := v_0.AuxInt
  3491  		v_1 := v.Args[1]
  3492  		if v_1.Op != OpConst8 {
  3493  			break
  3494  		}
  3495  		c := v_1.AuxInt
  3496  		v.reset(OpConst8)
  3497  		v.AuxInt = int64(int8(c + d))
  3498  		return true
  3499  	}
  3500  	// match: (Add8 <t> (Mul8 x y) (Mul8 x z))
  3501  	// cond:
  3502  	// result: (Mul8 x (Add8 <t> y z))
  3503  	for {
  3504  		t := v.Type
  3505  		_ = v.Args[1]
  3506  		v_0 := v.Args[0]
  3507  		if v_0.Op != OpMul8 {
  3508  			break
  3509  		}
  3510  		_ = v_0.Args[1]
  3511  		x := v_0.Args[0]
  3512  		y := v_0.Args[1]
  3513  		v_1 := v.Args[1]
  3514  		if v_1.Op != OpMul8 {
  3515  			break
  3516  		}
  3517  		_ = v_1.Args[1]
  3518  		if x != v_1.Args[0] {
  3519  			break
  3520  		}
  3521  		z := v_1.Args[1]
  3522  		v.reset(OpMul8)
  3523  		v.AddArg(x)
  3524  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3525  		v0.AddArg(y)
  3526  		v0.AddArg(z)
  3527  		v.AddArg(v0)
  3528  		return true
  3529  	}
  3530  	// match: (Add8 <t> (Mul8 y x) (Mul8 x z))
  3531  	// cond:
  3532  	// result: (Mul8 x (Add8 <t> y z))
  3533  	for {
  3534  		t := v.Type
  3535  		_ = v.Args[1]
  3536  		v_0 := v.Args[0]
  3537  		if v_0.Op != OpMul8 {
  3538  			break
  3539  		}
  3540  		_ = v_0.Args[1]
  3541  		y := v_0.Args[0]
  3542  		x := v_0.Args[1]
  3543  		v_1 := v.Args[1]
  3544  		if v_1.Op != OpMul8 {
  3545  			break
  3546  		}
  3547  		_ = v_1.Args[1]
  3548  		if x != v_1.Args[0] {
  3549  			break
  3550  		}
  3551  		z := v_1.Args[1]
  3552  		v.reset(OpMul8)
  3553  		v.AddArg(x)
  3554  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3555  		v0.AddArg(y)
  3556  		v0.AddArg(z)
  3557  		v.AddArg(v0)
  3558  		return true
  3559  	}
  3560  	// match: (Add8 <t> (Mul8 x y) (Mul8 z x))
  3561  	// cond:
  3562  	// result: (Mul8 x (Add8 <t> y z))
  3563  	for {
  3564  		t := v.Type
  3565  		_ = v.Args[1]
  3566  		v_0 := v.Args[0]
  3567  		if v_0.Op != OpMul8 {
  3568  			break
  3569  		}
  3570  		_ = v_0.Args[1]
  3571  		x := v_0.Args[0]
  3572  		y := v_0.Args[1]
  3573  		v_1 := v.Args[1]
  3574  		if v_1.Op != OpMul8 {
  3575  			break
  3576  		}
  3577  		_ = v_1.Args[1]
  3578  		z := v_1.Args[0]
  3579  		if x != v_1.Args[1] {
  3580  			break
  3581  		}
  3582  		v.reset(OpMul8)
  3583  		v.AddArg(x)
  3584  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3585  		v0.AddArg(y)
  3586  		v0.AddArg(z)
  3587  		v.AddArg(v0)
  3588  		return true
  3589  	}
  3590  	// match: (Add8 <t> (Mul8 y x) (Mul8 z x))
  3591  	// cond:
  3592  	// result: (Mul8 x (Add8 <t> y z))
  3593  	for {
  3594  		t := v.Type
  3595  		_ = v.Args[1]
  3596  		v_0 := v.Args[0]
  3597  		if v_0.Op != OpMul8 {
  3598  			break
  3599  		}
  3600  		_ = v_0.Args[1]
  3601  		y := v_0.Args[0]
  3602  		x := v_0.Args[1]
  3603  		v_1 := v.Args[1]
  3604  		if v_1.Op != OpMul8 {
  3605  			break
  3606  		}
  3607  		_ = v_1.Args[1]
  3608  		z := v_1.Args[0]
  3609  		if x != v_1.Args[1] {
  3610  			break
  3611  		}
  3612  		v.reset(OpMul8)
  3613  		v.AddArg(x)
  3614  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3615  		v0.AddArg(y)
  3616  		v0.AddArg(z)
  3617  		v.AddArg(v0)
  3618  		return true
  3619  	}
  3620  	// match: (Add8 <t> (Mul8 x z) (Mul8 x y))
  3621  	// cond:
  3622  	// result: (Mul8 x (Add8 <t> y z))
  3623  	for {
  3624  		t := v.Type
  3625  		_ = v.Args[1]
  3626  		v_0 := v.Args[0]
  3627  		if v_0.Op != OpMul8 {
  3628  			break
  3629  		}
  3630  		_ = v_0.Args[1]
  3631  		x := v_0.Args[0]
  3632  		z := v_0.Args[1]
  3633  		v_1 := v.Args[1]
  3634  		if v_1.Op != OpMul8 {
  3635  			break
  3636  		}
  3637  		_ = v_1.Args[1]
  3638  		if x != v_1.Args[0] {
  3639  			break
  3640  		}
  3641  		y := v_1.Args[1]
  3642  		v.reset(OpMul8)
  3643  		v.AddArg(x)
  3644  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3645  		v0.AddArg(y)
  3646  		v0.AddArg(z)
  3647  		v.AddArg(v0)
  3648  		return true
  3649  	}
  3650  	// match: (Add8 <t> (Mul8 z x) (Mul8 x y))
  3651  	// cond:
  3652  	// result: (Mul8 x (Add8 <t> y z))
  3653  	for {
  3654  		t := v.Type
  3655  		_ = v.Args[1]
  3656  		v_0 := v.Args[0]
  3657  		if v_0.Op != OpMul8 {
  3658  			break
  3659  		}
  3660  		_ = v_0.Args[1]
  3661  		z := v_0.Args[0]
  3662  		x := v_0.Args[1]
  3663  		v_1 := v.Args[1]
  3664  		if v_1.Op != OpMul8 {
  3665  			break
  3666  		}
  3667  		_ = v_1.Args[1]
  3668  		if x != v_1.Args[0] {
  3669  			break
  3670  		}
  3671  		y := v_1.Args[1]
  3672  		v.reset(OpMul8)
  3673  		v.AddArg(x)
  3674  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3675  		v0.AddArg(y)
  3676  		v0.AddArg(z)
  3677  		v.AddArg(v0)
  3678  		return true
  3679  	}
  3680  	// match: (Add8 <t> (Mul8 x z) (Mul8 y x))
  3681  	// cond:
  3682  	// result: (Mul8 x (Add8 <t> y z))
  3683  	for {
  3684  		t := v.Type
  3685  		_ = v.Args[1]
  3686  		v_0 := v.Args[0]
  3687  		if v_0.Op != OpMul8 {
  3688  			break
  3689  		}
  3690  		_ = v_0.Args[1]
  3691  		x := v_0.Args[0]
  3692  		z := v_0.Args[1]
  3693  		v_1 := v.Args[1]
  3694  		if v_1.Op != OpMul8 {
  3695  			break
  3696  		}
  3697  		_ = v_1.Args[1]
  3698  		y := v_1.Args[0]
  3699  		if x != v_1.Args[1] {
  3700  			break
  3701  		}
  3702  		v.reset(OpMul8)
  3703  		v.AddArg(x)
  3704  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3705  		v0.AddArg(y)
  3706  		v0.AddArg(z)
  3707  		v.AddArg(v0)
  3708  		return true
  3709  	}
  3710  	// match: (Add8 <t> (Mul8 z x) (Mul8 y x))
  3711  	// cond:
  3712  	// result: (Mul8 x (Add8 <t> y z))
  3713  	for {
  3714  		t := v.Type
  3715  		_ = v.Args[1]
  3716  		v_0 := v.Args[0]
  3717  		if v_0.Op != OpMul8 {
  3718  			break
  3719  		}
  3720  		_ = v_0.Args[1]
  3721  		z := v_0.Args[0]
  3722  		x := v_0.Args[1]
  3723  		v_1 := v.Args[1]
  3724  		if v_1.Op != OpMul8 {
  3725  			break
  3726  		}
  3727  		_ = v_1.Args[1]
  3728  		y := v_1.Args[0]
  3729  		if x != v_1.Args[1] {
  3730  			break
  3731  		}
  3732  		v.reset(OpMul8)
  3733  		v.AddArg(x)
  3734  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3735  		v0.AddArg(y)
  3736  		v0.AddArg(z)
  3737  		v.AddArg(v0)
  3738  		return true
  3739  	}
  3740  	return false
  3741  }
  3742  func rewriteValuegeneric_OpAdd8_10(v *Value) bool {
  3743  	b := v.Block
  3744  	_ = b
  3745  	// match: (Add8 (Const8 [0]) x)
  3746  	// cond:
  3747  	// result: x
  3748  	for {
  3749  		_ = v.Args[1]
  3750  		v_0 := v.Args[0]
  3751  		if v_0.Op != OpConst8 {
  3752  			break
  3753  		}
  3754  		if v_0.AuxInt != 0 {
  3755  			break
  3756  		}
  3757  		x := v.Args[1]
  3758  		v.reset(OpCopy)
  3759  		v.Type = x.Type
  3760  		v.AddArg(x)
  3761  		return true
  3762  	}
  3763  	// match: (Add8 x (Const8 [0]))
  3764  	// cond:
  3765  	// result: x
  3766  	for {
  3767  		_ = v.Args[1]
  3768  		x := v.Args[0]
  3769  		v_1 := v.Args[1]
  3770  		if v_1.Op != OpConst8 {
  3771  			break
  3772  		}
  3773  		if v_1.AuxInt != 0 {
  3774  			break
  3775  		}
  3776  		v.reset(OpCopy)
  3777  		v.Type = x.Type
  3778  		v.AddArg(x)
  3779  		return true
  3780  	}
  3781  	// match: (Add8 (Const8 [1]) (Com8 x))
  3782  	// cond:
  3783  	// result: (Neg8 x)
  3784  	for {
  3785  		_ = v.Args[1]
  3786  		v_0 := v.Args[0]
  3787  		if v_0.Op != OpConst8 {
  3788  			break
  3789  		}
  3790  		if v_0.AuxInt != 1 {
  3791  			break
  3792  		}
  3793  		v_1 := v.Args[1]
  3794  		if v_1.Op != OpCom8 {
  3795  			break
  3796  		}
  3797  		x := v_1.Args[0]
  3798  		v.reset(OpNeg8)
  3799  		v.AddArg(x)
  3800  		return true
  3801  	}
  3802  	// match: (Add8 (Com8 x) (Const8 [1]))
  3803  	// cond:
  3804  	// result: (Neg8 x)
  3805  	for {
  3806  		_ = v.Args[1]
  3807  		v_0 := v.Args[0]
  3808  		if v_0.Op != OpCom8 {
  3809  			break
  3810  		}
  3811  		x := v_0.Args[0]
  3812  		v_1 := v.Args[1]
  3813  		if v_1.Op != OpConst8 {
  3814  			break
  3815  		}
  3816  		if v_1.AuxInt != 1 {
  3817  			break
  3818  		}
  3819  		v.reset(OpNeg8)
  3820  		v.AddArg(x)
  3821  		return true
  3822  	}
  3823  	// match: (Add8 (Add8 i:(Const8 <t>) z) x)
  3824  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3825  	// result: (Add8 i (Add8 <t> z x))
  3826  	for {
  3827  		_ = v.Args[1]
  3828  		v_0 := v.Args[0]
  3829  		if v_0.Op != OpAdd8 {
  3830  			break
  3831  		}
  3832  		_ = v_0.Args[1]
  3833  		i := v_0.Args[0]
  3834  		if i.Op != OpConst8 {
  3835  			break
  3836  		}
  3837  		t := i.Type
  3838  		z := v_0.Args[1]
  3839  		x := v.Args[1]
  3840  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3841  			break
  3842  		}
  3843  		v.reset(OpAdd8)
  3844  		v.AddArg(i)
  3845  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3846  		v0.AddArg(z)
  3847  		v0.AddArg(x)
  3848  		v.AddArg(v0)
  3849  		return true
  3850  	}
  3851  	// match: (Add8 (Add8 z i:(Const8 <t>)) x)
  3852  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3853  	// result: (Add8 i (Add8 <t> z x))
  3854  	for {
  3855  		_ = v.Args[1]
  3856  		v_0 := v.Args[0]
  3857  		if v_0.Op != OpAdd8 {
  3858  			break
  3859  		}
  3860  		_ = v_0.Args[1]
  3861  		z := v_0.Args[0]
  3862  		i := v_0.Args[1]
  3863  		if i.Op != OpConst8 {
  3864  			break
  3865  		}
  3866  		t := i.Type
  3867  		x := v.Args[1]
  3868  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3869  			break
  3870  		}
  3871  		v.reset(OpAdd8)
  3872  		v.AddArg(i)
  3873  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3874  		v0.AddArg(z)
  3875  		v0.AddArg(x)
  3876  		v.AddArg(v0)
  3877  		return true
  3878  	}
  3879  	// match: (Add8 x (Add8 i:(Const8 <t>) z))
  3880  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3881  	// result: (Add8 i (Add8 <t> z x))
  3882  	for {
  3883  		_ = v.Args[1]
  3884  		x := v.Args[0]
  3885  		v_1 := v.Args[1]
  3886  		if v_1.Op != OpAdd8 {
  3887  			break
  3888  		}
  3889  		_ = v_1.Args[1]
  3890  		i := v_1.Args[0]
  3891  		if i.Op != OpConst8 {
  3892  			break
  3893  		}
  3894  		t := i.Type
  3895  		z := v_1.Args[1]
  3896  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3897  			break
  3898  		}
  3899  		v.reset(OpAdd8)
  3900  		v.AddArg(i)
  3901  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3902  		v0.AddArg(z)
  3903  		v0.AddArg(x)
  3904  		v.AddArg(v0)
  3905  		return true
  3906  	}
  3907  	// match: (Add8 x (Add8 z i:(Const8 <t>)))
  3908  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3909  	// result: (Add8 i (Add8 <t> z x))
  3910  	for {
  3911  		_ = v.Args[1]
  3912  		x := v.Args[0]
  3913  		v_1 := v.Args[1]
  3914  		if v_1.Op != OpAdd8 {
  3915  			break
  3916  		}
  3917  		_ = v_1.Args[1]
  3918  		z := v_1.Args[0]
  3919  		i := v_1.Args[1]
  3920  		if i.Op != OpConst8 {
  3921  			break
  3922  		}
  3923  		t := i.Type
  3924  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3925  			break
  3926  		}
  3927  		v.reset(OpAdd8)
  3928  		v.AddArg(i)
  3929  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  3930  		v0.AddArg(z)
  3931  		v0.AddArg(x)
  3932  		v.AddArg(v0)
  3933  		return true
  3934  	}
  3935  	// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
  3936  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3937  	// result: (Add8 i (Sub8 <t> x z))
  3938  	for {
  3939  		_ = v.Args[1]
  3940  		v_0 := v.Args[0]
  3941  		if v_0.Op != OpSub8 {
  3942  			break
  3943  		}
  3944  		_ = v_0.Args[1]
  3945  		i := v_0.Args[0]
  3946  		if i.Op != OpConst8 {
  3947  			break
  3948  		}
  3949  		t := i.Type
  3950  		z := v_0.Args[1]
  3951  		x := v.Args[1]
  3952  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3953  			break
  3954  		}
  3955  		v.reset(OpAdd8)
  3956  		v.AddArg(i)
  3957  		v0 := b.NewValue0(v.Pos, OpSub8, t)
  3958  		v0.AddArg(x)
  3959  		v0.AddArg(z)
  3960  		v.AddArg(v0)
  3961  		return true
  3962  	}
  3963  	// match: (Add8 x (Sub8 i:(Const8 <t>) z))
  3964  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3965  	// result: (Add8 i (Sub8 <t> x z))
  3966  	for {
  3967  		_ = v.Args[1]
  3968  		x := v.Args[0]
  3969  		v_1 := v.Args[1]
  3970  		if v_1.Op != OpSub8 {
  3971  			break
  3972  		}
  3973  		_ = v_1.Args[1]
  3974  		i := v_1.Args[0]
  3975  		if i.Op != OpConst8 {
  3976  			break
  3977  		}
  3978  		t := i.Type
  3979  		z := v_1.Args[1]
  3980  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  3981  			break
  3982  		}
  3983  		v.reset(OpAdd8)
  3984  		v.AddArg(i)
  3985  		v0 := b.NewValue0(v.Pos, OpSub8, t)
  3986  		v0.AddArg(x)
  3987  		v0.AddArg(z)
  3988  		v.AddArg(v0)
  3989  		return true
  3990  	}
  3991  	return false
  3992  }
  3993  func rewriteValuegeneric_OpAdd8_20(v *Value) bool {
  3994  	b := v.Block
  3995  	_ = b
  3996  	// match: (Add8 x (Sub8 i:(Const8 <t>) z))
  3997  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  3998  	// result: (Add8 i (Sub8 <t> x z))
  3999  	for {
  4000  		_ = v.Args[1]
  4001  		x := v.Args[0]
  4002  		v_1 := v.Args[1]
  4003  		if v_1.Op != OpSub8 {
  4004  			break
  4005  		}
  4006  		_ = v_1.Args[1]
  4007  		i := v_1.Args[0]
  4008  		if i.Op != OpConst8 {
  4009  			break
  4010  		}
  4011  		t := i.Type
  4012  		z := v_1.Args[1]
  4013  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4014  			break
  4015  		}
  4016  		v.reset(OpAdd8)
  4017  		v.AddArg(i)
  4018  		v0 := b.NewValue0(v.Pos, OpSub8, t)
  4019  		v0.AddArg(x)
  4020  		v0.AddArg(z)
  4021  		v.AddArg(v0)
  4022  		return true
  4023  	}
  4024  	// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
  4025  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  4026  	// result: (Add8 i (Sub8 <t> x z))
  4027  	for {
  4028  		_ = v.Args[1]
  4029  		v_0 := v.Args[0]
  4030  		if v_0.Op != OpSub8 {
  4031  			break
  4032  		}
  4033  		_ = v_0.Args[1]
  4034  		i := v_0.Args[0]
  4035  		if i.Op != OpConst8 {
  4036  			break
  4037  		}
  4038  		t := i.Type
  4039  		z := v_0.Args[1]
  4040  		x := v.Args[1]
  4041  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4042  			break
  4043  		}
  4044  		v.reset(OpAdd8)
  4045  		v.AddArg(i)
  4046  		v0 := b.NewValue0(v.Pos, OpSub8, t)
  4047  		v0.AddArg(x)
  4048  		v0.AddArg(z)
  4049  		v.AddArg(v0)
  4050  		return true
  4051  	}
  4052  	// match: (Add8 (Sub8 z i:(Const8 <t>)) x)
  4053  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  4054  	// result: (Sub8 (Add8 <t> x z) i)
  4055  	for {
  4056  		_ = v.Args[1]
  4057  		v_0 := v.Args[0]
  4058  		if v_0.Op != OpSub8 {
  4059  			break
  4060  		}
  4061  		_ = v_0.Args[1]
  4062  		z := v_0.Args[0]
  4063  		i := v_0.Args[1]
  4064  		if i.Op != OpConst8 {
  4065  			break
  4066  		}
  4067  		t := i.Type
  4068  		x := v.Args[1]
  4069  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4070  			break
  4071  		}
  4072  		v.reset(OpSub8)
  4073  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  4074  		v0.AddArg(x)
  4075  		v0.AddArg(z)
  4076  		v.AddArg(v0)
  4077  		v.AddArg(i)
  4078  		return true
  4079  	}
  4080  	// match: (Add8 x (Sub8 z i:(Const8 <t>)))
  4081  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  4082  	// result: (Sub8 (Add8 <t> x z) i)
  4083  	for {
  4084  		_ = v.Args[1]
  4085  		x := v.Args[0]
  4086  		v_1 := v.Args[1]
  4087  		if v_1.Op != OpSub8 {
  4088  			break
  4089  		}
  4090  		_ = v_1.Args[1]
  4091  		z := v_1.Args[0]
  4092  		i := v_1.Args[1]
  4093  		if i.Op != OpConst8 {
  4094  			break
  4095  		}
  4096  		t := i.Type
  4097  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4098  			break
  4099  		}
  4100  		v.reset(OpSub8)
  4101  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  4102  		v0.AddArg(x)
  4103  		v0.AddArg(z)
  4104  		v.AddArg(v0)
  4105  		v.AddArg(i)
  4106  		return true
  4107  	}
  4108  	// match: (Add8 x (Sub8 z i:(Const8 <t>)))
  4109  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  4110  	// result: (Sub8 (Add8 <t> x z) i)
  4111  	for {
  4112  		_ = v.Args[1]
  4113  		x := v.Args[0]
  4114  		v_1 := v.Args[1]
  4115  		if v_1.Op != OpSub8 {
  4116  			break
  4117  		}
  4118  		_ = v_1.Args[1]
  4119  		z := v_1.Args[0]
  4120  		i := v_1.Args[1]
  4121  		if i.Op != OpConst8 {
  4122  			break
  4123  		}
  4124  		t := i.Type
  4125  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4126  			break
  4127  		}
  4128  		v.reset(OpSub8)
  4129  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  4130  		v0.AddArg(x)
  4131  		v0.AddArg(z)
  4132  		v.AddArg(v0)
  4133  		v.AddArg(i)
  4134  		return true
  4135  	}
  4136  	// match: (Add8 (Sub8 z i:(Const8 <t>)) x)
  4137  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  4138  	// result: (Sub8 (Add8 <t> x z) i)
  4139  	for {
  4140  		_ = v.Args[1]
  4141  		v_0 := v.Args[0]
  4142  		if v_0.Op != OpSub8 {
  4143  			break
  4144  		}
  4145  		_ = v_0.Args[1]
  4146  		z := v_0.Args[0]
  4147  		i := v_0.Args[1]
  4148  		if i.Op != OpConst8 {
  4149  			break
  4150  		}
  4151  		t := i.Type
  4152  		x := v.Args[1]
  4153  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  4154  			break
  4155  		}
  4156  		v.reset(OpSub8)
  4157  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  4158  		v0.AddArg(x)
  4159  		v0.AddArg(z)
  4160  		v.AddArg(v0)
  4161  		v.AddArg(i)
  4162  		return true
  4163  	}
  4164  	// match: (Add8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
  4165  	// cond:
  4166  	// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4167  	for {
  4168  		_ = v.Args[1]
  4169  		v_0 := v.Args[0]
  4170  		if v_0.Op != OpConst8 {
  4171  			break
  4172  		}
  4173  		t := v_0.Type
  4174  		c := v_0.AuxInt
  4175  		v_1 := v.Args[1]
  4176  		if v_1.Op != OpAdd8 {
  4177  			break
  4178  		}
  4179  		_ = v_1.Args[1]
  4180  		v_1_0 := v_1.Args[0]
  4181  		if v_1_0.Op != OpConst8 {
  4182  			break
  4183  		}
  4184  		if v_1_0.Type != t {
  4185  			break
  4186  		}
  4187  		d := v_1_0.AuxInt
  4188  		x := v_1.Args[1]
  4189  		v.reset(OpAdd8)
  4190  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4191  		v0.AuxInt = int64(int8(c + d))
  4192  		v.AddArg(v0)
  4193  		v.AddArg(x)
  4194  		return true
  4195  	}
  4196  	// match: (Add8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d])))
  4197  	// cond:
  4198  	// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4199  	for {
  4200  		_ = v.Args[1]
  4201  		v_0 := v.Args[0]
  4202  		if v_0.Op != OpConst8 {
  4203  			break
  4204  		}
  4205  		t := v_0.Type
  4206  		c := v_0.AuxInt
  4207  		v_1 := v.Args[1]
  4208  		if v_1.Op != OpAdd8 {
  4209  			break
  4210  		}
  4211  		_ = v_1.Args[1]
  4212  		x := v_1.Args[0]
  4213  		v_1_1 := v_1.Args[1]
  4214  		if v_1_1.Op != OpConst8 {
  4215  			break
  4216  		}
  4217  		if v_1_1.Type != t {
  4218  			break
  4219  		}
  4220  		d := v_1_1.AuxInt
  4221  		v.reset(OpAdd8)
  4222  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4223  		v0.AuxInt = int64(int8(c + d))
  4224  		v.AddArg(v0)
  4225  		v.AddArg(x)
  4226  		return true
  4227  	}
  4228  	// match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
  4229  	// cond:
  4230  	// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4231  	for {
  4232  		_ = v.Args[1]
  4233  		v_0 := v.Args[0]
  4234  		if v_0.Op != OpAdd8 {
  4235  			break
  4236  		}
  4237  		_ = v_0.Args[1]
  4238  		v_0_0 := v_0.Args[0]
  4239  		if v_0_0.Op != OpConst8 {
  4240  			break
  4241  		}
  4242  		t := v_0_0.Type
  4243  		d := v_0_0.AuxInt
  4244  		x := v_0.Args[1]
  4245  		v_1 := v.Args[1]
  4246  		if v_1.Op != OpConst8 {
  4247  			break
  4248  		}
  4249  		if v_1.Type != t {
  4250  			break
  4251  		}
  4252  		c := v_1.AuxInt
  4253  		v.reset(OpAdd8)
  4254  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4255  		v0.AuxInt = int64(int8(c + d))
  4256  		v.AddArg(v0)
  4257  		v.AddArg(x)
  4258  		return true
  4259  	}
  4260  	// match: (Add8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c]))
  4261  	// cond:
  4262  	// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
  4263  	for {
  4264  		_ = v.Args[1]
  4265  		v_0 := v.Args[0]
  4266  		if v_0.Op != OpAdd8 {
  4267  			break
  4268  		}
  4269  		_ = v_0.Args[1]
  4270  		x := v_0.Args[0]
  4271  		v_0_1 := v_0.Args[1]
  4272  		if v_0_1.Op != OpConst8 {
  4273  			break
  4274  		}
  4275  		t := v_0_1.Type
  4276  		d := v_0_1.AuxInt
  4277  		v_1 := v.Args[1]
  4278  		if v_1.Op != OpConst8 {
  4279  			break
  4280  		}
  4281  		if v_1.Type != t {
  4282  			break
  4283  		}
  4284  		c := v_1.AuxInt
  4285  		v.reset(OpAdd8)
  4286  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4287  		v0.AuxInt = int64(int8(c + d))
  4288  		v.AddArg(v0)
  4289  		v.AddArg(x)
  4290  		return true
  4291  	}
  4292  	return false
  4293  }
  4294  func rewriteValuegeneric_OpAdd8_30(v *Value) bool {
  4295  	b := v.Block
  4296  	_ = b
  4297  	// match: (Add8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
  4298  	// cond:
  4299  	// result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x)
  4300  	for {
  4301  		_ = v.Args[1]
  4302  		v_0 := v.Args[0]
  4303  		if v_0.Op != OpConst8 {
  4304  			break
  4305  		}
  4306  		t := v_0.Type
  4307  		c := v_0.AuxInt
  4308  		v_1 := v.Args[1]
  4309  		if v_1.Op != OpSub8 {
  4310  			break
  4311  		}
  4312  		_ = v_1.Args[1]
  4313  		v_1_0 := v_1.Args[0]
  4314  		if v_1_0.Op != OpConst8 {
  4315  			break
  4316  		}
  4317  		if v_1_0.Type != t {
  4318  			break
  4319  		}
  4320  		d := v_1_0.AuxInt
  4321  		x := v_1.Args[1]
  4322  		v.reset(OpSub8)
  4323  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4324  		v0.AuxInt = int64(int8(c + d))
  4325  		v.AddArg(v0)
  4326  		v.AddArg(x)
  4327  		return true
  4328  	}
  4329  	// match: (Add8 (Sub8 (Const8 <t> [d]) x) (Const8 <t> [c]))
  4330  	// cond:
  4331  	// result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x)
  4332  	for {
  4333  		_ = v.Args[1]
  4334  		v_0 := v.Args[0]
  4335  		if v_0.Op != OpSub8 {
  4336  			break
  4337  		}
  4338  		_ = v_0.Args[1]
  4339  		v_0_0 := v_0.Args[0]
  4340  		if v_0_0.Op != OpConst8 {
  4341  			break
  4342  		}
  4343  		t := v_0_0.Type
  4344  		d := v_0_0.AuxInt
  4345  		x := v_0.Args[1]
  4346  		v_1 := v.Args[1]
  4347  		if v_1.Op != OpConst8 {
  4348  			break
  4349  		}
  4350  		if v_1.Type != t {
  4351  			break
  4352  		}
  4353  		c := v_1.AuxInt
  4354  		v.reset(OpSub8)
  4355  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4356  		v0.AuxInt = int64(int8(c + d))
  4357  		v.AddArg(v0)
  4358  		v.AddArg(x)
  4359  		return true
  4360  	}
  4361  	// match: (Add8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d])))
  4362  	// cond:
  4363  	// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
  4364  	for {
  4365  		_ = v.Args[1]
  4366  		v_0 := v.Args[0]
  4367  		if v_0.Op != OpConst8 {
  4368  			break
  4369  		}
  4370  		t := v_0.Type
  4371  		c := v_0.AuxInt
  4372  		v_1 := v.Args[1]
  4373  		if v_1.Op != OpSub8 {
  4374  			break
  4375  		}
  4376  		_ = v_1.Args[1]
  4377  		x := v_1.Args[0]
  4378  		v_1_1 := v_1.Args[1]
  4379  		if v_1_1.Op != OpConst8 {
  4380  			break
  4381  		}
  4382  		if v_1_1.Type != t {
  4383  			break
  4384  		}
  4385  		d := v_1_1.AuxInt
  4386  		v.reset(OpAdd8)
  4387  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4388  		v0.AuxInt = int64(int8(c - d))
  4389  		v.AddArg(v0)
  4390  		v.AddArg(x)
  4391  		return true
  4392  	}
  4393  	// match: (Add8 (Sub8 x (Const8 <t> [d])) (Const8 <t> [c]))
  4394  	// cond:
  4395  	// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
  4396  	for {
  4397  		_ = v.Args[1]
  4398  		v_0 := v.Args[0]
  4399  		if v_0.Op != OpSub8 {
  4400  			break
  4401  		}
  4402  		_ = v_0.Args[1]
  4403  		x := v_0.Args[0]
  4404  		v_0_1 := v_0.Args[1]
  4405  		if v_0_1.Op != OpConst8 {
  4406  			break
  4407  		}
  4408  		t := v_0_1.Type
  4409  		d := v_0_1.AuxInt
  4410  		v_1 := v.Args[1]
  4411  		if v_1.Op != OpConst8 {
  4412  			break
  4413  		}
  4414  		if v_1.Type != t {
  4415  			break
  4416  		}
  4417  		c := v_1.AuxInt
  4418  		v.reset(OpAdd8)
  4419  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  4420  		v0.AuxInt = int64(int8(c - d))
  4421  		v.AddArg(v0)
  4422  		v.AddArg(x)
  4423  		return true
  4424  	}
  4425  	return false
  4426  }
  4427  func rewriteValuegeneric_OpAddPtr_0(v *Value) bool {
  4428  	// match: (AddPtr <t> x (Const64 [c]))
  4429  	// cond:
  4430  	// result: (OffPtr <t> x [c])
  4431  	for {
  4432  		t := v.Type
  4433  		_ = v.Args[1]
  4434  		x := v.Args[0]
  4435  		v_1 := v.Args[1]
  4436  		if v_1.Op != OpConst64 {
  4437  			break
  4438  		}
  4439  		c := v_1.AuxInt
  4440  		v.reset(OpOffPtr)
  4441  		v.Type = t
  4442  		v.AuxInt = c
  4443  		v.AddArg(x)
  4444  		return true
  4445  	}
  4446  	// match: (AddPtr <t> x (Const32 [c]))
  4447  	// cond:
  4448  	// result: (OffPtr <t> x [c])
  4449  	for {
  4450  		t := v.Type
  4451  		_ = v.Args[1]
  4452  		x := v.Args[0]
  4453  		v_1 := v.Args[1]
  4454  		if v_1.Op != OpConst32 {
  4455  			break
  4456  		}
  4457  		c := v_1.AuxInt
  4458  		v.reset(OpOffPtr)
  4459  		v.Type = t
  4460  		v.AuxInt = c
  4461  		v.AddArg(x)
  4462  		return true
  4463  	}
  4464  	return false
  4465  }
  4466  func rewriteValuegeneric_OpAnd16_0(v *Value) bool {
  4467  	// match: (And16 (Const16 [c]) (Const16 [d]))
  4468  	// cond:
  4469  	// result: (Const16 [int64(int16(c&d))])
  4470  	for {
  4471  		_ = v.Args[1]
  4472  		v_0 := v.Args[0]
  4473  		if v_0.Op != OpConst16 {
  4474  			break
  4475  		}
  4476  		c := v_0.AuxInt
  4477  		v_1 := v.Args[1]
  4478  		if v_1.Op != OpConst16 {
  4479  			break
  4480  		}
  4481  		d := v_1.AuxInt
  4482  		v.reset(OpConst16)
  4483  		v.AuxInt = int64(int16(c & d))
  4484  		return true
  4485  	}
  4486  	// match: (And16 (Const16 [d]) (Const16 [c]))
  4487  	// cond:
  4488  	// result: (Const16 [int64(int16(c&d))])
  4489  	for {
  4490  		_ = v.Args[1]
  4491  		v_0 := v.Args[0]
  4492  		if v_0.Op != OpConst16 {
  4493  			break
  4494  		}
  4495  		d := v_0.AuxInt
  4496  		v_1 := v.Args[1]
  4497  		if v_1.Op != OpConst16 {
  4498  			break
  4499  		}
  4500  		c := v_1.AuxInt
  4501  		v.reset(OpConst16)
  4502  		v.AuxInt = int64(int16(c & d))
  4503  		return true
  4504  	}
  4505  	// match: (And16 (Const16 [m]) (Rsh16Ux64 _ (Const64 [c])))
  4506  	// cond: c >= 64-ntz(m)
  4507  	// result: (Const16 [0])
  4508  	for {
  4509  		_ = v.Args[1]
  4510  		v_0 := v.Args[0]
  4511  		if v_0.Op != OpConst16 {
  4512  			break
  4513  		}
  4514  		m := v_0.AuxInt
  4515  		v_1 := v.Args[1]
  4516  		if v_1.Op != OpRsh16Ux64 {
  4517  			break
  4518  		}
  4519  		_ = v_1.Args[1]
  4520  		v_1_1 := v_1.Args[1]
  4521  		if v_1_1.Op != OpConst64 {
  4522  			break
  4523  		}
  4524  		c := v_1_1.AuxInt
  4525  		if !(c >= 64-ntz(m)) {
  4526  			break
  4527  		}
  4528  		v.reset(OpConst16)
  4529  		v.AuxInt = 0
  4530  		return true
  4531  	}
  4532  	// match: (And16 (Rsh16Ux64 _ (Const64 [c])) (Const16 [m]))
  4533  	// cond: c >= 64-ntz(m)
  4534  	// result: (Const16 [0])
  4535  	for {
  4536  		_ = v.Args[1]
  4537  		v_0 := v.Args[0]
  4538  		if v_0.Op != OpRsh16Ux64 {
  4539  			break
  4540  		}
  4541  		_ = v_0.Args[1]
  4542  		v_0_1 := v_0.Args[1]
  4543  		if v_0_1.Op != OpConst64 {
  4544  			break
  4545  		}
  4546  		c := v_0_1.AuxInt
  4547  		v_1 := v.Args[1]
  4548  		if v_1.Op != OpConst16 {
  4549  			break
  4550  		}
  4551  		m := v_1.AuxInt
  4552  		if !(c >= 64-ntz(m)) {
  4553  			break
  4554  		}
  4555  		v.reset(OpConst16)
  4556  		v.AuxInt = 0
  4557  		return true
  4558  	}
  4559  	// match: (And16 (Const16 [m]) (Lsh16x64 _ (Const64 [c])))
  4560  	// cond: c >= 64-nlz(m)
  4561  	// result: (Const16 [0])
  4562  	for {
  4563  		_ = v.Args[1]
  4564  		v_0 := v.Args[0]
  4565  		if v_0.Op != OpConst16 {
  4566  			break
  4567  		}
  4568  		m := v_0.AuxInt
  4569  		v_1 := v.Args[1]
  4570  		if v_1.Op != OpLsh16x64 {
  4571  			break
  4572  		}
  4573  		_ = v_1.Args[1]
  4574  		v_1_1 := v_1.Args[1]
  4575  		if v_1_1.Op != OpConst64 {
  4576  			break
  4577  		}
  4578  		c := v_1_1.AuxInt
  4579  		if !(c >= 64-nlz(m)) {
  4580  			break
  4581  		}
  4582  		v.reset(OpConst16)
  4583  		v.AuxInt = 0
  4584  		return true
  4585  	}
  4586  	// match: (And16 (Lsh16x64 _ (Const64 [c])) (Const16 [m]))
  4587  	// cond: c >= 64-nlz(m)
  4588  	// result: (Const16 [0])
  4589  	for {
  4590  		_ = v.Args[1]
  4591  		v_0 := v.Args[0]
  4592  		if v_0.Op != OpLsh16x64 {
  4593  			break
  4594  		}
  4595  		_ = v_0.Args[1]
  4596  		v_0_1 := v_0.Args[1]
  4597  		if v_0_1.Op != OpConst64 {
  4598  			break
  4599  		}
  4600  		c := v_0_1.AuxInt
  4601  		v_1 := v.Args[1]
  4602  		if v_1.Op != OpConst16 {
  4603  			break
  4604  		}
  4605  		m := v_1.AuxInt
  4606  		if !(c >= 64-nlz(m)) {
  4607  			break
  4608  		}
  4609  		v.reset(OpConst16)
  4610  		v.AuxInt = 0
  4611  		return true
  4612  	}
  4613  	// match: (And16 x x)
  4614  	// cond:
  4615  	// result: x
  4616  	for {
  4617  		_ = v.Args[1]
  4618  		x := v.Args[0]
  4619  		if x != v.Args[1] {
  4620  			break
  4621  		}
  4622  		v.reset(OpCopy)
  4623  		v.Type = x.Type
  4624  		v.AddArg(x)
  4625  		return true
  4626  	}
  4627  	// match: (And16 (Const16 [-1]) x)
  4628  	// cond:
  4629  	// result: x
  4630  	for {
  4631  		_ = v.Args[1]
  4632  		v_0 := v.Args[0]
  4633  		if v_0.Op != OpConst16 {
  4634  			break
  4635  		}
  4636  		if v_0.AuxInt != -1 {
  4637  			break
  4638  		}
  4639  		x := v.Args[1]
  4640  		v.reset(OpCopy)
  4641  		v.Type = x.Type
  4642  		v.AddArg(x)
  4643  		return true
  4644  	}
  4645  	// match: (And16 x (Const16 [-1]))
  4646  	// cond:
  4647  	// result: x
  4648  	for {
  4649  		_ = v.Args[1]
  4650  		x := v.Args[0]
  4651  		v_1 := v.Args[1]
  4652  		if v_1.Op != OpConst16 {
  4653  			break
  4654  		}
  4655  		if v_1.AuxInt != -1 {
  4656  			break
  4657  		}
  4658  		v.reset(OpCopy)
  4659  		v.Type = x.Type
  4660  		v.AddArg(x)
  4661  		return true
  4662  	}
  4663  	// match: (And16 (Const16 [0]) _)
  4664  	// cond:
  4665  	// result: (Const16 [0])
  4666  	for {
  4667  		_ = v.Args[1]
  4668  		v_0 := v.Args[0]
  4669  		if v_0.Op != OpConst16 {
  4670  			break
  4671  		}
  4672  		if v_0.AuxInt != 0 {
  4673  			break
  4674  		}
  4675  		v.reset(OpConst16)
  4676  		v.AuxInt = 0
  4677  		return true
  4678  	}
  4679  	return false
  4680  }
  4681  func rewriteValuegeneric_OpAnd16_10(v *Value) bool {
  4682  	b := v.Block
  4683  	_ = b
  4684  	// match: (And16 _ (Const16 [0]))
  4685  	// cond:
  4686  	// result: (Const16 [0])
  4687  	for {
  4688  		_ = v.Args[1]
  4689  		v_1 := v.Args[1]
  4690  		if v_1.Op != OpConst16 {
  4691  			break
  4692  		}
  4693  		if v_1.AuxInt != 0 {
  4694  			break
  4695  		}
  4696  		v.reset(OpConst16)
  4697  		v.AuxInt = 0
  4698  		return true
  4699  	}
  4700  	// match: (And16 x (And16 x y))
  4701  	// cond:
  4702  	// result: (And16 x y)
  4703  	for {
  4704  		_ = v.Args[1]
  4705  		x := v.Args[0]
  4706  		v_1 := v.Args[1]
  4707  		if v_1.Op != OpAnd16 {
  4708  			break
  4709  		}
  4710  		_ = v_1.Args[1]
  4711  		if x != v_1.Args[0] {
  4712  			break
  4713  		}
  4714  		y := v_1.Args[1]
  4715  		v.reset(OpAnd16)
  4716  		v.AddArg(x)
  4717  		v.AddArg(y)
  4718  		return true
  4719  	}
  4720  	// match: (And16 x (And16 y x))
  4721  	// cond:
  4722  	// result: (And16 x y)
  4723  	for {
  4724  		_ = v.Args[1]
  4725  		x := v.Args[0]
  4726  		v_1 := v.Args[1]
  4727  		if v_1.Op != OpAnd16 {
  4728  			break
  4729  		}
  4730  		_ = v_1.Args[1]
  4731  		y := v_1.Args[0]
  4732  		if x != v_1.Args[1] {
  4733  			break
  4734  		}
  4735  		v.reset(OpAnd16)
  4736  		v.AddArg(x)
  4737  		v.AddArg(y)
  4738  		return true
  4739  	}
  4740  	// match: (And16 (And16 x y) x)
  4741  	// cond:
  4742  	// result: (And16 x y)
  4743  	for {
  4744  		_ = v.Args[1]
  4745  		v_0 := v.Args[0]
  4746  		if v_0.Op != OpAnd16 {
  4747  			break
  4748  		}
  4749  		_ = v_0.Args[1]
  4750  		x := v_0.Args[0]
  4751  		y := v_0.Args[1]
  4752  		if x != v.Args[1] {
  4753  			break
  4754  		}
  4755  		v.reset(OpAnd16)
  4756  		v.AddArg(x)
  4757  		v.AddArg(y)
  4758  		return true
  4759  	}
  4760  	// match: (And16 (And16 y x) x)
  4761  	// cond:
  4762  	// result: (And16 x y)
  4763  	for {
  4764  		_ = v.Args[1]
  4765  		v_0 := v.Args[0]
  4766  		if v_0.Op != OpAnd16 {
  4767  			break
  4768  		}
  4769  		_ = v_0.Args[1]
  4770  		y := v_0.Args[0]
  4771  		x := v_0.Args[1]
  4772  		if x != v.Args[1] {
  4773  			break
  4774  		}
  4775  		v.reset(OpAnd16)
  4776  		v.AddArg(x)
  4777  		v.AddArg(y)
  4778  		return true
  4779  	}
  4780  	// match: (And16 (And16 i:(Const16 <t>) z) x)
  4781  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4782  	// result: (And16 i (And16 <t> z x))
  4783  	for {
  4784  		_ = v.Args[1]
  4785  		v_0 := v.Args[0]
  4786  		if v_0.Op != OpAnd16 {
  4787  			break
  4788  		}
  4789  		_ = v_0.Args[1]
  4790  		i := v_0.Args[0]
  4791  		if i.Op != OpConst16 {
  4792  			break
  4793  		}
  4794  		t := i.Type
  4795  		z := v_0.Args[1]
  4796  		x := v.Args[1]
  4797  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4798  			break
  4799  		}
  4800  		v.reset(OpAnd16)
  4801  		v.AddArg(i)
  4802  		v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4803  		v0.AddArg(z)
  4804  		v0.AddArg(x)
  4805  		v.AddArg(v0)
  4806  		return true
  4807  	}
  4808  	// match: (And16 (And16 z i:(Const16 <t>)) x)
  4809  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4810  	// result: (And16 i (And16 <t> z x))
  4811  	for {
  4812  		_ = v.Args[1]
  4813  		v_0 := v.Args[0]
  4814  		if v_0.Op != OpAnd16 {
  4815  			break
  4816  		}
  4817  		_ = v_0.Args[1]
  4818  		z := v_0.Args[0]
  4819  		i := v_0.Args[1]
  4820  		if i.Op != OpConst16 {
  4821  			break
  4822  		}
  4823  		t := i.Type
  4824  		x := v.Args[1]
  4825  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4826  			break
  4827  		}
  4828  		v.reset(OpAnd16)
  4829  		v.AddArg(i)
  4830  		v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4831  		v0.AddArg(z)
  4832  		v0.AddArg(x)
  4833  		v.AddArg(v0)
  4834  		return true
  4835  	}
  4836  	// match: (And16 x (And16 i:(Const16 <t>) z))
  4837  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4838  	// result: (And16 i (And16 <t> z x))
  4839  	for {
  4840  		_ = v.Args[1]
  4841  		x := v.Args[0]
  4842  		v_1 := v.Args[1]
  4843  		if v_1.Op != OpAnd16 {
  4844  			break
  4845  		}
  4846  		_ = v_1.Args[1]
  4847  		i := v_1.Args[0]
  4848  		if i.Op != OpConst16 {
  4849  			break
  4850  		}
  4851  		t := i.Type
  4852  		z := v_1.Args[1]
  4853  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4854  			break
  4855  		}
  4856  		v.reset(OpAnd16)
  4857  		v.AddArg(i)
  4858  		v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4859  		v0.AddArg(z)
  4860  		v0.AddArg(x)
  4861  		v.AddArg(v0)
  4862  		return true
  4863  	}
  4864  	// match: (And16 x (And16 z i:(Const16 <t>)))
  4865  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
  4866  	// result: (And16 i (And16 <t> z x))
  4867  	for {
  4868  		_ = v.Args[1]
  4869  		x := v.Args[0]
  4870  		v_1 := v.Args[1]
  4871  		if v_1.Op != OpAnd16 {
  4872  			break
  4873  		}
  4874  		_ = v_1.Args[1]
  4875  		z := v_1.Args[0]
  4876  		i := v_1.Args[1]
  4877  		if i.Op != OpConst16 {
  4878  			break
  4879  		}
  4880  		t := i.Type
  4881  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
  4882  			break
  4883  		}
  4884  		v.reset(OpAnd16)
  4885  		v.AddArg(i)
  4886  		v0 := b.NewValue0(v.Pos, OpAnd16, t)
  4887  		v0.AddArg(z)
  4888  		v0.AddArg(x)
  4889  		v.AddArg(v0)
  4890  		return true
  4891  	}
  4892  	// match: (And16 (Const16 <t> [c]) (And16 (Const16 <t> [d]) x))
  4893  	// cond:
  4894  	// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4895  	for {
  4896  		_ = v.Args[1]
  4897  		v_0 := v.Args[0]
  4898  		if v_0.Op != OpConst16 {
  4899  			break
  4900  		}
  4901  		t := v_0.Type
  4902  		c := v_0.AuxInt
  4903  		v_1 := v.Args[1]
  4904  		if v_1.Op != OpAnd16 {
  4905  			break
  4906  		}
  4907  		_ = v_1.Args[1]
  4908  		v_1_0 := v_1.Args[0]
  4909  		if v_1_0.Op != OpConst16 {
  4910  			break
  4911  		}
  4912  		if v_1_0.Type != t {
  4913  			break
  4914  		}
  4915  		d := v_1_0.AuxInt
  4916  		x := v_1.Args[1]
  4917  		v.reset(OpAnd16)
  4918  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  4919  		v0.AuxInt = int64(int16(c & d))
  4920  		v.AddArg(v0)
  4921  		v.AddArg(x)
  4922  		return true
  4923  	}
  4924  	return false
  4925  }
  4926  func rewriteValuegeneric_OpAnd16_20(v *Value) bool {
  4927  	b := v.Block
  4928  	_ = b
  4929  	// match: (And16 (Const16 <t> [c]) (And16 x (Const16 <t> [d])))
  4930  	// cond:
  4931  	// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4932  	for {
  4933  		_ = v.Args[1]
  4934  		v_0 := v.Args[0]
  4935  		if v_0.Op != OpConst16 {
  4936  			break
  4937  		}
  4938  		t := v_0.Type
  4939  		c := v_0.AuxInt
  4940  		v_1 := v.Args[1]
  4941  		if v_1.Op != OpAnd16 {
  4942  			break
  4943  		}
  4944  		_ = v_1.Args[1]
  4945  		x := v_1.Args[0]
  4946  		v_1_1 := v_1.Args[1]
  4947  		if v_1_1.Op != OpConst16 {
  4948  			break
  4949  		}
  4950  		if v_1_1.Type != t {
  4951  			break
  4952  		}
  4953  		d := v_1_1.AuxInt
  4954  		v.reset(OpAnd16)
  4955  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  4956  		v0.AuxInt = int64(int16(c & d))
  4957  		v.AddArg(v0)
  4958  		v.AddArg(x)
  4959  		return true
  4960  	}
  4961  	// match: (And16 (And16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  4962  	// cond:
  4963  	// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4964  	for {
  4965  		_ = v.Args[1]
  4966  		v_0 := v.Args[0]
  4967  		if v_0.Op != OpAnd16 {
  4968  			break
  4969  		}
  4970  		_ = v_0.Args[1]
  4971  		v_0_0 := v_0.Args[0]
  4972  		if v_0_0.Op != OpConst16 {
  4973  			break
  4974  		}
  4975  		t := v_0_0.Type
  4976  		d := v_0_0.AuxInt
  4977  		x := v_0.Args[1]
  4978  		v_1 := v.Args[1]
  4979  		if v_1.Op != OpConst16 {
  4980  			break
  4981  		}
  4982  		if v_1.Type != t {
  4983  			break
  4984  		}
  4985  		c := v_1.AuxInt
  4986  		v.reset(OpAnd16)
  4987  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  4988  		v0.AuxInt = int64(int16(c & d))
  4989  		v.AddArg(v0)
  4990  		v.AddArg(x)
  4991  		return true
  4992  	}
  4993  	// match: (And16 (And16 x (Const16 <t> [d])) (Const16 <t> [c]))
  4994  	// cond:
  4995  	// result: (And16 (Const16 <t> [int64(int16(c&d))]) x)
  4996  	for {
  4997  		_ = v.Args[1]
  4998  		v_0 := v.Args[0]
  4999  		if v_0.Op != OpAnd16 {
  5000  			break
  5001  		}
  5002  		_ = v_0.Args[1]
  5003  		x := v_0.Args[0]
  5004  		v_0_1 := v_0.Args[1]
  5005  		if v_0_1.Op != OpConst16 {
  5006  			break
  5007  		}
  5008  		t := v_0_1.Type
  5009  		d := v_0_1.AuxInt
  5010  		v_1 := v.Args[1]
  5011  		if v_1.Op != OpConst16 {
  5012  			break
  5013  		}
  5014  		if v_1.Type != t {
  5015  			break
  5016  		}
  5017  		c := v_1.AuxInt
  5018  		v.reset(OpAnd16)
  5019  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  5020  		v0.AuxInt = int64(int16(c & d))
  5021  		v.AddArg(v0)
  5022  		v.AddArg(x)
  5023  		return true
  5024  	}
  5025  	return false
  5026  }
  5027  func rewriteValuegeneric_OpAnd32_0(v *Value) bool {
  5028  	// match: (And32 (Const32 [c]) (Const32 [d]))
  5029  	// cond:
  5030  	// result: (Const32 [int64(int32(c&d))])
  5031  	for {
  5032  		_ = v.Args[1]
  5033  		v_0 := v.Args[0]
  5034  		if v_0.Op != OpConst32 {
  5035  			break
  5036  		}
  5037  		c := v_0.AuxInt
  5038  		v_1 := v.Args[1]
  5039  		if v_1.Op != OpConst32 {
  5040  			break
  5041  		}
  5042  		d := v_1.AuxInt
  5043  		v.reset(OpConst32)
  5044  		v.AuxInt = int64(int32(c & d))
  5045  		return true
  5046  	}
  5047  	// match: (And32 (Const32 [d]) (Const32 [c]))
  5048  	// cond:
  5049  	// result: (Const32 [int64(int32(c&d))])
  5050  	for {
  5051  		_ = v.Args[1]
  5052  		v_0 := v.Args[0]
  5053  		if v_0.Op != OpConst32 {
  5054  			break
  5055  		}
  5056  		d := v_0.AuxInt
  5057  		v_1 := v.Args[1]
  5058  		if v_1.Op != OpConst32 {
  5059  			break
  5060  		}
  5061  		c := v_1.AuxInt
  5062  		v.reset(OpConst32)
  5063  		v.AuxInt = int64(int32(c & d))
  5064  		return true
  5065  	}
  5066  	// match: (And32 (Const32 [m]) (Rsh32Ux64 _ (Const64 [c])))
  5067  	// cond: c >= 64-ntz(m)
  5068  	// result: (Const32 [0])
  5069  	for {
  5070  		_ = v.Args[1]
  5071  		v_0 := v.Args[0]
  5072  		if v_0.Op != OpConst32 {
  5073  			break
  5074  		}
  5075  		m := v_0.AuxInt
  5076  		v_1 := v.Args[1]
  5077  		if v_1.Op != OpRsh32Ux64 {
  5078  			break
  5079  		}
  5080  		_ = v_1.Args[1]
  5081  		v_1_1 := v_1.Args[1]
  5082  		if v_1_1.Op != OpConst64 {
  5083  			break
  5084  		}
  5085  		c := v_1_1.AuxInt
  5086  		if !(c >= 64-ntz(m)) {
  5087  			break
  5088  		}
  5089  		v.reset(OpConst32)
  5090  		v.AuxInt = 0
  5091  		return true
  5092  	}
  5093  	// match: (And32 (Rsh32Ux64 _ (Const64 [c])) (Const32 [m]))
  5094  	// cond: c >= 64-ntz(m)
  5095  	// result: (Const32 [0])
  5096  	for {
  5097  		_ = v.Args[1]
  5098  		v_0 := v.Args[0]
  5099  		if v_0.Op != OpRsh32Ux64 {
  5100  			break
  5101  		}
  5102  		_ = v_0.Args[1]
  5103  		v_0_1 := v_0.Args[1]
  5104  		if v_0_1.Op != OpConst64 {
  5105  			break
  5106  		}
  5107  		c := v_0_1.AuxInt
  5108  		v_1 := v.Args[1]
  5109  		if v_1.Op != OpConst32 {
  5110  			break
  5111  		}
  5112  		m := v_1.AuxInt
  5113  		if !(c >= 64-ntz(m)) {
  5114  			break
  5115  		}
  5116  		v.reset(OpConst32)
  5117  		v.AuxInt = 0
  5118  		return true
  5119  	}
  5120  	// match: (And32 (Const32 [m]) (Lsh32x64 _ (Const64 [c])))
  5121  	// cond: c >= 64-nlz(m)
  5122  	// result: (Const32 [0])
  5123  	for {
  5124  		_ = v.Args[1]
  5125  		v_0 := v.Args[0]
  5126  		if v_0.Op != OpConst32 {
  5127  			break
  5128  		}
  5129  		m := v_0.AuxInt
  5130  		v_1 := v.Args[1]
  5131  		if v_1.Op != OpLsh32x64 {
  5132  			break
  5133  		}
  5134  		_ = v_1.Args[1]
  5135  		v_1_1 := v_1.Args[1]
  5136  		if v_1_1.Op != OpConst64 {
  5137  			break
  5138  		}
  5139  		c := v_1_1.AuxInt
  5140  		if !(c >= 64-nlz(m)) {
  5141  			break
  5142  		}
  5143  		v.reset(OpConst32)
  5144  		v.AuxInt = 0
  5145  		return true
  5146  	}
  5147  	// match: (And32 (Lsh32x64 _ (Const64 [c])) (Const32 [m]))
  5148  	// cond: c >= 64-nlz(m)
  5149  	// result: (Const32 [0])
  5150  	for {
  5151  		_ = v.Args[1]
  5152  		v_0 := v.Args[0]
  5153  		if v_0.Op != OpLsh32x64 {
  5154  			break
  5155  		}
  5156  		_ = v_0.Args[1]
  5157  		v_0_1 := v_0.Args[1]
  5158  		if v_0_1.Op != OpConst64 {
  5159  			break
  5160  		}
  5161  		c := v_0_1.AuxInt
  5162  		v_1 := v.Args[1]
  5163  		if v_1.Op != OpConst32 {
  5164  			break
  5165  		}
  5166  		m := v_1.AuxInt
  5167  		if !(c >= 64-nlz(m)) {
  5168  			break
  5169  		}
  5170  		v.reset(OpConst32)
  5171  		v.AuxInt = 0
  5172  		return true
  5173  	}
  5174  	// match: (And32 x x)
  5175  	// cond:
  5176  	// result: x
  5177  	for {
  5178  		_ = v.Args[1]
  5179  		x := v.Args[0]
  5180  		if x != v.Args[1] {
  5181  			break
  5182  		}
  5183  		v.reset(OpCopy)
  5184  		v.Type = x.Type
  5185  		v.AddArg(x)
  5186  		return true
  5187  	}
  5188  	// match: (And32 (Const32 [-1]) x)
  5189  	// cond:
  5190  	// result: x
  5191  	for {
  5192  		_ = v.Args[1]
  5193  		v_0 := v.Args[0]
  5194  		if v_0.Op != OpConst32 {
  5195  			break
  5196  		}
  5197  		if v_0.AuxInt != -1 {
  5198  			break
  5199  		}
  5200  		x := v.Args[1]
  5201  		v.reset(OpCopy)
  5202  		v.Type = x.Type
  5203  		v.AddArg(x)
  5204  		return true
  5205  	}
  5206  	// match: (And32 x (Const32 [-1]))
  5207  	// cond:
  5208  	// result: x
  5209  	for {
  5210  		_ = v.Args[1]
  5211  		x := v.Args[0]
  5212  		v_1 := v.Args[1]
  5213  		if v_1.Op != OpConst32 {
  5214  			break
  5215  		}
  5216  		if v_1.AuxInt != -1 {
  5217  			break
  5218  		}
  5219  		v.reset(OpCopy)
  5220  		v.Type = x.Type
  5221  		v.AddArg(x)
  5222  		return true
  5223  	}
  5224  	// match: (And32 (Const32 [0]) _)
  5225  	// cond:
  5226  	// result: (Const32 [0])
  5227  	for {
  5228  		_ = v.Args[1]
  5229  		v_0 := v.Args[0]
  5230  		if v_0.Op != OpConst32 {
  5231  			break
  5232  		}
  5233  		if v_0.AuxInt != 0 {
  5234  			break
  5235  		}
  5236  		v.reset(OpConst32)
  5237  		v.AuxInt = 0
  5238  		return true
  5239  	}
  5240  	return false
  5241  }
  5242  func rewriteValuegeneric_OpAnd32_10(v *Value) bool {
  5243  	b := v.Block
  5244  	_ = b
  5245  	// match: (And32 _ (Const32 [0]))
  5246  	// cond:
  5247  	// result: (Const32 [0])
  5248  	for {
  5249  		_ = v.Args[1]
  5250  		v_1 := v.Args[1]
  5251  		if v_1.Op != OpConst32 {
  5252  			break
  5253  		}
  5254  		if v_1.AuxInt != 0 {
  5255  			break
  5256  		}
  5257  		v.reset(OpConst32)
  5258  		v.AuxInt = 0
  5259  		return true
  5260  	}
  5261  	// match: (And32 x (And32 x y))
  5262  	// cond:
  5263  	// result: (And32 x y)
  5264  	for {
  5265  		_ = v.Args[1]
  5266  		x := v.Args[0]
  5267  		v_1 := v.Args[1]
  5268  		if v_1.Op != OpAnd32 {
  5269  			break
  5270  		}
  5271  		_ = v_1.Args[1]
  5272  		if x != v_1.Args[0] {
  5273  			break
  5274  		}
  5275  		y := v_1.Args[1]
  5276  		v.reset(OpAnd32)
  5277  		v.AddArg(x)
  5278  		v.AddArg(y)
  5279  		return true
  5280  	}
  5281  	// match: (And32 x (And32 y x))
  5282  	// cond:
  5283  	// result: (And32 x y)
  5284  	for {
  5285  		_ = v.Args[1]
  5286  		x := v.Args[0]
  5287  		v_1 := v.Args[1]
  5288  		if v_1.Op != OpAnd32 {
  5289  			break
  5290  		}
  5291  		_ = v_1.Args[1]
  5292  		y := v_1.Args[0]
  5293  		if x != v_1.Args[1] {
  5294  			break
  5295  		}
  5296  		v.reset(OpAnd32)
  5297  		v.AddArg(x)
  5298  		v.AddArg(y)
  5299  		return true
  5300  	}
  5301  	// match: (And32 (And32 x y) x)
  5302  	// cond:
  5303  	// result: (And32 x y)
  5304  	for {
  5305  		_ = v.Args[1]
  5306  		v_0 := v.Args[0]
  5307  		if v_0.Op != OpAnd32 {
  5308  			break
  5309  		}
  5310  		_ = v_0.Args[1]
  5311  		x := v_0.Args[0]
  5312  		y := v_0.Args[1]
  5313  		if x != v.Args[1] {
  5314  			break
  5315  		}
  5316  		v.reset(OpAnd32)
  5317  		v.AddArg(x)
  5318  		v.AddArg(y)
  5319  		return true
  5320  	}
  5321  	// match: (And32 (And32 y x) x)
  5322  	// cond:
  5323  	// result: (And32 x y)
  5324  	for {
  5325  		_ = v.Args[1]
  5326  		v_0 := v.Args[0]
  5327  		if v_0.Op != OpAnd32 {
  5328  			break
  5329  		}
  5330  		_ = v_0.Args[1]
  5331  		y := v_0.Args[0]
  5332  		x := v_0.Args[1]
  5333  		if x != v.Args[1] {
  5334  			break
  5335  		}
  5336  		v.reset(OpAnd32)
  5337  		v.AddArg(x)
  5338  		v.AddArg(y)
  5339  		return true
  5340  	}
  5341  	// match: (And32 (And32 i:(Const32 <t>) z) x)
  5342  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5343  	// result: (And32 i (And32 <t> z x))
  5344  	for {
  5345  		_ = v.Args[1]
  5346  		v_0 := v.Args[0]
  5347  		if v_0.Op != OpAnd32 {
  5348  			break
  5349  		}
  5350  		_ = v_0.Args[1]
  5351  		i := v_0.Args[0]
  5352  		if i.Op != OpConst32 {
  5353  			break
  5354  		}
  5355  		t := i.Type
  5356  		z := v_0.Args[1]
  5357  		x := v.Args[1]
  5358  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5359  			break
  5360  		}
  5361  		v.reset(OpAnd32)
  5362  		v.AddArg(i)
  5363  		v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5364  		v0.AddArg(z)
  5365  		v0.AddArg(x)
  5366  		v.AddArg(v0)
  5367  		return true
  5368  	}
  5369  	// match: (And32 (And32 z i:(Const32 <t>)) x)
  5370  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5371  	// result: (And32 i (And32 <t> z x))
  5372  	for {
  5373  		_ = v.Args[1]
  5374  		v_0 := v.Args[0]
  5375  		if v_0.Op != OpAnd32 {
  5376  			break
  5377  		}
  5378  		_ = v_0.Args[1]
  5379  		z := v_0.Args[0]
  5380  		i := v_0.Args[1]
  5381  		if i.Op != OpConst32 {
  5382  			break
  5383  		}
  5384  		t := i.Type
  5385  		x := v.Args[1]
  5386  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5387  			break
  5388  		}
  5389  		v.reset(OpAnd32)
  5390  		v.AddArg(i)
  5391  		v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5392  		v0.AddArg(z)
  5393  		v0.AddArg(x)
  5394  		v.AddArg(v0)
  5395  		return true
  5396  	}
  5397  	// match: (And32 x (And32 i:(Const32 <t>) z))
  5398  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5399  	// result: (And32 i (And32 <t> z x))
  5400  	for {
  5401  		_ = v.Args[1]
  5402  		x := v.Args[0]
  5403  		v_1 := v.Args[1]
  5404  		if v_1.Op != OpAnd32 {
  5405  			break
  5406  		}
  5407  		_ = v_1.Args[1]
  5408  		i := v_1.Args[0]
  5409  		if i.Op != OpConst32 {
  5410  			break
  5411  		}
  5412  		t := i.Type
  5413  		z := v_1.Args[1]
  5414  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5415  			break
  5416  		}
  5417  		v.reset(OpAnd32)
  5418  		v.AddArg(i)
  5419  		v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5420  		v0.AddArg(z)
  5421  		v0.AddArg(x)
  5422  		v.AddArg(v0)
  5423  		return true
  5424  	}
  5425  	// match: (And32 x (And32 z i:(Const32 <t>)))
  5426  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
  5427  	// result: (And32 i (And32 <t> z x))
  5428  	for {
  5429  		_ = v.Args[1]
  5430  		x := v.Args[0]
  5431  		v_1 := v.Args[1]
  5432  		if v_1.Op != OpAnd32 {
  5433  			break
  5434  		}
  5435  		_ = v_1.Args[1]
  5436  		z := v_1.Args[0]
  5437  		i := v_1.Args[1]
  5438  		if i.Op != OpConst32 {
  5439  			break
  5440  		}
  5441  		t := i.Type
  5442  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
  5443  			break
  5444  		}
  5445  		v.reset(OpAnd32)
  5446  		v.AddArg(i)
  5447  		v0 := b.NewValue0(v.Pos, OpAnd32, t)
  5448  		v0.AddArg(z)
  5449  		v0.AddArg(x)
  5450  		v.AddArg(v0)
  5451  		return true
  5452  	}
  5453  	// match: (And32 (Const32 <t> [c]) (And32 (Const32 <t> [d]) x))
  5454  	// cond:
  5455  	// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5456  	for {
  5457  		_ = v.Args[1]
  5458  		v_0 := v.Args[0]
  5459  		if v_0.Op != OpConst32 {
  5460  			break
  5461  		}
  5462  		t := v_0.Type
  5463  		c := v_0.AuxInt
  5464  		v_1 := v.Args[1]
  5465  		if v_1.Op != OpAnd32 {
  5466  			break
  5467  		}
  5468  		_ = v_1.Args[1]
  5469  		v_1_0 := v_1.Args[0]
  5470  		if v_1_0.Op != OpConst32 {
  5471  			break
  5472  		}
  5473  		if v_1_0.Type != t {
  5474  			break
  5475  		}
  5476  		d := v_1_0.AuxInt
  5477  		x := v_1.Args[1]
  5478  		v.reset(OpAnd32)
  5479  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  5480  		v0.AuxInt = int64(int32(c & d))
  5481  		v.AddArg(v0)
  5482  		v.AddArg(x)
  5483  		return true
  5484  	}
  5485  	return false
  5486  }
  5487  func rewriteValuegeneric_OpAnd32_20(v *Value) bool {
  5488  	b := v.Block
  5489  	_ = b
  5490  	// match: (And32 (Const32 <t> [c]) (And32 x (Const32 <t> [d])))
  5491  	// cond:
  5492  	// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5493  	for {
  5494  		_ = v.Args[1]
  5495  		v_0 := v.Args[0]
  5496  		if v_0.Op != OpConst32 {
  5497  			break
  5498  		}
  5499  		t := v_0.Type
  5500  		c := v_0.AuxInt
  5501  		v_1 := v.Args[1]
  5502  		if v_1.Op != OpAnd32 {
  5503  			break
  5504  		}
  5505  		_ = v_1.Args[1]
  5506  		x := v_1.Args[0]
  5507  		v_1_1 := v_1.Args[1]
  5508  		if v_1_1.Op != OpConst32 {
  5509  			break
  5510  		}
  5511  		if v_1_1.Type != t {
  5512  			break
  5513  		}
  5514  		d := v_1_1.AuxInt
  5515  		v.reset(OpAnd32)
  5516  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  5517  		v0.AuxInt = int64(int32(c & d))
  5518  		v.AddArg(v0)
  5519  		v.AddArg(x)
  5520  		return true
  5521  	}
  5522  	// match: (And32 (And32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  5523  	// cond:
  5524  	// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5525  	for {
  5526  		_ = v.Args[1]
  5527  		v_0 := v.Args[0]
  5528  		if v_0.Op != OpAnd32 {
  5529  			break
  5530  		}
  5531  		_ = v_0.Args[1]
  5532  		v_0_0 := v_0.Args[0]
  5533  		if v_0_0.Op != OpConst32 {
  5534  			break
  5535  		}
  5536  		t := v_0_0.Type
  5537  		d := v_0_0.AuxInt
  5538  		x := v_0.Args[1]
  5539  		v_1 := v.Args[1]
  5540  		if v_1.Op != OpConst32 {
  5541  			break
  5542  		}
  5543  		if v_1.Type != t {
  5544  			break
  5545  		}
  5546  		c := v_1.AuxInt
  5547  		v.reset(OpAnd32)
  5548  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  5549  		v0.AuxInt = int64(int32(c & d))
  5550  		v.AddArg(v0)
  5551  		v.AddArg(x)
  5552  		return true
  5553  	}
  5554  	// match: (And32 (And32 x (Const32 <t> [d])) (Const32 <t> [c]))
  5555  	// cond:
  5556  	// result: (And32 (Const32 <t> [int64(int32(c&d))]) x)
  5557  	for {
  5558  		_ = v.Args[1]
  5559  		v_0 := v.Args[0]
  5560  		if v_0.Op != OpAnd32 {
  5561  			break
  5562  		}
  5563  		_ = v_0.Args[1]
  5564  		x := v_0.Args[0]
  5565  		v_0_1 := v_0.Args[1]
  5566  		if v_0_1.Op != OpConst32 {
  5567  			break
  5568  		}
  5569  		t := v_0_1.Type
  5570  		d := v_0_1.AuxInt
  5571  		v_1 := v.Args[1]
  5572  		if v_1.Op != OpConst32 {
  5573  			break
  5574  		}
  5575  		if v_1.Type != t {
  5576  			break
  5577  		}
  5578  		c := v_1.AuxInt
  5579  		v.reset(OpAnd32)
  5580  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  5581  		v0.AuxInt = int64(int32(c & d))
  5582  		v.AddArg(v0)
  5583  		v.AddArg(x)
  5584  		return true
  5585  	}
  5586  	return false
  5587  }
  5588  func rewriteValuegeneric_OpAnd64_0(v *Value) bool {
  5589  	// match: (And64 (Const64 [c]) (Const64 [d]))
  5590  	// cond:
  5591  	// result: (Const64 [c&d])
  5592  	for {
  5593  		_ = v.Args[1]
  5594  		v_0 := v.Args[0]
  5595  		if v_0.Op != OpConst64 {
  5596  			break
  5597  		}
  5598  		c := v_0.AuxInt
  5599  		v_1 := v.Args[1]
  5600  		if v_1.Op != OpConst64 {
  5601  			break
  5602  		}
  5603  		d := v_1.AuxInt
  5604  		v.reset(OpConst64)
  5605  		v.AuxInt = c & d
  5606  		return true
  5607  	}
  5608  	// match: (And64 (Const64 [d]) (Const64 [c]))
  5609  	// cond:
  5610  	// result: (Const64 [c&d])
  5611  	for {
  5612  		_ = v.Args[1]
  5613  		v_0 := v.Args[0]
  5614  		if v_0.Op != OpConst64 {
  5615  			break
  5616  		}
  5617  		d := v_0.AuxInt
  5618  		v_1 := v.Args[1]
  5619  		if v_1.Op != OpConst64 {
  5620  			break
  5621  		}
  5622  		c := v_1.AuxInt
  5623  		v.reset(OpConst64)
  5624  		v.AuxInt = c & d
  5625  		return true
  5626  	}
  5627  	// match: (And64 (Const64 [m]) (Rsh64Ux64 _ (Const64 [c])))
  5628  	// cond: c >= 64-ntz(m)
  5629  	// result: (Const64 [0])
  5630  	for {
  5631  		_ = v.Args[1]
  5632  		v_0 := v.Args[0]
  5633  		if v_0.Op != OpConst64 {
  5634  			break
  5635  		}
  5636  		m := v_0.AuxInt
  5637  		v_1 := v.Args[1]
  5638  		if v_1.Op != OpRsh64Ux64 {
  5639  			break
  5640  		}
  5641  		_ = v_1.Args[1]
  5642  		v_1_1 := v_1.Args[1]
  5643  		if v_1_1.Op != OpConst64 {
  5644  			break
  5645  		}
  5646  		c := v_1_1.AuxInt
  5647  		if !(c >= 64-ntz(m)) {
  5648  			break
  5649  		}
  5650  		v.reset(OpConst64)
  5651  		v.AuxInt = 0
  5652  		return true
  5653  	}
  5654  	// match: (And64 (Rsh64Ux64 _ (Const64 [c])) (Const64 [m]))
  5655  	// cond: c >= 64-ntz(m)
  5656  	// result: (Const64 [0])
  5657  	for {
  5658  		_ = v.Args[1]
  5659  		v_0 := v.Args[0]
  5660  		if v_0.Op != OpRsh64Ux64 {
  5661  			break
  5662  		}
  5663  		_ = v_0.Args[1]
  5664  		v_0_1 := v_0.Args[1]
  5665  		if v_0_1.Op != OpConst64 {
  5666  			break
  5667  		}
  5668  		c := v_0_1.AuxInt
  5669  		v_1 := v.Args[1]
  5670  		if v_1.Op != OpConst64 {
  5671  			break
  5672  		}
  5673  		m := v_1.AuxInt
  5674  		if !(c >= 64-ntz(m)) {
  5675  			break
  5676  		}
  5677  		v.reset(OpConst64)
  5678  		v.AuxInt = 0
  5679  		return true
  5680  	}
  5681  	// match: (And64 (Const64 [m]) (Lsh64x64 _ (Const64 [c])))
  5682  	// cond: c >= 64-nlz(m)
  5683  	// result: (Const64 [0])
  5684  	for {
  5685  		_ = v.Args[1]
  5686  		v_0 := v.Args[0]
  5687  		if v_0.Op != OpConst64 {
  5688  			break
  5689  		}
  5690  		m := v_0.AuxInt
  5691  		v_1 := v.Args[1]
  5692  		if v_1.Op != OpLsh64x64 {
  5693  			break
  5694  		}
  5695  		_ = v_1.Args[1]
  5696  		v_1_1 := v_1.Args[1]
  5697  		if v_1_1.Op != OpConst64 {
  5698  			break
  5699  		}
  5700  		c := v_1_1.AuxInt
  5701  		if !(c >= 64-nlz(m)) {
  5702  			break
  5703  		}
  5704  		v.reset(OpConst64)
  5705  		v.AuxInt = 0
  5706  		return true
  5707  	}
  5708  	// match: (And64 (Lsh64x64 _ (Const64 [c])) (Const64 [m]))
  5709  	// cond: c >= 64-nlz(m)
  5710  	// result: (Const64 [0])
  5711  	for {
  5712  		_ = v.Args[1]
  5713  		v_0 := v.Args[0]
  5714  		if v_0.Op != OpLsh64x64 {
  5715  			break
  5716  		}
  5717  		_ = v_0.Args[1]
  5718  		v_0_1 := v_0.Args[1]
  5719  		if v_0_1.Op != OpConst64 {
  5720  			break
  5721  		}
  5722  		c := v_0_1.AuxInt
  5723  		v_1 := v.Args[1]
  5724  		if v_1.Op != OpConst64 {
  5725  			break
  5726  		}
  5727  		m := v_1.AuxInt
  5728  		if !(c >= 64-nlz(m)) {
  5729  			break
  5730  		}
  5731  		v.reset(OpConst64)
  5732  		v.AuxInt = 0
  5733  		return true
  5734  	}
  5735  	// match: (And64 x x)
  5736  	// cond:
  5737  	// result: x
  5738  	for {
  5739  		_ = v.Args[1]
  5740  		x := v.Args[0]
  5741  		if x != v.Args[1] {
  5742  			break
  5743  		}
  5744  		v.reset(OpCopy)
  5745  		v.Type = x.Type
  5746  		v.AddArg(x)
  5747  		return true
  5748  	}
  5749  	// match: (And64 (Const64 [-1]) x)
  5750  	// cond:
  5751  	// result: x
  5752  	for {
  5753  		_ = v.Args[1]
  5754  		v_0 := v.Args[0]
  5755  		if v_0.Op != OpConst64 {
  5756  			break
  5757  		}
  5758  		if v_0.AuxInt != -1 {
  5759  			break
  5760  		}
  5761  		x := v.Args[1]
  5762  		v.reset(OpCopy)
  5763  		v.Type = x.Type
  5764  		v.AddArg(x)
  5765  		return true
  5766  	}
  5767  	// match: (And64 x (Const64 [-1]))
  5768  	// cond:
  5769  	// result: x
  5770  	for {
  5771  		_ = v.Args[1]
  5772  		x := v.Args[0]
  5773  		v_1 := v.Args[1]
  5774  		if v_1.Op != OpConst64 {
  5775  			break
  5776  		}
  5777  		if v_1.AuxInt != -1 {
  5778  			break
  5779  		}
  5780  		v.reset(OpCopy)
  5781  		v.Type = x.Type
  5782  		v.AddArg(x)
  5783  		return true
  5784  	}
  5785  	// match: (And64 (Const64 [0]) _)
  5786  	// cond:
  5787  	// result: (Const64 [0])
  5788  	for {
  5789  		_ = v.Args[1]
  5790  		v_0 := v.Args[0]
  5791  		if v_0.Op != OpConst64 {
  5792  			break
  5793  		}
  5794  		if v_0.AuxInt != 0 {
  5795  			break
  5796  		}
  5797  		v.reset(OpConst64)
  5798  		v.AuxInt = 0
  5799  		return true
  5800  	}
  5801  	return false
  5802  }
  5803  func rewriteValuegeneric_OpAnd64_10(v *Value) bool {
  5804  	b := v.Block
  5805  	_ = b
  5806  	// match: (And64 _ (Const64 [0]))
  5807  	// cond:
  5808  	// result: (Const64 [0])
  5809  	for {
  5810  		_ = v.Args[1]
  5811  		v_1 := v.Args[1]
  5812  		if v_1.Op != OpConst64 {
  5813  			break
  5814  		}
  5815  		if v_1.AuxInt != 0 {
  5816  			break
  5817  		}
  5818  		v.reset(OpConst64)
  5819  		v.AuxInt = 0
  5820  		return true
  5821  	}
  5822  	// match: (And64 x (And64 x y))
  5823  	// cond:
  5824  	// result: (And64 x y)
  5825  	for {
  5826  		_ = v.Args[1]
  5827  		x := v.Args[0]
  5828  		v_1 := v.Args[1]
  5829  		if v_1.Op != OpAnd64 {
  5830  			break
  5831  		}
  5832  		_ = v_1.Args[1]
  5833  		if x != v_1.Args[0] {
  5834  			break
  5835  		}
  5836  		y := v_1.Args[1]
  5837  		v.reset(OpAnd64)
  5838  		v.AddArg(x)
  5839  		v.AddArg(y)
  5840  		return true
  5841  	}
  5842  	// match: (And64 x (And64 y x))
  5843  	// cond:
  5844  	// result: (And64 x y)
  5845  	for {
  5846  		_ = v.Args[1]
  5847  		x := v.Args[0]
  5848  		v_1 := v.Args[1]
  5849  		if v_1.Op != OpAnd64 {
  5850  			break
  5851  		}
  5852  		_ = v_1.Args[1]
  5853  		y := v_1.Args[0]
  5854  		if x != v_1.Args[1] {
  5855  			break
  5856  		}
  5857  		v.reset(OpAnd64)
  5858  		v.AddArg(x)
  5859  		v.AddArg(y)
  5860  		return true
  5861  	}
  5862  	// match: (And64 (And64 x y) x)
  5863  	// cond:
  5864  	// result: (And64 x y)
  5865  	for {
  5866  		_ = v.Args[1]
  5867  		v_0 := v.Args[0]
  5868  		if v_0.Op != OpAnd64 {
  5869  			break
  5870  		}
  5871  		_ = v_0.Args[1]
  5872  		x := v_0.Args[0]
  5873  		y := v_0.Args[1]
  5874  		if x != v.Args[1] {
  5875  			break
  5876  		}
  5877  		v.reset(OpAnd64)
  5878  		v.AddArg(x)
  5879  		v.AddArg(y)
  5880  		return true
  5881  	}
  5882  	// match: (And64 (And64 y x) x)
  5883  	// cond:
  5884  	// result: (And64 x y)
  5885  	for {
  5886  		_ = v.Args[1]
  5887  		v_0 := v.Args[0]
  5888  		if v_0.Op != OpAnd64 {
  5889  			break
  5890  		}
  5891  		_ = v_0.Args[1]
  5892  		y := v_0.Args[0]
  5893  		x := v_0.Args[1]
  5894  		if x != v.Args[1] {
  5895  			break
  5896  		}
  5897  		v.reset(OpAnd64)
  5898  		v.AddArg(x)
  5899  		v.AddArg(y)
  5900  		return true
  5901  	}
  5902  	// match: (And64 <t> (Const64 [y]) x)
  5903  	// cond: nlz(y) + nto(y) == 64 && nto(y) >= 32
  5904  	// result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)]))
  5905  	for {
  5906  		t := v.Type
  5907  		_ = v.Args[1]
  5908  		v_0 := v.Args[0]
  5909  		if v_0.Op != OpConst64 {
  5910  			break
  5911  		}
  5912  		y := v_0.AuxInt
  5913  		x := v.Args[1]
  5914  		if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) {
  5915  			break
  5916  		}
  5917  		v.reset(OpRsh64Ux64)
  5918  		v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
  5919  		v0.AddArg(x)
  5920  		v1 := b.NewValue0(v.Pos, OpConst64, t)
  5921  		v1.AuxInt = nlz(y)
  5922  		v0.AddArg(v1)
  5923  		v.AddArg(v0)
  5924  		v2 := b.NewValue0(v.Pos, OpConst64, t)
  5925  		v2.AuxInt = nlz(y)
  5926  		v.AddArg(v2)
  5927  		return true
  5928  	}
  5929  	// match: (And64 <t> x (Const64 [y]))
  5930  	// cond: nlz(y) + nto(y) == 64 && nto(y) >= 32
  5931  	// result: (Rsh64Ux64 (Lsh64x64 <t> x (Const64 <t> [nlz(y)])) (Const64 <t> [nlz(y)]))
  5932  	for {
  5933  		t := v.Type
  5934  		_ = v.Args[1]
  5935  		x := v.Args[0]
  5936  		v_1 := v.Args[1]
  5937  		if v_1.Op != OpConst64 {
  5938  			break
  5939  		}
  5940  		y := v_1.AuxInt
  5941  		if !(nlz(y)+nto(y) == 64 && nto(y) >= 32) {
  5942  			break
  5943  		}
  5944  		v.reset(OpRsh64Ux64)
  5945  		v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
  5946  		v0.AddArg(x)
  5947  		v1 := b.NewValue0(v.Pos, OpConst64, t)
  5948  		v1.AuxInt = nlz(y)
  5949  		v0.AddArg(v1)
  5950  		v.AddArg(v0)
  5951  		v2 := b.NewValue0(v.Pos, OpConst64, t)
  5952  		v2.AuxInt = nlz(y)
  5953  		v.AddArg(v2)
  5954  		return true
  5955  	}
  5956  	// match: (And64 <t> (Const64 [y]) x)
  5957  	// cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32
  5958  	// result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)]))
  5959  	for {
  5960  		t := v.Type
  5961  		_ = v.Args[1]
  5962  		v_0 := v.Args[0]
  5963  		if v_0.Op != OpConst64 {
  5964  			break
  5965  		}
  5966  		y := v_0.AuxInt
  5967  		x := v.Args[1]
  5968  		if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) {
  5969  			break
  5970  		}
  5971  		v.reset(OpLsh64x64)
  5972  		v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  5973  		v0.AddArg(x)
  5974  		v1 := b.NewValue0(v.Pos, OpConst64, t)
  5975  		v1.AuxInt = ntz(y)
  5976  		v0.AddArg(v1)
  5977  		v.AddArg(v0)
  5978  		v2 := b.NewValue0(v.Pos, OpConst64, t)
  5979  		v2.AuxInt = ntz(y)
  5980  		v.AddArg(v2)
  5981  		return true
  5982  	}
  5983  	// match: (And64 <t> x (Const64 [y]))
  5984  	// cond: nlo(y) + ntz(y) == 64 && ntz(y) >= 32
  5985  	// result: (Lsh64x64 (Rsh64Ux64 <t> x (Const64 <t> [ntz(y)])) (Const64 <t> [ntz(y)]))
  5986  	for {
  5987  		t := v.Type
  5988  		_ = v.Args[1]
  5989  		x := v.Args[0]
  5990  		v_1 := v.Args[1]
  5991  		if v_1.Op != OpConst64 {
  5992  			break
  5993  		}
  5994  		y := v_1.AuxInt
  5995  		if !(nlo(y)+ntz(y) == 64 && ntz(y) >= 32) {
  5996  			break
  5997  		}
  5998  		v.reset(OpLsh64x64)
  5999  		v0 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  6000  		v0.AddArg(x)
  6001  		v1 := b.NewValue0(v.Pos, OpConst64, t)
  6002  		v1.AuxInt = ntz(y)
  6003  		v0.AddArg(v1)
  6004  		v.AddArg(v0)
  6005  		v2 := b.NewValue0(v.Pos, OpConst64, t)
  6006  		v2.AuxInt = ntz(y)
  6007  		v.AddArg(v2)
  6008  		return true
  6009  	}
  6010  	// match: (And64 (And64 i:(Const64 <t>) z) x)
  6011  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  6012  	// result: (And64 i (And64 <t> z x))
  6013  	for {
  6014  		_ = v.Args[1]
  6015  		v_0 := v.Args[0]
  6016  		if v_0.Op != OpAnd64 {
  6017  			break
  6018  		}
  6019  		_ = v_0.Args[1]
  6020  		i := v_0.Args[0]
  6021  		if i.Op != OpConst64 {
  6022  			break
  6023  		}
  6024  		t := i.Type
  6025  		z := v_0.Args[1]
  6026  		x := v.Args[1]
  6027  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  6028  			break
  6029  		}
  6030  		v.reset(OpAnd64)
  6031  		v.AddArg(i)
  6032  		v0 := b.NewValue0(v.Pos, OpAnd64, t)
  6033  		v0.AddArg(z)
  6034  		v0.AddArg(x)
  6035  		v.AddArg(v0)
  6036  		return true
  6037  	}
  6038  	return false
  6039  }
  6040  func rewriteValuegeneric_OpAnd64_20(v *Value) bool {
  6041  	b := v.Block
  6042  	_ = b
  6043  	// match: (And64 (And64 z i:(Const64 <t>)) x)
  6044  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  6045  	// result: (And64 i (And64 <t> z x))
  6046  	for {
  6047  		_ = v.Args[1]
  6048  		v_0 := v.Args[0]
  6049  		if v_0.Op != OpAnd64 {
  6050  			break
  6051  		}
  6052  		_ = v_0.Args[1]
  6053  		z := v_0.Args[0]
  6054  		i := v_0.Args[1]
  6055  		if i.Op != OpConst64 {
  6056  			break
  6057  		}
  6058  		t := i.Type
  6059  		x := v.Args[1]
  6060  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  6061  			break
  6062  		}
  6063  		v.reset(OpAnd64)
  6064  		v.AddArg(i)
  6065  		v0 := b.NewValue0(v.Pos, OpAnd64, t)
  6066  		v0.AddArg(z)
  6067  		v0.AddArg(x)
  6068  		v.AddArg(v0)
  6069  		return true
  6070  	}
  6071  	// match: (And64 x (And64 i:(Const64 <t>) z))
  6072  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  6073  	// result: (And64 i (And64 <t> z x))
  6074  	for {
  6075  		_ = v.Args[1]
  6076  		x := v.Args[0]
  6077  		v_1 := v.Args[1]
  6078  		if v_1.Op != OpAnd64 {
  6079  			break
  6080  		}
  6081  		_ = v_1.Args[1]
  6082  		i := v_1.Args[0]
  6083  		if i.Op != OpConst64 {
  6084  			break
  6085  		}
  6086  		t := i.Type
  6087  		z := v_1.Args[1]
  6088  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  6089  			break
  6090  		}
  6091  		v.reset(OpAnd64)
  6092  		v.AddArg(i)
  6093  		v0 := b.NewValue0(v.Pos, OpAnd64, t)
  6094  		v0.AddArg(z)
  6095  		v0.AddArg(x)
  6096  		v.AddArg(v0)
  6097  		return true
  6098  	}
  6099  	// match: (And64 x (And64 z i:(Const64 <t>)))
  6100  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
  6101  	// result: (And64 i (And64 <t> z x))
  6102  	for {
  6103  		_ = v.Args[1]
  6104  		x := v.Args[0]
  6105  		v_1 := v.Args[1]
  6106  		if v_1.Op != OpAnd64 {
  6107  			break
  6108  		}
  6109  		_ = v_1.Args[1]
  6110  		z := v_1.Args[0]
  6111  		i := v_1.Args[1]
  6112  		if i.Op != OpConst64 {
  6113  			break
  6114  		}
  6115  		t := i.Type
  6116  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
  6117  			break
  6118  		}
  6119  		v.reset(OpAnd64)
  6120  		v.AddArg(i)
  6121  		v0 := b.NewValue0(v.Pos, OpAnd64, t)
  6122  		v0.AddArg(z)
  6123  		v0.AddArg(x)
  6124  		v.AddArg(v0)
  6125  		return true
  6126  	}
  6127  	// match: (And64 (Const64 <t> [c]) (And64 (Const64 <t> [d]) x))
  6128  	// cond:
  6129  	// result: (And64 (Const64 <t> [c&d]) x)
  6130  	for {
  6131  		_ = v.Args[1]
  6132  		v_0 := v.Args[0]
  6133  		if v_0.Op != OpConst64 {
  6134  			break
  6135  		}
  6136  		t := v_0.Type
  6137  		c := v_0.AuxInt
  6138  		v_1 := v.Args[1]
  6139  		if v_1.Op != OpAnd64 {
  6140  			break
  6141  		}
  6142  		_ = v_1.Args[1]
  6143  		v_1_0 := v_1.Args[0]
  6144  		if v_1_0.Op != OpConst64 {
  6145  			break
  6146  		}
  6147  		if v_1_0.Type != t {
  6148  			break
  6149  		}
  6150  		d := v_1_0.AuxInt
  6151  		x := v_1.Args[1]
  6152  		v.reset(OpAnd64)
  6153  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  6154  		v0.AuxInt = c & d
  6155  		v.AddArg(v0)
  6156  		v.AddArg(x)
  6157  		return true
  6158  	}
  6159  	// match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d])))
  6160  	// cond:
  6161  	// result: (And64 (Const64 <t> [c&d]) x)
  6162  	for {
  6163  		_ = v.Args[1]
  6164  		v_0 := v.Args[0]
  6165  		if v_0.Op != OpConst64 {
  6166  			break
  6167  		}
  6168  		t := v_0.Type
  6169  		c := v_0.AuxInt
  6170  		v_1 := v.Args[1]
  6171  		if v_1.Op != OpAnd64 {
  6172  			break
  6173  		}
  6174  		_ = v_1.Args[1]
  6175  		x := v_1.Args[0]
  6176  		v_1_1 := v_1.Args[1]
  6177  		if v_1_1.Op != OpConst64 {
  6178  			break
  6179  		}
  6180  		if v_1_1.Type != t {
  6181  			break
  6182  		}
  6183  		d := v_1_1.AuxInt
  6184  		v.reset(OpAnd64)
  6185  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  6186  		v0.AuxInt = c & d
  6187  		v.AddArg(v0)
  6188  		v.AddArg(x)
  6189  		return true
  6190  	}
  6191  	// match: (And64 (And64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  6192  	// cond:
  6193  	// result: (And64 (Const64 <t> [c&d]) x)
  6194  	for {
  6195  		_ = v.Args[1]
  6196  		v_0 := v.Args[0]
  6197  		if v_0.Op != OpAnd64 {
  6198  			break
  6199  		}
  6200  		_ = v_0.Args[1]
  6201  		v_0_0 := v_0.Args[0]
  6202  		if v_0_0.Op != OpConst64 {
  6203  			break
  6204  		}
  6205  		t := v_0_0.Type
  6206  		d := v_0_0.AuxInt
  6207  		x := v_0.Args[1]
  6208  		v_1 := v.Args[1]
  6209  		if v_1.Op != OpConst64 {
  6210  			break
  6211  		}
  6212  		if v_1.Type != t {
  6213  			break
  6214  		}
  6215  		c := v_1.AuxInt
  6216  		v.reset(OpAnd64)
  6217  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  6218  		v0.AuxInt = c & d
  6219  		v.AddArg(v0)
  6220  		v.AddArg(x)
  6221  		return true
  6222  	}
  6223  	// match: (And64 (And64 x (Const64 <t> [d])) (Const64 <t> [c]))
  6224  	// cond:
  6225  	// result: (And64 (Const64 <t> [c&d]) x)
  6226  	for {
  6227  		_ = v.Args[1]
  6228  		v_0 := v.Args[0]
  6229  		if v_0.Op != OpAnd64 {
  6230  			break
  6231  		}
  6232  		_ = v_0.Args[1]
  6233  		x := v_0.Args[0]
  6234  		v_0_1 := v_0.Args[1]
  6235  		if v_0_1.Op != OpConst64 {
  6236  			break
  6237  		}
  6238  		t := v_0_1.Type
  6239  		d := v_0_1.AuxInt
  6240  		v_1 := v.Args[1]
  6241  		if v_1.Op != OpConst64 {
  6242  			break
  6243  		}
  6244  		if v_1.Type != t {
  6245  			break
  6246  		}
  6247  		c := v_1.AuxInt
  6248  		v.reset(OpAnd64)
  6249  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  6250  		v0.AuxInt = c & d
  6251  		v.AddArg(v0)
  6252  		v.AddArg(x)
  6253  		return true
  6254  	}
  6255  	return false
  6256  }
  6257  func rewriteValuegeneric_OpAnd8_0(v *Value) bool {
  6258  	// match: (And8 (Const8 [c]) (Const8 [d]))
  6259  	// cond:
  6260  	// result: (Const8 [int64(int8(c&d))])
  6261  	for {
  6262  		_ = v.Args[1]
  6263  		v_0 := v.Args[0]
  6264  		if v_0.Op != OpConst8 {
  6265  			break
  6266  		}
  6267  		c := v_0.AuxInt
  6268  		v_1 := v.Args[1]
  6269  		if v_1.Op != OpConst8 {
  6270  			break
  6271  		}
  6272  		d := v_1.AuxInt
  6273  		v.reset(OpConst8)
  6274  		v.AuxInt = int64(int8(c & d))
  6275  		return true
  6276  	}
  6277  	// match: (And8 (Const8 [d]) (Const8 [c]))
  6278  	// cond:
  6279  	// result: (Const8 [int64(int8(c&d))])
  6280  	for {
  6281  		_ = v.Args[1]
  6282  		v_0 := v.Args[0]
  6283  		if v_0.Op != OpConst8 {
  6284  			break
  6285  		}
  6286  		d := v_0.AuxInt
  6287  		v_1 := v.Args[1]
  6288  		if v_1.Op != OpConst8 {
  6289  			break
  6290  		}
  6291  		c := v_1.AuxInt
  6292  		v.reset(OpConst8)
  6293  		v.AuxInt = int64(int8(c & d))
  6294  		return true
  6295  	}
  6296  	// match: (And8 (Const8 [m]) (Rsh8Ux64 _ (Const64 [c])))
  6297  	// cond: c >= 64-ntz(m)
  6298  	// result: (Const8 [0])
  6299  	for {
  6300  		_ = v.Args[1]
  6301  		v_0 := v.Args[0]
  6302  		if v_0.Op != OpConst8 {
  6303  			break
  6304  		}
  6305  		m := v_0.AuxInt
  6306  		v_1 := v.Args[1]
  6307  		if v_1.Op != OpRsh8Ux64 {
  6308  			break
  6309  		}
  6310  		_ = v_1.Args[1]
  6311  		v_1_1 := v_1.Args[1]
  6312  		if v_1_1.Op != OpConst64 {
  6313  			break
  6314  		}
  6315  		c := v_1_1.AuxInt
  6316  		if !(c >= 64-ntz(m)) {
  6317  			break
  6318  		}
  6319  		v.reset(OpConst8)
  6320  		v.AuxInt = 0
  6321  		return true
  6322  	}
  6323  	// match: (And8 (Rsh8Ux64 _ (Const64 [c])) (Const8 [m]))
  6324  	// cond: c >= 64-ntz(m)
  6325  	// result: (Const8 [0])
  6326  	for {
  6327  		_ = v.Args[1]
  6328  		v_0 := v.Args[0]
  6329  		if v_0.Op != OpRsh8Ux64 {
  6330  			break
  6331  		}
  6332  		_ = v_0.Args[1]
  6333  		v_0_1 := v_0.Args[1]
  6334  		if v_0_1.Op != OpConst64 {
  6335  			break
  6336  		}
  6337  		c := v_0_1.AuxInt
  6338  		v_1 := v.Args[1]
  6339  		if v_1.Op != OpConst8 {
  6340  			break
  6341  		}
  6342  		m := v_1.AuxInt
  6343  		if !(c >= 64-ntz(m)) {
  6344  			break
  6345  		}
  6346  		v.reset(OpConst8)
  6347  		v.AuxInt = 0
  6348  		return true
  6349  	}
  6350  	// match: (And8 (Const8 [m]) (Lsh8x64 _ (Const64 [c])))
  6351  	// cond: c >= 64-nlz(m)
  6352  	// result: (Const8 [0])
  6353  	for {
  6354  		_ = v.Args[1]
  6355  		v_0 := v.Args[0]
  6356  		if v_0.Op != OpConst8 {
  6357  			break
  6358  		}
  6359  		m := v_0.AuxInt
  6360  		v_1 := v.Args[1]
  6361  		if v_1.Op != OpLsh8x64 {
  6362  			break
  6363  		}
  6364  		_ = v_1.Args[1]
  6365  		v_1_1 := v_1.Args[1]
  6366  		if v_1_1.Op != OpConst64 {
  6367  			break
  6368  		}
  6369  		c := v_1_1.AuxInt
  6370  		if !(c >= 64-nlz(m)) {
  6371  			break
  6372  		}
  6373  		v.reset(OpConst8)
  6374  		v.AuxInt = 0
  6375  		return true
  6376  	}
  6377  	// match: (And8 (Lsh8x64 _ (Const64 [c])) (Const8 [m]))
  6378  	// cond: c >= 64-nlz(m)
  6379  	// result: (Const8 [0])
  6380  	for {
  6381  		_ = v.Args[1]
  6382  		v_0 := v.Args[0]
  6383  		if v_0.Op != OpLsh8x64 {
  6384  			break
  6385  		}
  6386  		_ = v_0.Args[1]
  6387  		v_0_1 := v_0.Args[1]
  6388  		if v_0_1.Op != OpConst64 {
  6389  			break
  6390  		}
  6391  		c := v_0_1.AuxInt
  6392  		v_1 := v.Args[1]
  6393  		if v_1.Op != OpConst8 {
  6394  			break
  6395  		}
  6396  		m := v_1.AuxInt
  6397  		if !(c >= 64-nlz(m)) {
  6398  			break
  6399  		}
  6400  		v.reset(OpConst8)
  6401  		v.AuxInt = 0
  6402  		return true
  6403  	}
  6404  	// match: (And8 x x)
  6405  	// cond:
  6406  	// result: x
  6407  	for {
  6408  		_ = v.Args[1]
  6409  		x := v.Args[0]
  6410  		if x != v.Args[1] {
  6411  			break
  6412  		}
  6413  		v.reset(OpCopy)
  6414  		v.Type = x.Type
  6415  		v.AddArg(x)
  6416  		return true
  6417  	}
  6418  	// match: (And8 (Const8 [-1]) x)
  6419  	// cond:
  6420  	// result: x
  6421  	for {
  6422  		_ = v.Args[1]
  6423  		v_0 := v.Args[0]
  6424  		if v_0.Op != OpConst8 {
  6425  			break
  6426  		}
  6427  		if v_0.AuxInt != -1 {
  6428  			break
  6429  		}
  6430  		x := v.Args[1]
  6431  		v.reset(OpCopy)
  6432  		v.Type = x.Type
  6433  		v.AddArg(x)
  6434  		return true
  6435  	}
  6436  	// match: (And8 x (Const8 [-1]))
  6437  	// cond:
  6438  	// result: x
  6439  	for {
  6440  		_ = v.Args[1]
  6441  		x := v.Args[0]
  6442  		v_1 := v.Args[1]
  6443  		if v_1.Op != OpConst8 {
  6444  			break
  6445  		}
  6446  		if v_1.AuxInt != -1 {
  6447  			break
  6448  		}
  6449  		v.reset(OpCopy)
  6450  		v.Type = x.Type
  6451  		v.AddArg(x)
  6452  		return true
  6453  	}
  6454  	// match: (And8 (Const8 [0]) _)
  6455  	// cond:
  6456  	// result: (Const8 [0])
  6457  	for {
  6458  		_ = v.Args[1]
  6459  		v_0 := v.Args[0]
  6460  		if v_0.Op != OpConst8 {
  6461  			break
  6462  		}
  6463  		if v_0.AuxInt != 0 {
  6464  			break
  6465  		}
  6466  		v.reset(OpConst8)
  6467  		v.AuxInt = 0
  6468  		return true
  6469  	}
  6470  	return false
  6471  }
  6472  func rewriteValuegeneric_OpAnd8_10(v *Value) bool {
  6473  	b := v.Block
  6474  	_ = b
  6475  	// match: (And8 _ (Const8 [0]))
  6476  	// cond:
  6477  	// result: (Const8 [0])
  6478  	for {
  6479  		_ = v.Args[1]
  6480  		v_1 := v.Args[1]
  6481  		if v_1.Op != OpConst8 {
  6482  			break
  6483  		}
  6484  		if v_1.AuxInt != 0 {
  6485  			break
  6486  		}
  6487  		v.reset(OpConst8)
  6488  		v.AuxInt = 0
  6489  		return true
  6490  	}
  6491  	// match: (And8 x (And8 x y))
  6492  	// cond:
  6493  	// result: (And8 x y)
  6494  	for {
  6495  		_ = v.Args[1]
  6496  		x := v.Args[0]
  6497  		v_1 := v.Args[1]
  6498  		if v_1.Op != OpAnd8 {
  6499  			break
  6500  		}
  6501  		_ = v_1.Args[1]
  6502  		if x != v_1.Args[0] {
  6503  			break
  6504  		}
  6505  		y := v_1.Args[1]
  6506  		v.reset(OpAnd8)
  6507  		v.AddArg(x)
  6508  		v.AddArg(y)
  6509  		return true
  6510  	}
  6511  	// match: (And8 x (And8 y x))
  6512  	// cond:
  6513  	// result: (And8 x y)
  6514  	for {
  6515  		_ = v.Args[1]
  6516  		x := v.Args[0]
  6517  		v_1 := v.Args[1]
  6518  		if v_1.Op != OpAnd8 {
  6519  			break
  6520  		}
  6521  		_ = v_1.Args[1]
  6522  		y := v_1.Args[0]
  6523  		if x != v_1.Args[1] {
  6524  			break
  6525  		}
  6526  		v.reset(OpAnd8)
  6527  		v.AddArg(x)
  6528  		v.AddArg(y)
  6529  		return true
  6530  	}
  6531  	// match: (And8 (And8 x y) x)
  6532  	// cond:
  6533  	// result: (And8 x y)
  6534  	for {
  6535  		_ = v.Args[1]
  6536  		v_0 := v.Args[0]
  6537  		if v_0.Op != OpAnd8 {
  6538  			break
  6539  		}
  6540  		_ = v_0.Args[1]
  6541  		x := v_0.Args[0]
  6542  		y := v_0.Args[1]
  6543  		if x != v.Args[1] {
  6544  			break
  6545  		}
  6546  		v.reset(OpAnd8)
  6547  		v.AddArg(x)
  6548  		v.AddArg(y)
  6549  		return true
  6550  	}
  6551  	// match: (And8 (And8 y x) x)
  6552  	// cond:
  6553  	// result: (And8 x y)
  6554  	for {
  6555  		_ = v.Args[1]
  6556  		v_0 := v.Args[0]
  6557  		if v_0.Op != OpAnd8 {
  6558  			break
  6559  		}
  6560  		_ = v_0.Args[1]
  6561  		y := v_0.Args[0]
  6562  		x := v_0.Args[1]
  6563  		if x != v.Args[1] {
  6564  			break
  6565  		}
  6566  		v.reset(OpAnd8)
  6567  		v.AddArg(x)
  6568  		v.AddArg(y)
  6569  		return true
  6570  	}
  6571  	// match: (And8 (And8 i:(Const8 <t>) z) x)
  6572  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6573  	// result: (And8 i (And8 <t> z x))
  6574  	for {
  6575  		_ = v.Args[1]
  6576  		v_0 := v.Args[0]
  6577  		if v_0.Op != OpAnd8 {
  6578  			break
  6579  		}
  6580  		_ = v_0.Args[1]
  6581  		i := v_0.Args[0]
  6582  		if i.Op != OpConst8 {
  6583  			break
  6584  		}
  6585  		t := i.Type
  6586  		z := v_0.Args[1]
  6587  		x := v.Args[1]
  6588  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6589  			break
  6590  		}
  6591  		v.reset(OpAnd8)
  6592  		v.AddArg(i)
  6593  		v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6594  		v0.AddArg(z)
  6595  		v0.AddArg(x)
  6596  		v.AddArg(v0)
  6597  		return true
  6598  	}
  6599  	// match: (And8 (And8 z i:(Const8 <t>)) x)
  6600  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6601  	// result: (And8 i (And8 <t> z x))
  6602  	for {
  6603  		_ = v.Args[1]
  6604  		v_0 := v.Args[0]
  6605  		if v_0.Op != OpAnd8 {
  6606  			break
  6607  		}
  6608  		_ = v_0.Args[1]
  6609  		z := v_0.Args[0]
  6610  		i := v_0.Args[1]
  6611  		if i.Op != OpConst8 {
  6612  			break
  6613  		}
  6614  		t := i.Type
  6615  		x := v.Args[1]
  6616  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6617  			break
  6618  		}
  6619  		v.reset(OpAnd8)
  6620  		v.AddArg(i)
  6621  		v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6622  		v0.AddArg(z)
  6623  		v0.AddArg(x)
  6624  		v.AddArg(v0)
  6625  		return true
  6626  	}
  6627  	// match: (And8 x (And8 i:(Const8 <t>) z))
  6628  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6629  	// result: (And8 i (And8 <t> z x))
  6630  	for {
  6631  		_ = v.Args[1]
  6632  		x := v.Args[0]
  6633  		v_1 := v.Args[1]
  6634  		if v_1.Op != OpAnd8 {
  6635  			break
  6636  		}
  6637  		_ = v_1.Args[1]
  6638  		i := v_1.Args[0]
  6639  		if i.Op != OpConst8 {
  6640  			break
  6641  		}
  6642  		t := i.Type
  6643  		z := v_1.Args[1]
  6644  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6645  			break
  6646  		}
  6647  		v.reset(OpAnd8)
  6648  		v.AddArg(i)
  6649  		v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6650  		v0.AddArg(z)
  6651  		v0.AddArg(x)
  6652  		v.AddArg(v0)
  6653  		return true
  6654  	}
  6655  	// match: (And8 x (And8 z i:(Const8 <t>)))
  6656  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
  6657  	// result: (And8 i (And8 <t> z x))
  6658  	for {
  6659  		_ = v.Args[1]
  6660  		x := v.Args[0]
  6661  		v_1 := v.Args[1]
  6662  		if v_1.Op != OpAnd8 {
  6663  			break
  6664  		}
  6665  		_ = v_1.Args[1]
  6666  		z := v_1.Args[0]
  6667  		i := v_1.Args[1]
  6668  		if i.Op != OpConst8 {
  6669  			break
  6670  		}
  6671  		t := i.Type
  6672  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
  6673  			break
  6674  		}
  6675  		v.reset(OpAnd8)
  6676  		v.AddArg(i)
  6677  		v0 := b.NewValue0(v.Pos, OpAnd8, t)
  6678  		v0.AddArg(z)
  6679  		v0.AddArg(x)
  6680  		v.AddArg(v0)
  6681  		return true
  6682  	}
  6683  	// match: (And8 (Const8 <t> [c]) (And8 (Const8 <t> [d]) x))
  6684  	// cond:
  6685  	// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6686  	for {
  6687  		_ = v.Args[1]
  6688  		v_0 := v.Args[0]
  6689  		if v_0.Op != OpConst8 {
  6690  			break
  6691  		}
  6692  		t := v_0.Type
  6693  		c := v_0.AuxInt
  6694  		v_1 := v.Args[1]
  6695  		if v_1.Op != OpAnd8 {
  6696  			break
  6697  		}
  6698  		_ = v_1.Args[1]
  6699  		v_1_0 := v_1.Args[0]
  6700  		if v_1_0.Op != OpConst8 {
  6701  			break
  6702  		}
  6703  		if v_1_0.Type != t {
  6704  			break
  6705  		}
  6706  		d := v_1_0.AuxInt
  6707  		x := v_1.Args[1]
  6708  		v.reset(OpAnd8)
  6709  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  6710  		v0.AuxInt = int64(int8(c & d))
  6711  		v.AddArg(v0)
  6712  		v.AddArg(x)
  6713  		return true
  6714  	}
  6715  	return false
  6716  }
  6717  func rewriteValuegeneric_OpAnd8_20(v *Value) bool {
  6718  	b := v.Block
  6719  	_ = b
  6720  	// match: (And8 (Const8 <t> [c]) (And8 x (Const8 <t> [d])))
  6721  	// cond:
  6722  	// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6723  	for {
  6724  		_ = v.Args[1]
  6725  		v_0 := v.Args[0]
  6726  		if v_0.Op != OpConst8 {
  6727  			break
  6728  		}
  6729  		t := v_0.Type
  6730  		c := v_0.AuxInt
  6731  		v_1 := v.Args[1]
  6732  		if v_1.Op != OpAnd8 {
  6733  			break
  6734  		}
  6735  		_ = v_1.Args[1]
  6736  		x := v_1.Args[0]
  6737  		v_1_1 := v_1.Args[1]
  6738  		if v_1_1.Op != OpConst8 {
  6739  			break
  6740  		}
  6741  		if v_1_1.Type != t {
  6742  			break
  6743  		}
  6744  		d := v_1_1.AuxInt
  6745  		v.reset(OpAnd8)
  6746  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  6747  		v0.AuxInt = int64(int8(c & d))
  6748  		v.AddArg(v0)
  6749  		v.AddArg(x)
  6750  		return true
  6751  	}
  6752  	// match: (And8 (And8 (Const8 <t> [d]) x) (Const8 <t> [c]))
  6753  	// cond:
  6754  	// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6755  	for {
  6756  		_ = v.Args[1]
  6757  		v_0 := v.Args[0]
  6758  		if v_0.Op != OpAnd8 {
  6759  			break
  6760  		}
  6761  		_ = v_0.Args[1]
  6762  		v_0_0 := v_0.Args[0]
  6763  		if v_0_0.Op != OpConst8 {
  6764  			break
  6765  		}
  6766  		t := v_0_0.Type
  6767  		d := v_0_0.AuxInt
  6768  		x := v_0.Args[1]
  6769  		v_1 := v.Args[1]
  6770  		if v_1.Op != OpConst8 {
  6771  			break
  6772  		}
  6773  		if v_1.Type != t {
  6774  			break
  6775  		}
  6776  		c := v_1.AuxInt
  6777  		v.reset(OpAnd8)
  6778  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  6779  		v0.AuxInt = int64(int8(c & d))
  6780  		v.AddArg(v0)
  6781  		v.AddArg(x)
  6782  		return true
  6783  	}
  6784  	// match: (And8 (And8 x (Const8 <t> [d])) (Const8 <t> [c]))
  6785  	// cond:
  6786  	// result: (And8 (Const8 <t> [int64(int8(c&d))]) x)
  6787  	for {
  6788  		_ = v.Args[1]
  6789  		v_0 := v.Args[0]
  6790  		if v_0.Op != OpAnd8 {
  6791  			break
  6792  		}
  6793  		_ = v_0.Args[1]
  6794  		x := v_0.Args[0]
  6795  		v_0_1 := v_0.Args[1]
  6796  		if v_0_1.Op != OpConst8 {
  6797  			break
  6798  		}
  6799  		t := v_0_1.Type
  6800  		d := v_0_1.AuxInt
  6801  		v_1 := v.Args[1]
  6802  		if v_1.Op != OpConst8 {
  6803  			break
  6804  		}
  6805  		if v_1.Type != t {
  6806  			break
  6807  		}
  6808  		c := v_1.AuxInt
  6809  		v.reset(OpAnd8)
  6810  		v0 := b.NewValue0(v.Pos, OpConst8, t)
  6811  		v0.AuxInt = int64(int8(c & d))
  6812  		v.AddArg(v0)
  6813  		v.AddArg(x)
  6814  		return true
  6815  	}
  6816  	return false
  6817  }
  6818  func rewriteValuegeneric_OpArg_0(v *Value) bool {
  6819  	b := v.Block
  6820  	_ = b
  6821  	config := b.Func.Config
  6822  	_ = config
  6823  	fe := b.Func.fe
  6824  	_ = fe
  6825  	typ := &b.Func.Config.Types
  6826  	_ = typ
  6827  	// match: (Arg {n} [off])
  6828  	// cond: v.Type.IsString()
  6829  	// result: (StringMake (Arg <typ.BytePtr> {n} [off]) (Arg <typ.Int> {n} [off+config.PtrSize]))
  6830  	for {
  6831  		off := v.AuxInt
  6832  		n := v.Aux
  6833  		if !(v.Type.IsString()) {
  6834  			break
  6835  		}
  6836  		v.reset(OpStringMake)
  6837  		v0 := b.NewValue0(v.Pos, OpArg, typ.BytePtr)
  6838  		v0.AuxInt = off
  6839  		v0.Aux = n
  6840  		v.AddArg(v0)
  6841  		v1 := b.NewValue0(v.Pos, OpArg, typ.Int)
  6842  		v1.AuxInt = off + config.PtrSize
  6843  		v1.Aux = n
  6844  		v.AddArg(v1)
  6845  		return true
  6846  	}
  6847  	// match: (Arg {n} [off])
  6848  	// cond: v.Type.IsSlice()
  6849  	// result: (SliceMake (Arg <v.Type.Elem().PtrTo()> {n} [off]) (Arg <typ.Int> {n} [off+config.PtrSize]) (Arg <typ.Int> {n} [off+2*config.PtrSize]))
  6850  	for {
  6851  		off := v.AuxInt
  6852  		n := v.Aux
  6853  		if !(v.Type.IsSlice()) {
  6854  			break
  6855  		}
  6856  		v.reset(OpSliceMake)
  6857  		v0 := b.NewValue0(v.Pos, OpArg, v.Type.Elem().PtrTo())
  6858  		v0.AuxInt = off
  6859  		v0.Aux = n
  6860  		v.AddArg(v0)
  6861  		v1 := b.NewValue0(v.Pos, OpArg, typ.Int)
  6862  		v1.AuxInt = off + config.PtrSize
  6863  		v1.Aux = n
  6864  		v.AddArg(v1)
  6865  		v2 := b.NewValue0(v.Pos, OpArg, typ.Int)
  6866  		v2.AuxInt = off + 2*config.PtrSize
  6867  		v2.Aux = n
  6868  		v.AddArg(v2)
  6869  		return true
  6870  	}
  6871  	// match: (Arg {n} [off])
  6872  	// cond: v.Type.IsInterface()
  6873  	// result: (IMake (Arg <typ.Uintptr> {n} [off]) (Arg <typ.BytePtr> {n} [off+config.PtrSize]))
  6874  	for {
  6875  		off := v.AuxInt
  6876  		n := v.Aux
  6877  		if !(v.Type.IsInterface()) {
  6878  			break
  6879  		}
  6880  		v.reset(OpIMake)
  6881  		v0 := b.NewValue0(v.Pos, OpArg, typ.Uintptr)
  6882  		v0.AuxInt = off
  6883  		v0.Aux = n
  6884  		v.AddArg(v0)
  6885  		v1 := b.NewValue0(v.Pos, OpArg, typ.BytePtr)
  6886  		v1.AuxInt = off + config.PtrSize
  6887  		v1.Aux = n
  6888  		v.AddArg(v1)
  6889  		return true
  6890  	}
  6891  	// match: (Arg {n} [off])
  6892  	// cond: v.Type.IsComplex() && v.Type.Size() == 16
  6893  	// result: (ComplexMake (Arg <typ.Float64> {n} [off]) (Arg <typ.Float64> {n} [off+8]))
  6894  	for {
  6895  		off := v.AuxInt
  6896  		n := v.Aux
  6897  		if !(v.Type.IsComplex() && v.Type.Size() == 16) {
  6898  			break
  6899  		}
  6900  		v.reset(OpComplexMake)
  6901  		v0 := b.NewValue0(v.Pos, OpArg, typ.Float64)
  6902  		v0.AuxInt = off
  6903  		v0.Aux = n
  6904  		v.AddArg(v0)
  6905  		v1 := b.NewValue0(v.Pos, OpArg, typ.Float64)
  6906  		v1.AuxInt = off + 8
  6907  		v1.Aux = n
  6908  		v.AddArg(v1)
  6909  		return true
  6910  	}
  6911  	// match: (Arg {n} [off])
  6912  	// cond: v.Type.IsComplex() && v.Type.Size() == 8
  6913  	// result: (ComplexMake (Arg <typ.Float32> {n} [off]) (Arg <typ.Float32> {n} [off+4]))
  6914  	for {
  6915  		off := v.AuxInt
  6916  		n := v.Aux
  6917  		if !(v.Type.IsComplex() && v.Type.Size() == 8) {
  6918  			break
  6919  		}
  6920  		v.reset(OpComplexMake)
  6921  		v0 := b.NewValue0(v.Pos, OpArg, typ.Float32)
  6922  		v0.AuxInt = off
  6923  		v0.Aux = n
  6924  		v.AddArg(v0)
  6925  		v1 := b.NewValue0(v.Pos, OpArg, typ.Float32)
  6926  		v1.AuxInt = off + 4
  6927  		v1.Aux = n
  6928  		v.AddArg(v1)
  6929  		return true
  6930  	}
  6931  	// match: (Arg <t>)
  6932  	// cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)
  6933  	// result: (StructMake0)
  6934  	for {
  6935  		t := v.Type
  6936  		if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) {
  6937  			break
  6938  		}
  6939  		v.reset(OpStructMake0)
  6940  		return true
  6941  	}
  6942  	// match: (Arg <t> {n} [off])
  6943  	// cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)
  6944  	// result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]))
  6945  	for {
  6946  		t := v.Type
  6947  		off := v.AuxInt
  6948  		n := v.Aux
  6949  		if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) {
  6950  			break
  6951  		}
  6952  		v.reset(OpStructMake1)
  6953  		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
  6954  		v0.AuxInt = off + t.FieldOff(0)
  6955  		v0.Aux = n
  6956  		v.AddArg(v0)
  6957  		return true
  6958  	}
  6959  	// match: (Arg <t> {n} [off])
  6960  	// cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)
  6961  	// result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]))
  6962  	for {
  6963  		t := v.Type
  6964  		off := v.AuxInt
  6965  		n := v.Aux
  6966  		if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) {
  6967  			break
  6968  		}
  6969  		v.reset(OpStructMake2)
  6970  		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
  6971  		v0.AuxInt = off + t.FieldOff(0)
  6972  		v0.Aux = n
  6973  		v.AddArg(v0)
  6974  		v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
  6975  		v1.AuxInt = off + t.FieldOff(1)
  6976  		v1.Aux = n
  6977  		v.AddArg(v1)
  6978  		return true
  6979  	}
  6980  	// match: (Arg <t> {n} [off])
  6981  	// cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)
  6982  	// result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]))
  6983  	for {
  6984  		t := v.Type
  6985  		off := v.AuxInt
  6986  		n := v.Aux
  6987  		if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) {
  6988  			break
  6989  		}
  6990  		v.reset(OpStructMake3)
  6991  		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
  6992  		v0.AuxInt = off + t.FieldOff(0)
  6993  		v0.Aux = n
  6994  		v.AddArg(v0)
  6995  		v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
  6996  		v1.AuxInt = off + t.FieldOff(1)
  6997  		v1.Aux = n
  6998  		v.AddArg(v1)
  6999  		v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2))
  7000  		v2.AuxInt = off + t.FieldOff(2)
  7001  		v2.Aux = n
  7002  		v.AddArg(v2)
  7003  		return true
  7004  	}
  7005  	// match: (Arg <t> {n} [off])
  7006  	// cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)
  7007  	// result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]) (Arg <t.FieldType(3)> {n} [off+t.FieldOff(3)]))
  7008  	for {
  7009  		t := v.Type
  7010  		off := v.AuxInt
  7011  		n := v.Aux
  7012  		if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) {
  7013  			break
  7014  		}
  7015  		v.reset(OpStructMake4)
  7016  		v0 := b.NewValue0(v.Pos, OpArg, t.FieldType(0))
  7017  		v0.AuxInt = off + t.FieldOff(0)
  7018  		v0.Aux = n
  7019  		v.AddArg(v0)
  7020  		v1 := b.NewValue0(v.Pos, OpArg, t.FieldType(1))
  7021  		v1.AuxInt = off + t.FieldOff(1)
  7022  		v1.Aux = n
  7023  		v.AddArg(v1)
  7024  		v2 := b.NewValue0(v.Pos, OpArg, t.FieldType(2))
  7025  		v2.AuxInt = off + t.FieldOff(2)
  7026  		v2.Aux = n
  7027  		v.AddArg(v2)
  7028  		v3 := b.NewValue0(v.Pos, OpArg, t.FieldType(3))
  7029  		v3.AuxInt = off + t.FieldOff(3)
  7030  		v3.Aux = n
  7031  		v.AddArg(v3)
  7032  		return true
  7033  	}
  7034  	return false
  7035  }
  7036  func rewriteValuegeneric_OpArg_10(v *Value) bool {
  7037  	b := v.Block
  7038  	_ = b
  7039  	fe := b.Func.fe
  7040  	_ = fe
  7041  	// match: (Arg <t>)
  7042  	// cond: t.IsArray() && t.NumElem() == 0
  7043  	// result: (ArrayMake0)
  7044  	for {
  7045  		t := v.Type
  7046  		if !(t.IsArray() && t.NumElem() == 0) {
  7047  			break
  7048  		}
  7049  		v.reset(OpArrayMake0)
  7050  		return true
  7051  	}
  7052  	// match: (Arg <t> {n} [off])
  7053  	// cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)
  7054  	// result: (ArrayMake1 (Arg <t.Elem()> {n} [off]))
  7055  	for {
  7056  		t := v.Type
  7057  		off := v.AuxInt
  7058  		n := v.Aux
  7059  		if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) {
  7060  			break
  7061  		}
  7062  		v.reset(OpArrayMake1)
  7063  		v0 := b.NewValue0(v.Pos, OpArg, t.Elem())
  7064  		v0.AuxInt = off
  7065  		v0.Aux = n
  7066  		v.AddArg(v0)
  7067  		return true
  7068  	}
  7069  	return false
  7070  }
  7071  func rewriteValuegeneric_OpArraySelect_0(v *Value) bool {
  7072  	// match: (ArraySelect (ArrayMake1 x))
  7073  	// cond:
  7074  	// result: x
  7075  	for {
  7076  		v_0 := v.Args[0]
  7077  		if v_0.Op != OpArrayMake1 {
  7078  			break
  7079  		}
  7080  		x := v_0.Args[0]
  7081  		v.reset(OpCopy)
  7082  		v.Type = x.Type
  7083  		v.AddArg(x)
  7084  		return true
  7085  	}
  7086  	// match: (ArraySelect [0] x:(IData _))
  7087  	// cond:
  7088  	// result: x
  7089  	for {
  7090  		if v.AuxInt != 0 {
  7091  			break
  7092  		}
  7093  		x := v.Args[0]
  7094  		if x.Op != OpIData {
  7095  			break
  7096  		}
  7097  		v.reset(OpCopy)
  7098  		v.Type = x.Type
  7099  		v.AddArg(x)
  7100  		return true
  7101  	}
  7102  	return false
  7103  }
  7104  func rewriteValuegeneric_OpCom16_0(v *Value) bool {
  7105  	// match: (Com16 (Com16 x))
  7106  	// cond:
  7107  	// result: x
  7108  	for {
  7109  		v_0 := v.Args[0]
  7110  		if v_0.Op != OpCom16 {
  7111  			break
  7112  		}
  7113  		x := v_0.Args[0]
  7114  		v.reset(OpCopy)
  7115  		v.Type = x.Type
  7116  		v.AddArg(x)
  7117  		return true
  7118  	}
  7119  	// match: (Com16 (Const16 [c]))
  7120  	// cond:
  7121  	// result: (Const16 [^c])
  7122  	for {
  7123  		v_0 := v.Args[0]
  7124  		if v_0.Op != OpConst16 {
  7125  			break
  7126  		}
  7127  		c := v_0.AuxInt
  7128  		v.reset(OpConst16)
  7129  		v.AuxInt = ^c
  7130  		return true
  7131  	}
  7132  	return false
  7133  }
  7134  func rewriteValuegeneric_OpCom32_0(v *Value) bool {
  7135  	// match: (Com32 (Com32 x))
  7136  	// cond:
  7137  	// result: x
  7138  	for {
  7139  		v_0 := v.Args[0]
  7140  		if v_0.Op != OpCom32 {
  7141  			break
  7142  		}
  7143  		x := v_0.Args[0]
  7144  		v.reset(OpCopy)
  7145  		v.Type = x.Type
  7146  		v.AddArg(x)
  7147  		return true
  7148  	}
  7149  	// match: (Com32 (Const32 [c]))
  7150  	// cond:
  7151  	// result: (Const32 [^c])
  7152  	for {
  7153  		v_0 := v.Args[0]
  7154  		if v_0.Op != OpConst32 {
  7155  			break
  7156  		}
  7157  		c := v_0.AuxInt
  7158  		v.reset(OpConst32)
  7159  		v.AuxInt = ^c
  7160  		return true
  7161  	}
  7162  	return false
  7163  }
  7164  func rewriteValuegeneric_OpCom64_0(v *Value) bool {
  7165  	// match: (Com64 (Com64 x))
  7166  	// cond:
  7167  	// result: x
  7168  	for {
  7169  		v_0 := v.Args[0]
  7170  		if v_0.Op != OpCom64 {
  7171  			break
  7172  		}
  7173  		x := v_0.Args[0]
  7174  		v.reset(OpCopy)
  7175  		v.Type = x.Type
  7176  		v.AddArg(x)
  7177  		return true
  7178  	}
  7179  	// match: (Com64 (Const64 [c]))
  7180  	// cond:
  7181  	// result: (Const64 [^c])
  7182  	for {
  7183  		v_0 := v.Args[0]
  7184  		if v_0.Op != OpConst64 {
  7185  			break
  7186  		}
  7187  		c := v_0.AuxInt
  7188  		v.reset(OpConst64)
  7189  		v.AuxInt = ^c
  7190  		return true
  7191  	}
  7192  	return false
  7193  }
  7194  func rewriteValuegeneric_OpCom8_0(v *Value) bool {
  7195  	// match: (Com8 (Com8 x))
  7196  	// cond:
  7197  	// result: x
  7198  	for {
  7199  		v_0 := v.Args[0]
  7200  		if v_0.Op != OpCom8 {
  7201  			break
  7202  		}
  7203  		x := v_0.Args[0]
  7204  		v.reset(OpCopy)
  7205  		v.Type = x.Type
  7206  		v.AddArg(x)
  7207  		return true
  7208  	}
  7209  	// match: (Com8 (Const8 [c]))
  7210  	// cond:
  7211  	// result: (Const8 [^c])
  7212  	for {
  7213  		v_0 := v.Args[0]
  7214  		if v_0.Op != OpConst8 {
  7215  			break
  7216  		}
  7217  		c := v_0.AuxInt
  7218  		v.reset(OpConst8)
  7219  		v.AuxInt = ^c
  7220  		return true
  7221  	}
  7222  	return false
  7223  }
  7224  func rewriteValuegeneric_OpConstInterface_0(v *Value) bool {
  7225  	b := v.Block
  7226  	_ = b
  7227  	typ := &b.Func.Config.Types
  7228  	_ = typ
  7229  	// match: (ConstInterface)
  7230  	// cond:
  7231  	// result: (IMake (ConstNil <typ.Uintptr>) (ConstNil <typ.BytePtr>))
  7232  	for {
  7233  		v.reset(OpIMake)
  7234  		v0 := b.NewValue0(v.Pos, OpConstNil, typ.Uintptr)
  7235  		v.AddArg(v0)
  7236  		v1 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
  7237  		v.AddArg(v1)
  7238  		return true
  7239  	}
  7240  }
  7241  func rewriteValuegeneric_OpConstSlice_0(v *Value) bool {
  7242  	b := v.Block
  7243  	_ = b
  7244  	config := b.Func.Config
  7245  	_ = config
  7246  	typ := &b.Func.Config.Types
  7247  	_ = typ
  7248  	// match: (ConstSlice)
  7249  	// cond: config.PtrSize == 4
  7250  	// result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const32 <typ.Int> [0]) (Const32 <typ.Int> [0]))
  7251  	for {
  7252  		if !(config.PtrSize == 4) {
  7253  			break
  7254  		}
  7255  		v.reset(OpSliceMake)
  7256  		v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo())
  7257  		v.AddArg(v0)
  7258  		v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  7259  		v1.AuxInt = 0
  7260  		v.AddArg(v1)
  7261  		v2 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  7262  		v2.AuxInt = 0
  7263  		v.AddArg(v2)
  7264  		return true
  7265  	}
  7266  	// match: (ConstSlice)
  7267  	// cond: config.PtrSize == 8
  7268  	// result: (SliceMake (ConstNil <v.Type.Elem().PtrTo()>) (Const64 <typ.Int> [0]) (Const64 <typ.Int> [0]))
  7269  	for {
  7270  		if !(config.PtrSize == 8) {
  7271  			break
  7272  		}
  7273  		v.reset(OpSliceMake)
  7274  		v0 := b.NewValue0(v.Pos, OpConstNil, v.Type.Elem().PtrTo())
  7275  		v.AddArg(v0)
  7276  		v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  7277  		v1.AuxInt = 0
  7278  		v.AddArg(v1)
  7279  		v2 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  7280  		v2.AuxInt = 0
  7281  		v.AddArg(v2)
  7282  		return true
  7283  	}
  7284  	return false
  7285  }
  7286  func rewriteValuegeneric_OpConstString_0(v *Value) bool {
  7287  	b := v.Block
  7288  	_ = b
  7289  	config := b.Func.Config
  7290  	_ = config
  7291  	fe := b.Func.fe
  7292  	_ = fe
  7293  	typ := &b.Func.Config.Types
  7294  	_ = typ
  7295  	// match: (ConstString {s})
  7296  	// cond: config.PtrSize == 4 && s.(string) == ""
  7297  	// result: (StringMake (ConstNil) (Const32 <typ.Int> [0]))
  7298  	for {
  7299  		s := v.Aux
  7300  		if !(config.PtrSize == 4 && s.(string) == "") {
  7301  			break
  7302  		}
  7303  		v.reset(OpStringMake)
  7304  		v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
  7305  		v.AddArg(v0)
  7306  		v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  7307  		v1.AuxInt = 0
  7308  		v.AddArg(v1)
  7309  		return true
  7310  	}
  7311  	// match: (ConstString {s})
  7312  	// cond: config.PtrSize == 8 && s.(string) == ""
  7313  	// result: (StringMake (ConstNil) (Const64 <typ.Int> [0]))
  7314  	for {
  7315  		s := v.Aux
  7316  		if !(config.PtrSize == 8 && s.(string) == "") {
  7317  			break
  7318  		}
  7319  		v.reset(OpStringMake)
  7320  		v0 := b.NewValue0(v.Pos, OpConstNil, typ.BytePtr)
  7321  		v.AddArg(v0)
  7322  		v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  7323  		v1.AuxInt = 0
  7324  		v.AddArg(v1)
  7325  		return true
  7326  	}
  7327  	// match: (ConstString {s})
  7328  	// cond: config.PtrSize == 4 && s.(string) != ""
  7329  	// result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const32 <typ.Int> [int64(len(s.(string)))]))
  7330  	for {
  7331  		s := v.Aux
  7332  		if !(config.PtrSize == 4 && s.(string) != "") {
  7333  			break
  7334  		}
  7335  		v.reset(OpStringMake)
  7336  		v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr)
  7337  		v0.Aux = fe.StringData(s.(string))
  7338  		v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr)
  7339  		v0.AddArg(v1)
  7340  		v.AddArg(v0)
  7341  		v2 := b.NewValue0(v.Pos, OpConst32, typ.Int)
  7342  		v2.AuxInt = int64(len(s.(string)))
  7343  		v.AddArg(v2)
  7344  		return true
  7345  	}
  7346  	// match: (ConstString {s})
  7347  	// cond: config.PtrSize == 8 && s.(string) != ""
  7348  	// result: (StringMake (Addr <typ.BytePtr> {fe.StringData(s.(string))} (SB)) (Const64 <typ.Int> [int64(len(s.(string)))]))
  7349  	for {
  7350  		s := v.Aux
  7351  		if !(config.PtrSize == 8 && s.(string) != "") {
  7352  			break
  7353  		}
  7354  		v.reset(OpStringMake)
  7355  		v0 := b.NewValue0(v.Pos, OpAddr, typ.BytePtr)
  7356  		v0.Aux = fe.StringData(s.(string))
  7357  		v1 := b.NewValue0(v.Pos, OpSB, typ.Uintptr)
  7358  		v0.AddArg(v1)
  7359  		v.AddArg(v0)
  7360  		v2 := b.NewValue0(v.Pos, OpConst64, typ.Int)
  7361  		v2.AuxInt = int64(len(s.(string)))
  7362  		v.AddArg(v2)
  7363  		return true
  7364  	}
  7365  	return false
  7366  }
  7367  func rewriteValuegeneric_OpConvert_0(v *Value) bool {
  7368  	// match: (Convert (Add64 (Convert ptr mem) off) mem)
  7369  	// cond:
  7370  	// result: (Add64 ptr off)
  7371  	for {
  7372  		_ = v.Args[1]
  7373  		v_0 := v.Args[0]
  7374  		if v_0.Op != OpAdd64 {
  7375  			break
  7376  		}
  7377  		_ = v_0.Args[1]
  7378  		v_0_0 := v_0.Args[0]
  7379  		if v_0_0.Op != OpConvert {
  7380  			break
  7381  		}
  7382  		_ = v_0_0.Args[1]
  7383  		ptr := v_0_0.Args[0]
  7384  		mem := v_0_0.Args[1]
  7385  		off := v_0.Args[1]
  7386  		if mem != v.Args[1] {
  7387  			break
  7388  		}
  7389  		v.reset(OpAdd64)
  7390  		v.AddArg(ptr)
  7391  		v.AddArg(off)
  7392  		return true
  7393  	}
  7394  	// match: (Convert (Add64 off (Convert ptr mem)) mem)
  7395  	// cond:
  7396  	// result: (Add64 ptr off)
  7397  	for {
  7398  		_ = v.Args[1]
  7399  		v_0 := v.Args[0]
  7400  		if v_0.Op != OpAdd64 {
  7401  			break
  7402  		}
  7403  		_ = v_0.Args[1]
  7404  		off := v_0.Args[0]
  7405  		v_0_1 := v_0.Args[1]
  7406  		if v_0_1.Op != OpConvert {
  7407  			break
  7408  		}
  7409  		_ = v_0_1.Args[1]
  7410  		ptr := v_0_1.Args[0]
  7411  		mem := v_0_1.Args[1]
  7412  		if mem != v.Args[1] {
  7413  			break
  7414  		}
  7415  		v.reset(OpAdd64)
  7416  		v.AddArg(ptr)
  7417  		v.AddArg(off)
  7418  		return true
  7419  	}
  7420  	// match: (Convert (Add32 (Convert ptr mem) off) mem)
  7421  	// cond:
  7422  	// result: (Add32 ptr off)
  7423  	for {
  7424  		_ = v.Args[1]
  7425  		v_0 := v.Args[0]
  7426  		if v_0.Op != OpAdd32 {
  7427  			break
  7428  		}
  7429  		_ = v_0.Args[1]
  7430  		v_0_0 := v_0.Args[0]
  7431  		if v_0_0.Op != OpConvert {
  7432  			break
  7433  		}
  7434  		_ = v_0_0.Args[1]
  7435  		ptr := v_0_0.Args[0]
  7436  		mem := v_0_0.Args[1]
  7437  		off := v_0.Args[1]
  7438  		if mem != v.Args[1] {
  7439  			break
  7440  		}
  7441  		v.reset(OpAdd32)
  7442  		v.AddArg(ptr)
  7443  		v.AddArg(off)
  7444  		return true
  7445  	}
  7446  	// match: (Convert (Add32 off (Convert ptr mem)) mem)
  7447  	// cond:
  7448  	// result: (Add32 ptr off)
  7449  	for {
  7450  		_ = v.Args[1]
  7451  		v_0 := v.Args[0]
  7452  		if v_0.Op != OpAdd32 {
  7453  			break
  7454  		}
  7455  		_ = v_0.Args[1]
  7456  		off := v_0.Args[0]
  7457  		v_0_1 := v_0.Args[1]
  7458  		if v_0_1.Op != OpConvert {
  7459  			break
  7460  		}
  7461  		_ = v_0_1.Args[1]
  7462  		ptr := v_0_1.Args[0]
  7463  		mem := v_0_1.Args[1]
  7464  		if mem != v.Args[1] {
  7465  			break
  7466  		}
  7467  		v.reset(OpAdd32)
  7468  		v.AddArg(ptr)
  7469  		v.AddArg(off)
  7470  		return true
  7471  	}
  7472  	// match: (Convert (Convert ptr mem) mem)
  7473  	// cond:
  7474  	// result: ptr
  7475  	for {
  7476  		_ = v.Args[1]
  7477  		v_0 := v.Args[0]
  7478  		if v_0.Op != OpConvert {
  7479  			break
  7480  		}
  7481  		_ = v_0.Args[1]
  7482  		ptr := v_0.Args[0]
  7483  		mem := v_0.Args[1]
  7484  		if mem != v.Args[1] {
  7485  			break
  7486  		}
  7487  		v.reset(OpCopy)
  7488  		v.Type = ptr.Type
  7489  		v.AddArg(ptr)
  7490  		return true
  7491  	}
  7492  	return false
  7493  }
  7494  func rewriteValuegeneric_OpCvt32Fto32_0(v *Value) bool {
  7495  	// match: (Cvt32Fto32 (Const32F [c]))
  7496  	// cond:
  7497  	// result: (Const32 [int64(int32(auxTo32F(c)))])
  7498  	for {
  7499  		v_0 := v.Args[0]
  7500  		if v_0.Op != OpConst32F {
  7501  			break
  7502  		}
  7503  		c := v_0.AuxInt
  7504  		v.reset(OpConst32)
  7505  		v.AuxInt = int64(int32(auxTo32F(c)))
  7506  		return true
  7507  	}
  7508  	return false
  7509  }
  7510  func rewriteValuegeneric_OpCvt32Fto64_0(v *Value) bool {
  7511  	// match: (Cvt32Fto64 (Const32F [c]))
  7512  	// cond:
  7513  	// result: (Const64 [int64(auxTo32F(c))])
  7514  	for {
  7515  		v_0 := v.Args[0]
  7516  		if v_0.Op != OpConst32F {
  7517  			break
  7518  		}
  7519  		c := v_0.AuxInt
  7520  		v.reset(OpConst64)
  7521  		v.AuxInt = int64(auxTo32F(c))
  7522  		return true
  7523  	}
  7524  	return false
  7525  }
  7526  func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool {
  7527  	// match: (Cvt32Fto64F (Const32F [c]))
  7528  	// cond:
  7529  	// result: (Const64F [c])
  7530  	for {
  7531  		v_0 := v.Args[0]
  7532  		if v_0.Op != OpConst32F {
  7533  			break
  7534  		}
  7535  		c := v_0.AuxInt
  7536  		v.reset(OpConst64F)
  7537  		v.AuxInt = c
  7538  		return true
  7539  	}
  7540  	return false
  7541  }
  7542  func rewriteValuegeneric_OpCvt32to32F_0(v *Value) bool {
  7543  	// match: (Cvt32to32F (Const32 [c]))
  7544  	// cond:
  7545  	// result: (Const32F [auxFrom32F(float32(int32(c)))])
  7546  	for {
  7547  		v_0 := v.Args[0]
  7548  		if v_0.Op != OpConst32 {
  7549  			break
  7550  		}
  7551  		c := v_0.AuxInt
  7552  		v.reset(OpConst32F)
  7553  		v.AuxInt = auxFrom32F(float32(int32(c)))
  7554  		return true
  7555  	}
  7556  	return false
  7557  }
  7558  func rewriteValuegeneric_OpCvt32to64F_0(v *Value) bool {
  7559  	// match: (Cvt32to64F (Const32 [c]))
  7560  	// cond:
  7561  	// result: (Const64F [auxFrom64F(float64(int32(c)))])
  7562  	for {
  7563  		v_0 := v.Args[0]
  7564  		if v_0.Op != OpConst32 {
  7565  			break
  7566  		}
  7567  		c := v_0.AuxInt
  7568  		v.reset(OpConst64F)
  7569  		v.AuxInt = auxFrom64F(float64(int32(c)))
  7570  		return true
  7571  	}
  7572  	return false
  7573  }
  7574  func rewriteValuegeneric_OpCvt64Fto32_0(v *Value) bool {
  7575  	// match: (Cvt64Fto32 (Const64F [c]))
  7576  	// cond:
  7577  	// result: (Const32 [int64(int32(auxTo64F(c)))])
  7578  	for {
  7579  		v_0 := v.Args[0]
  7580  		if v_0.Op != OpConst64F {
  7581  			break
  7582  		}
  7583  		c := v_0.AuxInt
  7584  		v.reset(OpConst32)
  7585  		v.AuxInt = int64(int32(auxTo64F(c)))
  7586  		return true
  7587  	}
  7588  	return false
  7589  }
  7590  func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool {
  7591  	// match: (Cvt64Fto32F (Const64F [c]))
  7592  	// cond:
  7593  	// result: (Const32F [auxFrom32F(float32(auxTo64F(c)))])
  7594  	for {
  7595  		v_0 := v.Args[0]
  7596  		if v_0.Op != OpConst64F {
  7597  			break
  7598  		}
  7599  		c := v_0.AuxInt
  7600  		v.reset(OpConst32F)
  7601  		v.AuxInt = auxFrom32F(float32(auxTo64F(c)))
  7602  		return true
  7603  	}
  7604  	return false
  7605  }
  7606  func rewriteValuegeneric_OpCvt64Fto64_0(v *Value) bool {
  7607  	// match: (Cvt64Fto64 (Const64F [c]))
  7608  	// cond:
  7609  	// result: (Const64 [int64(auxTo64F(c))])
  7610  	for {
  7611  		v_0 := v.Args[0]
  7612  		if v_0.Op != OpConst64F {
  7613  			break
  7614  		}
  7615  		c := v_0.AuxInt
  7616  		v.reset(OpConst64)
  7617  		v.AuxInt = int64(auxTo64F(c))
  7618  		return true
  7619  	}
  7620  	return false
  7621  }
  7622  func rewriteValuegeneric_OpCvt64to32F_0(v *Value) bool {
  7623  	// match: (Cvt64to32F (Const64 [c]))
  7624  	// cond:
  7625  	// result: (Const32F [auxFrom32F(float32(c))])
  7626  	for {
  7627  		v_0 := v.Args[0]
  7628  		if v_0.Op != OpConst64 {
  7629  			break
  7630  		}
  7631  		c := v_0.AuxInt
  7632  		v.reset(OpConst32F)
  7633  		v.AuxInt = auxFrom32F(float32(c))
  7634  		return true
  7635  	}
  7636  	return false
  7637  }
  7638  func rewriteValuegeneric_OpCvt64to64F_0(v *Value) bool {
  7639  	// match: (Cvt64to64F (Const64 [c]))
  7640  	// cond:
  7641  	// result: (Const64F [auxFrom64F(float64(c))])
  7642  	for {
  7643  		v_0 := v.Args[0]
  7644  		if v_0.Op != OpConst64 {
  7645  			break
  7646  		}
  7647  		c := v_0.AuxInt
  7648  		v.reset(OpConst64F)
  7649  		v.AuxInt = auxFrom64F(float64(c))
  7650  		return true
  7651  	}
  7652  	return false
  7653  }
  7654  func rewriteValuegeneric_OpDiv16_0(v *Value) bool {
  7655  	b := v.Block
  7656  	_ = b
  7657  	typ := &b.Func.Config.Types
  7658  	_ = typ
  7659  	// match: (Div16 (Const16 [c]) (Const16 [d]))
  7660  	// cond: d != 0
  7661  	// result: (Const16 [int64(int16(c)/int16(d))])
  7662  	for {
  7663  		_ = v.Args[1]
  7664  		v_0 := v.Args[0]
  7665  		if v_0.Op != OpConst16 {
  7666  			break
  7667  		}
  7668  		c := v_0.AuxInt
  7669  		v_1 := v.Args[1]
  7670  		if v_1.Op != OpConst16 {
  7671  			break
  7672  		}
  7673  		d := v_1.AuxInt
  7674  		if !(d != 0) {
  7675  			break
  7676  		}
  7677  		v.reset(OpConst16)
  7678  		v.AuxInt = int64(int16(c) / int16(d))
  7679  		return true
  7680  	}
  7681  	// match: (Div16 n (Const16 [c]))
  7682  	// cond: isNonNegative(n) && isPowerOfTwo(c&0xffff)
  7683  	// result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)]))
  7684  	for {
  7685  		_ = v.Args[1]
  7686  		n := v.Args[0]
  7687  		v_1 := v.Args[1]
  7688  		if v_1.Op != OpConst16 {
  7689  			break
  7690  		}
  7691  		c := v_1.AuxInt
  7692  		if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) {
  7693  			break
  7694  		}
  7695  		v.reset(OpRsh16Ux64)
  7696  		v.AddArg(n)
  7697  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7698  		v0.AuxInt = log2(c & 0xffff)
  7699  		v.AddArg(v0)
  7700  		return true
  7701  	}
  7702  	// match: (Div16 <t> n (Const16 [c]))
  7703  	// cond: c < 0 && c != -1<<15
  7704  	// result: (Neg16 (Div16 <t> n (Const16 <t> [-c])))
  7705  	for {
  7706  		t := v.Type
  7707  		_ = v.Args[1]
  7708  		n := v.Args[0]
  7709  		v_1 := v.Args[1]
  7710  		if v_1.Op != OpConst16 {
  7711  			break
  7712  		}
  7713  		c := v_1.AuxInt
  7714  		if !(c < 0 && c != -1<<15) {
  7715  			break
  7716  		}
  7717  		v.reset(OpNeg16)
  7718  		v0 := b.NewValue0(v.Pos, OpDiv16, t)
  7719  		v0.AddArg(n)
  7720  		v1 := b.NewValue0(v.Pos, OpConst16, t)
  7721  		v1.AuxInt = -c
  7722  		v0.AddArg(v1)
  7723  		v.AddArg(v0)
  7724  		return true
  7725  	}
  7726  	// match: (Div16 <t> x (Const16 [-1<<15]))
  7727  	// cond:
  7728  	// result: (Rsh16Ux64 (And16 <t> x (Neg16 <t> x)) (Const64 <typ.UInt64> [15]))
  7729  	for {
  7730  		t := v.Type
  7731  		_ = v.Args[1]
  7732  		x := v.Args[0]
  7733  		v_1 := v.Args[1]
  7734  		if v_1.Op != OpConst16 {
  7735  			break
  7736  		}
  7737  		if v_1.AuxInt != -1<<15 {
  7738  			break
  7739  		}
  7740  		v.reset(OpRsh16Ux64)
  7741  		v0 := b.NewValue0(v.Pos, OpAnd16, t)
  7742  		v0.AddArg(x)
  7743  		v1 := b.NewValue0(v.Pos, OpNeg16, t)
  7744  		v1.AddArg(x)
  7745  		v0.AddArg(v1)
  7746  		v.AddArg(v0)
  7747  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7748  		v2.AuxInt = 15
  7749  		v.AddArg(v2)
  7750  		return true
  7751  	}
  7752  	// match: (Div16 <t> n (Const16 [c]))
  7753  	// cond: isPowerOfTwo(c)
  7754  	// result: (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [16-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  7755  	for {
  7756  		t := v.Type
  7757  		_ = v.Args[1]
  7758  		n := v.Args[0]
  7759  		v_1 := v.Args[1]
  7760  		if v_1.Op != OpConst16 {
  7761  			break
  7762  		}
  7763  		c := v_1.AuxInt
  7764  		if !(isPowerOfTwo(c)) {
  7765  			break
  7766  		}
  7767  		v.reset(OpRsh16x64)
  7768  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
  7769  		v0.AddArg(n)
  7770  		v1 := b.NewValue0(v.Pos, OpRsh16Ux64, t)
  7771  		v2 := b.NewValue0(v.Pos, OpRsh16x64, t)
  7772  		v2.AddArg(n)
  7773  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7774  		v3.AuxInt = 15
  7775  		v2.AddArg(v3)
  7776  		v1.AddArg(v2)
  7777  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7778  		v4.AuxInt = 16 - log2(c)
  7779  		v1.AddArg(v4)
  7780  		v0.AddArg(v1)
  7781  		v.AddArg(v0)
  7782  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7783  		v5.AuxInt = log2(c)
  7784  		v.AddArg(v5)
  7785  		return true
  7786  	}
  7787  	// match: (Div16 <t> x (Const16 [c]))
  7788  	// cond: smagicOK(16,c)
  7789  	// result: (Sub16 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(16,c).m)]) (SignExt16to32 x)) (Const64 <typ.UInt64> [16+smagic(16,c).s])) (Rsh32x64 <t> (SignExt16to32 x) (Const64 <typ.UInt64> [31])))
  7790  	for {
  7791  		t := v.Type
  7792  		_ = v.Args[1]
  7793  		x := v.Args[0]
  7794  		v_1 := v.Args[1]
  7795  		if v_1.Op != OpConst16 {
  7796  			break
  7797  		}
  7798  		c := v_1.AuxInt
  7799  		if !(smagicOK(16, c)) {
  7800  			break
  7801  		}
  7802  		v.reset(OpSub16)
  7803  		v.Type = t
  7804  		v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7805  		v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7806  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7807  		v2.AuxInt = int64(smagic(16, c).m)
  7808  		v1.AddArg(v2)
  7809  		v3 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  7810  		v3.AddArg(x)
  7811  		v1.AddArg(v3)
  7812  		v0.AddArg(v1)
  7813  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7814  		v4.AuxInt = 16 + smagic(16, c).s
  7815  		v0.AddArg(v4)
  7816  		v.AddArg(v0)
  7817  		v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
  7818  		v6 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
  7819  		v6.AddArg(x)
  7820  		v5.AddArg(v6)
  7821  		v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7822  		v7.AuxInt = 31
  7823  		v5.AddArg(v7)
  7824  		v.AddArg(v5)
  7825  		return true
  7826  	}
  7827  	return false
  7828  }
  7829  func rewriteValuegeneric_OpDiv16u_0(v *Value) bool {
  7830  	b := v.Block
  7831  	_ = b
  7832  	config := b.Func.Config
  7833  	_ = config
  7834  	typ := &b.Func.Config.Types
  7835  	_ = typ
  7836  	// match: (Div16u (Const16 [c]) (Const16 [d]))
  7837  	// cond: d != 0
  7838  	// result: (Const16 [int64(int16(uint16(c)/uint16(d)))])
  7839  	for {
  7840  		_ = v.Args[1]
  7841  		v_0 := v.Args[0]
  7842  		if v_0.Op != OpConst16 {
  7843  			break
  7844  		}
  7845  		c := v_0.AuxInt
  7846  		v_1 := v.Args[1]
  7847  		if v_1.Op != OpConst16 {
  7848  			break
  7849  		}
  7850  		d := v_1.AuxInt
  7851  		if !(d != 0) {
  7852  			break
  7853  		}
  7854  		v.reset(OpConst16)
  7855  		v.AuxInt = int64(int16(uint16(c) / uint16(d)))
  7856  		return true
  7857  	}
  7858  	// match: (Div16u n (Const16 [c]))
  7859  	// cond: isPowerOfTwo(c&0xffff)
  7860  	// result: (Rsh16Ux64 n (Const64 <typ.UInt64> [log2(c&0xffff)]))
  7861  	for {
  7862  		_ = v.Args[1]
  7863  		n := v.Args[0]
  7864  		v_1 := v.Args[1]
  7865  		if v_1.Op != OpConst16 {
  7866  			break
  7867  		}
  7868  		c := v_1.AuxInt
  7869  		if !(isPowerOfTwo(c & 0xffff)) {
  7870  			break
  7871  		}
  7872  		v.reset(OpRsh16Ux64)
  7873  		v.AddArg(n)
  7874  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7875  		v0.AuxInt = log2(c & 0xffff)
  7876  		v.AddArg(v0)
  7877  		return true
  7878  	}
  7879  	// match: (Div16u x (Const16 [c]))
  7880  	// cond: umagicOK(16, c) && config.RegSize == 8
  7881  	// result: (Trunc64to16 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<16+umagic(16,c).m)]) (ZeroExt16to64 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s])))
  7882  	for {
  7883  		_ = v.Args[1]
  7884  		x := v.Args[0]
  7885  		v_1 := v.Args[1]
  7886  		if v_1.Op != OpConst16 {
  7887  			break
  7888  		}
  7889  		c := v_1.AuxInt
  7890  		if !(umagicOK(16, c) && config.RegSize == 8) {
  7891  			break
  7892  		}
  7893  		v.reset(OpTrunc64to16)
  7894  		v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  7895  		v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  7896  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7897  		v2.AuxInt = int64(1<<16 + umagic(16, c).m)
  7898  		v1.AddArg(v2)
  7899  		v3 := b.NewValue0(v.Pos, OpZeroExt16to64, typ.UInt64)
  7900  		v3.AddArg(x)
  7901  		v1.AddArg(v3)
  7902  		v0.AddArg(v1)
  7903  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7904  		v4.AuxInt = 16 + umagic(16, c).s
  7905  		v0.AddArg(v4)
  7906  		v.AddArg(v0)
  7907  		return true
  7908  	}
  7909  	// match: (Div16u x (Const16 [c]))
  7910  	// cond: umagicOK(16, c) && config.RegSize == 4 && umagic(16,c).m&1 == 0
  7911  	// result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+umagic(16,c).m/2)]) (ZeroExt16to32 x)) (Const64 <typ.UInt64> [16+umagic(16,c).s-1])))
  7912  	for {
  7913  		_ = v.Args[1]
  7914  		x := v.Args[0]
  7915  		v_1 := v.Args[1]
  7916  		if v_1.Op != OpConst16 {
  7917  			break
  7918  		}
  7919  		c := v_1.AuxInt
  7920  		if !(umagicOK(16, c) && config.RegSize == 4 && umagic(16, c).m&1 == 0) {
  7921  			break
  7922  		}
  7923  		v.reset(OpTrunc32to16)
  7924  		v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7925  		v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7926  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7927  		v2.AuxInt = int64(1<<15 + umagic(16, c).m/2)
  7928  		v1.AddArg(v2)
  7929  		v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7930  		v3.AddArg(x)
  7931  		v1.AddArg(v3)
  7932  		v0.AddArg(v1)
  7933  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7934  		v4.AuxInt = 16 + umagic(16, c).s - 1
  7935  		v0.AddArg(v4)
  7936  		v.AddArg(v0)
  7937  		return true
  7938  	}
  7939  	// match: (Div16u x (Const16 [c]))
  7940  	// cond: umagicOK(16, c) && config.RegSize == 4 && c&1 == 0
  7941  	// result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<15+(umagic(16,c).m+1)/2)]) (Rsh32Ux64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [16+umagic(16,c).s-2])))
  7942  	for {
  7943  		_ = v.Args[1]
  7944  		x := v.Args[0]
  7945  		v_1 := v.Args[1]
  7946  		if v_1.Op != OpConst16 {
  7947  			break
  7948  		}
  7949  		c := v_1.AuxInt
  7950  		if !(umagicOK(16, c) && config.RegSize == 4 && c&1 == 0) {
  7951  			break
  7952  		}
  7953  		v.reset(OpTrunc32to16)
  7954  		v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7955  		v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  7956  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  7957  		v2.AuxInt = int64(1<<15 + (umagic(16, c).m+1)/2)
  7958  		v1.AddArg(v2)
  7959  		v3 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7960  		v4 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7961  		v4.AddArg(x)
  7962  		v3.AddArg(v4)
  7963  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7964  		v5.AuxInt = 1
  7965  		v3.AddArg(v5)
  7966  		v1.AddArg(v3)
  7967  		v0.AddArg(v1)
  7968  		v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7969  		v6.AuxInt = 16 + umagic(16, c).s - 2
  7970  		v0.AddArg(v6)
  7971  		v.AddArg(v0)
  7972  		return true
  7973  	}
  7974  	// match: (Div16u x (Const16 [c]))
  7975  	// cond: umagicOK(16, c) && config.RegSize == 4 && config.useAvg
  7976  	// result: (Trunc32to16 (Rsh32Ux64 <typ.UInt32> (Avg32u (Lsh32x64 <typ.UInt32> (ZeroExt16to32 x) (Const64 <typ.UInt64> [16])) (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(umagic(16,c).m)]) (ZeroExt16to32 x))) (Const64 <typ.UInt64> [16+umagic(16,c).s-1])))
  7977  	for {
  7978  		_ = v.Args[1]
  7979  		x := v.Args[0]
  7980  		v_1 := v.Args[1]
  7981  		if v_1.Op != OpConst16 {
  7982  			break
  7983  		}
  7984  		c := v_1.AuxInt
  7985  		if !(umagicOK(16, c) && config.RegSize == 4 && config.useAvg) {
  7986  			break
  7987  		}
  7988  		v.reset(OpTrunc32to16)
  7989  		v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  7990  		v1 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32)
  7991  		v2 := b.NewValue0(v.Pos, OpLsh32x64, typ.UInt32)
  7992  		v3 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  7993  		v3.AddArg(x)
  7994  		v2.AddArg(v3)
  7995  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  7996  		v4.AuxInt = 16
  7997  		v2.AddArg(v4)
  7998  		v1.AddArg(v2)
  7999  		v5 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  8000  		v6 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8001  		v6.AuxInt = int64(umagic(16, c).m)
  8002  		v5.AddArg(v6)
  8003  		v7 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
  8004  		v7.AddArg(x)
  8005  		v5.AddArg(v7)
  8006  		v1.AddArg(v5)
  8007  		v0.AddArg(v1)
  8008  		v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8009  		v8.AuxInt = 16 + umagic(16, c).s - 1
  8010  		v0.AddArg(v8)
  8011  		v.AddArg(v0)
  8012  		return true
  8013  	}
  8014  	return false
  8015  }
  8016  func rewriteValuegeneric_OpDiv32_0(v *Value) bool {
  8017  	b := v.Block
  8018  	_ = b
  8019  	config := b.Func.Config
  8020  	_ = config
  8021  	typ := &b.Func.Config.Types
  8022  	_ = typ
  8023  	// match: (Div32 (Const32 [c]) (Const32 [d]))
  8024  	// cond: d != 0
  8025  	// result: (Const32 [int64(int32(c)/int32(d))])
  8026  	for {
  8027  		_ = v.Args[1]
  8028  		v_0 := v.Args[0]
  8029  		if v_0.Op != OpConst32 {
  8030  			break
  8031  		}
  8032  		c := v_0.AuxInt
  8033  		v_1 := v.Args[1]
  8034  		if v_1.Op != OpConst32 {
  8035  			break
  8036  		}
  8037  		d := v_1.AuxInt
  8038  		if !(d != 0) {
  8039  			break
  8040  		}
  8041  		v.reset(OpConst32)
  8042  		v.AuxInt = int64(int32(c) / int32(d))
  8043  		return true
  8044  	}
  8045  	// match: (Div32 n (Const32 [c]))
  8046  	// cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff)
  8047  	// result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)]))
  8048  	for {
  8049  		_ = v.Args[1]
  8050  		n := v.Args[0]
  8051  		v_1 := v.Args[1]
  8052  		if v_1.Op != OpConst32 {
  8053  			break
  8054  		}
  8055  		c := v_1.AuxInt
  8056  		if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) {
  8057  			break
  8058  		}
  8059  		v.reset(OpRsh32Ux64)
  8060  		v.AddArg(n)
  8061  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8062  		v0.AuxInt = log2(c & 0xffffffff)
  8063  		v.AddArg(v0)
  8064  		return true
  8065  	}
  8066  	// match: (Div32 <t> n (Const32 [c]))
  8067  	// cond: c < 0 && c != -1<<31
  8068  	// result: (Neg32 (Div32 <t> n (Const32 <t> [-c])))
  8069  	for {
  8070  		t := v.Type
  8071  		_ = v.Args[1]
  8072  		n := v.Args[0]
  8073  		v_1 := v.Args[1]
  8074  		if v_1.Op != OpConst32 {
  8075  			break
  8076  		}
  8077  		c := v_1.AuxInt
  8078  		if !(c < 0 && c != -1<<31) {
  8079  			break
  8080  		}
  8081  		v.reset(OpNeg32)
  8082  		v0 := b.NewValue0(v.Pos, OpDiv32, t)
  8083  		v0.AddArg(n)
  8084  		v1 := b.NewValue0(v.Pos, OpConst32, t)
  8085  		v1.AuxInt = -c
  8086  		v0.AddArg(v1)
  8087  		v.AddArg(v0)
  8088  		return true
  8089  	}
  8090  	// match: (Div32 <t> x (Const32 [-1<<31]))
  8091  	// cond:
  8092  	// result: (Rsh32Ux64 (And32 <t> x (Neg32 <t> x)) (Const64 <typ.UInt64> [31]))
  8093  	for {
  8094  		t := v.Type
  8095  		_ = v.Args[1]
  8096  		x := v.Args[0]
  8097  		v_1 := v.Args[1]
  8098  		if v_1.Op != OpConst32 {
  8099  			break
  8100  		}
  8101  		if v_1.AuxInt != -1<<31 {
  8102  			break
  8103  		}
  8104  		v.reset(OpRsh32Ux64)
  8105  		v0 := b.NewValue0(v.Pos, OpAnd32, t)
  8106  		v0.AddArg(x)
  8107  		v1 := b.NewValue0(v.Pos, OpNeg32, t)
  8108  		v1.AddArg(x)
  8109  		v0.AddArg(v1)
  8110  		v.AddArg(v0)
  8111  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8112  		v2.AuxInt = 31
  8113  		v.AddArg(v2)
  8114  		return true
  8115  	}
  8116  	// match: (Div32 <t> n (Const32 [c]))
  8117  	// cond: isPowerOfTwo(c)
  8118  	// result: (Rsh32x64 (Add32 <t> n (Rsh32Ux64 <t> (Rsh32x64 <t> n (Const64 <typ.UInt64> [31])) (Const64 <typ.UInt64> [32-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  8119  	for {
  8120  		t := v.Type
  8121  		_ = v.Args[1]
  8122  		n := v.Args[0]
  8123  		v_1 := v.Args[1]
  8124  		if v_1.Op != OpConst32 {
  8125  			break
  8126  		}
  8127  		c := v_1.AuxInt
  8128  		if !(isPowerOfTwo(c)) {
  8129  			break
  8130  		}
  8131  		v.reset(OpRsh32x64)
  8132  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
  8133  		v0.AddArg(n)
  8134  		v1 := b.NewValue0(v.Pos, OpRsh32Ux64, t)
  8135  		v2 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8136  		v2.AddArg(n)
  8137  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8138  		v3.AuxInt = 31
  8139  		v2.AddArg(v3)
  8140  		v1.AddArg(v2)
  8141  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8142  		v4.AuxInt = 32 - log2(c)
  8143  		v1.AddArg(v4)
  8144  		v0.AddArg(v1)
  8145  		v.AddArg(v0)
  8146  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8147  		v5.AuxInt = log2(c)
  8148  		v.AddArg(v5)
  8149  		return true
  8150  	}
  8151  	// match: (Div32 <t> x (Const32 [c]))
  8152  	// cond: smagicOK(32,c) && config.RegSize == 8
  8153  	// result: (Sub32 <t> (Rsh64x64 <t> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(smagic(32,c).m)]) (SignExt32to64 x)) (Const64 <typ.UInt64> [32+smagic(32,c).s])) (Rsh64x64 <t> (SignExt32to64 x) (Const64 <typ.UInt64> [63])))
  8154  	for {
  8155  		t := v.Type
  8156  		_ = v.Args[1]
  8157  		x := v.Args[0]
  8158  		v_1 := v.Args[1]
  8159  		if v_1.Op != OpConst32 {
  8160  			break
  8161  		}
  8162  		c := v_1.AuxInt
  8163  		if !(smagicOK(32, c) && config.RegSize == 8) {
  8164  			break
  8165  		}
  8166  		v.reset(OpSub32)
  8167  		v.Type = t
  8168  		v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8169  		v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8170  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8171  		v2.AuxInt = int64(smagic(32, c).m)
  8172  		v1.AddArg(v2)
  8173  		v3 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  8174  		v3.AddArg(x)
  8175  		v1.AddArg(v3)
  8176  		v0.AddArg(v1)
  8177  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8178  		v4.AuxInt = 32 + smagic(32, c).s
  8179  		v0.AddArg(v4)
  8180  		v.AddArg(v0)
  8181  		v5 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8182  		v6 := b.NewValue0(v.Pos, OpSignExt32to64, typ.Int64)
  8183  		v6.AddArg(x)
  8184  		v5.AddArg(v6)
  8185  		v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8186  		v7.AuxInt = 63
  8187  		v5.AddArg(v7)
  8188  		v.AddArg(v5)
  8189  		return true
  8190  	}
  8191  	// match: (Div32 <t> x (Const32 [c]))
  8192  	// cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 == 0 && config.useHmul
  8193  	// result: (Sub32 <t> (Rsh32x64 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [smagic(32,c).s-1])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31])))
  8194  	for {
  8195  		t := v.Type
  8196  		_ = v.Args[1]
  8197  		x := v.Args[0]
  8198  		v_1 := v.Args[1]
  8199  		if v_1.Op != OpConst32 {
  8200  			break
  8201  		}
  8202  		c := v_1.AuxInt
  8203  		if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 == 0 && config.useHmul) {
  8204  			break
  8205  		}
  8206  		v.reset(OpSub32)
  8207  		v.Type = t
  8208  		v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8209  		v1 := b.NewValue0(v.Pos, OpHmul32, t)
  8210  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8211  		v2.AuxInt = int64(int32(smagic(32, c).m / 2))
  8212  		v1.AddArg(v2)
  8213  		v1.AddArg(x)
  8214  		v0.AddArg(v1)
  8215  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8216  		v3.AuxInt = smagic(32, c).s - 1
  8217  		v0.AddArg(v3)
  8218  		v.AddArg(v0)
  8219  		v4 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8220  		v4.AddArg(x)
  8221  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8222  		v5.AuxInt = 31
  8223  		v4.AddArg(v5)
  8224  		v.AddArg(v4)
  8225  		return true
  8226  	}
  8227  	// match: (Div32 <t> x (Const32 [c]))
  8228  	// cond: smagicOK(32,c) && config.RegSize == 4 && smagic(32,c).m&1 != 0 && config.useHmul
  8229  	// result: (Sub32 <t> (Rsh32x64 <t> (Add32 <t> (Hmul32 <t> (Const32 <typ.UInt32> [int64(int32(smagic(32,c).m))]) x) x) (Const64 <typ.UInt64> [smagic(32,c).s])) (Rsh32x64 <t> x (Const64 <typ.UInt64> [31])))
  8230  	for {
  8231  		t := v.Type
  8232  		_ = v.Args[1]
  8233  		x := v.Args[0]
  8234  		v_1 := v.Args[1]
  8235  		if v_1.Op != OpConst32 {
  8236  			break
  8237  		}
  8238  		c := v_1.AuxInt
  8239  		if !(smagicOK(32, c) && config.RegSize == 4 && smagic(32, c).m&1 != 0 && config.useHmul) {
  8240  			break
  8241  		}
  8242  		v.reset(OpSub32)
  8243  		v.Type = t
  8244  		v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8245  		v1 := b.NewValue0(v.Pos, OpAdd32, t)
  8246  		v2 := b.NewValue0(v.Pos, OpHmul32, t)
  8247  		v3 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8248  		v3.AuxInt = int64(int32(smagic(32, c).m))
  8249  		v2.AddArg(v3)
  8250  		v2.AddArg(x)
  8251  		v1.AddArg(v2)
  8252  		v1.AddArg(x)
  8253  		v0.AddArg(v1)
  8254  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8255  		v4.AuxInt = smagic(32, c).s
  8256  		v0.AddArg(v4)
  8257  		v.AddArg(v0)
  8258  		v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
  8259  		v5.AddArg(x)
  8260  		v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8261  		v6.AuxInt = 31
  8262  		v5.AddArg(v6)
  8263  		v.AddArg(v5)
  8264  		return true
  8265  	}
  8266  	return false
  8267  }
  8268  func rewriteValuegeneric_OpDiv32F_0(v *Value) bool {
  8269  	b := v.Block
  8270  	_ = b
  8271  	// match: (Div32F (Const32F [c]) (Const32F [d]))
  8272  	// cond:
  8273  	// result: (Const32F [auxFrom32F(auxTo32F(c) / auxTo32F(d))])
  8274  	for {
  8275  		_ = v.Args[1]
  8276  		v_0 := v.Args[0]
  8277  		if v_0.Op != OpConst32F {
  8278  			break
  8279  		}
  8280  		c := v_0.AuxInt
  8281  		v_1 := v.Args[1]
  8282  		if v_1.Op != OpConst32F {
  8283  			break
  8284  		}
  8285  		d := v_1.AuxInt
  8286  		v.reset(OpConst32F)
  8287  		v.AuxInt = auxFrom32F(auxTo32F(c) / auxTo32F(d))
  8288  		return true
  8289  	}
  8290  	// match: (Div32F x (Const32F <t> [c]))
  8291  	// cond: reciprocalExact32(auxTo32F(c))
  8292  	// result: (Mul32F x (Const32F <t> [auxFrom32F(1/auxTo32F(c))]))
  8293  	for {
  8294  		_ = v.Args[1]
  8295  		x := v.Args[0]
  8296  		v_1 := v.Args[1]
  8297  		if v_1.Op != OpConst32F {
  8298  			break
  8299  		}
  8300  		t := v_1.Type
  8301  		c := v_1.AuxInt
  8302  		if !(reciprocalExact32(auxTo32F(c))) {
  8303  			break
  8304  		}
  8305  		v.reset(OpMul32F)
  8306  		v.AddArg(x)
  8307  		v0 := b.NewValue0(v.Pos, OpConst32F, t)
  8308  		v0.AuxInt = auxFrom32F(1 / auxTo32F(c))
  8309  		v.AddArg(v0)
  8310  		return true
  8311  	}
  8312  	return false
  8313  }
  8314  func rewriteValuegeneric_OpDiv32u_0(v *Value) bool {
  8315  	b := v.Block
  8316  	_ = b
  8317  	config := b.Func.Config
  8318  	_ = config
  8319  	typ := &b.Func.Config.Types
  8320  	_ = typ
  8321  	// match: (Div32u (Const32 [c]) (Const32 [d]))
  8322  	// cond: d != 0
  8323  	// result: (Const32 [int64(int32(uint32(c)/uint32(d)))])
  8324  	for {
  8325  		_ = v.Args[1]
  8326  		v_0 := v.Args[0]
  8327  		if v_0.Op != OpConst32 {
  8328  			break
  8329  		}
  8330  		c := v_0.AuxInt
  8331  		v_1 := v.Args[1]
  8332  		if v_1.Op != OpConst32 {
  8333  			break
  8334  		}
  8335  		d := v_1.AuxInt
  8336  		if !(d != 0) {
  8337  			break
  8338  		}
  8339  		v.reset(OpConst32)
  8340  		v.AuxInt = int64(int32(uint32(c) / uint32(d)))
  8341  		return true
  8342  	}
  8343  	// match: (Div32u n (Const32 [c]))
  8344  	// cond: isPowerOfTwo(c&0xffffffff)
  8345  	// result: (Rsh32Ux64 n (Const64 <typ.UInt64> [log2(c&0xffffffff)]))
  8346  	for {
  8347  		_ = v.Args[1]
  8348  		n := v.Args[0]
  8349  		v_1 := v.Args[1]
  8350  		if v_1.Op != OpConst32 {
  8351  			break
  8352  		}
  8353  		c := v_1.AuxInt
  8354  		if !(isPowerOfTwo(c & 0xffffffff)) {
  8355  			break
  8356  		}
  8357  		v.reset(OpRsh32Ux64)
  8358  		v.AddArg(n)
  8359  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8360  		v0.AuxInt = log2(c & 0xffffffff)
  8361  		v.AddArg(v0)
  8362  		return true
  8363  	}
  8364  	// match: (Div32u x (Const32 [c]))
  8365  	// cond: umagicOK(32, c) && config.RegSize == 4 && umagic(32,c).m&1 == 0 && config.useHmul
  8366  	// result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+umagic(32,c).m/2))]) x) (Const64 <typ.UInt64> [umagic(32,c).s-1]))
  8367  	for {
  8368  		_ = v.Args[1]
  8369  		x := v.Args[0]
  8370  		v_1 := v.Args[1]
  8371  		if v_1.Op != OpConst32 {
  8372  			break
  8373  		}
  8374  		c := v_1.AuxInt
  8375  		if !(umagicOK(32, c) && config.RegSize == 4 && umagic(32, c).m&1 == 0 && config.useHmul) {
  8376  			break
  8377  		}
  8378  		v.reset(OpRsh32Ux64)
  8379  		v.Type = typ.UInt32
  8380  		v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32)
  8381  		v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8382  		v1.AuxInt = int64(int32(1<<31 + umagic(32, c).m/2))
  8383  		v0.AddArg(v1)
  8384  		v0.AddArg(x)
  8385  		v.AddArg(v0)
  8386  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8387  		v2.AuxInt = umagic(32, c).s - 1
  8388  		v.AddArg(v2)
  8389  		return true
  8390  	}
  8391  	// match: (Div32u x (Const32 [c]))
  8392  	// cond: umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul
  8393  	// result: (Rsh32Ux64 <typ.UInt32> (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(1<<31+(umagic(32,c).m+1)/2))]) (Rsh32Ux64 <typ.UInt32> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(32,c).s-2]))
  8394  	for {
  8395  		_ = v.Args[1]
  8396  		x := v.Args[0]
  8397  		v_1 := v.Args[1]
  8398  		if v_1.Op != OpConst32 {
  8399  			break
  8400  		}
  8401  		c := v_1.AuxInt
  8402  		if !(umagicOK(32, c) && config.RegSize == 4 && c&1 == 0 && config.useHmul) {
  8403  			break
  8404  		}
  8405  		v.reset(OpRsh32Ux64)
  8406  		v.Type = typ.UInt32
  8407  		v0 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32)
  8408  		v1 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8409  		v1.AuxInt = int64(int32(1<<31 + (umagic(32, c).m+1)/2))
  8410  		v0.AddArg(v1)
  8411  		v2 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  8412  		v2.AddArg(x)
  8413  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8414  		v3.AuxInt = 1
  8415  		v2.AddArg(v3)
  8416  		v0.AddArg(v2)
  8417  		v.AddArg(v0)
  8418  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8419  		v4.AuxInt = umagic(32, c).s - 2
  8420  		v.AddArg(v4)
  8421  		return true
  8422  	}
  8423  	// match: (Div32u x (Const32 [c]))
  8424  	// cond: umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul
  8425  	// result: (Rsh32Ux64 <typ.UInt32> (Avg32u x (Hmul32u <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(umagic(32,c).m))]) x)) (Const64 <typ.UInt64> [umagic(32,c).s-1]))
  8426  	for {
  8427  		_ = v.Args[1]
  8428  		x := v.Args[0]
  8429  		v_1 := v.Args[1]
  8430  		if v_1.Op != OpConst32 {
  8431  			break
  8432  		}
  8433  		c := v_1.AuxInt
  8434  		if !(umagicOK(32, c) && config.RegSize == 4 && config.useAvg && config.useHmul) {
  8435  			break
  8436  		}
  8437  		v.reset(OpRsh32Ux64)
  8438  		v.Type = typ.UInt32
  8439  		v0 := b.NewValue0(v.Pos, OpAvg32u, typ.UInt32)
  8440  		v0.AddArg(x)
  8441  		v1 := b.NewValue0(v.Pos, OpHmul32u, typ.UInt32)
  8442  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  8443  		v2.AuxInt = int64(int32(umagic(32, c).m))
  8444  		v1.AddArg(v2)
  8445  		v1.AddArg(x)
  8446  		v0.AddArg(v1)
  8447  		v.AddArg(v0)
  8448  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8449  		v3.AuxInt = umagic(32, c).s - 1
  8450  		v.AddArg(v3)
  8451  		return true
  8452  	}
  8453  	// match: (Div32u x (Const32 [c]))
  8454  	// cond: umagicOK(32, c) && config.RegSize == 8 && umagic(32,c).m&1 == 0
  8455  	// result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+umagic(32,c).m/2)]) (ZeroExt32to64 x)) (Const64 <typ.UInt64> [32+umagic(32,c).s-1])))
  8456  	for {
  8457  		_ = v.Args[1]
  8458  		x := v.Args[0]
  8459  		v_1 := v.Args[1]
  8460  		if v_1.Op != OpConst32 {
  8461  			break
  8462  		}
  8463  		c := v_1.AuxInt
  8464  		if !(umagicOK(32, c) && config.RegSize == 8 && umagic(32, c).m&1 == 0) {
  8465  			break
  8466  		}
  8467  		v.reset(OpTrunc64to32)
  8468  		v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8469  		v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8470  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8471  		v2.AuxInt = int64(1<<31 + umagic(32, c).m/2)
  8472  		v1.AddArg(v2)
  8473  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8474  		v3.AddArg(x)
  8475  		v1.AddArg(v3)
  8476  		v0.AddArg(v1)
  8477  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8478  		v4.AuxInt = 32 + umagic(32, c).s - 1
  8479  		v0.AddArg(v4)
  8480  		v.AddArg(v0)
  8481  		return true
  8482  	}
  8483  	// match: (Div32u x (Const32 [c]))
  8484  	// cond: umagicOK(32, c) && config.RegSize == 8 && c&1 == 0
  8485  	// result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Mul64 <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<31+(umagic(32,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [32+umagic(32,c).s-2])))
  8486  	for {
  8487  		_ = v.Args[1]
  8488  		x := v.Args[0]
  8489  		v_1 := v.Args[1]
  8490  		if v_1.Op != OpConst32 {
  8491  			break
  8492  		}
  8493  		c := v_1.AuxInt
  8494  		if !(umagicOK(32, c) && config.RegSize == 8 && c&1 == 0) {
  8495  			break
  8496  		}
  8497  		v.reset(OpTrunc64to32)
  8498  		v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8499  		v1 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8500  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8501  		v2.AuxInt = int64(1<<31 + (umagic(32, c).m+1)/2)
  8502  		v1.AddArg(v2)
  8503  		v3 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8504  		v4 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8505  		v4.AddArg(x)
  8506  		v3.AddArg(v4)
  8507  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8508  		v5.AuxInt = 1
  8509  		v3.AddArg(v5)
  8510  		v1.AddArg(v3)
  8511  		v0.AddArg(v1)
  8512  		v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8513  		v6.AuxInt = 32 + umagic(32, c).s - 2
  8514  		v0.AddArg(v6)
  8515  		v.AddArg(v0)
  8516  		return true
  8517  	}
  8518  	// match: (Div32u x (Const32 [c]))
  8519  	// cond: umagicOK(32, c) && config.RegSize == 8 && config.useAvg
  8520  	// result: (Trunc64to32 (Rsh64Ux64 <typ.UInt64> (Avg64u (Lsh64x64 <typ.UInt64> (ZeroExt32to64 x) (Const64 <typ.UInt64> [32])) (Mul64 <typ.UInt64> (Const64 <typ.UInt32> [int64(umagic(32,c).m)]) (ZeroExt32to64 x))) (Const64 <typ.UInt64> [32+umagic(32,c).s-1])))
  8521  	for {
  8522  		_ = v.Args[1]
  8523  		x := v.Args[0]
  8524  		v_1 := v.Args[1]
  8525  		if v_1.Op != OpConst32 {
  8526  			break
  8527  		}
  8528  		c := v_1.AuxInt
  8529  		if !(umagicOK(32, c) && config.RegSize == 8 && config.useAvg) {
  8530  			break
  8531  		}
  8532  		v.reset(OpTrunc64to32)
  8533  		v0 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8534  		v1 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64)
  8535  		v2 := b.NewValue0(v.Pos, OpLsh64x64, typ.UInt64)
  8536  		v3 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8537  		v3.AddArg(x)
  8538  		v2.AddArg(v3)
  8539  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8540  		v4.AuxInt = 32
  8541  		v2.AddArg(v4)
  8542  		v1.AddArg(v2)
  8543  		v5 := b.NewValue0(v.Pos, OpMul64, typ.UInt64)
  8544  		v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt32)
  8545  		v6.AuxInt = int64(umagic(32, c).m)
  8546  		v5.AddArg(v6)
  8547  		v7 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64)
  8548  		v7.AddArg(x)
  8549  		v5.AddArg(v7)
  8550  		v1.AddArg(v5)
  8551  		v0.AddArg(v1)
  8552  		v8 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8553  		v8.AuxInt = 32 + umagic(32, c).s - 1
  8554  		v0.AddArg(v8)
  8555  		v.AddArg(v0)
  8556  		return true
  8557  	}
  8558  	return false
  8559  }
  8560  func rewriteValuegeneric_OpDiv64_0(v *Value) bool {
  8561  	b := v.Block
  8562  	_ = b
  8563  	config := b.Func.Config
  8564  	_ = config
  8565  	typ := &b.Func.Config.Types
  8566  	_ = typ
  8567  	// match: (Div64 (Const64 [c]) (Const64 [d]))
  8568  	// cond: d != 0
  8569  	// result: (Const64 [c/d])
  8570  	for {
  8571  		_ = v.Args[1]
  8572  		v_0 := v.Args[0]
  8573  		if v_0.Op != OpConst64 {
  8574  			break
  8575  		}
  8576  		c := v_0.AuxInt
  8577  		v_1 := v.Args[1]
  8578  		if v_1.Op != OpConst64 {
  8579  			break
  8580  		}
  8581  		d := v_1.AuxInt
  8582  		if !(d != 0) {
  8583  			break
  8584  		}
  8585  		v.reset(OpConst64)
  8586  		v.AuxInt = c / d
  8587  		return true
  8588  	}
  8589  	// match: (Div64 n (Const64 [c]))
  8590  	// cond: isNonNegative(n) && isPowerOfTwo(c)
  8591  	// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)]))
  8592  	for {
  8593  		_ = v.Args[1]
  8594  		n := v.Args[0]
  8595  		v_1 := v.Args[1]
  8596  		if v_1.Op != OpConst64 {
  8597  			break
  8598  		}
  8599  		c := v_1.AuxInt
  8600  		if !(isNonNegative(n) && isPowerOfTwo(c)) {
  8601  			break
  8602  		}
  8603  		v.reset(OpRsh64Ux64)
  8604  		v.AddArg(n)
  8605  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8606  		v0.AuxInt = log2(c)
  8607  		v.AddArg(v0)
  8608  		return true
  8609  	}
  8610  	// match: (Div64 n (Const64 [-1<<63]))
  8611  	// cond: isNonNegative(n)
  8612  	// result: (Const64 [0])
  8613  	for {
  8614  		_ = v.Args[1]
  8615  		n := v.Args[0]
  8616  		v_1 := v.Args[1]
  8617  		if v_1.Op != OpConst64 {
  8618  			break
  8619  		}
  8620  		if v_1.AuxInt != -1<<63 {
  8621  			break
  8622  		}
  8623  		if !(isNonNegative(n)) {
  8624  			break
  8625  		}
  8626  		v.reset(OpConst64)
  8627  		v.AuxInt = 0
  8628  		return true
  8629  	}
  8630  	// match: (Div64 <t> n (Const64 [c]))
  8631  	// cond: c < 0 && c != -1<<63
  8632  	// result: (Neg64 (Div64 <t> n (Const64 <t> [-c])))
  8633  	for {
  8634  		t := v.Type
  8635  		_ = v.Args[1]
  8636  		n := v.Args[0]
  8637  		v_1 := v.Args[1]
  8638  		if v_1.Op != OpConst64 {
  8639  			break
  8640  		}
  8641  		c := v_1.AuxInt
  8642  		if !(c < 0 && c != -1<<63) {
  8643  			break
  8644  		}
  8645  		v.reset(OpNeg64)
  8646  		v0 := b.NewValue0(v.Pos, OpDiv64, t)
  8647  		v0.AddArg(n)
  8648  		v1 := b.NewValue0(v.Pos, OpConst64, t)
  8649  		v1.AuxInt = -c
  8650  		v0.AddArg(v1)
  8651  		v.AddArg(v0)
  8652  		return true
  8653  	}
  8654  	// match: (Div64 <t> x (Const64 [-1<<63]))
  8655  	// cond:
  8656  	// result: (Rsh64Ux64 (And64 <t> x (Neg64 <t> x)) (Const64 <typ.UInt64> [63]))
  8657  	for {
  8658  		t := v.Type
  8659  		_ = v.Args[1]
  8660  		x := v.Args[0]
  8661  		v_1 := v.Args[1]
  8662  		if v_1.Op != OpConst64 {
  8663  			break
  8664  		}
  8665  		if v_1.AuxInt != -1<<63 {
  8666  			break
  8667  		}
  8668  		v.reset(OpRsh64Ux64)
  8669  		v0 := b.NewValue0(v.Pos, OpAnd64, t)
  8670  		v0.AddArg(x)
  8671  		v1 := b.NewValue0(v.Pos, OpNeg64, t)
  8672  		v1.AddArg(x)
  8673  		v0.AddArg(v1)
  8674  		v.AddArg(v0)
  8675  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8676  		v2.AuxInt = 63
  8677  		v.AddArg(v2)
  8678  		return true
  8679  	}
  8680  	// match: (Div64 <t> n (Const64 [c]))
  8681  	// cond: isPowerOfTwo(c)
  8682  	// result: (Rsh64x64 (Add64 <t> n (Rsh64Ux64 <t> (Rsh64x64 <t> n (Const64 <typ.UInt64> [63])) (Const64 <typ.UInt64> [64-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  8683  	for {
  8684  		t := v.Type
  8685  		_ = v.Args[1]
  8686  		n := v.Args[0]
  8687  		v_1 := v.Args[1]
  8688  		if v_1.Op != OpConst64 {
  8689  			break
  8690  		}
  8691  		c := v_1.AuxInt
  8692  		if !(isPowerOfTwo(c)) {
  8693  			break
  8694  		}
  8695  		v.reset(OpRsh64x64)
  8696  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
  8697  		v0.AddArg(n)
  8698  		v1 := b.NewValue0(v.Pos, OpRsh64Ux64, t)
  8699  		v2 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8700  		v2.AddArg(n)
  8701  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8702  		v3.AuxInt = 63
  8703  		v2.AddArg(v3)
  8704  		v1.AddArg(v2)
  8705  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8706  		v4.AuxInt = 64 - log2(c)
  8707  		v1.AddArg(v4)
  8708  		v0.AddArg(v1)
  8709  		v.AddArg(v0)
  8710  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8711  		v5.AuxInt = log2(c)
  8712  		v.AddArg(v5)
  8713  		return true
  8714  	}
  8715  	// match: (Div64 <t> x (Const64 [c]))
  8716  	// cond: smagicOK(64,c) && smagic(64,c).m&1 == 0 && config.useHmul
  8717  	// result: (Sub64 <t> (Rsh64x64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [smagic(64,c).s-1])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63])))
  8718  	for {
  8719  		t := v.Type
  8720  		_ = v.Args[1]
  8721  		x := v.Args[0]
  8722  		v_1 := v.Args[1]
  8723  		if v_1.Op != OpConst64 {
  8724  			break
  8725  		}
  8726  		c := v_1.AuxInt
  8727  		if !(smagicOK(64, c) && smagic(64, c).m&1 == 0 && config.useHmul) {
  8728  			break
  8729  		}
  8730  		v.reset(OpSub64)
  8731  		v.Type = t
  8732  		v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8733  		v1 := b.NewValue0(v.Pos, OpHmul64, t)
  8734  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8735  		v2.AuxInt = int64(smagic(64, c).m / 2)
  8736  		v1.AddArg(v2)
  8737  		v1.AddArg(x)
  8738  		v0.AddArg(v1)
  8739  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8740  		v3.AuxInt = smagic(64, c).s - 1
  8741  		v0.AddArg(v3)
  8742  		v.AddArg(v0)
  8743  		v4 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8744  		v4.AddArg(x)
  8745  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8746  		v5.AuxInt = 63
  8747  		v4.AddArg(v5)
  8748  		v.AddArg(v4)
  8749  		return true
  8750  	}
  8751  	// match: (Div64 <t> x (Const64 [c]))
  8752  	// cond: smagicOK(64,c) && smagic(64,c).m&1 != 0 && config.useHmul
  8753  	// result: (Sub64 <t> (Rsh64x64 <t> (Add64 <t> (Hmul64 <t> (Const64 <typ.UInt64> [int64(smagic(64,c).m)]) x) x) (Const64 <typ.UInt64> [smagic(64,c).s])) (Rsh64x64 <t> x (Const64 <typ.UInt64> [63])))
  8754  	for {
  8755  		t := v.Type
  8756  		_ = v.Args[1]
  8757  		x := v.Args[0]
  8758  		v_1 := v.Args[1]
  8759  		if v_1.Op != OpConst64 {
  8760  			break
  8761  		}
  8762  		c := v_1.AuxInt
  8763  		if !(smagicOK(64, c) && smagic(64, c).m&1 != 0 && config.useHmul) {
  8764  			break
  8765  		}
  8766  		v.reset(OpSub64)
  8767  		v.Type = t
  8768  		v0 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8769  		v1 := b.NewValue0(v.Pos, OpAdd64, t)
  8770  		v2 := b.NewValue0(v.Pos, OpHmul64, t)
  8771  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8772  		v3.AuxInt = int64(smagic(64, c).m)
  8773  		v2.AddArg(v3)
  8774  		v2.AddArg(x)
  8775  		v1.AddArg(v2)
  8776  		v1.AddArg(x)
  8777  		v0.AddArg(v1)
  8778  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8779  		v4.AuxInt = smagic(64, c).s
  8780  		v0.AddArg(v4)
  8781  		v.AddArg(v0)
  8782  		v5 := b.NewValue0(v.Pos, OpRsh64x64, t)
  8783  		v5.AddArg(x)
  8784  		v6 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8785  		v6.AuxInt = 63
  8786  		v5.AddArg(v6)
  8787  		v.AddArg(v5)
  8788  		return true
  8789  	}
  8790  	return false
  8791  }
  8792  func rewriteValuegeneric_OpDiv64F_0(v *Value) bool {
  8793  	b := v.Block
  8794  	_ = b
  8795  	// match: (Div64F (Const64F [c]) (Const64F [d]))
  8796  	// cond:
  8797  	// result: (Const64F [auxFrom64F(auxTo64F(c) / auxTo64F(d))])
  8798  	for {
  8799  		_ = v.Args[1]
  8800  		v_0 := v.Args[0]
  8801  		if v_0.Op != OpConst64F {
  8802  			break
  8803  		}
  8804  		c := v_0.AuxInt
  8805  		v_1 := v.Args[1]
  8806  		if v_1.Op != OpConst64F {
  8807  			break
  8808  		}
  8809  		d := v_1.AuxInt
  8810  		v.reset(OpConst64F)
  8811  		v.AuxInt = auxFrom64F(auxTo64F(c) / auxTo64F(d))
  8812  		return true
  8813  	}
  8814  	// match: (Div64F x (Const64F <t> [c]))
  8815  	// cond: reciprocalExact64(auxTo64F(c))
  8816  	// result: (Mul64F x (Const64F <t> [auxFrom64F(1/auxTo64F(c))]))
  8817  	for {
  8818  		_ = v.Args[1]
  8819  		x := v.Args[0]
  8820  		v_1 := v.Args[1]
  8821  		if v_1.Op != OpConst64F {
  8822  			break
  8823  		}
  8824  		t := v_1.Type
  8825  		c := v_1.AuxInt
  8826  		if !(reciprocalExact64(auxTo64F(c))) {
  8827  			break
  8828  		}
  8829  		v.reset(OpMul64F)
  8830  		v.AddArg(x)
  8831  		v0 := b.NewValue0(v.Pos, OpConst64F, t)
  8832  		v0.AuxInt = auxFrom64F(1 / auxTo64F(c))
  8833  		v.AddArg(v0)
  8834  		return true
  8835  	}
  8836  	return false
  8837  }
  8838  func rewriteValuegeneric_OpDiv64u_0(v *Value) bool {
  8839  	b := v.Block
  8840  	_ = b
  8841  	config := b.Func.Config
  8842  	_ = config
  8843  	typ := &b.Func.Config.Types
  8844  	_ = typ
  8845  	// match: (Div64u (Const64 [c]) (Const64 [d]))
  8846  	// cond: d != 0
  8847  	// result: (Const64 [int64(uint64(c)/uint64(d))])
  8848  	for {
  8849  		_ = v.Args[1]
  8850  		v_0 := v.Args[0]
  8851  		if v_0.Op != OpConst64 {
  8852  			break
  8853  		}
  8854  		c := v_0.AuxInt
  8855  		v_1 := v.Args[1]
  8856  		if v_1.Op != OpConst64 {
  8857  			break
  8858  		}
  8859  		d := v_1.AuxInt
  8860  		if !(d != 0) {
  8861  			break
  8862  		}
  8863  		v.reset(OpConst64)
  8864  		v.AuxInt = int64(uint64(c) / uint64(d))
  8865  		return true
  8866  	}
  8867  	// match: (Div64u n (Const64 [c]))
  8868  	// cond: isPowerOfTwo(c)
  8869  	// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [log2(c)]))
  8870  	for {
  8871  		_ = v.Args[1]
  8872  		n := v.Args[0]
  8873  		v_1 := v.Args[1]
  8874  		if v_1.Op != OpConst64 {
  8875  			break
  8876  		}
  8877  		c := v_1.AuxInt
  8878  		if !(isPowerOfTwo(c)) {
  8879  			break
  8880  		}
  8881  		v.reset(OpRsh64Ux64)
  8882  		v.AddArg(n)
  8883  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8884  		v0.AuxInt = log2(c)
  8885  		v.AddArg(v0)
  8886  		return true
  8887  	}
  8888  	// match: (Div64u n (Const64 [-1<<63]))
  8889  	// cond:
  8890  	// result: (Rsh64Ux64 n (Const64 <typ.UInt64> [63]))
  8891  	for {
  8892  		_ = v.Args[1]
  8893  		n := v.Args[0]
  8894  		v_1 := v.Args[1]
  8895  		if v_1.Op != OpConst64 {
  8896  			break
  8897  		}
  8898  		if v_1.AuxInt != -1<<63 {
  8899  			break
  8900  		}
  8901  		v.reset(OpRsh64Ux64)
  8902  		v.AddArg(n)
  8903  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8904  		v0.AuxInt = 63
  8905  		v.AddArg(v0)
  8906  		return true
  8907  	}
  8908  	// match: (Div64u x (Const64 [c]))
  8909  	// cond: umagicOK(64, c) && config.RegSize == 8 && umagic(64,c).m&1 == 0 && config.useHmul
  8910  	// result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+umagic(64,c).m/2)]) x) (Const64 <typ.UInt64> [umagic(64,c).s-1]))
  8911  	for {
  8912  		_ = v.Args[1]
  8913  		x := v.Args[0]
  8914  		v_1 := v.Args[1]
  8915  		if v_1.Op != OpConst64 {
  8916  			break
  8917  		}
  8918  		c := v_1.AuxInt
  8919  		if !(umagicOK(64, c) && config.RegSize == 8 && umagic(64, c).m&1 == 0 && config.useHmul) {
  8920  			break
  8921  		}
  8922  		v.reset(OpRsh64Ux64)
  8923  		v.Type = typ.UInt64
  8924  		v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
  8925  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8926  		v1.AuxInt = int64(1<<63 + umagic(64, c).m/2)
  8927  		v0.AddArg(v1)
  8928  		v0.AddArg(x)
  8929  		v.AddArg(v0)
  8930  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8931  		v2.AuxInt = umagic(64, c).s - 1
  8932  		v.AddArg(v2)
  8933  		return true
  8934  	}
  8935  	// match: (Div64u x (Const64 [c]))
  8936  	// cond: umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul
  8937  	// result: (Rsh64Ux64 <typ.UInt64> (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(1<<63+(umagic(64,c).m+1)/2)]) (Rsh64Ux64 <typ.UInt64> x (Const64 <typ.UInt64> [1]))) (Const64 <typ.UInt64> [umagic(64,c).s-2]))
  8938  	for {
  8939  		_ = v.Args[1]
  8940  		x := v.Args[0]
  8941  		v_1 := v.Args[1]
  8942  		if v_1.Op != OpConst64 {
  8943  			break
  8944  		}
  8945  		c := v_1.AuxInt
  8946  		if !(umagicOK(64, c) && config.RegSize == 8 && c&1 == 0 && config.useHmul) {
  8947  			break
  8948  		}
  8949  		v.reset(OpRsh64Ux64)
  8950  		v.Type = typ.UInt64
  8951  		v0 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
  8952  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8953  		v1.AuxInt = int64(1<<63 + (umagic(64, c).m+1)/2)
  8954  		v0.AddArg(v1)
  8955  		v2 := b.NewValue0(v.Pos, OpRsh64Ux64, typ.UInt64)
  8956  		v2.AddArg(x)
  8957  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8958  		v3.AuxInt = 1
  8959  		v2.AddArg(v3)
  8960  		v0.AddArg(v2)
  8961  		v.AddArg(v0)
  8962  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8963  		v4.AuxInt = umagic(64, c).s - 2
  8964  		v.AddArg(v4)
  8965  		return true
  8966  	}
  8967  	// match: (Div64u x (Const64 [c]))
  8968  	// cond: umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul
  8969  	// result: (Rsh64Ux64 <typ.UInt64> (Avg64u x (Hmul64u <typ.UInt64> (Const64 <typ.UInt64> [int64(umagic(64,c).m)]) x)) (Const64 <typ.UInt64> [umagic(64,c).s-1]))
  8970  	for {
  8971  		_ = v.Args[1]
  8972  		x := v.Args[0]
  8973  		v_1 := v.Args[1]
  8974  		if v_1.Op != OpConst64 {
  8975  			break
  8976  		}
  8977  		c := v_1.AuxInt
  8978  		if !(umagicOK(64, c) && config.RegSize == 8 && config.useAvg && config.useHmul) {
  8979  			break
  8980  		}
  8981  		v.reset(OpRsh64Ux64)
  8982  		v.Type = typ.UInt64
  8983  		v0 := b.NewValue0(v.Pos, OpAvg64u, typ.UInt64)
  8984  		v0.AddArg(x)
  8985  		v1 := b.NewValue0(v.Pos, OpHmul64u, typ.UInt64)
  8986  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8987  		v2.AuxInt = int64(umagic(64, c).m)
  8988  		v1.AddArg(v2)
  8989  		v1.AddArg(x)
  8990  		v0.AddArg(v1)
  8991  		v.AddArg(v0)
  8992  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  8993  		v3.AuxInt = umagic(64, c).s - 1
  8994  		v.AddArg(v3)
  8995  		return true
  8996  	}
  8997  	return false
  8998  }
  8999  func rewriteValuegeneric_OpDiv8_0(v *Value) bool {
  9000  	b := v.Block
  9001  	_ = b
  9002  	typ := &b.Func.Config.Types
  9003  	_ = typ
  9004  	// match: (Div8 (Const8 [c]) (Const8 [d]))
  9005  	// cond: d != 0
  9006  	// result: (Const8 [int64(int8(c)/int8(d))])
  9007  	for {
  9008  		_ = v.Args[1]
  9009  		v_0 := v.Args[0]
  9010  		if v_0.Op != OpConst8 {
  9011  			break
  9012  		}
  9013  		c := v_0.AuxInt
  9014  		v_1 := v.Args[1]
  9015  		if v_1.Op != OpConst8 {
  9016  			break
  9017  		}
  9018  		d := v_1.AuxInt
  9019  		if !(d != 0) {
  9020  			break
  9021  		}
  9022  		v.reset(OpConst8)
  9023  		v.AuxInt = int64(int8(c) / int8(d))
  9024  		return true
  9025  	}
  9026  	// match: (Div8 n (Const8 [c]))
  9027  	// cond: isNonNegative(n) && isPowerOfTwo(c&0xff)
  9028  	// result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)]))
  9029  	for {
  9030  		_ = v.Args[1]
  9031  		n := v.Args[0]
  9032  		v_1 := v.Args[1]
  9033  		if v_1.Op != OpConst8 {
  9034  			break
  9035  		}
  9036  		c := v_1.AuxInt
  9037  		if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) {
  9038  			break
  9039  		}
  9040  		v.reset(OpRsh8Ux64)
  9041  		v.AddArg(n)
  9042  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9043  		v0.AuxInt = log2(c & 0xff)
  9044  		v.AddArg(v0)
  9045  		return true
  9046  	}
  9047  	// match: (Div8 <t> n (Const8 [c]))
  9048  	// cond: c < 0 && c != -1<<7
  9049  	// result: (Neg8 (Div8 <t> n (Const8 <t> [-c])))
  9050  	for {
  9051  		t := v.Type
  9052  		_ = v.Args[1]
  9053  		n := v.Args[0]
  9054  		v_1 := v.Args[1]
  9055  		if v_1.Op != OpConst8 {
  9056  			break
  9057  		}
  9058  		c := v_1.AuxInt
  9059  		if !(c < 0 && c != -1<<7) {
  9060  			break
  9061  		}
  9062  		v.reset(OpNeg8)
  9063  		v0 := b.NewValue0(v.Pos, OpDiv8, t)
  9064  		v0.AddArg(n)
  9065  		v1 := b.NewValue0(v.Pos, OpConst8, t)
  9066  		v1.AuxInt = -c
  9067  		v0.AddArg(v1)
  9068  		v.AddArg(v0)
  9069  		return true
  9070  	}
  9071  	// match: (Div8 <t> x (Const8 [-1<<7 ]))
  9072  	// cond:
  9073  	// result: (Rsh8Ux64 (And8 <t> x (Neg8 <t> x)) (Const64 <typ.UInt64> [7 ]))
  9074  	for {
  9075  		t := v.Type
  9076  		_ = v.Args[1]
  9077  		x := v.Args[0]
  9078  		v_1 := v.Args[1]
  9079  		if v_1.Op != OpConst8 {
  9080  			break
  9081  		}
  9082  		if v_1.AuxInt != -1<<7 {
  9083  			break
  9084  		}
  9085  		v.reset(OpRsh8Ux64)
  9086  		v0 := b.NewValue0(v.Pos, OpAnd8, t)
  9087  		v0.AddArg(x)
  9088  		v1 := b.NewValue0(v.Pos, OpNeg8, t)
  9089  		v1.AddArg(x)
  9090  		v0.AddArg(v1)
  9091  		v.AddArg(v0)
  9092  		v2 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9093  		v2.AuxInt = 7
  9094  		v.AddArg(v2)
  9095  		return true
  9096  	}
  9097  	// match: (Div8 <t> n (Const8 [c]))
  9098  	// cond: isPowerOfTwo(c)
  9099  	// result: (Rsh8x64 (Add8 <t> n (Rsh8Ux64 <t> (Rsh8x64 <t> n (Const64 <typ.UInt64> [ 7])) (Const64 <typ.UInt64> [ 8-log2(c)]))) (Const64 <typ.UInt64> [log2(c)]))
  9100  	for {
  9101  		t := v.Type
  9102  		_ = v.Args[1]
  9103  		n := v.Args[0]
  9104  		v_1 := v.Args[1]
  9105  		if v_1.Op != OpConst8 {
  9106  			break
  9107  		}
  9108  		c := v_1.AuxInt
  9109  		if !(isPowerOfTwo(c)) {
  9110  			break
  9111  		}
  9112  		v.reset(OpRsh8x64)
  9113  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
  9114  		v0.AddArg(n)
  9115  		v1 := b.NewValue0(v.Pos, OpRsh8Ux64, t)
  9116  		v2 := b.NewValue0(v.Pos, OpRsh8x64, t)
  9117  		v2.AddArg(n)
  9118  		v3 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9119  		v3.AuxInt = 7
  9120  		v2.AddArg(v3)
  9121  		v1.AddArg(v2)
  9122  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9123  		v4.AuxInt = 8 - log2(c)
  9124  		v1.AddArg(v4)
  9125  		v0.AddArg(v1)
  9126  		v.AddArg(v0)
  9127  		v5 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9128  		v5.AuxInt = log2(c)
  9129  		v.AddArg(v5)
  9130  		return true
  9131  	}
  9132  	// match: (Div8 <t> x (Const8 [c]))
  9133  	// cond: smagicOK(8,c)
  9134  	// result: (Sub8 <t> (Rsh32x64 <t> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(smagic(8,c).m)]) (SignExt8to32 x)) (Const64 <typ.UInt64> [8+smagic(8,c).s])) (Rsh32x64 <t> (SignExt8to32 x) (Const64 <typ.UInt64> [31])))
  9135  	for {
  9136  		t := v.Type
  9137  		_ = v.Args[1]
  9138  		x := v.Args[0]
  9139  		v_1 := v.Args[1]
  9140  		if v_1.Op != OpConst8 {
  9141  			break
  9142  		}
  9143  		c := v_1.AuxInt
  9144  		if !(smagicOK(8, c)) {
  9145  			break
  9146  		}
  9147  		v.reset(OpSub8)
  9148  		v.Type = t
  9149  		v0 := b.NewValue0(v.Pos, OpRsh32x64, t)
  9150  		v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  9151  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  9152  		v2.AuxInt = int64(smagic(8, c).m)
  9153  		v1.AddArg(v2)
  9154  		v3 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  9155  		v3.AddArg(x)
  9156  		v1.AddArg(v3)
  9157  		v0.AddArg(v1)
  9158  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9159  		v4.AuxInt = 8 + smagic(8, c).s
  9160  		v0.AddArg(v4)
  9161  		v.AddArg(v0)
  9162  		v5 := b.NewValue0(v.Pos, OpRsh32x64, t)
  9163  		v6 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
  9164  		v6.AddArg(x)
  9165  		v5.AddArg(v6)
  9166  		v7 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9167  		v7.AuxInt = 31
  9168  		v5.AddArg(v7)
  9169  		v.AddArg(v5)
  9170  		return true
  9171  	}
  9172  	return false
  9173  }
  9174  func rewriteValuegeneric_OpDiv8u_0(v *Value) bool {
  9175  	b := v.Block
  9176  	_ = b
  9177  	typ := &b.Func.Config.Types
  9178  	_ = typ
  9179  	// match: (Div8u (Const8 [c]) (Const8 [d]))
  9180  	// cond: d != 0
  9181  	// result: (Const8 [int64(int8(uint8(c)/uint8(d)))])
  9182  	for {
  9183  		_ = v.Args[1]
  9184  		v_0 := v.Args[0]
  9185  		if v_0.Op != OpConst8 {
  9186  			break
  9187  		}
  9188  		c := v_0.AuxInt
  9189  		v_1 := v.Args[1]
  9190  		if v_1.Op != OpConst8 {
  9191  			break
  9192  		}
  9193  		d := v_1.AuxInt
  9194  		if !(d != 0) {
  9195  			break
  9196  		}
  9197  		v.reset(OpConst8)
  9198  		v.AuxInt = int64(int8(uint8(c) / uint8(d)))
  9199  		return true
  9200  	}
  9201  	// match: (Div8u n (Const8 [c]))
  9202  	// cond: isPowerOfTwo(c&0xff)
  9203  	// result: (Rsh8Ux64 n (Const64 <typ.UInt64> [log2(c&0xff)]))
  9204  	for {
  9205  		_ = v.Args[1]
  9206  		n := v.Args[0]
  9207  		v_1 := v.Args[1]
  9208  		if v_1.Op != OpConst8 {
  9209  			break
  9210  		}
  9211  		c := v_1.AuxInt
  9212  		if !(isPowerOfTwo(c & 0xff)) {
  9213  			break
  9214  		}
  9215  		v.reset(OpRsh8Ux64)
  9216  		v.AddArg(n)
  9217  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9218  		v0.AuxInt = log2(c & 0xff)
  9219  		v.AddArg(v0)
  9220  		return true
  9221  	}
  9222  	// match: (Div8u x (Const8 [c]))
  9223  	// cond: umagicOK(8, c)
  9224  	// result: (Trunc32to8 (Rsh32Ux64 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(1<<8+umagic(8,c).m)]) (ZeroExt8to32 x)) (Const64 <typ.UInt64> [8+umagic(8,c).s])))
  9225  	for {
  9226  		_ = v.Args[1]
  9227  		x := v.Args[0]
  9228  		v_1 := v.Args[1]
  9229  		if v_1.Op != OpConst8 {
  9230  			break
  9231  		}
  9232  		c := v_1.AuxInt
  9233  		if !(umagicOK(8, c)) {
  9234  			break
  9235  		}
  9236  		v.reset(OpTrunc32to8)
  9237  		v0 := b.NewValue0(v.Pos, OpRsh32Ux64, typ.UInt32)
  9238  		v1 := b.NewValue0(v.Pos, OpMul32, typ.UInt32)
  9239  		v2 := b.NewValue0(v.Pos, OpConst32, typ.UInt32)
  9240  		v2.AuxInt = int64(1<<8 + umagic(8, c).m)
  9241  		v1.AddArg(v2)
  9242  		v3 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
  9243  		v3.AddArg(x)
  9244  		v1.AddArg(v3)
  9245  		v0.AddArg(v1)
  9246  		v4 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
  9247  		v4.AuxInt = 8 + umagic(8, c).s
  9248  		v0.AddArg(v4)
  9249  		v.AddArg(v0)
  9250  		return true
  9251  	}
  9252  	return false
  9253  }
  9254  func rewriteValuegeneric_OpEq16_0(v *Value) bool {
  9255  	b := v.Block
  9256  	_ = b
  9257  	// match: (Eq16 x x)
  9258  	// cond:
  9259  	// result: (ConstBool [1])
  9260  	for {
  9261  		_ = v.Args[1]
  9262  		x := v.Args[0]
  9263  		if x != v.Args[1] {
  9264  			break
  9265  		}
  9266  		v.reset(OpConstBool)
  9267  		v.AuxInt = 1
  9268  		return true
  9269  	}
  9270  	// match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
  9271  	// cond:
  9272  	// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  9273  	for {
  9274  		_ = v.Args[1]
  9275  		v_0 := v.Args[0]
  9276  		if v_0.Op != OpConst16 {
  9277  			break
  9278  		}
  9279  		t := v_0.Type
  9280  		c := v_0.AuxInt
  9281  		v_1 := v.Args[1]
  9282  		if v_1.Op != OpAdd16 {
  9283  			break
  9284  		}
  9285  		_ = v_1.Args[1]
  9286  		v_1_0 := v_1.Args[0]
  9287  		if v_1_0.Op != OpConst16 {
  9288  			break
  9289  		}
  9290  		if v_1_0.Type != t {
  9291  			break
  9292  		}
  9293  		d := v_1_0.AuxInt
  9294  		x := v_1.Args[1]
  9295  		v.reset(OpEq16)
  9296  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  9297  		v0.AuxInt = int64(int16(c - d))
  9298  		v.AddArg(v0)
  9299  		v.AddArg(x)
  9300  		return true
  9301  	}
  9302  	// match: (Eq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d])))
  9303  	// cond:
  9304  	// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  9305  	for {
  9306  		_ = v.Args[1]
  9307  		v_0 := v.Args[0]
  9308  		if v_0.Op != OpConst16 {
  9309  			break
  9310  		}
  9311  		t := v_0.Type
  9312  		c := v_0.AuxInt
  9313  		v_1 := v.Args[1]
  9314  		if v_1.Op != OpAdd16 {
  9315  			break
  9316  		}
  9317  		_ = v_1.Args[1]
  9318  		x := v_1.Args[0]
  9319  		v_1_1 := v_1.Args[1]
  9320  		if v_1_1.Op != OpConst16 {
  9321  			break
  9322  		}
  9323  		if v_1_1.Type != t {
  9324  			break
  9325  		}
  9326  		d := v_1_1.AuxInt
  9327  		v.reset(OpEq16)
  9328  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  9329  		v0.AuxInt = int64(int16(c - d))
  9330  		v.AddArg(v0)
  9331  		v.AddArg(x)
  9332  		return true
  9333  	}
  9334  	// match: (Eq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
  9335  	// cond:
  9336  	// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  9337  	for {
  9338  		_ = v.Args[1]
  9339  		v_0 := v.Args[0]
  9340  		if v_0.Op != OpAdd16 {
  9341  			break
  9342  		}
  9343  		_ = v_0.Args[1]
  9344  		v_0_0 := v_0.Args[0]
  9345  		if v_0_0.Op != OpConst16 {
  9346  			break
  9347  		}
  9348  		t := v_0_0.Type
  9349  		d := v_0_0.AuxInt
  9350  		x := v_0.Args[1]
  9351  		v_1 := v.Args[1]
  9352  		if v_1.Op != OpConst16 {
  9353  			break
  9354  		}
  9355  		if v_1.Type != t {
  9356  			break
  9357  		}
  9358  		c := v_1.AuxInt
  9359  		v.reset(OpEq16)
  9360  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  9361  		v0.AuxInt = int64(int16(c - d))
  9362  		v.AddArg(v0)
  9363  		v.AddArg(x)
  9364  		return true
  9365  	}
  9366  	// match: (Eq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c]))
  9367  	// cond:
  9368  	// result: (Eq16 (Const16 <t> [int64(int16(c-d))]) x)
  9369  	for {
  9370  		_ = v.Args[1]
  9371  		v_0 := v.Args[0]
  9372  		if v_0.Op != OpAdd16 {
  9373  			break
  9374  		}
  9375  		_ = v_0.Args[1]
  9376  		x := v_0.Args[0]
  9377  		v_0_1 := v_0.Args[1]
  9378  		if v_0_1.Op != OpConst16 {
  9379  			break
  9380  		}
  9381  		t := v_0_1.Type
  9382  		d := v_0_1.AuxInt
  9383  		v_1 := v.Args[1]
  9384  		if v_1.Op != OpConst16 {
  9385  			break
  9386  		}
  9387  		if v_1.Type != t {
  9388  			break
  9389  		}
  9390  		c := v_1.AuxInt
  9391  		v.reset(OpEq16)
  9392  		v0 := b.NewValue0(v.Pos, OpConst16, t)
  9393  		v0.AuxInt = int64(int16(c - d))
  9394  		v.AddArg(v0)
  9395  		v.AddArg(x)
  9396  		return true
  9397  	}
  9398  	// match: (Eq16 (Const16 [c]) (Const16 [d]))
  9399  	// cond:
  9400  	// result: (ConstBool [b2i(c == d)])
  9401  	for {
  9402  		_ = v.Args[1]
  9403  		v_0 := v.Args[0]
  9404  		if v_0.Op != OpConst16 {
  9405  			break
  9406  		}
  9407  		c := v_0.AuxInt
  9408  		v_1 := v.Args[1]
  9409  		if v_1.Op != OpConst16 {
  9410  			break
  9411  		}
  9412  		d := v_1.AuxInt
  9413  		v.reset(OpConstBool)
  9414  		v.AuxInt = b2i(c == d)
  9415  		return true
  9416  	}
  9417  	// match: (Eq16 (Const16 [d]) (Const16 [c]))
  9418  	// cond:
  9419  	// result: (ConstBool [b2i(c == d)])
  9420  	for {
  9421  		_ = v.Args[1]
  9422  		v_0 := v.Args[0]
  9423  		if v_0.Op != OpConst16 {
  9424  			break
  9425  		}
  9426  		d := v_0.AuxInt
  9427  		v_1 := v.Args[1]
  9428  		if v_1.Op != OpConst16 {
  9429  			break
  9430  		}
  9431  		c := v_1.AuxInt
  9432  		v.reset(OpConstBool)
  9433  		v.AuxInt = b2i(c == d)
  9434  		return true
  9435  	}
  9436  	// match: (Eq16 s:(Sub16 x y) (Const16 [0]))
  9437  	// cond: s.Uses == 1
  9438  	// result: (Eq16 x y)
  9439  	for {
  9440  		_ = v.Args[1]
  9441  		s := v.Args[0]
  9442  		if s.Op != OpSub16 {
  9443  			break
  9444  		}
  9445  		_ = s.Args[1]
  9446  		x := s.Args[0]
  9447  		y := s.Args[1]
  9448  		v_1 := v.Args[1]
  9449  		if v_1.Op != OpConst16 {
  9450  			break
  9451  		}
  9452  		if v_1.AuxInt != 0 {
  9453  			break
  9454  		}
  9455  		if !(s.Uses == 1) {
  9456  			break
  9457  		}
  9458  		v.reset(OpEq16)
  9459  		v.AddArg(x)
  9460  		v.AddArg(y)
  9461  		return true
  9462  	}
  9463  	// match: (Eq16 (Const16 [0]) s:(Sub16 x y))
  9464  	// cond: s.Uses == 1
  9465  	// result: (Eq16 x y)
  9466  	for {
  9467  		_ = v.Args[1]
  9468  		v_0 := v.Args[0]
  9469  		if v_0.Op != OpConst16 {
  9470  			break
  9471  		}
  9472  		if v_0.AuxInt != 0 {
  9473  			break
  9474  		}
  9475  		s := v.Args[1]
  9476  		if s.Op != OpSub16 {
  9477  			break
  9478  		}
  9479  		_ = s.Args[1]
  9480  		x := s.Args[0]
  9481  		y := s.Args[1]
  9482  		if !(s.Uses == 1) {
  9483  			break
  9484  		}
  9485  		v.reset(OpEq16)
  9486  		v.AddArg(x)
  9487  		v.AddArg(y)
  9488  		return true
  9489  	}
  9490  	return false
  9491  }
  9492  func rewriteValuegeneric_OpEq32_0(v *Value) bool {
  9493  	b := v.Block
  9494  	_ = b
  9495  	// match: (Eq32 x x)
  9496  	// cond:
  9497  	// result: (ConstBool [1])
  9498  	for {
  9499  		_ = v.Args[1]
  9500  		x := v.Args[0]
  9501  		if x != v.Args[1] {
  9502  			break
  9503  		}
  9504  		v.reset(OpConstBool)
  9505  		v.AuxInt = 1
  9506  		return true
  9507  	}
  9508  	// match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
  9509  	// cond:
  9510  	// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
  9511  	for {
  9512  		_ = v.Args[1]
  9513  		v_0 := v.Args[0]
  9514  		if v_0.Op != OpConst32 {
  9515  			break
  9516  		}
  9517  		t := v_0.Type
  9518  		c := v_0.AuxInt
  9519  		v_1 := v.Args[1]
  9520  		if v_1.Op != OpAdd32 {
  9521  			break
  9522  		}
  9523  		_ = v_1.Args[1]
  9524  		v_1_0 := v_1.Args[0]
  9525  		if v_1_0.Op != OpConst32 {
  9526  			break
  9527  		}
  9528  		if v_1_0.Type != t {
  9529  			break
  9530  		}
  9531  		d := v_1_0.AuxInt
  9532  		x := v_1.Args[1]
  9533  		v.reset(OpEq32)
  9534  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  9535  		v0.AuxInt = int64(int32(c - d))
  9536  		v.AddArg(v0)
  9537  		v.AddArg(x)
  9538  		return true
  9539  	}
  9540  	// match: (Eq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d])))
  9541  	// cond:
  9542  	// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
  9543  	for {
  9544  		_ = v.Args[1]
  9545  		v_0 := v.Args[0]
  9546  		if v_0.Op != OpConst32 {
  9547  			break
  9548  		}
  9549  		t := v_0.Type
  9550  		c := v_0.AuxInt
  9551  		v_1 := v.Args[1]
  9552  		if v_1.Op != OpAdd32 {
  9553  			break
  9554  		}
  9555  		_ = v_1.Args[1]
  9556  		x := v_1.Args[0]
  9557  		v_1_1 := v_1.Args[1]
  9558  		if v_1_1.Op != OpConst32 {
  9559  			break
  9560  		}
  9561  		if v_1_1.Type != t {
  9562  			break
  9563  		}
  9564  		d := v_1_1.AuxInt
  9565  		v.reset(OpEq32)
  9566  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  9567  		v0.AuxInt = int64(int32(c - d))
  9568  		v.AddArg(v0)
  9569  		v.AddArg(x)
  9570  		return true
  9571  	}
  9572  	// match: (Eq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
  9573  	// cond:
  9574  	// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
  9575  	for {
  9576  		_ = v.Args[1]
  9577  		v_0 := v.Args[0]
  9578  		if v_0.Op != OpAdd32 {
  9579  			break
  9580  		}
  9581  		_ = v_0.Args[1]
  9582  		v_0_0 := v_0.Args[0]
  9583  		if v_0_0.Op != OpConst32 {
  9584  			break
  9585  		}
  9586  		t := v_0_0.Type
  9587  		d := v_0_0.AuxInt
  9588  		x := v_0.Args[1]
  9589  		v_1 := v.Args[1]
  9590  		if v_1.Op != OpConst32 {
  9591  			break
  9592  		}
  9593  		if v_1.Type != t {
  9594  			break
  9595  		}
  9596  		c := v_1.AuxInt
  9597  		v.reset(OpEq32)
  9598  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  9599  		v0.AuxInt = int64(int32(c - d))
  9600  		v.AddArg(v0)
  9601  		v.AddArg(x)
  9602  		return true
  9603  	}
  9604  	// match: (Eq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c]))
  9605  	// cond:
  9606  	// result: (Eq32 (Const32 <t> [int64(int32(c-d))]) x)
  9607  	for {
  9608  		_ = v.Args[1]
  9609  		v_0 := v.Args[0]
  9610  		if v_0.Op != OpAdd32 {
  9611  			break
  9612  		}
  9613  		_ = v_0.Args[1]
  9614  		x := v_0.Args[0]
  9615  		v_0_1 := v_0.Args[1]
  9616  		if v_0_1.Op != OpConst32 {
  9617  			break
  9618  		}
  9619  		t := v_0_1.Type
  9620  		d := v_0_1.AuxInt
  9621  		v_1 := v.Args[1]
  9622  		if v_1.Op != OpConst32 {
  9623  			break
  9624  		}
  9625  		if v_1.Type != t {
  9626  			break
  9627  		}
  9628  		c := v_1.AuxInt
  9629  		v.reset(OpEq32)
  9630  		v0 := b.NewValue0(v.Pos, OpConst32, t)
  9631  		v0.AuxInt = int64(int32(c - d))
  9632  		v.AddArg(v0)
  9633  		v.AddArg(x)
  9634  		return true
  9635  	}
  9636  	// match: (Eq32 (Const32 [c]) (Const32 [d]))
  9637  	// cond:
  9638  	// result: (ConstBool [b2i(c == d)])
  9639  	for {
  9640  		_ = v.Args[1]
  9641  		v_0 := v.Args[0]
  9642  		if v_0.Op != OpConst32 {
  9643  			break
  9644  		}
  9645  		c := v_0.AuxInt
  9646  		v_1 := v.Args[1]
  9647  		if v_1.Op != OpConst32 {
  9648  			break
  9649  		}
  9650  		d := v_1.AuxInt
  9651  		v.reset(OpConstBool)
  9652  		v.AuxInt = b2i(c == d)
  9653  		return true
  9654  	}
  9655  	// match: (Eq32 (Const32 [d]) (Const32 [c]))
  9656  	// cond:
  9657  	// result: (ConstBool [b2i(c == d)])
  9658  	for {
  9659  		_ = v.Args[1]
  9660  		v_0 := v.Args[0]
  9661  		if v_0.Op != OpConst32 {
  9662  			break
  9663  		}
  9664  		d := v_0.AuxInt
  9665  		v_1 := v.Args[1]
  9666  		if v_1.Op != OpConst32 {
  9667  			break
  9668  		}
  9669  		c := v_1.AuxInt
  9670  		v.reset(OpConstBool)
  9671  		v.AuxInt = b2i(c == d)
  9672  		return true
  9673  	}
  9674  	// match: (Eq32 s:(Sub32 x y) (Const32 [0]))
  9675  	// cond: s.Uses == 1
  9676  	// result: (Eq32 x y)
  9677  	for {
  9678  		_ = v.Args[1]
  9679  		s := v.Args[0]
  9680  		if s.Op != OpSub32 {
  9681  			break
  9682  		}
  9683  		_ = s.Args[1]
  9684  		x := s.Args[0]
  9685  		y := s.Args[1]
  9686  		v_1 := v.Args[1]
  9687  		if v_1.Op != OpConst32 {
  9688  			break
  9689  		}
  9690  		if v_1.AuxInt != 0 {
  9691  			break
  9692  		}
  9693  		if !(s.Uses == 1) {
  9694  			break
  9695  		}
  9696  		v.reset(OpEq32)
  9697  		v.AddArg(x)
  9698  		v.AddArg(y)
  9699  		return true
  9700  	}
  9701  	// match: (Eq32 (Const32 [0]) s:(Sub32 x y))
  9702  	// cond: s.Uses == 1
  9703  	// result: (Eq32 x y)
  9704  	for {
  9705  		_ = v.Args[1]
  9706  		v_0 := v.Args[0]
  9707  		if v_0.Op != OpConst32 {
  9708  			break
  9709  		}
  9710  		if v_0.AuxInt != 0 {
  9711  			break
  9712  		}
  9713  		s := v.Args[1]
  9714  		if s.Op != OpSub32 {
  9715  			break
  9716  		}
  9717  		_ = s.Args[1]
  9718  		x := s.Args[0]
  9719  		y := s.Args[1]
  9720  		if !(s.Uses == 1) {
  9721  			break
  9722  		}
  9723  		v.reset(OpEq32)
  9724  		v.AddArg(x)
  9725  		v.AddArg(y)
  9726  		return true
  9727  	}
  9728  	return false
  9729  }
  9730  func rewriteValuegeneric_OpEq32F_0(v *Value) bool {
  9731  	// match: (Eq32F (Const32F [c]) (Const32F [d]))
  9732  	// cond:
  9733  	// result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))])
  9734  	for {
  9735  		_ = v.Args[1]
  9736  		v_0 := v.Args[0]
  9737  		if v_0.Op != OpConst32F {
  9738  			break
  9739  		}
  9740  		c := v_0.AuxInt
  9741  		v_1 := v.Args[1]
  9742  		if v_1.Op != OpConst32F {
  9743  			break
  9744  		}
  9745  		d := v_1.AuxInt
  9746  		v.reset(OpConstBool)
  9747  		v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d))
  9748  		return true
  9749  	}
  9750  	// match: (Eq32F (Const32F [d]) (Const32F [c]))
  9751  	// cond:
  9752  	// result: (ConstBool [b2i(auxTo32F(c) == auxTo32F(d))])
  9753  	for {
  9754  		_ = v.Args[1]
  9755  		v_0 := v.Args[0]
  9756  		if v_0.Op != OpConst32F {
  9757  			break
  9758  		}
  9759  		d := v_0.AuxInt
  9760  		v_1 := v.Args[1]
  9761  		if v_1.Op != OpConst32F {
  9762  			break
  9763  		}
  9764  		c := v_1.AuxInt
  9765  		v.reset(OpConstBool)
  9766  		v.AuxInt = b2i(auxTo32F(c) == auxTo32F(d))
  9767  		return true
  9768  	}
  9769  	return false
  9770  }
  9771  func rewriteValuegeneric_OpEq64_0(v *Value) bool {
  9772  	b := v.Block
  9773  	_ = b
  9774  	// match: (Eq64 x x)
  9775  	// cond:
  9776  	// result: (ConstBool [1])
  9777  	for {
  9778  		_ = v.Args[1]
  9779  		x := v.Args[0]
  9780  		if x != v.Args[1] {
  9781  			break
  9782  		}
  9783  		v.reset(OpConstBool)
  9784  		v.AuxInt = 1
  9785  		return true
  9786  	}
  9787  	// match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
  9788  	// cond:
  9789  	// result: (Eq64 (Const64 <t> [c-d]) x)
  9790  	for {
  9791  		_ = v.Args[1]
  9792  		v_0 := v.Args[0]
  9793  		if v_0.Op != OpConst64 {
  9794  			break
  9795  		}
  9796  		t := v_0.Type
  9797  		c := v_0.AuxInt
  9798  		v_1 := v.Args[1]
  9799  		if v_1.Op != OpAdd64 {
  9800  			break
  9801  		}
  9802  		_ = v_1.Args[1]
  9803  		v_1_0 := v_1.Args[0]
  9804  		if v_1_0.Op != OpConst64 {
  9805  			break
  9806  		}
  9807  		if v_1_0.Type != t {
  9808  			break
  9809  		}
  9810  		d := v_1_0.AuxInt
  9811  		x := v_1.Args[1]
  9812  		v.reset(OpEq64)
  9813  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  9814  		v0.AuxInt = c - d
  9815  		v.AddArg(v0)
  9816  		v.AddArg(x)
  9817  		return true
  9818  	}
  9819  	// match: (Eq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d])))
  9820  	// cond:
  9821  	// result: (Eq64 (Const64 <t> [c-d]) x)
  9822  	for {
  9823  		_ = v.Args[1]
  9824  		v_0 := v.Args[0]
  9825  		if v_0.Op != OpConst64 {
  9826  			break
  9827  		}
  9828  		t := v_0.Type
  9829  		c := v_0.AuxInt
  9830  		v_1 := v.Args[1]
  9831  		if v_1.Op != OpAdd64 {
  9832  			break
  9833  		}
  9834  		_ = v_1.Args[1]
  9835  		x := v_1.Args[0]
  9836  		v_1_1 := v_1.Args[1]
  9837  		if v_1_1.Op != OpConst64 {
  9838  			break
  9839  		}
  9840  		if v_1_1.Type != t {
  9841  			break
  9842  		}
  9843  		d := v_1_1.AuxInt
  9844  		v.reset(OpEq64)
  9845  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  9846  		v0.AuxInt = c - d
  9847  		v.AddArg(v0)
  9848  		v.AddArg(x)
  9849  		return true
  9850  	}
  9851  	// match: (Eq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
  9852  	// cond:
  9853  	// result: (Eq64 (Const64 <t> [c-d]) x)
  9854  	for {
  9855  		_ = v.Args[1]
  9856  		v_0 := v.Args[0]
  9857  		if v_0.Op != OpAdd64 {
  9858  			break
  9859  		}
  9860  		_ = v_0.Args[1]
  9861  		v_0_0 := v_0.Args[0]
  9862  		if v_0_0.Op != OpConst64 {
  9863  			break
  9864  		}
  9865  		t := v_0_0.Type
  9866  		d := v_0_0.AuxInt
  9867  		x := v_0.Args[1]
  9868  		v_1 := v.Args[1]
  9869  		if v_1.Op != OpConst64 {
  9870  			break
  9871  		}
  9872  		if v_1.Type != t {
  9873  			break
  9874  		}
  9875  		c := v_1.AuxInt
  9876  		v.reset(OpEq64)
  9877  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  9878  		v0.AuxInt = c - d
  9879  		v.AddArg(v0)
  9880  		v.AddArg(x)
  9881  		return true
  9882  	}
  9883  	// match: (Eq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c]))
  9884  	// cond:
  9885  	// result: (Eq64 (Const64 <t> [c-d]) x)
  9886  	for {
  9887  		_ = v.Args[1]
  9888  		v_0 := v.Args[0]
  9889  		if v_0.Op != OpAdd64 {
  9890  			break
  9891  		}
  9892  		_ = v_0.Args[1]
  9893  		x := v_0.Args[0]
  9894  		v_0_1 := v_0.Args[1]
  9895  		if v_0_1.Op != OpConst64 {
  9896  			break
  9897  		}
  9898  		t := v_0_1.Type
  9899  		d := v_0_1.AuxInt
  9900  		v_1 := v.Args[1]
  9901  		if v_1.Op != OpConst64 {
  9902  			break
  9903  		}
  9904  		if v_1.Type != t {
  9905  			break
  9906  		}
  9907  		c := v_1.AuxInt
  9908  		v.reset(OpEq64)
  9909  		v0 := b.NewValue0(v.Pos, OpConst64, t)
  9910  		v0.AuxInt = c - d
  9911  		v.AddArg(v0)
  9912  		v.AddArg(x)
  9913  		return true
  9914  	}
  9915  	// match: (Eq64 (Const64 [c]) (Const64 [d]))
  9916  	// cond:
  9917  	// result: (ConstBool [b2i(c == d)])
  9918  	for {
  9919  		_ = v.Args[1]
  9920  		v_0 := v.Args[0]
  9921  		if v_0.Op != OpConst64 {
  9922  			break
  9923  		}
  9924  		c := v_0.AuxInt
  9925  		v_1 := v.Args[1]
  9926  		if v_1.Op != OpConst64 {
  9927  			break
  9928  		}
  9929  		d := v_1.AuxInt
  9930  		v.reset(OpConstBool)
  9931  		v.AuxInt = b2i(c == d)
  9932  		return true
  9933  	}
  9934  	// match: (Eq64 (Const64 [d]) (Const64 [c]))
  9935  	// cond:
  9936  	// result: (ConstBool [b2i(c == d)])
  9937  	for {
  9938  		_ = v.Args[1]
  9939  		v_0 := v.Args[0]
  9940  		if v_0.Op != OpConst64 {
  9941  			break
  9942  		}
  9943  		d := v_0.AuxInt
  9944  		v_1 := v.Args[1]
  9945  		if v_1.Op != OpConst64 {
  9946  			break
  9947  		}
  9948  		c := v_1.AuxInt
  9949  		v.reset(OpConstBool)
  9950  		v.AuxInt = b2i(c == d)
  9951  		return true
  9952  	}
  9953  	// match: (Eq64 s:(Sub64 x y) (Const64 [0]))
  9954  	// cond: s.Uses == 1
  9955  	// result: (Eq64 x y)
  9956  	for {
  9957  		_ = v.Args[1]
  9958  		s := v.Args[0]
  9959  		if s.Op != OpSub64 {
  9960  			break
  9961  		}
  9962  		_ = s.Args[1]
  9963  		x := s.Args[0]
  9964  		y := s.Args[1]
  9965  		v_1 := v.Args[1]
  9966  		if v_1.Op != OpConst64 {
  9967  			break
  9968  		}
  9969  		if v_1.AuxInt != 0 {
  9970  			break
  9971  		}
  9972  		if !(s.Uses == 1) {
  9973  			break
  9974  		}
  9975  		v.reset(OpEq64)
  9976  		v.AddArg(x)
  9977  		v.AddArg(y)
  9978  		return true
  9979  	}
  9980  	// match: (Eq64 (Const64 [0]) s:(Sub64 x y))
  9981  	// cond: s.Uses == 1
  9982  	// result: (Eq64 x y)
  9983  	for {
  9984  		_ = v.Args[1]
  9985  		v_0 := v.Args[0]
  9986  		if v_0.Op != OpConst64 {
  9987  			break
  9988  		}
  9989  		if v_0.AuxInt != 0 {
  9990  			break
  9991  		}
  9992  		s := v.Args[1]
  9993  		if s.Op != OpSub64 {
  9994  			break
  9995  		}
  9996  		_ = s.Args[1]
  9997  		x := s.Args[0]
  9998  		y := s.Args[1]
  9999  		if !(s.Uses == 1) {
 10000  			break
 10001  		}
 10002  		v.reset(OpEq64)
 10003  		v.AddArg(x)
 10004  		v.AddArg(y)
 10005  		return true
 10006  	}
 10007  	return false
 10008  }
 10009  func rewriteValuegeneric_OpEq64F_0(v *Value) bool {
 10010  	// match: (Eq64F (Const64F [c]) (Const64F [d]))
 10011  	// cond:
 10012  	// result: (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))])
 10013  	for {
 10014  		_ = v.Args[1]
 10015  		v_0 := v.Args[0]
 10016  		if v_0.Op != OpConst64F {
 10017  			break
 10018  		}
 10019  		c := v_0.AuxInt
 10020  		v_1 := v.Args[1]
 10021  		if v_1.Op != OpConst64F {
 10022  			break
 10023  		}
 10024  		d := v_1.AuxInt
 10025  		v.reset(OpConstBool)
 10026  		v.AuxInt = b2i(auxTo64F(c) == auxTo64F(d))
 10027  		return true
 10028  	}
 10029  	// match: (Eq64F (Const64F [d]) (Const64F [c]))
 10030  	// cond:
 10031  	// result: (ConstBool [b2i(auxTo64F(c) == auxTo64F(d))])
 10032  	for {
 10033  		_ = v.Args[1]
 10034  		v_0 := v.Args[0]
 10035  		if v_0.Op != OpConst64F {
 10036  			break
 10037  		}
 10038  		d := v_0.AuxInt
 10039  		v_1 := v.Args[1]
 10040  		if v_1.Op != OpConst64F {
 10041  			break
 10042  		}
 10043  		c := v_1.AuxInt
 10044  		v.reset(OpConstBool)
 10045  		v.AuxInt = b2i(auxTo64F(c) == auxTo64F(d))
 10046  		return true
 10047  	}
 10048  	return false
 10049  }
 10050  func rewriteValuegeneric_OpEq8_0(v *Value) bool {
 10051  	b := v.Block
 10052  	_ = b
 10053  	// match: (Eq8 x x)
 10054  	// cond:
 10055  	// result: (ConstBool [1])
 10056  	for {
 10057  		_ = v.Args[1]
 10058  		x := v.Args[0]
 10059  		if x != v.Args[1] {
 10060  			break
 10061  		}
 10062  		v.reset(OpConstBool)
 10063  		v.AuxInt = 1
 10064  		return true
 10065  	}
 10066  	// match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
 10067  	// cond:
 10068  	// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 10069  	for {
 10070  		_ = v.Args[1]
 10071  		v_0 := v.Args[0]
 10072  		if v_0.Op != OpConst8 {
 10073  			break
 10074  		}
 10075  		t := v_0.Type
 10076  		c := v_0.AuxInt
 10077  		v_1 := v.Args[1]
 10078  		if v_1.Op != OpAdd8 {
 10079  			break
 10080  		}
 10081  		_ = v_1.Args[1]
 10082  		v_1_0 := v_1.Args[0]
 10083  		if v_1_0.Op != OpConst8 {
 10084  			break
 10085  		}
 10086  		if v_1_0.Type != t {
 10087  			break
 10088  		}
 10089  		d := v_1_0.AuxInt
 10090  		x := v_1.Args[1]
 10091  		v.reset(OpEq8)
 10092  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 10093  		v0.AuxInt = int64(int8(c - d))
 10094  		v.AddArg(v0)
 10095  		v.AddArg(x)
 10096  		return true
 10097  	}
 10098  	// match: (Eq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d])))
 10099  	// cond:
 10100  	// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 10101  	for {
 10102  		_ = v.Args[1]
 10103  		v_0 := v.Args[0]
 10104  		if v_0.Op != OpConst8 {
 10105  			break
 10106  		}
 10107  		t := v_0.Type
 10108  		c := v_0.AuxInt
 10109  		v_1 := v.Args[1]
 10110  		if v_1.Op != OpAdd8 {
 10111  			break
 10112  		}
 10113  		_ = v_1.Args[1]
 10114  		x := v_1.Args[0]
 10115  		v_1_1 := v_1.Args[1]
 10116  		if v_1_1.Op != OpConst8 {
 10117  			break
 10118  		}
 10119  		if v_1_1.Type != t {
 10120  			break
 10121  		}
 10122  		d := v_1_1.AuxInt
 10123  		v.reset(OpEq8)
 10124  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 10125  		v0.AuxInt = int64(int8(c - d))
 10126  		v.AddArg(v0)
 10127  		v.AddArg(x)
 10128  		return true
 10129  	}
 10130  	// match: (Eq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 10131  	// cond:
 10132  	// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 10133  	for {
 10134  		_ = v.Args[1]
 10135  		v_0 := v.Args[0]
 10136  		if v_0.Op != OpAdd8 {
 10137  			break
 10138  		}
 10139  		_ = v_0.Args[1]
 10140  		v_0_0 := v_0.Args[0]
 10141  		if v_0_0.Op != OpConst8 {
 10142  			break
 10143  		}
 10144  		t := v_0_0.Type
 10145  		d := v_0_0.AuxInt
 10146  		x := v_0.Args[1]
 10147  		v_1 := v.Args[1]
 10148  		if v_1.Op != OpConst8 {
 10149  			break
 10150  		}
 10151  		if v_1.Type != t {
 10152  			break
 10153  		}
 10154  		c := v_1.AuxInt
 10155  		v.reset(OpEq8)
 10156  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 10157  		v0.AuxInt = int64(int8(c - d))
 10158  		v.AddArg(v0)
 10159  		v.AddArg(x)
 10160  		return true
 10161  	}
 10162  	// match: (Eq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c]))
 10163  	// cond:
 10164  	// result: (Eq8 (Const8 <t> [int64(int8(c-d))]) x)
 10165  	for {
 10166  		_ = v.Args[1]
 10167  		v_0 := v.Args[0]
 10168  		if v_0.Op != OpAdd8 {
 10169  			break
 10170  		}
 10171  		_ = v_0.Args[1]
 10172  		x := v_0.Args[0]
 10173  		v_0_1 := v_0.Args[1]
 10174  		if v_0_1.Op != OpConst8 {
 10175  			break
 10176  		}
 10177  		t := v_0_1.Type
 10178  		d := v_0_1.AuxInt
 10179  		v_1 := v.Args[1]
 10180  		if v_1.Op != OpConst8 {
 10181  			break
 10182  		}
 10183  		if v_1.Type != t {
 10184  			break
 10185  		}
 10186  		c := v_1.AuxInt
 10187  		v.reset(OpEq8)
 10188  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 10189  		v0.AuxInt = int64(int8(c - d))
 10190  		v.AddArg(v0)
 10191  		v.AddArg(x)
 10192  		return true
 10193  	}
 10194  	// match: (Eq8 (Const8 [c]) (Const8 [d]))
 10195  	// cond:
 10196  	// result: (ConstBool [b2i(c == d)])
 10197  	for {
 10198  		_ = v.Args[1]
 10199  		v_0 := v.Args[0]
 10200  		if v_0.Op != OpConst8 {
 10201  			break
 10202  		}
 10203  		c := v_0.AuxInt
 10204  		v_1 := v.Args[1]
 10205  		if v_1.Op != OpConst8 {
 10206  			break
 10207  		}
 10208  		d := v_1.AuxInt
 10209  		v.reset(OpConstBool)
 10210  		v.AuxInt = b2i(c == d)
 10211  		return true
 10212  	}
 10213  	// match: (Eq8 (Const8 [d]) (Const8 [c]))
 10214  	// cond:
 10215  	// result: (ConstBool [b2i(c == d)])
 10216  	for {
 10217  		_ = v.Args[1]
 10218  		v_0 := v.Args[0]
 10219  		if v_0.Op != OpConst8 {
 10220  			break
 10221  		}
 10222  		d := v_0.AuxInt
 10223  		v_1 := v.Args[1]
 10224  		if v_1.Op != OpConst8 {
 10225  			break
 10226  		}
 10227  		c := v_1.AuxInt
 10228  		v.reset(OpConstBool)
 10229  		v.AuxInt = b2i(c == d)
 10230  		return true
 10231  	}
 10232  	// match: (Eq8 s:(Sub8 x y) (Const8 [0]))
 10233  	// cond: s.Uses == 1
 10234  	// result: (Eq8 x y)
 10235  	for {
 10236  		_ = v.Args[1]
 10237  		s := v.Args[0]
 10238  		if s.Op != OpSub8 {
 10239  			break
 10240  		}
 10241  		_ = s.Args[1]
 10242  		x := s.Args[0]
 10243  		y := s.Args[1]
 10244  		v_1 := v.Args[1]
 10245  		if v_1.Op != OpConst8 {
 10246  			break
 10247  		}
 10248  		if v_1.AuxInt != 0 {
 10249  			break
 10250  		}
 10251  		if !(s.Uses == 1) {
 10252  			break
 10253  		}
 10254  		v.reset(OpEq8)
 10255  		v.AddArg(x)
 10256  		v.AddArg(y)
 10257  		return true
 10258  	}
 10259  	// match: (Eq8 (Const8 [0]) s:(Sub8 x y))
 10260  	// cond: s.Uses == 1
 10261  	// result: (Eq8 x y)
 10262  	for {
 10263  		_ = v.Args[1]
 10264  		v_0 := v.Args[0]
 10265  		if v_0.Op != OpConst8 {
 10266  			break
 10267  		}
 10268  		if v_0.AuxInt != 0 {
 10269  			break
 10270  		}
 10271  		s := v.Args[1]
 10272  		if s.Op != OpSub8 {
 10273  			break
 10274  		}
 10275  		_ = s.Args[1]
 10276  		x := s.Args[0]
 10277  		y := s.Args[1]
 10278  		if !(s.Uses == 1) {
 10279  			break
 10280  		}
 10281  		v.reset(OpEq8)
 10282  		v.AddArg(x)
 10283  		v.AddArg(y)
 10284  		return true
 10285  	}
 10286  	return false
 10287  }
 10288  func rewriteValuegeneric_OpEqB_0(v *Value) bool {
 10289  	// match: (EqB (ConstBool [c]) (ConstBool [d]))
 10290  	// cond:
 10291  	// result: (ConstBool [b2i(c == d)])
 10292  	for {
 10293  		_ = v.Args[1]
 10294  		v_0 := v.Args[0]
 10295  		if v_0.Op != OpConstBool {
 10296  			break
 10297  		}
 10298  		c := v_0.AuxInt
 10299  		v_1 := v.Args[1]
 10300  		if v_1.Op != OpConstBool {
 10301  			break
 10302  		}
 10303  		d := v_1.AuxInt
 10304  		v.reset(OpConstBool)
 10305  		v.AuxInt = b2i(c == d)
 10306  		return true
 10307  	}
 10308  	// match: (EqB (ConstBool [d]) (ConstBool [c]))
 10309  	// cond:
 10310  	// result: (ConstBool [b2i(c == d)])
 10311  	for {
 10312  		_ = v.Args[1]
 10313  		v_0 := v.Args[0]
 10314  		if v_0.Op != OpConstBool {
 10315  			break
 10316  		}
 10317  		d := v_0.AuxInt
 10318  		v_1 := v.Args[1]
 10319  		if v_1.Op != OpConstBool {
 10320  			break
 10321  		}
 10322  		c := v_1.AuxInt
 10323  		v.reset(OpConstBool)
 10324  		v.AuxInt = b2i(c == d)
 10325  		return true
 10326  	}
 10327  	// match: (EqB (ConstBool [0]) x)
 10328  	// cond:
 10329  	// result: (Not x)
 10330  	for {
 10331  		_ = v.Args[1]
 10332  		v_0 := v.Args[0]
 10333  		if v_0.Op != OpConstBool {
 10334  			break
 10335  		}
 10336  		if v_0.AuxInt != 0 {
 10337  			break
 10338  		}
 10339  		x := v.Args[1]
 10340  		v.reset(OpNot)
 10341  		v.AddArg(x)
 10342  		return true
 10343  	}
 10344  	// match: (EqB x (ConstBool [0]))
 10345  	// cond:
 10346  	// result: (Not x)
 10347  	for {
 10348  		_ = v.Args[1]
 10349  		x := v.Args[0]
 10350  		v_1 := v.Args[1]
 10351  		if v_1.Op != OpConstBool {
 10352  			break
 10353  		}
 10354  		if v_1.AuxInt != 0 {
 10355  			break
 10356  		}
 10357  		v.reset(OpNot)
 10358  		v.AddArg(x)
 10359  		return true
 10360  	}
 10361  	// match: (EqB (ConstBool [1]) x)
 10362  	// cond:
 10363  	// result: x
 10364  	for {
 10365  		_ = v.Args[1]
 10366  		v_0 := v.Args[0]
 10367  		if v_0.Op != OpConstBool {
 10368  			break
 10369  		}
 10370  		if v_0.AuxInt != 1 {
 10371  			break
 10372  		}
 10373  		x := v.Args[1]
 10374  		v.reset(OpCopy)
 10375  		v.Type = x.Type
 10376  		v.AddArg(x)
 10377  		return true
 10378  	}
 10379  	// match: (EqB x (ConstBool [1]))
 10380  	// cond:
 10381  	// result: x
 10382  	for {
 10383  		_ = v.Args[1]
 10384  		x := v.Args[0]
 10385  		v_1 := v.Args[1]
 10386  		if v_1.Op != OpConstBool {
 10387  			break
 10388  		}
 10389  		if v_1.AuxInt != 1 {
 10390  			break
 10391  		}
 10392  		v.reset(OpCopy)
 10393  		v.Type = x.Type
 10394  		v.AddArg(x)
 10395  		return true
 10396  	}
 10397  	return false
 10398  }
 10399  func rewriteValuegeneric_OpEqInter_0(v *Value) bool {
 10400  	b := v.Block
 10401  	_ = b
 10402  	typ := &b.Func.Config.Types
 10403  	_ = typ
 10404  	// match: (EqInter x y)
 10405  	// cond:
 10406  	// result: (EqPtr (ITab x) (ITab y))
 10407  	for {
 10408  		_ = v.Args[1]
 10409  		x := v.Args[0]
 10410  		y := v.Args[1]
 10411  		v.reset(OpEqPtr)
 10412  		v0 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 10413  		v0.AddArg(x)
 10414  		v.AddArg(v0)
 10415  		v1 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 10416  		v1.AddArg(y)
 10417  		v.AddArg(v1)
 10418  		return true
 10419  	}
 10420  }
 10421  func rewriteValuegeneric_OpEqPtr_0(v *Value) bool {
 10422  	// match: (EqPtr x x)
 10423  	// cond:
 10424  	// result: (ConstBool [1])
 10425  	for {
 10426  		_ = v.Args[1]
 10427  		x := v.Args[0]
 10428  		if x != v.Args[1] {
 10429  			break
 10430  		}
 10431  		v.reset(OpConstBool)
 10432  		v.AuxInt = 1
 10433  		return true
 10434  	}
 10435  	// match: (EqPtr (Addr {a} _) (Addr {b} _))
 10436  	// cond:
 10437  	// result: (ConstBool [b2i(a == b)])
 10438  	for {
 10439  		_ = v.Args[1]
 10440  		v_0 := v.Args[0]
 10441  		if v_0.Op != OpAddr {
 10442  			break
 10443  		}
 10444  		a := v_0.Aux
 10445  		v_1 := v.Args[1]
 10446  		if v_1.Op != OpAddr {
 10447  			break
 10448  		}
 10449  		b := v_1.Aux
 10450  		v.reset(OpConstBool)
 10451  		v.AuxInt = b2i(a == b)
 10452  		return true
 10453  	}
 10454  	// match: (EqPtr (Addr {b} _) (Addr {a} _))
 10455  	// cond:
 10456  	// result: (ConstBool [b2i(a == b)])
 10457  	for {
 10458  		_ = v.Args[1]
 10459  		v_0 := v.Args[0]
 10460  		if v_0.Op != OpAddr {
 10461  			break
 10462  		}
 10463  		b := v_0.Aux
 10464  		v_1 := v.Args[1]
 10465  		if v_1.Op != OpAddr {
 10466  			break
 10467  		}
 10468  		a := v_1.Aux
 10469  		v.reset(OpConstBool)
 10470  		v.AuxInt = b2i(a == b)
 10471  		return true
 10472  	}
 10473  	// match: (EqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _))
 10474  	// cond:
 10475  	// result: (ConstBool [b2i(a == b)])
 10476  	for {
 10477  		_ = v.Args[1]
 10478  		v_0 := v.Args[0]
 10479  		if v_0.Op != OpLocalAddr {
 10480  			break
 10481  		}
 10482  		a := v_0.Aux
 10483  		_ = v_0.Args[1]
 10484  		v_1 := v.Args[1]
 10485  		if v_1.Op != OpLocalAddr {
 10486  			break
 10487  		}
 10488  		b := v_1.Aux
 10489  		_ = v_1.Args[1]
 10490  		v.reset(OpConstBool)
 10491  		v.AuxInt = b2i(a == b)
 10492  		return true
 10493  	}
 10494  	// match: (EqPtr (LocalAddr {b} _ _) (LocalAddr {a} _ _))
 10495  	// cond:
 10496  	// result: (ConstBool [b2i(a == b)])
 10497  	for {
 10498  		_ = v.Args[1]
 10499  		v_0 := v.Args[0]
 10500  		if v_0.Op != OpLocalAddr {
 10501  			break
 10502  		}
 10503  		b := v_0.Aux
 10504  		_ = v_0.Args[1]
 10505  		v_1 := v.Args[1]
 10506  		if v_1.Op != OpLocalAddr {
 10507  			break
 10508  		}
 10509  		a := v_1.Aux
 10510  		_ = v_1.Args[1]
 10511  		v.reset(OpConstBool)
 10512  		v.AuxInt = b2i(a == b)
 10513  		return true
 10514  	}
 10515  	// match: (EqPtr (OffPtr [o1] p1) p2)
 10516  	// cond: isSamePtr(p1, p2)
 10517  	// result: (ConstBool [b2i(o1 == 0)])
 10518  	for {
 10519  		_ = v.Args[1]
 10520  		v_0 := v.Args[0]
 10521  		if v_0.Op != OpOffPtr {
 10522  			break
 10523  		}
 10524  		o1 := v_0.AuxInt
 10525  		p1 := v_0.Args[0]
 10526  		p2 := v.Args[1]
 10527  		if !(isSamePtr(p1, p2)) {
 10528  			break
 10529  		}
 10530  		v.reset(OpConstBool)
 10531  		v.AuxInt = b2i(o1 == 0)
 10532  		return true
 10533  	}
 10534  	// match: (EqPtr p2 (OffPtr [o1] p1))
 10535  	// cond: isSamePtr(p1, p2)
 10536  	// result: (ConstBool [b2i(o1 == 0)])
 10537  	for {
 10538  		_ = v.Args[1]
 10539  		p2 := v.Args[0]
 10540  		v_1 := v.Args[1]
 10541  		if v_1.Op != OpOffPtr {
 10542  			break
 10543  		}
 10544  		o1 := v_1.AuxInt
 10545  		p1 := v_1.Args[0]
 10546  		if !(isSamePtr(p1, p2)) {
 10547  			break
 10548  		}
 10549  		v.reset(OpConstBool)
 10550  		v.AuxInt = b2i(o1 == 0)
 10551  		return true
 10552  	}
 10553  	// match: (EqPtr (OffPtr [o1] p1) (OffPtr [o2] p2))
 10554  	// cond: isSamePtr(p1, p2)
 10555  	// result: (ConstBool [b2i(o1 == o2)])
 10556  	for {
 10557  		_ = v.Args[1]
 10558  		v_0 := v.Args[0]
 10559  		if v_0.Op != OpOffPtr {
 10560  			break
 10561  		}
 10562  		o1 := v_0.AuxInt
 10563  		p1 := v_0.Args[0]
 10564  		v_1 := v.Args[1]
 10565  		if v_1.Op != OpOffPtr {
 10566  			break
 10567  		}
 10568  		o2 := v_1.AuxInt
 10569  		p2 := v_1.Args[0]
 10570  		if !(isSamePtr(p1, p2)) {
 10571  			break
 10572  		}
 10573  		v.reset(OpConstBool)
 10574  		v.AuxInt = b2i(o1 == o2)
 10575  		return true
 10576  	}
 10577  	// match: (EqPtr (OffPtr [o2] p2) (OffPtr [o1] p1))
 10578  	// cond: isSamePtr(p1, p2)
 10579  	// result: (ConstBool [b2i(o1 == o2)])
 10580  	for {
 10581  		_ = v.Args[1]
 10582  		v_0 := v.Args[0]
 10583  		if v_0.Op != OpOffPtr {
 10584  			break
 10585  		}
 10586  		o2 := v_0.AuxInt
 10587  		p2 := v_0.Args[0]
 10588  		v_1 := v.Args[1]
 10589  		if v_1.Op != OpOffPtr {
 10590  			break
 10591  		}
 10592  		o1 := v_1.AuxInt
 10593  		p1 := v_1.Args[0]
 10594  		if !(isSamePtr(p1, p2)) {
 10595  			break
 10596  		}
 10597  		v.reset(OpConstBool)
 10598  		v.AuxInt = b2i(o1 == o2)
 10599  		return true
 10600  	}
 10601  	// match: (EqPtr (Const32 [c]) (Const32 [d]))
 10602  	// cond:
 10603  	// result: (ConstBool [b2i(c == d)])
 10604  	for {
 10605  		_ = v.Args[1]
 10606  		v_0 := v.Args[0]
 10607  		if v_0.Op != OpConst32 {
 10608  			break
 10609  		}
 10610  		c := v_0.AuxInt
 10611  		v_1 := v.Args[1]
 10612  		if v_1.Op != OpConst32 {
 10613  			break
 10614  		}
 10615  		d := v_1.AuxInt
 10616  		v.reset(OpConstBool)
 10617  		v.AuxInt = b2i(c == d)
 10618  		return true
 10619  	}
 10620  	return false
 10621  }
 10622  func rewriteValuegeneric_OpEqPtr_10(v *Value) bool {
 10623  	b := v.Block
 10624  	_ = b
 10625  	typ := &b.Func.Config.Types
 10626  	_ = typ
 10627  	// match: (EqPtr (Const32 [d]) (Const32 [c]))
 10628  	// cond:
 10629  	// result: (ConstBool [b2i(c == d)])
 10630  	for {
 10631  		_ = v.Args[1]
 10632  		v_0 := v.Args[0]
 10633  		if v_0.Op != OpConst32 {
 10634  			break
 10635  		}
 10636  		d := v_0.AuxInt
 10637  		v_1 := v.Args[1]
 10638  		if v_1.Op != OpConst32 {
 10639  			break
 10640  		}
 10641  		c := v_1.AuxInt
 10642  		v.reset(OpConstBool)
 10643  		v.AuxInt = b2i(c == d)
 10644  		return true
 10645  	}
 10646  	// match: (EqPtr (Const64 [c]) (Const64 [d]))
 10647  	// cond:
 10648  	// result: (ConstBool [b2i(c == d)])
 10649  	for {
 10650  		_ = v.Args[1]
 10651  		v_0 := v.Args[0]
 10652  		if v_0.Op != OpConst64 {
 10653  			break
 10654  		}
 10655  		c := v_0.AuxInt
 10656  		v_1 := v.Args[1]
 10657  		if v_1.Op != OpConst64 {
 10658  			break
 10659  		}
 10660  		d := v_1.AuxInt
 10661  		v.reset(OpConstBool)
 10662  		v.AuxInt = b2i(c == d)
 10663  		return true
 10664  	}
 10665  	// match: (EqPtr (Const64 [d]) (Const64 [c]))
 10666  	// cond:
 10667  	// result: (ConstBool [b2i(c == d)])
 10668  	for {
 10669  		_ = v.Args[1]
 10670  		v_0 := v.Args[0]
 10671  		if v_0.Op != OpConst64 {
 10672  			break
 10673  		}
 10674  		d := v_0.AuxInt
 10675  		v_1 := v.Args[1]
 10676  		if v_1.Op != OpConst64 {
 10677  			break
 10678  		}
 10679  		c := v_1.AuxInt
 10680  		v.reset(OpConstBool)
 10681  		v.AuxInt = b2i(c == d)
 10682  		return true
 10683  	}
 10684  	// match: (EqPtr (LocalAddr _ _) (Addr _))
 10685  	// cond:
 10686  	// result: (ConstBool [0])
 10687  	for {
 10688  		_ = v.Args[1]
 10689  		v_0 := v.Args[0]
 10690  		if v_0.Op != OpLocalAddr {
 10691  			break
 10692  		}
 10693  		_ = v_0.Args[1]
 10694  		v_1 := v.Args[1]
 10695  		if v_1.Op != OpAddr {
 10696  			break
 10697  		}
 10698  		v.reset(OpConstBool)
 10699  		v.AuxInt = 0
 10700  		return true
 10701  	}
 10702  	// match: (EqPtr (Addr _) (LocalAddr _ _))
 10703  	// cond:
 10704  	// result: (ConstBool [0])
 10705  	for {
 10706  		_ = v.Args[1]
 10707  		v_0 := v.Args[0]
 10708  		if v_0.Op != OpAddr {
 10709  			break
 10710  		}
 10711  		v_1 := v.Args[1]
 10712  		if v_1.Op != OpLocalAddr {
 10713  			break
 10714  		}
 10715  		_ = v_1.Args[1]
 10716  		v.reset(OpConstBool)
 10717  		v.AuxInt = 0
 10718  		return true
 10719  	}
 10720  	// match: (EqPtr (Addr _) (LocalAddr _ _))
 10721  	// cond:
 10722  	// result: (ConstBool [0])
 10723  	for {
 10724  		_ = v.Args[1]
 10725  		v_0 := v.Args[0]
 10726  		if v_0.Op != OpAddr {
 10727  			break
 10728  		}
 10729  		v_1 := v.Args[1]
 10730  		if v_1.Op != OpLocalAddr {
 10731  			break
 10732  		}
 10733  		_ = v_1.Args[1]
 10734  		v.reset(OpConstBool)
 10735  		v.AuxInt = 0
 10736  		return true
 10737  	}
 10738  	// match: (EqPtr (LocalAddr _ _) (Addr _))
 10739  	// cond:
 10740  	// result: (ConstBool [0])
 10741  	for {
 10742  		_ = v.Args[1]
 10743  		v_0 := v.Args[0]
 10744  		if v_0.Op != OpLocalAddr {
 10745  			break
 10746  		}
 10747  		_ = v_0.Args[1]
 10748  		v_1 := v.Args[1]
 10749  		if v_1.Op != OpAddr {
 10750  			break
 10751  		}
 10752  		v.reset(OpConstBool)
 10753  		v.AuxInt = 0
 10754  		return true
 10755  	}
 10756  	// match: (EqPtr (AddPtr p1 o1) p2)
 10757  	// cond: isSamePtr(p1, p2)
 10758  	// result: (Not (IsNonNil o1))
 10759  	for {
 10760  		_ = v.Args[1]
 10761  		v_0 := v.Args[0]
 10762  		if v_0.Op != OpAddPtr {
 10763  			break
 10764  		}
 10765  		_ = v_0.Args[1]
 10766  		p1 := v_0.Args[0]
 10767  		o1 := v_0.Args[1]
 10768  		p2 := v.Args[1]
 10769  		if !(isSamePtr(p1, p2)) {
 10770  			break
 10771  		}
 10772  		v.reset(OpNot)
 10773  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10774  		v0.AddArg(o1)
 10775  		v.AddArg(v0)
 10776  		return true
 10777  	}
 10778  	// match: (EqPtr p2 (AddPtr p1 o1))
 10779  	// cond: isSamePtr(p1, p2)
 10780  	// result: (Not (IsNonNil o1))
 10781  	for {
 10782  		_ = v.Args[1]
 10783  		p2 := v.Args[0]
 10784  		v_1 := v.Args[1]
 10785  		if v_1.Op != OpAddPtr {
 10786  			break
 10787  		}
 10788  		_ = v_1.Args[1]
 10789  		p1 := v_1.Args[0]
 10790  		o1 := v_1.Args[1]
 10791  		if !(isSamePtr(p1, p2)) {
 10792  			break
 10793  		}
 10794  		v.reset(OpNot)
 10795  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10796  		v0.AddArg(o1)
 10797  		v.AddArg(v0)
 10798  		return true
 10799  	}
 10800  	// match: (EqPtr (Const32 [0]) p)
 10801  	// cond:
 10802  	// result: (Not (IsNonNil p))
 10803  	for {
 10804  		_ = v.Args[1]
 10805  		v_0 := v.Args[0]
 10806  		if v_0.Op != OpConst32 {
 10807  			break
 10808  		}
 10809  		if v_0.AuxInt != 0 {
 10810  			break
 10811  		}
 10812  		p := v.Args[1]
 10813  		v.reset(OpNot)
 10814  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10815  		v0.AddArg(p)
 10816  		v.AddArg(v0)
 10817  		return true
 10818  	}
 10819  	return false
 10820  }
 10821  func rewriteValuegeneric_OpEqPtr_20(v *Value) bool {
 10822  	b := v.Block
 10823  	_ = b
 10824  	typ := &b.Func.Config.Types
 10825  	_ = typ
 10826  	// match: (EqPtr p (Const32 [0]))
 10827  	// cond:
 10828  	// result: (Not (IsNonNil p))
 10829  	for {
 10830  		_ = v.Args[1]
 10831  		p := v.Args[0]
 10832  		v_1 := v.Args[1]
 10833  		if v_1.Op != OpConst32 {
 10834  			break
 10835  		}
 10836  		if v_1.AuxInt != 0 {
 10837  			break
 10838  		}
 10839  		v.reset(OpNot)
 10840  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10841  		v0.AddArg(p)
 10842  		v.AddArg(v0)
 10843  		return true
 10844  	}
 10845  	// match: (EqPtr (Const64 [0]) p)
 10846  	// cond:
 10847  	// result: (Not (IsNonNil p))
 10848  	for {
 10849  		_ = v.Args[1]
 10850  		v_0 := v.Args[0]
 10851  		if v_0.Op != OpConst64 {
 10852  			break
 10853  		}
 10854  		if v_0.AuxInt != 0 {
 10855  			break
 10856  		}
 10857  		p := v.Args[1]
 10858  		v.reset(OpNot)
 10859  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10860  		v0.AddArg(p)
 10861  		v.AddArg(v0)
 10862  		return true
 10863  	}
 10864  	// match: (EqPtr p (Const64 [0]))
 10865  	// cond:
 10866  	// result: (Not (IsNonNil p))
 10867  	for {
 10868  		_ = v.Args[1]
 10869  		p := v.Args[0]
 10870  		v_1 := v.Args[1]
 10871  		if v_1.Op != OpConst64 {
 10872  			break
 10873  		}
 10874  		if v_1.AuxInt != 0 {
 10875  			break
 10876  		}
 10877  		v.reset(OpNot)
 10878  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10879  		v0.AddArg(p)
 10880  		v.AddArg(v0)
 10881  		return true
 10882  	}
 10883  	// match: (EqPtr (ConstNil) p)
 10884  	// cond:
 10885  	// result: (Not (IsNonNil p))
 10886  	for {
 10887  		_ = v.Args[1]
 10888  		v_0 := v.Args[0]
 10889  		if v_0.Op != OpConstNil {
 10890  			break
 10891  		}
 10892  		p := v.Args[1]
 10893  		v.reset(OpNot)
 10894  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10895  		v0.AddArg(p)
 10896  		v.AddArg(v0)
 10897  		return true
 10898  	}
 10899  	// match: (EqPtr p (ConstNil))
 10900  	// cond:
 10901  	// result: (Not (IsNonNil p))
 10902  	for {
 10903  		_ = v.Args[1]
 10904  		p := v.Args[0]
 10905  		v_1 := v.Args[1]
 10906  		if v_1.Op != OpConstNil {
 10907  			break
 10908  		}
 10909  		v.reset(OpNot)
 10910  		v0 := b.NewValue0(v.Pos, OpIsNonNil, typ.Bool)
 10911  		v0.AddArg(p)
 10912  		v.AddArg(v0)
 10913  		return true
 10914  	}
 10915  	return false
 10916  }
 10917  func rewriteValuegeneric_OpEqSlice_0(v *Value) bool {
 10918  	b := v.Block
 10919  	_ = b
 10920  	typ := &b.Func.Config.Types
 10921  	_ = typ
 10922  	// match: (EqSlice x y)
 10923  	// cond:
 10924  	// result: (EqPtr (SlicePtr x) (SlicePtr y))
 10925  	for {
 10926  		_ = v.Args[1]
 10927  		x := v.Args[0]
 10928  		y := v.Args[1]
 10929  		v.reset(OpEqPtr)
 10930  		v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 10931  		v0.AddArg(x)
 10932  		v.AddArg(v0)
 10933  		v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 10934  		v1.AddArg(y)
 10935  		v.AddArg(v1)
 10936  		return true
 10937  	}
 10938  }
 10939  func rewriteValuegeneric_OpGeq16_0(v *Value) bool {
 10940  	// match: (Geq16 (Const16 [c]) (Const16 [d]))
 10941  	// cond:
 10942  	// result: (ConstBool [b2i(c >= d)])
 10943  	for {
 10944  		_ = v.Args[1]
 10945  		v_0 := v.Args[0]
 10946  		if v_0.Op != OpConst16 {
 10947  			break
 10948  		}
 10949  		c := v_0.AuxInt
 10950  		v_1 := v.Args[1]
 10951  		if v_1.Op != OpConst16 {
 10952  			break
 10953  		}
 10954  		d := v_1.AuxInt
 10955  		v.reset(OpConstBool)
 10956  		v.AuxInt = b2i(c >= d)
 10957  		return true
 10958  	}
 10959  	return false
 10960  }
 10961  func rewriteValuegeneric_OpGeq16U_0(v *Value) bool {
 10962  	// match: (Geq16U (Const16 [c]) (Const16 [d]))
 10963  	// cond:
 10964  	// result: (ConstBool [b2i(uint16(c) >= uint16(d))])
 10965  	for {
 10966  		_ = v.Args[1]
 10967  		v_0 := v.Args[0]
 10968  		if v_0.Op != OpConst16 {
 10969  			break
 10970  		}
 10971  		c := v_0.AuxInt
 10972  		v_1 := v.Args[1]
 10973  		if v_1.Op != OpConst16 {
 10974  			break
 10975  		}
 10976  		d := v_1.AuxInt
 10977  		v.reset(OpConstBool)
 10978  		v.AuxInt = b2i(uint16(c) >= uint16(d))
 10979  		return true
 10980  	}
 10981  	return false
 10982  }
 10983  func rewriteValuegeneric_OpGeq32_0(v *Value) bool {
 10984  	// match: (Geq32 (Const32 [c]) (Const32 [d]))
 10985  	// cond:
 10986  	// result: (ConstBool [b2i(c >= d)])
 10987  	for {
 10988  		_ = v.Args[1]
 10989  		v_0 := v.Args[0]
 10990  		if v_0.Op != OpConst32 {
 10991  			break
 10992  		}
 10993  		c := v_0.AuxInt
 10994  		v_1 := v.Args[1]
 10995  		if v_1.Op != OpConst32 {
 10996  			break
 10997  		}
 10998  		d := v_1.AuxInt
 10999  		v.reset(OpConstBool)
 11000  		v.AuxInt = b2i(c >= d)
 11001  		return true
 11002  	}
 11003  	return false
 11004  }
 11005  func rewriteValuegeneric_OpGeq32F_0(v *Value) bool {
 11006  	// match: (Geq32F (Const32F [c]) (Const32F [d]))
 11007  	// cond:
 11008  	// result: (ConstBool [b2i(auxTo32F(c) >= auxTo32F(d))])
 11009  	for {
 11010  		_ = v.Args[1]
 11011  		v_0 := v.Args[0]
 11012  		if v_0.Op != OpConst32F {
 11013  			break
 11014  		}
 11015  		c := v_0.AuxInt
 11016  		v_1 := v.Args[1]
 11017  		if v_1.Op != OpConst32F {
 11018  			break
 11019  		}
 11020  		d := v_1.AuxInt
 11021  		v.reset(OpConstBool)
 11022  		v.AuxInt = b2i(auxTo32F(c) >= auxTo32F(d))
 11023  		return true
 11024  	}
 11025  	return false
 11026  }
 11027  func rewriteValuegeneric_OpGeq32U_0(v *Value) bool {
 11028  	// match: (Geq32U (Const32 [c]) (Const32 [d]))
 11029  	// cond:
 11030  	// result: (ConstBool [b2i(uint32(c) >= uint32(d))])
 11031  	for {
 11032  		_ = v.Args[1]
 11033  		v_0 := v.Args[0]
 11034  		if v_0.Op != OpConst32 {
 11035  			break
 11036  		}
 11037  		c := v_0.AuxInt
 11038  		v_1 := v.Args[1]
 11039  		if v_1.Op != OpConst32 {
 11040  			break
 11041  		}
 11042  		d := v_1.AuxInt
 11043  		v.reset(OpConstBool)
 11044  		v.AuxInt = b2i(uint32(c) >= uint32(d))
 11045  		return true
 11046  	}
 11047  	return false
 11048  }
 11049  func rewriteValuegeneric_OpGeq64_0(v *Value) bool {
 11050  	// match: (Geq64 (Const64 [c]) (Const64 [d]))
 11051  	// cond:
 11052  	// result: (ConstBool [b2i(c >= d)])
 11053  	for {
 11054  		_ = v.Args[1]
 11055  		v_0 := v.Args[0]
 11056  		if v_0.Op != OpConst64 {
 11057  			break
 11058  		}
 11059  		c := v_0.AuxInt
 11060  		v_1 := v.Args[1]
 11061  		if v_1.Op != OpConst64 {
 11062  			break
 11063  		}
 11064  		d := v_1.AuxInt
 11065  		v.reset(OpConstBool)
 11066  		v.AuxInt = b2i(c >= d)
 11067  		return true
 11068  	}
 11069  	return false
 11070  }
 11071  func rewriteValuegeneric_OpGeq64F_0(v *Value) bool {
 11072  	// match: (Geq64F (Const64F [c]) (Const64F [d]))
 11073  	// cond:
 11074  	// result: (ConstBool [b2i(auxTo64F(c) >= auxTo64F(d))])
 11075  	for {
 11076  		_ = v.Args[1]
 11077  		v_0 := v.Args[0]
 11078  		if v_0.Op != OpConst64F {
 11079  			break
 11080  		}
 11081  		c := v_0.AuxInt
 11082  		v_1 := v.Args[1]
 11083  		if v_1.Op != OpConst64F {
 11084  			break
 11085  		}
 11086  		d := v_1.AuxInt
 11087  		v.reset(OpConstBool)
 11088  		v.AuxInt = b2i(auxTo64F(c) >= auxTo64F(d))
 11089  		return true
 11090  	}
 11091  	return false
 11092  }
 11093  func rewriteValuegeneric_OpGeq64U_0(v *Value) bool {
 11094  	// match: (Geq64U (Const64 [c]) (Const64 [d]))
 11095  	// cond:
 11096  	// result: (ConstBool [b2i(uint64(c) >= uint64(d))])
 11097  	for {
 11098  		_ = v.Args[1]
 11099  		v_0 := v.Args[0]
 11100  		if v_0.Op != OpConst64 {
 11101  			break
 11102  		}
 11103  		c := v_0.AuxInt
 11104  		v_1 := v.Args[1]
 11105  		if v_1.Op != OpConst64 {
 11106  			break
 11107  		}
 11108  		d := v_1.AuxInt
 11109  		v.reset(OpConstBool)
 11110  		v.AuxInt = b2i(uint64(c) >= uint64(d))
 11111  		return true
 11112  	}
 11113  	return false
 11114  }
 11115  func rewriteValuegeneric_OpGeq8_0(v *Value) bool {
 11116  	// match: (Geq8 (Const8 [c]) (Const8 [d]))
 11117  	// cond:
 11118  	// result: (ConstBool [b2i(c >= d)])
 11119  	for {
 11120  		_ = v.Args[1]
 11121  		v_0 := v.Args[0]
 11122  		if v_0.Op != OpConst8 {
 11123  			break
 11124  		}
 11125  		c := v_0.AuxInt
 11126  		v_1 := v.Args[1]
 11127  		if v_1.Op != OpConst8 {
 11128  			break
 11129  		}
 11130  		d := v_1.AuxInt
 11131  		v.reset(OpConstBool)
 11132  		v.AuxInt = b2i(c >= d)
 11133  		return true
 11134  	}
 11135  	return false
 11136  }
 11137  func rewriteValuegeneric_OpGeq8U_0(v *Value) bool {
 11138  	// match: (Geq8U (Const8 [c]) (Const8 [d]))
 11139  	// cond:
 11140  	// result: (ConstBool [b2i(uint8(c) >= uint8(d))])
 11141  	for {
 11142  		_ = v.Args[1]
 11143  		v_0 := v.Args[0]
 11144  		if v_0.Op != OpConst8 {
 11145  			break
 11146  		}
 11147  		c := v_0.AuxInt
 11148  		v_1 := v.Args[1]
 11149  		if v_1.Op != OpConst8 {
 11150  			break
 11151  		}
 11152  		d := v_1.AuxInt
 11153  		v.reset(OpConstBool)
 11154  		v.AuxInt = b2i(uint8(c) >= uint8(d))
 11155  		return true
 11156  	}
 11157  	return false
 11158  }
 11159  func rewriteValuegeneric_OpGreater16_0(v *Value) bool {
 11160  	// match: (Greater16 (Const16 [c]) (Const16 [d]))
 11161  	// cond:
 11162  	// result: (ConstBool [b2i(c > d)])
 11163  	for {
 11164  		_ = v.Args[1]
 11165  		v_0 := v.Args[0]
 11166  		if v_0.Op != OpConst16 {
 11167  			break
 11168  		}
 11169  		c := v_0.AuxInt
 11170  		v_1 := v.Args[1]
 11171  		if v_1.Op != OpConst16 {
 11172  			break
 11173  		}
 11174  		d := v_1.AuxInt
 11175  		v.reset(OpConstBool)
 11176  		v.AuxInt = b2i(c > d)
 11177  		return true
 11178  	}
 11179  	return false
 11180  }
 11181  func rewriteValuegeneric_OpGreater16U_0(v *Value) bool {
 11182  	// match: (Greater16U (Const16 [c]) (Const16 [d]))
 11183  	// cond:
 11184  	// result: (ConstBool [b2i(uint16(c) > uint16(d))])
 11185  	for {
 11186  		_ = v.Args[1]
 11187  		v_0 := v.Args[0]
 11188  		if v_0.Op != OpConst16 {
 11189  			break
 11190  		}
 11191  		c := v_0.AuxInt
 11192  		v_1 := v.Args[1]
 11193  		if v_1.Op != OpConst16 {
 11194  			break
 11195  		}
 11196  		d := v_1.AuxInt
 11197  		v.reset(OpConstBool)
 11198  		v.AuxInt = b2i(uint16(c) > uint16(d))
 11199  		return true
 11200  	}
 11201  	return false
 11202  }
 11203  func rewriteValuegeneric_OpGreater32_0(v *Value) bool {
 11204  	// match: (Greater32 (Const32 [c]) (Const32 [d]))
 11205  	// cond:
 11206  	// result: (ConstBool [b2i(c > d)])
 11207  	for {
 11208  		_ = v.Args[1]
 11209  		v_0 := v.Args[0]
 11210  		if v_0.Op != OpConst32 {
 11211  			break
 11212  		}
 11213  		c := v_0.AuxInt
 11214  		v_1 := v.Args[1]
 11215  		if v_1.Op != OpConst32 {
 11216  			break
 11217  		}
 11218  		d := v_1.AuxInt
 11219  		v.reset(OpConstBool)
 11220  		v.AuxInt = b2i(c > d)
 11221  		return true
 11222  	}
 11223  	return false
 11224  }
 11225  func rewriteValuegeneric_OpGreater32F_0(v *Value) bool {
 11226  	// match: (Greater32F (Const32F [c]) (Const32F [d]))
 11227  	// cond:
 11228  	// result: (ConstBool [b2i(auxTo32F(c) > auxTo32F(d))])
 11229  	for {
 11230  		_ = v.Args[1]
 11231  		v_0 := v.Args[0]
 11232  		if v_0.Op != OpConst32F {
 11233  			break
 11234  		}
 11235  		c := v_0.AuxInt
 11236  		v_1 := v.Args[1]
 11237  		if v_1.Op != OpConst32F {
 11238  			break
 11239  		}
 11240  		d := v_1.AuxInt
 11241  		v.reset(OpConstBool)
 11242  		v.AuxInt = b2i(auxTo32F(c) > auxTo32F(d))
 11243  		return true
 11244  	}
 11245  	return false
 11246  }
 11247  func rewriteValuegeneric_OpGreater32U_0(v *Value) bool {
 11248  	// match: (Greater32U (Const32 [c]) (Const32 [d]))
 11249  	// cond:
 11250  	// result: (ConstBool [b2i(uint32(c) > uint32(d))])
 11251  	for {
 11252  		_ = v.Args[1]
 11253  		v_0 := v.Args[0]
 11254  		if v_0.Op != OpConst32 {
 11255  			break
 11256  		}
 11257  		c := v_0.AuxInt
 11258  		v_1 := v.Args[1]
 11259  		if v_1.Op != OpConst32 {
 11260  			break
 11261  		}
 11262  		d := v_1.AuxInt
 11263  		v.reset(OpConstBool)
 11264  		v.AuxInt = b2i(uint32(c) > uint32(d))
 11265  		return true
 11266  	}
 11267  	return false
 11268  }
 11269  func rewriteValuegeneric_OpGreater64_0(v *Value) bool {
 11270  	// match: (Greater64 (Const64 [c]) (Const64 [d]))
 11271  	// cond:
 11272  	// result: (ConstBool [b2i(c > d)])
 11273  	for {
 11274  		_ = v.Args[1]
 11275  		v_0 := v.Args[0]
 11276  		if v_0.Op != OpConst64 {
 11277  			break
 11278  		}
 11279  		c := v_0.AuxInt
 11280  		v_1 := v.Args[1]
 11281  		if v_1.Op != OpConst64 {
 11282  			break
 11283  		}
 11284  		d := v_1.AuxInt
 11285  		v.reset(OpConstBool)
 11286  		v.AuxInt = b2i(c > d)
 11287  		return true
 11288  	}
 11289  	return false
 11290  }
 11291  func rewriteValuegeneric_OpGreater64F_0(v *Value) bool {
 11292  	// match: (Greater64F (Const64F [c]) (Const64F [d]))
 11293  	// cond:
 11294  	// result: (ConstBool [b2i(auxTo64F(c) > auxTo64F(d))])
 11295  	for {
 11296  		_ = v.Args[1]
 11297  		v_0 := v.Args[0]
 11298  		if v_0.Op != OpConst64F {
 11299  			break
 11300  		}
 11301  		c := v_0.AuxInt
 11302  		v_1 := v.Args[1]
 11303  		if v_1.Op != OpConst64F {
 11304  			break
 11305  		}
 11306  		d := v_1.AuxInt
 11307  		v.reset(OpConstBool)
 11308  		v.AuxInt = b2i(auxTo64F(c) > auxTo64F(d))
 11309  		return true
 11310  	}
 11311  	return false
 11312  }
 11313  func rewriteValuegeneric_OpGreater64U_0(v *Value) bool {
 11314  	// match: (Greater64U (Const64 [c]) (Const64 [d]))
 11315  	// cond:
 11316  	// result: (ConstBool [b2i(uint64(c) > uint64(d))])
 11317  	for {
 11318  		_ = v.Args[1]
 11319  		v_0 := v.Args[0]
 11320  		if v_0.Op != OpConst64 {
 11321  			break
 11322  		}
 11323  		c := v_0.AuxInt
 11324  		v_1 := v.Args[1]
 11325  		if v_1.Op != OpConst64 {
 11326  			break
 11327  		}
 11328  		d := v_1.AuxInt
 11329  		v.reset(OpConstBool)
 11330  		v.AuxInt = b2i(uint64(c) > uint64(d))
 11331  		return true
 11332  	}
 11333  	return false
 11334  }
 11335  func rewriteValuegeneric_OpGreater8_0(v *Value) bool {
 11336  	// match: (Greater8 (Const8 [c]) (Const8 [d]))
 11337  	// cond:
 11338  	// result: (ConstBool [b2i(c > d)])
 11339  	for {
 11340  		_ = v.Args[1]
 11341  		v_0 := v.Args[0]
 11342  		if v_0.Op != OpConst8 {
 11343  			break
 11344  		}
 11345  		c := v_0.AuxInt
 11346  		v_1 := v.Args[1]
 11347  		if v_1.Op != OpConst8 {
 11348  			break
 11349  		}
 11350  		d := v_1.AuxInt
 11351  		v.reset(OpConstBool)
 11352  		v.AuxInt = b2i(c > d)
 11353  		return true
 11354  	}
 11355  	return false
 11356  }
 11357  func rewriteValuegeneric_OpGreater8U_0(v *Value) bool {
 11358  	// match: (Greater8U (Const8 [c]) (Const8 [d]))
 11359  	// cond:
 11360  	// result: (ConstBool [b2i(uint8(c) > uint8(d))])
 11361  	for {
 11362  		_ = v.Args[1]
 11363  		v_0 := v.Args[0]
 11364  		if v_0.Op != OpConst8 {
 11365  			break
 11366  		}
 11367  		c := v_0.AuxInt
 11368  		v_1 := v.Args[1]
 11369  		if v_1.Op != OpConst8 {
 11370  			break
 11371  		}
 11372  		d := v_1.AuxInt
 11373  		v.reset(OpConstBool)
 11374  		v.AuxInt = b2i(uint8(c) > uint8(d))
 11375  		return true
 11376  	}
 11377  	return false
 11378  }
 11379  func rewriteValuegeneric_OpIMake_0(v *Value) bool {
 11380  	// match: (IMake typ (StructMake1 val))
 11381  	// cond:
 11382  	// result: (IMake typ val)
 11383  	for {
 11384  		_ = v.Args[1]
 11385  		typ := v.Args[0]
 11386  		v_1 := v.Args[1]
 11387  		if v_1.Op != OpStructMake1 {
 11388  			break
 11389  		}
 11390  		val := v_1.Args[0]
 11391  		v.reset(OpIMake)
 11392  		v.AddArg(typ)
 11393  		v.AddArg(val)
 11394  		return true
 11395  	}
 11396  	// match: (IMake typ (ArrayMake1 val))
 11397  	// cond:
 11398  	// result: (IMake typ val)
 11399  	for {
 11400  		_ = v.Args[1]
 11401  		typ := v.Args[0]
 11402  		v_1 := v.Args[1]
 11403  		if v_1.Op != OpArrayMake1 {
 11404  			break
 11405  		}
 11406  		val := v_1.Args[0]
 11407  		v.reset(OpIMake)
 11408  		v.AddArg(typ)
 11409  		v.AddArg(val)
 11410  		return true
 11411  	}
 11412  	return false
 11413  }
 11414  func rewriteValuegeneric_OpInterCall_0(v *Value) bool {
 11415  	// match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
 11416  	// cond: devirt(v, itab, off) != nil
 11417  	// result: (StaticCall [argsize] {devirt(v, itab, off)} mem)
 11418  	for {
 11419  		argsize := v.AuxInt
 11420  		_ = v.Args[1]
 11421  		v_0 := v.Args[0]
 11422  		if v_0.Op != OpLoad {
 11423  			break
 11424  		}
 11425  		_ = v_0.Args[1]
 11426  		v_0_0 := v_0.Args[0]
 11427  		if v_0_0.Op != OpOffPtr {
 11428  			break
 11429  		}
 11430  		off := v_0_0.AuxInt
 11431  		v_0_0_0 := v_0_0.Args[0]
 11432  		if v_0_0_0.Op != OpITab {
 11433  			break
 11434  		}
 11435  		v_0_0_0_0 := v_0_0_0.Args[0]
 11436  		if v_0_0_0_0.Op != OpIMake {
 11437  			break
 11438  		}
 11439  		_ = v_0_0_0_0.Args[1]
 11440  		v_0_0_0_0_0 := v_0_0_0_0.Args[0]
 11441  		if v_0_0_0_0_0.Op != OpAddr {
 11442  			break
 11443  		}
 11444  		itab := v_0_0_0_0_0.Aux
 11445  		v_0_0_0_0_0_0 := v_0_0_0_0_0.Args[0]
 11446  		if v_0_0_0_0_0_0.Op != OpSB {
 11447  			break
 11448  		}
 11449  		mem := v.Args[1]
 11450  		if !(devirt(v, itab, off) != nil) {
 11451  			break
 11452  		}
 11453  		v.reset(OpStaticCall)
 11454  		v.AuxInt = argsize
 11455  		v.Aux = devirt(v, itab, off)
 11456  		v.AddArg(mem)
 11457  		return true
 11458  	}
 11459  	return false
 11460  }
 11461  func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool {
 11462  	// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
 11463  	// cond: (1 << 8) <= c
 11464  	// result: (ConstBool [1])
 11465  	for {
 11466  		_ = v.Args[1]
 11467  		v_0 := v.Args[0]
 11468  		if v_0.Op != OpZeroExt8to32 {
 11469  			break
 11470  		}
 11471  		v_1 := v.Args[1]
 11472  		if v_1.Op != OpConst32 {
 11473  			break
 11474  		}
 11475  		c := v_1.AuxInt
 11476  		if !((1 << 8) <= c) {
 11477  			break
 11478  		}
 11479  		v.reset(OpConstBool)
 11480  		v.AuxInt = 1
 11481  		return true
 11482  	}
 11483  	// match: (IsInBounds (ZeroExt8to64 _) (Const64 [c]))
 11484  	// cond: (1 << 8) <= c
 11485  	// result: (ConstBool [1])
 11486  	for {
 11487  		_ = v.Args[1]
 11488  		v_0 := v.Args[0]
 11489  		if v_0.Op != OpZeroExt8to64 {
 11490  			break
 11491  		}
 11492  		v_1 := v.Args[1]
 11493  		if v_1.Op != OpConst64 {
 11494  			break
 11495  		}
 11496  		c := v_1.AuxInt
 11497  		if !((1 << 8) <= c) {
 11498  			break
 11499  		}
 11500  		v.reset(OpConstBool)
 11501  		v.AuxInt = 1
 11502  		return true
 11503  	}
 11504  	// match: (IsInBounds (ZeroExt16to32 _) (Const32 [c]))
 11505  	// cond: (1 << 16) <= c
 11506  	// result: (ConstBool [1])
 11507  	for {
 11508  		_ = v.Args[1]
 11509  		v_0 := v.Args[0]
 11510  		if v_0.Op != OpZeroExt16to32 {
 11511  			break
 11512  		}
 11513  		v_1 := v.Args[1]
 11514  		if v_1.Op != OpConst32 {
 11515  			break
 11516  		}
 11517  		c := v_1.AuxInt
 11518  		if !((1 << 16) <= c) {
 11519  			break
 11520  		}
 11521  		v.reset(OpConstBool)
 11522  		v.AuxInt = 1
 11523  		return true
 11524  	}
 11525  	// match: (IsInBounds (ZeroExt16to64 _) (Const64 [c]))
 11526  	// cond: (1 << 16) <= c
 11527  	// result: (ConstBool [1])
 11528  	for {
 11529  		_ = v.Args[1]
 11530  		v_0 := v.Args[0]
 11531  		if v_0.Op != OpZeroExt16to64 {
 11532  			break
 11533  		}
 11534  		v_1 := v.Args[1]
 11535  		if v_1.Op != OpConst64 {
 11536  			break
 11537  		}
 11538  		c := v_1.AuxInt
 11539  		if !((1 << 16) <= c) {
 11540  			break
 11541  		}
 11542  		v.reset(OpConstBool)
 11543  		v.AuxInt = 1
 11544  		return true
 11545  	}
 11546  	// match: (IsInBounds x x)
 11547  	// cond:
 11548  	// result: (ConstBool [0])
 11549  	for {
 11550  		_ = v.Args[1]
 11551  		x := v.Args[0]
 11552  		if x != v.Args[1] {
 11553  			break
 11554  		}
 11555  		v.reset(OpConstBool)
 11556  		v.AuxInt = 0
 11557  		return true
 11558  	}
 11559  	// match: (IsInBounds (And8 (Const8 [c]) _) (Const8 [d]))
 11560  	// cond: 0 <= c && c < d
 11561  	// result: (ConstBool [1])
 11562  	for {
 11563  		_ = v.Args[1]
 11564  		v_0 := v.Args[0]
 11565  		if v_0.Op != OpAnd8 {
 11566  			break
 11567  		}
 11568  		_ = v_0.Args[1]
 11569  		v_0_0 := v_0.Args[0]
 11570  		if v_0_0.Op != OpConst8 {
 11571  			break
 11572  		}
 11573  		c := v_0_0.AuxInt
 11574  		v_1 := v.Args[1]
 11575  		if v_1.Op != OpConst8 {
 11576  			break
 11577  		}
 11578  		d := v_1.AuxInt
 11579  		if !(0 <= c && c < d) {
 11580  			break
 11581  		}
 11582  		v.reset(OpConstBool)
 11583  		v.AuxInt = 1
 11584  		return true
 11585  	}
 11586  	// match: (IsInBounds (And8 _ (Const8 [c])) (Const8 [d]))
 11587  	// cond: 0 <= c && c < d
 11588  	// result: (ConstBool [1])
 11589  	for {
 11590  		_ = v.Args[1]
 11591  		v_0 := v.Args[0]
 11592  		if v_0.Op != OpAnd8 {
 11593  			break
 11594  		}
 11595  		_ = v_0.Args[1]
 11596  		v_0_1 := v_0.Args[1]
 11597  		if v_0_1.Op != OpConst8 {
 11598  			break
 11599  		}
 11600  		c := v_0_1.AuxInt
 11601  		v_1 := v.Args[1]
 11602  		if v_1.Op != OpConst8 {
 11603  			break
 11604  		}
 11605  		d := v_1.AuxInt
 11606  		if !(0 <= c && c < d) {
 11607  			break
 11608  		}
 11609  		v.reset(OpConstBool)
 11610  		v.AuxInt = 1
 11611  		return true
 11612  	}
 11613  	// match: (IsInBounds (ZeroExt8to16 (And8 (Const8 [c]) _)) (Const16 [d]))
 11614  	// cond: 0 <= c && c < d
 11615  	// result: (ConstBool [1])
 11616  	for {
 11617  		_ = v.Args[1]
 11618  		v_0 := v.Args[0]
 11619  		if v_0.Op != OpZeroExt8to16 {
 11620  			break
 11621  		}
 11622  		v_0_0 := v_0.Args[0]
 11623  		if v_0_0.Op != OpAnd8 {
 11624  			break
 11625  		}
 11626  		_ = v_0_0.Args[1]
 11627  		v_0_0_0 := v_0_0.Args[0]
 11628  		if v_0_0_0.Op != OpConst8 {
 11629  			break
 11630  		}
 11631  		c := v_0_0_0.AuxInt
 11632  		v_1 := v.Args[1]
 11633  		if v_1.Op != OpConst16 {
 11634  			break
 11635  		}
 11636  		d := v_1.AuxInt
 11637  		if !(0 <= c && c < d) {
 11638  			break
 11639  		}
 11640  		v.reset(OpConstBool)
 11641  		v.AuxInt = 1
 11642  		return true
 11643  	}
 11644  	// match: (IsInBounds (ZeroExt8to16 (And8 _ (Const8 [c]))) (Const16 [d]))
 11645  	// cond: 0 <= c && c < d
 11646  	// result: (ConstBool [1])
 11647  	for {
 11648  		_ = v.Args[1]
 11649  		v_0 := v.Args[0]
 11650  		if v_0.Op != OpZeroExt8to16 {
 11651  			break
 11652  		}
 11653  		v_0_0 := v_0.Args[0]
 11654  		if v_0_0.Op != OpAnd8 {
 11655  			break
 11656  		}
 11657  		_ = v_0_0.Args[1]
 11658  		v_0_0_1 := v_0_0.Args[1]
 11659  		if v_0_0_1.Op != OpConst8 {
 11660  			break
 11661  		}
 11662  		c := v_0_0_1.AuxInt
 11663  		v_1 := v.Args[1]
 11664  		if v_1.Op != OpConst16 {
 11665  			break
 11666  		}
 11667  		d := v_1.AuxInt
 11668  		if !(0 <= c && c < d) {
 11669  			break
 11670  		}
 11671  		v.reset(OpConstBool)
 11672  		v.AuxInt = 1
 11673  		return true
 11674  	}
 11675  	// match: (IsInBounds (ZeroExt8to32 (And8 (Const8 [c]) _)) (Const32 [d]))
 11676  	// cond: 0 <= c && c < d
 11677  	// result: (ConstBool [1])
 11678  	for {
 11679  		_ = v.Args[1]
 11680  		v_0 := v.Args[0]
 11681  		if v_0.Op != OpZeroExt8to32 {
 11682  			break
 11683  		}
 11684  		v_0_0 := v_0.Args[0]
 11685  		if v_0_0.Op != OpAnd8 {
 11686  			break
 11687  		}
 11688  		_ = v_0_0.Args[1]
 11689  		v_0_0_0 := v_0_0.Args[0]
 11690  		if v_0_0_0.Op != OpConst8 {
 11691  			break
 11692  		}
 11693  		c := v_0_0_0.AuxInt
 11694  		v_1 := v.Args[1]
 11695  		if v_1.Op != OpConst32 {
 11696  			break
 11697  		}
 11698  		d := v_1.AuxInt
 11699  		if !(0 <= c && c < d) {
 11700  			break
 11701  		}
 11702  		v.reset(OpConstBool)
 11703  		v.AuxInt = 1
 11704  		return true
 11705  	}
 11706  	return false
 11707  }
 11708  func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool {
 11709  	// match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d]))
 11710  	// cond: 0 <= c && c < d
 11711  	// result: (ConstBool [1])
 11712  	for {
 11713  		_ = v.Args[1]
 11714  		v_0 := v.Args[0]
 11715  		if v_0.Op != OpZeroExt8to32 {
 11716  			break
 11717  		}
 11718  		v_0_0 := v_0.Args[0]
 11719  		if v_0_0.Op != OpAnd8 {
 11720  			break
 11721  		}
 11722  		_ = v_0_0.Args[1]
 11723  		v_0_0_1 := v_0_0.Args[1]
 11724  		if v_0_0_1.Op != OpConst8 {
 11725  			break
 11726  		}
 11727  		c := v_0_0_1.AuxInt
 11728  		v_1 := v.Args[1]
 11729  		if v_1.Op != OpConst32 {
 11730  			break
 11731  		}
 11732  		d := v_1.AuxInt
 11733  		if !(0 <= c && c < d) {
 11734  			break
 11735  		}
 11736  		v.reset(OpConstBool)
 11737  		v.AuxInt = 1
 11738  		return true
 11739  	}
 11740  	// match: (IsInBounds (ZeroExt8to64 (And8 (Const8 [c]) _)) (Const64 [d]))
 11741  	// cond: 0 <= c && c < d
 11742  	// result: (ConstBool [1])
 11743  	for {
 11744  		_ = v.Args[1]
 11745  		v_0 := v.Args[0]
 11746  		if v_0.Op != OpZeroExt8to64 {
 11747  			break
 11748  		}
 11749  		v_0_0 := v_0.Args[0]
 11750  		if v_0_0.Op != OpAnd8 {
 11751  			break
 11752  		}
 11753  		_ = v_0_0.Args[1]
 11754  		v_0_0_0 := v_0_0.Args[0]
 11755  		if v_0_0_0.Op != OpConst8 {
 11756  			break
 11757  		}
 11758  		c := v_0_0_0.AuxInt
 11759  		v_1 := v.Args[1]
 11760  		if v_1.Op != OpConst64 {
 11761  			break
 11762  		}
 11763  		d := v_1.AuxInt
 11764  		if !(0 <= c && c < d) {
 11765  			break
 11766  		}
 11767  		v.reset(OpConstBool)
 11768  		v.AuxInt = 1
 11769  		return true
 11770  	}
 11771  	// match: (IsInBounds (ZeroExt8to64 (And8 _ (Const8 [c]))) (Const64 [d]))
 11772  	// cond: 0 <= c && c < d
 11773  	// result: (ConstBool [1])
 11774  	for {
 11775  		_ = v.Args[1]
 11776  		v_0 := v.Args[0]
 11777  		if v_0.Op != OpZeroExt8to64 {
 11778  			break
 11779  		}
 11780  		v_0_0 := v_0.Args[0]
 11781  		if v_0_0.Op != OpAnd8 {
 11782  			break
 11783  		}
 11784  		_ = v_0_0.Args[1]
 11785  		v_0_0_1 := v_0_0.Args[1]
 11786  		if v_0_0_1.Op != OpConst8 {
 11787  			break
 11788  		}
 11789  		c := v_0_0_1.AuxInt
 11790  		v_1 := v.Args[1]
 11791  		if v_1.Op != OpConst64 {
 11792  			break
 11793  		}
 11794  		d := v_1.AuxInt
 11795  		if !(0 <= c && c < d) {
 11796  			break
 11797  		}
 11798  		v.reset(OpConstBool)
 11799  		v.AuxInt = 1
 11800  		return true
 11801  	}
 11802  	// match: (IsInBounds (And16 (Const16 [c]) _) (Const16 [d]))
 11803  	// cond: 0 <= c && c < d
 11804  	// result: (ConstBool [1])
 11805  	for {
 11806  		_ = v.Args[1]
 11807  		v_0 := v.Args[0]
 11808  		if v_0.Op != OpAnd16 {
 11809  			break
 11810  		}
 11811  		_ = v_0.Args[1]
 11812  		v_0_0 := v_0.Args[0]
 11813  		if v_0_0.Op != OpConst16 {
 11814  			break
 11815  		}
 11816  		c := v_0_0.AuxInt
 11817  		v_1 := v.Args[1]
 11818  		if v_1.Op != OpConst16 {
 11819  			break
 11820  		}
 11821  		d := v_1.AuxInt
 11822  		if !(0 <= c && c < d) {
 11823  			break
 11824  		}
 11825  		v.reset(OpConstBool)
 11826  		v.AuxInt = 1
 11827  		return true
 11828  	}
 11829  	// match: (IsInBounds (And16 _ (Const16 [c])) (Const16 [d]))
 11830  	// cond: 0 <= c && c < d
 11831  	// result: (ConstBool [1])
 11832  	for {
 11833  		_ = v.Args[1]
 11834  		v_0 := v.Args[0]
 11835  		if v_0.Op != OpAnd16 {
 11836  			break
 11837  		}
 11838  		_ = v_0.Args[1]
 11839  		v_0_1 := v_0.Args[1]
 11840  		if v_0_1.Op != OpConst16 {
 11841  			break
 11842  		}
 11843  		c := v_0_1.AuxInt
 11844  		v_1 := v.Args[1]
 11845  		if v_1.Op != OpConst16 {
 11846  			break
 11847  		}
 11848  		d := v_1.AuxInt
 11849  		if !(0 <= c && c < d) {
 11850  			break
 11851  		}
 11852  		v.reset(OpConstBool)
 11853  		v.AuxInt = 1
 11854  		return true
 11855  	}
 11856  	// match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d]))
 11857  	// cond: 0 <= c && c < d
 11858  	// result: (ConstBool [1])
 11859  	for {
 11860  		_ = v.Args[1]
 11861  		v_0 := v.Args[0]
 11862  		if v_0.Op != OpZeroExt16to32 {
 11863  			break
 11864  		}
 11865  		v_0_0 := v_0.Args[0]
 11866  		if v_0_0.Op != OpAnd16 {
 11867  			break
 11868  		}
 11869  		_ = v_0_0.Args[1]
 11870  		v_0_0_0 := v_0_0.Args[0]
 11871  		if v_0_0_0.Op != OpConst16 {
 11872  			break
 11873  		}
 11874  		c := v_0_0_0.AuxInt
 11875  		v_1 := v.Args[1]
 11876  		if v_1.Op != OpConst32 {
 11877  			break
 11878  		}
 11879  		d := v_1.AuxInt
 11880  		if !(0 <= c && c < d) {
 11881  			break
 11882  		}
 11883  		v.reset(OpConstBool)
 11884  		v.AuxInt = 1
 11885  		return true
 11886  	}
 11887  	// match: (IsInBounds (ZeroExt16to32 (And16 _ (Const16 [c]))) (Const32 [d]))
 11888  	// cond: 0 <= c && c < d
 11889  	// result: (ConstBool [1])
 11890  	for {
 11891  		_ = v.Args[1]
 11892  		v_0 := v.Args[0]
 11893  		if v_0.Op != OpZeroExt16to32 {
 11894  			break
 11895  		}
 11896  		v_0_0 := v_0.Args[0]
 11897  		if v_0_0.Op != OpAnd16 {
 11898  			break
 11899  		}
 11900  		_ = v_0_0.Args[1]
 11901  		v_0_0_1 := v_0_0.Args[1]
 11902  		if v_0_0_1.Op != OpConst16 {
 11903  			break
 11904  		}
 11905  		c := v_0_0_1.AuxInt
 11906  		v_1 := v.Args[1]
 11907  		if v_1.Op != OpConst32 {
 11908  			break
 11909  		}
 11910  		d := v_1.AuxInt
 11911  		if !(0 <= c && c < d) {
 11912  			break
 11913  		}
 11914  		v.reset(OpConstBool)
 11915  		v.AuxInt = 1
 11916  		return true
 11917  	}
 11918  	// match: (IsInBounds (ZeroExt16to64 (And16 (Const16 [c]) _)) (Const64 [d]))
 11919  	// cond: 0 <= c && c < d
 11920  	// result: (ConstBool [1])
 11921  	for {
 11922  		_ = v.Args[1]
 11923  		v_0 := v.Args[0]
 11924  		if v_0.Op != OpZeroExt16to64 {
 11925  			break
 11926  		}
 11927  		v_0_0 := v_0.Args[0]
 11928  		if v_0_0.Op != OpAnd16 {
 11929  			break
 11930  		}
 11931  		_ = v_0_0.Args[1]
 11932  		v_0_0_0 := v_0_0.Args[0]
 11933  		if v_0_0_0.Op != OpConst16 {
 11934  			break
 11935  		}
 11936  		c := v_0_0_0.AuxInt
 11937  		v_1 := v.Args[1]
 11938  		if v_1.Op != OpConst64 {
 11939  			break
 11940  		}
 11941  		d := v_1.AuxInt
 11942  		if !(0 <= c && c < d) {
 11943  			break
 11944  		}
 11945  		v.reset(OpConstBool)
 11946  		v.AuxInt = 1
 11947  		return true
 11948  	}
 11949  	// match: (IsInBounds (ZeroExt16to64 (And16 _ (Const16 [c]))) (Const64 [d]))
 11950  	// cond: 0 <= c && c < d
 11951  	// result: (ConstBool [1])
 11952  	for {
 11953  		_ = v.Args[1]
 11954  		v_0 := v.Args[0]
 11955  		if v_0.Op != OpZeroExt16to64 {
 11956  			break
 11957  		}
 11958  		v_0_0 := v_0.Args[0]
 11959  		if v_0_0.Op != OpAnd16 {
 11960  			break
 11961  		}
 11962  		_ = v_0_0.Args[1]
 11963  		v_0_0_1 := v_0_0.Args[1]
 11964  		if v_0_0_1.Op != OpConst16 {
 11965  			break
 11966  		}
 11967  		c := v_0_0_1.AuxInt
 11968  		v_1 := v.Args[1]
 11969  		if v_1.Op != OpConst64 {
 11970  			break
 11971  		}
 11972  		d := v_1.AuxInt
 11973  		if !(0 <= c && c < d) {
 11974  			break
 11975  		}
 11976  		v.reset(OpConstBool)
 11977  		v.AuxInt = 1
 11978  		return true
 11979  	}
 11980  	// match: (IsInBounds (And32 (Const32 [c]) _) (Const32 [d]))
 11981  	// cond: 0 <= c && c < d
 11982  	// result: (ConstBool [1])
 11983  	for {
 11984  		_ = v.Args[1]
 11985  		v_0 := v.Args[0]
 11986  		if v_0.Op != OpAnd32 {
 11987  			break
 11988  		}
 11989  		_ = v_0.Args[1]
 11990  		v_0_0 := v_0.Args[0]
 11991  		if v_0_0.Op != OpConst32 {
 11992  			break
 11993  		}
 11994  		c := v_0_0.AuxInt
 11995  		v_1 := v.Args[1]
 11996  		if v_1.Op != OpConst32 {
 11997  			break
 11998  		}
 11999  		d := v_1.AuxInt
 12000  		if !(0 <= c && c < d) {
 12001  			break
 12002  		}
 12003  		v.reset(OpConstBool)
 12004  		v.AuxInt = 1
 12005  		return true
 12006  	}
 12007  	return false
 12008  }
 12009  func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool {
 12010  	// match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d]))
 12011  	// cond: 0 <= c && c < d
 12012  	// result: (ConstBool [1])
 12013  	for {
 12014  		_ = v.Args[1]
 12015  		v_0 := v.Args[0]
 12016  		if v_0.Op != OpAnd32 {
 12017  			break
 12018  		}
 12019  		_ = v_0.Args[1]
 12020  		v_0_1 := v_0.Args[1]
 12021  		if v_0_1.Op != OpConst32 {
 12022  			break
 12023  		}
 12024  		c := v_0_1.AuxInt
 12025  		v_1 := v.Args[1]
 12026  		if v_1.Op != OpConst32 {
 12027  			break
 12028  		}
 12029  		d := v_1.AuxInt
 12030  		if !(0 <= c && c < d) {
 12031  			break
 12032  		}
 12033  		v.reset(OpConstBool)
 12034  		v.AuxInt = 1
 12035  		return true
 12036  	}
 12037  	// match: (IsInBounds (ZeroExt32to64 (And32 (Const32 [c]) _)) (Const64 [d]))
 12038  	// cond: 0 <= c && c < d
 12039  	// result: (ConstBool [1])
 12040  	for {
 12041  		_ = v.Args[1]
 12042  		v_0 := v.Args[0]
 12043  		if v_0.Op != OpZeroExt32to64 {
 12044  			break
 12045  		}
 12046  		v_0_0 := v_0.Args[0]
 12047  		if v_0_0.Op != OpAnd32 {
 12048  			break
 12049  		}
 12050  		_ = v_0_0.Args[1]
 12051  		v_0_0_0 := v_0_0.Args[0]
 12052  		if v_0_0_0.Op != OpConst32 {
 12053  			break
 12054  		}
 12055  		c := v_0_0_0.AuxInt
 12056  		v_1 := v.Args[1]
 12057  		if v_1.Op != OpConst64 {
 12058  			break
 12059  		}
 12060  		d := v_1.AuxInt
 12061  		if !(0 <= c && c < d) {
 12062  			break
 12063  		}
 12064  		v.reset(OpConstBool)
 12065  		v.AuxInt = 1
 12066  		return true
 12067  	}
 12068  	// match: (IsInBounds (ZeroExt32to64 (And32 _ (Const32 [c]))) (Const64 [d]))
 12069  	// cond: 0 <= c && c < d
 12070  	// result: (ConstBool [1])
 12071  	for {
 12072  		_ = v.Args[1]
 12073  		v_0 := v.Args[0]
 12074  		if v_0.Op != OpZeroExt32to64 {
 12075  			break
 12076  		}
 12077  		v_0_0 := v_0.Args[0]
 12078  		if v_0_0.Op != OpAnd32 {
 12079  			break
 12080  		}
 12081  		_ = v_0_0.Args[1]
 12082  		v_0_0_1 := v_0_0.Args[1]
 12083  		if v_0_0_1.Op != OpConst32 {
 12084  			break
 12085  		}
 12086  		c := v_0_0_1.AuxInt
 12087  		v_1 := v.Args[1]
 12088  		if v_1.Op != OpConst64 {
 12089  			break
 12090  		}
 12091  		d := v_1.AuxInt
 12092  		if !(0 <= c && c < d) {
 12093  			break
 12094  		}
 12095  		v.reset(OpConstBool)
 12096  		v.AuxInt = 1
 12097  		return true
 12098  	}
 12099  	// match: (IsInBounds (And64 (Const64 [c]) _) (Const64 [d]))
 12100  	// cond: 0 <= c && c < d
 12101  	// result: (ConstBool [1])
 12102  	for {
 12103  		_ = v.Args[1]
 12104  		v_0 := v.Args[0]
 12105  		if v_0.Op != OpAnd64 {
 12106  			break
 12107  		}
 12108  		_ = v_0.Args[1]
 12109  		v_0_0 := v_0.Args[0]
 12110  		if v_0_0.Op != OpConst64 {
 12111  			break
 12112  		}
 12113  		c := v_0_0.AuxInt
 12114  		v_1 := v.Args[1]
 12115  		if v_1.Op != OpConst64 {
 12116  			break
 12117  		}
 12118  		d := v_1.AuxInt
 12119  		if !(0 <= c && c < d) {
 12120  			break
 12121  		}
 12122  		v.reset(OpConstBool)
 12123  		v.AuxInt = 1
 12124  		return true
 12125  	}
 12126  	// match: (IsInBounds (And64 _ (Const64 [c])) (Const64 [d]))
 12127  	// cond: 0 <= c && c < d
 12128  	// result: (ConstBool [1])
 12129  	for {
 12130  		_ = v.Args[1]
 12131  		v_0 := v.Args[0]
 12132  		if v_0.Op != OpAnd64 {
 12133  			break
 12134  		}
 12135  		_ = v_0.Args[1]
 12136  		v_0_1 := v_0.Args[1]
 12137  		if v_0_1.Op != OpConst64 {
 12138  			break
 12139  		}
 12140  		c := v_0_1.AuxInt
 12141  		v_1 := v.Args[1]
 12142  		if v_1.Op != OpConst64 {
 12143  			break
 12144  		}
 12145  		d := v_1.AuxInt
 12146  		if !(0 <= c && c < d) {
 12147  			break
 12148  		}
 12149  		v.reset(OpConstBool)
 12150  		v.AuxInt = 1
 12151  		return true
 12152  	}
 12153  	// match: (IsInBounds (Const32 [c]) (Const32 [d]))
 12154  	// cond:
 12155  	// result: (ConstBool [b2i(0 <= c && c < d)])
 12156  	for {
 12157  		_ = v.Args[1]
 12158  		v_0 := v.Args[0]
 12159  		if v_0.Op != OpConst32 {
 12160  			break
 12161  		}
 12162  		c := v_0.AuxInt
 12163  		v_1 := v.Args[1]
 12164  		if v_1.Op != OpConst32 {
 12165  			break
 12166  		}
 12167  		d := v_1.AuxInt
 12168  		v.reset(OpConstBool)
 12169  		v.AuxInt = b2i(0 <= c && c < d)
 12170  		return true
 12171  	}
 12172  	// match: (IsInBounds (Const64 [c]) (Const64 [d]))
 12173  	// cond:
 12174  	// result: (ConstBool [b2i(0 <= c && c < d)])
 12175  	for {
 12176  		_ = v.Args[1]
 12177  		v_0 := v.Args[0]
 12178  		if v_0.Op != OpConst64 {
 12179  			break
 12180  		}
 12181  		c := v_0.AuxInt
 12182  		v_1 := v.Args[1]
 12183  		if v_1.Op != OpConst64 {
 12184  			break
 12185  		}
 12186  		d := v_1.AuxInt
 12187  		v.reset(OpConstBool)
 12188  		v.AuxInt = b2i(0 <= c && c < d)
 12189  		return true
 12190  	}
 12191  	// match: (IsInBounds (Mod32u _ y) y)
 12192  	// cond:
 12193  	// result: (ConstBool [1])
 12194  	for {
 12195  		_ = v.Args[1]
 12196  		v_0 := v.Args[0]
 12197  		if v_0.Op != OpMod32u {
 12198  			break
 12199  		}
 12200  		_ = v_0.Args[1]
 12201  		y := v_0.Args[1]
 12202  		if y != v.Args[1] {
 12203  			break
 12204  		}
 12205  		v.reset(OpConstBool)
 12206  		v.AuxInt = 1
 12207  		return true
 12208  	}
 12209  	// match: (IsInBounds (Mod64u _ y) y)
 12210  	// cond:
 12211  	// result: (ConstBool [1])
 12212  	for {
 12213  		_ = v.Args[1]
 12214  		v_0 := v.Args[0]
 12215  		if v_0.Op != OpMod64u {
 12216  			break
 12217  		}
 12218  		_ = v_0.Args[1]
 12219  		y := v_0.Args[1]
 12220  		if y != v.Args[1] {
 12221  			break
 12222  		}
 12223  		v.reset(OpConstBool)
 12224  		v.AuxInt = 1
 12225  		return true
 12226  	}
 12227  	// match: (IsInBounds (ZeroExt8to64 (Rsh8Ux64 _ (Const64 [c]))) (Const64 [d]))
 12228  	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 12229  	// result: (ConstBool [1])
 12230  	for {
 12231  		_ = v.Args[1]
 12232  		v_0 := v.Args[0]
 12233  		if v_0.Op != OpZeroExt8to64 {
 12234  			break
 12235  		}
 12236  		v_0_0 := v_0.Args[0]
 12237  		if v_0_0.Op != OpRsh8Ux64 {
 12238  			break
 12239  		}
 12240  		_ = v_0_0.Args[1]
 12241  		v_0_0_1 := v_0_0.Args[1]
 12242  		if v_0_0_1.Op != OpConst64 {
 12243  			break
 12244  		}
 12245  		c := v_0_0_1.AuxInt
 12246  		v_1 := v.Args[1]
 12247  		if v_1.Op != OpConst64 {
 12248  			break
 12249  		}
 12250  		d := v_1.AuxInt
 12251  		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 12252  			break
 12253  		}
 12254  		v.reset(OpConstBool)
 12255  		v.AuxInt = 1
 12256  		return true
 12257  	}
 12258  	return false
 12259  }
 12260  func rewriteValuegeneric_OpIsInBounds_30(v *Value) bool {
 12261  	// match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d]))
 12262  	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 12263  	// result: (ConstBool [1])
 12264  	for {
 12265  		_ = v.Args[1]
 12266  		v_0 := v.Args[0]
 12267  		if v_0.Op != OpZeroExt8to32 {
 12268  			break
 12269  		}
 12270  		v_0_0 := v_0.Args[0]
 12271  		if v_0_0.Op != OpRsh8Ux64 {
 12272  			break
 12273  		}
 12274  		_ = v_0_0.Args[1]
 12275  		v_0_0_1 := v_0_0.Args[1]
 12276  		if v_0_0_1.Op != OpConst64 {
 12277  			break
 12278  		}
 12279  		c := v_0_0_1.AuxInt
 12280  		v_1 := v.Args[1]
 12281  		if v_1.Op != OpConst32 {
 12282  			break
 12283  		}
 12284  		d := v_1.AuxInt
 12285  		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 12286  			break
 12287  		}
 12288  		v.reset(OpConstBool)
 12289  		v.AuxInt = 1
 12290  		return true
 12291  	}
 12292  	// match: (IsInBounds (ZeroExt8to16 (Rsh8Ux64 _ (Const64 [c]))) (Const16 [d]))
 12293  	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 12294  	// result: (ConstBool [1])
 12295  	for {
 12296  		_ = v.Args[1]
 12297  		v_0 := v.Args[0]
 12298  		if v_0.Op != OpZeroExt8to16 {
 12299  			break
 12300  		}
 12301  		v_0_0 := v_0.Args[0]
 12302  		if v_0_0.Op != OpRsh8Ux64 {
 12303  			break
 12304  		}
 12305  		_ = v_0_0.Args[1]
 12306  		v_0_0_1 := v_0_0.Args[1]
 12307  		if v_0_0_1.Op != OpConst64 {
 12308  			break
 12309  		}
 12310  		c := v_0_0_1.AuxInt
 12311  		v_1 := v.Args[1]
 12312  		if v_1.Op != OpConst16 {
 12313  			break
 12314  		}
 12315  		d := v_1.AuxInt
 12316  		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 12317  			break
 12318  		}
 12319  		v.reset(OpConstBool)
 12320  		v.AuxInt = 1
 12321  		return true
 12322  	}
 12323  	// match: (IsInBounds (Rsh8Ux64 _ (Const64 [c])) (Const64 [d]))
 12324  	// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
 12325  	// result: (ConstBool [1])
 12326  	for {
 12327  		_ = v.Args[1]
 12328  		v_0 := v.Args[0]
 12329  		if v_0.Op != OpRsh8Ux64 {
 12330  			break
 12331  		}
 12332  		_ = v_0.Args[1]
 12333  		v_0_1 := v_0.Args[1]
 12334  		if v_0_1.Op != OpConst64 {
 12335  			break
 12336  		}
 12337  		c := v_0_1.AuxInt
 12338  		v_1 := v.Args[1]
 12339  		if v_1.Op != OpConst64 {
 12340  			break
 12341  		}
 12342  		d := v_1.AuxInt
 12343  		if !(0 < c && c < 8 && 1<<uint(8-c)-1 < d) {
 12344  			break
 12345  		}
 12346  		v.reset(OpConstBool)
 12347  		v.AuxInt = 1
 12348  		return true
 12349  	}
 12350  	// match: (IsInBounds (ZeroExt16to64 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
 12351  	// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
 12352  	// result: (ConstBool [1])
 12353  	for {
 12354  		_ = v.Args[1]
 12355  		v_0 := v.Args[0]
 12356  		if v_0.Op != OpZeroExt16to64 {
 12357  			break
 12358  		}
 12359  		v_0_0 := v_0.Args[0]
 12360  		if v_0_0.Op != OpRsh16Ux64 {
 12361  			break
 12362  		}
 12363  		_ = v_0_0.Args[1]
 12364  		v_0_0_1 := v_0_0.Args[1]
 12365  		if v_0_0_1.Op != OpConst64 {
 12366  			break
 12367  		}
 12368  		c := v_0_0_1.AuxInt
 12369  		v_1 := v.Args[1]
 12370  		if v_1.Op != OpConst64 {
 12371  			break
 12372  		}
 12373  		d := v_1.AuxInt
 12374  		if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
 12375  			break
 12376  		}
 12377  		v.reset(OpConstBool)
 12378  		v.AuxInt = 1
 12379  		return true
 12380  	}
 12381  	// match: (IsInBounds (ZeroExt16to32 (Rsh16Ux64 _ (Const64 [c]))) (Const64 [d]))
 12382  	// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
 12383  	// result: (ConstBool [1])
 12384  	for {
 12385  		_ = v.Args[1]
 12386  		v_0 := v.Args[0]
 12387  		if v_0.Op != OpZeroExt16to32 {
 12388  			break
 12389  		}
 12390  		v_0_0 := v_0.Args[0]
 12391  		if v_0_0.Op != OpRsh16Ux64 {
 12392  			break
 12393  		}
 12394  		_ = v_0_0.Args[1]
 12395  		v_0_0_1 := v_0_0.Args[1]
 12396  		if v_0_0_1.Op != OpConst64 {
 12397  			break
 12398  		}
 12399  		c := v_0_0_1.AuxInt
 12400  		v_1 := v.Args[1]
 12401  		if v_1.Op != OpConst64 {
 12402  			break
 12403  		}
 12404  		d := v_1.AuxInt
 12405  		if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
 12406  			break
 12407  		}
 12408  		v.reset(OpConstBool)
 12409  		v.AuxInt = 1
 12410  		return true
 12411  	}
 12412  	// match: (IsInBounds (Rsh16Ux64 _ (Const64 [c])) (Const64 [d]))
 12413  	// cond: 0 < c && c < 16 && 1<<uint(16-c)-1 < d
 12414  	// result: (ConstBool [1])
 12415  	for {
 12416  		_ = v.Args[1]
 12417  		v_0 := v.Args[0]
 12418  		if v_0.Op != OpRsh16Ux64 {
 12419  			break
 12420  		}
 12421  		_ = v_0.Args[1]
 12422  		v_0_1 := v_0.Args[1]
 12423  		if v_0_1.Op != OpConst64 {
 12424  			break
 12425  		}
 12426  		c := v_0_1.AuxInt
 12427  		v_1 := v.Args[1]
 12428  		if v_1.Op != OpConst64 {
 12429  			break
 12430  		}
 12431  		d := v_1.AuxInt
 12432  		if !(0 < c && c < 16 && 1<<uint(16-c)-1 < d) {
 12433  			break
 12434  		}
 12435  		v.reset(OpConstBool)
 12436  		v.AuxInt = 1
 12437  		return true
 12438  	}
 12439  	// match: (IsInBounds (ZeroExt32to64 (Rsh32Ux64 _ (Const64 [c]))) (Const64 [d]))
 12440  	// cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d
 12441  	// result: (ConstBool [1])
 12442  	for {
 12443  		_ = v.Args[1]
 12444  		v_0 := v.Args[0]
 12445  		if v_0.Op != OpZeroExt32to64 {
 12446  			break
 12447  		}
 12448  		v_0_0 := v_0.Args[0]
 12449  		if v_0_0.Op != OpRsh32Ux64 {
 12450  			break
 12451  		}
 12452  		_ = v_0_0.Args[1]
 12453  		v_0_0_1 := v_0_0.Args[1]
 12454  		if v_0_0_1.Op != OpConst64 {
 12455  			break
 12456  		}
 12457  		c := v_0_0_1.AuxInt
 12458  		v_1 := v.Args[1]
 12459  		if v_1.Op != OpConst64 {
 12460  			break
 12461  		}
 12462  		d := v_1.AuxInt
 12463  		if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) {
 12464  			break
 12465  		}
 12466  		v.reset(OpConstBool)
 12467  		v.AuxInt = 1
 12468  		return true
 12469  	}
 12470  	// match: (IsInBounds (Rsh32Ux64 _ (Const64 [c])) (Const64 [d]))
 12471  	// cond: 0 < c && c < 32 && 1<<uint(32-c)-1 < d
 12472  	// result: (ConstBool [1])
 12473  	for {
 12474  		_ = v.Args[1]
 12475  		v_0 := v.Args[0]
 12476  		if v_0.Op != OpRsh32Ux64 {
 12477  			break
 12478  		}
 12479  		_ = v_0.Args[1]
 12480  		v_0_1 := v_0.Args[1]
 12481  		if v_0_1.Op != OpConst64 {
 12482  			break
 12483  		}
 12484  		c := v_0_1.AuxInt
 12485  		v_1 := v.Args[1]
 12486  		if v_1.Op != OpConst64 {
 12487  			break
 12488  		}
 12489  		d := v_1.AuxInt
 12490  		if !(0 < c && c < 32 && 1<<uint(32-c)-1 < d) {
 12491  			break
 12492  		}
 12493  		v.reset(OpConstBool)
 12494  		v.AuxInt = 1
 12495  		return true
 12496  	}
 12497  	// match: (IsInBounds (Rsh64Ux64 _ (Const64 [c])) (Const64 [d]))
 12498  	// cond: 0 < c && c < 64 && 1<<uint(64-c)-1 < d
 12499  	// result: (ConstBool [1])
 12500  	for {
 12501  		_ = v.Args[1]
 12502  		v_0 := v.Args[0]
 12503  		if v_0.Op != OpRsh64Ux64 {
 12504  			break
 12505  		}
 12506  		_ = v_0.Args[1]
 12507  		v_0_1 := v_0.Args[1]
 12508  		if v_0_1.Op != OpConst64 {
 12509  			break
 12510  		}
 12511  		c := v_0_1.AuxInt
 12512  		v_1 := v.Args[1]
 12513  		if v_1.Op != OpConst64 {
 12514  			break
 12515  		}
 12516  		d := v_1.AuxInt
 12517  		if !(0 < c && c < 64 && 1<<uint(64-c)-1 < d) {
 12518  			break
 12519  		}
 12520  		v.reset(OpConstBool)
 12521  		v.AuxInt = 1
 12522  		return true
 12523  	}
 12524  	return false
 12525  }
 12526  func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool {
 12527  	// match: (IsNonNil (ConstNil))
 12528  	// cond:
 12529  	// result: (ConstBool [0])
 12530  	for {
 12531  		v_0 := v.Args[0]
 12532  		if v_0.Op != OpConstNil {
 12533  			break
 12534  		}
 12535  		v.reset(OpConstBool)
 12536  		v.AuxInt = 0
 12537  		return true
 12538  	}
 12539  	// match: (IsNonNil (Const32 [c]))
 12540  	// cond:
 12541  	// result: (ConstBool [b2i(c != 0)])
 12542  	for {
 12543  		v_0 := v.Args[0]
 12544  		if v_0.Op != OpConst32 {
 12545  			break
 12546  		}
 12547  		c := v_0.AuxInt
 12548  		v.reset(OpConstBool)
 12549  		v.AuxInt = b2i(c != 0)
 12550  		return true
 12551  	}
 12552  	// match: (IsNonNil (Const64 [c]))
 12553  	// cond:
 12554  	// result: (ConstBool [b2i(c != 0)])
 12555  	for {
 12556  		v_0 := v.Args[0]
 12557  		if v_0.Op != OpConst64 {
 12558  			break
 12559  		}
 12560  		c := v_0.AuxInt
 12561  		v.reset(OpConstBool)
 12562  		v.AuxInt = b2i(c != 0)
 12563  		return true
 12564  	}
 12565  	// match: (IsNonNil (Addr _))
 12566  	// cond:
 12567  	// result: (ConstBool [1])
 12568  	for {
 12569  		v_0 := v.Args[0]
 12570  		if v_0.Op != OpAddr {
 12571  			break
 12572  		}
 12573  		v.reset(OpConstBool)
 12574  		v.AuxInt = 1
 12575  		return true
 12576  	}
 12577  	// match: (IsNonNil (LocalAddr _ _))
 12578  	// cond:
 12579  	// result: (ConstBool [1])
 12580  	for {
 12581  		v_0 := v.Args[0]
 12582  		if v_0.Op != OpLocalAddr {
 12583  			break
 12584  		}
 12585  		_ = v_0.Args[1]
 12586  		v.reset(OpConstBool)
 12587  		v.AuxInt = 1
 12588  		return true
 12589  	}
 12590  	return false
 12591  }
 12592  func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool {
 12593  	// match: (IsSliceInBounds x x)
 12594  	// cond:
 12595  	// result: (ConstBool [1])
 12596  	for {
 12597  		_ = v.Args[1]
 12598  		x := v.Args[0]
 12599  		if x != v.Args[1] {
 12600  			break
 12601  		}
 12602  		v.reset(OpConstBool)
 12603  		v.AuxInt = 1
 12604  		return true
 12605  	}
 12606  	// match: (IsSliceInBounds (And32 (Const32 [c]) _) (Const32 [d]))
 12607  	// cond: 0 <= c && c <= d
 12608  	// result: (ConstBool [1])
 12609  	for {
 12610  		_ = v.Args[1]
 12611  		v_0 := v.Args[0]
 12612  		if v_0.Op != OpAnd32 {
 12613  			break
 12614  		}
 12615  		_ = v_0.Args[1]
 12616  		v_0_0 := v_0.Args[0]
 12617  		if v_0_0.Op != OpConst32 {
 12618  			break
 12619  		}
 12620  		c := v_0_0.AuxInt
 12621  		v_1 := v.Args[1]
 12622  		if v_1.Op != OpConst32 {
 12623  			break
 12624  		}
 12625  		d := v_1.AuxInt
 12626  		if !(0 <= c && c <= d) {
 12627  			break
 12628  		}
 12629  		v.reset(OpConstBool)
 12630  		v.AuxInt = 1
 12631  		return true
 12632  	}
 12633  	// match: (IsSliceInBounds (And32 _ (Const32 [c])) (Const32 [d]))
 12634  	// cond: 0 <= c && c <= d
 12635  	// result: (ConstBool [1])
 12636  	for {
 12637  		_ = v.Args[1]
 12638  		v_0 := v.Args[0]
 12639  		if v_0.Op != OpAnd32 {
 12640  			break
 12641  		}
 12642  		_ = v_0.Args[1]
 12643  		v_0_1 := v_0.Args[1]
 12644  		if v_0_1.Op != OpConst32 {
 12645  			break
 12646  		}
 12647  		c := v_0_1.AuxInt
 12648  		v_1 := v.Args[1]
 12649  		if v_1.Op != OpConst32 {
 12650  			break
 12651  		}
 12652  		d := v_1.AuxInt
 12653  		if !(0 <= c && c <= d) {
 12654  			break
 12655  		}
 12656  		v.reset(OpConstBool)
 12657  		v.AuxInt = 1
 12658  		return true
 12659  	}
 12660  	// match: (IsSliceInBounds (And64 (Const64 [c]) _) (Const64 [d]))
 12661  	// cond: 0 <= c && c <= d
 12662  	// result: (ConstBool [1])
 12663  	for {
 12664  		_ = v.Args[1]
 12665  		v_0 := v.Args[0]
 12666  		if v_0.Op != OpAnd64 {
 12667  			break
 12668  		}
 12669  		_ = v_0.Args[1]
 12670  		v_0_0 := v_0.Args[0]
 12671  		if v_0_0.Op != OpConst64 {
 12672  			break
 12673  		}
 12674  		c := v_0_0.AuxInt
 12675  		v_1 := v.Args[1]
 12676  		if v_1.Op != OpConst64 {
 12677  			break
 12678  		}
 12679  		d := v_1.AuxInt
 12680  		if !(0 <= c && c <= d) {
 12681  			break
 12682  		}
 12683  		v.reset(OpConstBool)
 12684  		v.AuxInt = 1
 12685  		return true
 12686  	}
 12687  	// match: (IsSliceInBounds (And64 _ (Const64 [c])) (Const64 [d]))
 12688  	// cond: 0 <= c && c <= d
 12689  	// result: (ConstBool [1])
 12690  	for {
 12691  		_ = v.Args[1]
 12692  		v_0 := v.Args[0]
 12693  		if v_0.Op != OpAnd64 {
 12694  			break
 12695  		}
 12696  		_ = v_0.Args[1]
 12697  		v_0_1 := v_0.Args[1]
 12698  		if v_0_1.Op != OpConst64 {
 12699  			break
 12700  		}
 12701  		c := v_0_1.AuxInt
 12702  		v_1 := v.Args[1]
 12703  		if v_1.Op != OpConst64 {
 12704  			break
 12705  		}
 12706  		d := v_1.AuxInt
 12707  		if !(0 <= c && c <= d) {
 12708  			break
 12709  		}
 12710  		v.reset(OpConstBool)
 12711  		v.AuxInt = 1
 12712  		return true
 12713  	}
 12714  	// match: (IsSliceInBounds (Const32 [0]) _)
 12715  	// cond:
 12716  	// result: (ConstBool [1])
 12717  	for {
 12718  		_ = v.Args[1]
 12719  		v_0 := v.Args[0]
 12720  		if v_0.Op != OpConst32 {
 12721  			break
 12722  		}
 12723  		if v_0.AuxInt != 0 {
 12724  			break
 12725  		}
 12726  		v.reset(OpConstBool)
 12727  		v.AuxInt = 1
 12728  		return true
 12729  	}
 12730  	// match: (IsSliceInBounds (Const64 [0]) _)
 12731  	// cond:
 12732  	// result: (ConstBool [1])
 12733  	for {
 12734  		_ = v.Args[1]
 12735  		v_0 := v.Args[0]
 12736  		if v_0.Op != OpConst64 {
 12737  			break
 12738  		}
 12739  		if v_0.AuxInt != 0 {
 12740  			break
 12741  		}
 12742  		v.reset(OpConstBool)
 12743  		v.AuxInt = 1
 12744  		return true
 12745  	}
 12746  	// match: (IsSliceInBounds (Const32 [c]) (Const32 [d]))
 12747  	// cond:
 12748  	// result: (ConstBool [b2i(0 <= c && c <= d)])
 12749  	for {
 12750  		_ = v.Args[1]
 12751  		v_0 := v.Args[0]
 12752  		if v_0.Op != OpConst32 {
 12753  			break
 12754  		}
 12755  		c := v_0.AuxInt
 12756  		v_1 := v.Args[1]
 12757  		if v_1.Op != OpConst32 {
 12758  			break
 12759  		}
 12760  		d := v_1.AuxInt
 12761  		v.reset(OpConstBool)
 12762  		v.AuxInt = b2i(0 <= c && c <= d)
 12763  		return true
 12764  	}
 12765  	// match: (IsSliceInBounds (Const64 [c]) (Const64 [d]))
 12766  	// cond:
 12767  	// result: (ConstBool [b2i(0 <= c && c <= d)])
 12768  	for {
 12769  		_ = v.Args[1]
 12770  		v_0 := v.Args[0]
 12771  		if v_0.Op != OpConst64 {
 12772  			break
 12773  		}
 12774  		c := v_0.AuxInt
 12775  		v_1 := v.Args[1]
 12776  		if v_1.Op != OpConst64 {
 12777  			break
 12778  		}
 12779  		d := v_1.AuxInt
 12780  		v.reset(OpConstBool)
 12781  		v.AuxInt = b2i(0 <= c && c <= d)
 12782  		return true
 12783  	}
 12784  	// match: (IsSliceInBounds (SliceLen x) (SliceCap x))
 12785  	// cond:
 12786  	// result: (ConstBool [1])
 12787  	for {
 12788  		_ = v.Args[1]
 12789  		v_0 := v.Args[0]
 12790  		if v_0.Op != OpSliceLen {
 12791  			break
 12792  		}
 12793  		x := v_0.Args[0]
 12794  		v_1 := v.Args[1]
 12795  		if v_1.Op != OpSliceCap {
 12796  			break
 12797  		}
 12798  		if x != v_1.Args[0] {
 12799  			break
 12800  		}
 12801  		v.reset(OpConstBool)
 12802  		v.AuxInt = 1
 12803  		return true
 12804  	}
 12805  	return false
 12806  }
 12807  func rewriteValuegeneric_OpLeq16_0(v *Value) bool {
 12808  	// match: (Leq16 (Const16 [c]) (Const16 [d]))
 12809  	// cond:
 12810  	// result: (ConstBool [b2i(c <= d)])
 12811  	for {
 12812  		_ = v.Args[1]
 12813  		v_0 := v.Args[0]
 12814  		if v_0.Op != OpConst16 {
 12815  			break
 12816  		}
 12817  		c := v_0.AuxInt
 12818  		v_1 := v.Args[1]
 12819  		if v_1.Op != OpConst16 {
 12820  			break
 12821  		}
 12822  		d := v_1.AuxInt
 12823  		v.reset(OpConstBool)
 12824  		v.AuxInt = b2i(c <= d)
 12825  		return true
 12826  	}
 12827  	return false
 12828  }
 12829  func rewriteValuegeneric_OpLeq16U_0(v *Value) bool {
 12830  	// match: (Leq16U (Const16 [c]) (Const16 [d]))
 12831  	// cond:
 12832  	// result: (ConstBool [b2i(uint16(c) <= uint16(d))])
 12833  	for {
 12834  		_ = v.Args[1]
 12835  		v_0 := v.Args[0]
 12836  		if v_0.Op != OpConst16 {
 12837  			break
 12838  		}
 12839  		c := v_0.AuxInt
 12840  		v_1 := v.Args[1]
 12841  		if v_1.Op != OpConst16 {
 12842  			break
 12843  		}
 12844  		d := v_1.AuxInt
 12845  		v.reset(OpConstBool)
 12846  		v.AuxInt = b2i(uint16(c) <= uint16(d))
 12847  		return true
 12848  	}
 12849  	return false
 12850  }
 12851  func rewriteValuegeneric_OpLeq32_0(v *Value) bool {
 12852  	// match: (Leq32 (Const32 [c]) (Const32 [d]))
 12853  	// cond:
 12854  	// result: (ConstBool [b2i(c <= d)])
 12855  	for {
 12856  		_ = v.Args[1]
 12857  		v_0 := v.Args[0]
 12858  		if v_0.Op != OpConst32 {
 12859  			break
 12860  		}
 12861  		c := v_0.AuxInt
 12862  		v_1 := v.Args[1]
 12863  		if v_1.Op != OpConst32 {
 12864  			break
 12865  		}
 12866  		d := v_1.AuxInt
 12867  		v.reset(OpConstBool)
 12868  		v.AuxInt = b2i(c <= d)
 12869  		return true
 12870  	}
 12871  	return false
 12872  }
 12873  func rewriteValuegeneric_OpLeq32F_0(v *Value) bool {
 12874  	// match: (Leq32F (Const32F [c]) (Const32F [d]))
 12875  	// cond:
 12876  	// result: (ConstBool [b2i(auxTo32F(c) <= auxTo32F(d))])
 12877  	for {
 12878  		_ = v.Args[1]
 12879  		v_0 := v.Args[0]
 12880  		if v_0.Op != OpConst32F {
 12881  			break
 12882  		}
 12883  		c := v_0.AuxInt
 12884  		v_1 := v.Args[1]
 12885  		if v_1.Op != OpConst32F {
 12886  			break
 12887  		}
 12888  		d := v_1.AuxInt
 12889  		v.reset(OpConstBool)
 12890  		v.AuxInt = b2i(auxTo32F(c) <= auxTo32F(d))
 12891  		return true
 12892  	}
 12893  	return false
 12894  }
 12895  func rewriteValuegeneric_OpLeq32U_0(v *Value) bool {
 12896  	// match: (Leq32U (Const32 [c]) (Const32 [d]))
 12897  	// cond:
 12898  	// result: (ConstBool [b2i(uint32(c) <= uint32(d))])
 12899  	for {
 12900  		_ = v.Args[1]
 12901  		v_0 := v.Args[0]
 12902  		if v_0.Op != OpConst32 {
 12903  			break
 12904  		}
 12905  		c := v_0.AuxInt
 12906  		v_1 := v.Args[1]
 12907  		if v_1.Op != OpConst32 {
 12908  			break
 12909  		}
 12910  		d := v_1.AuxInt
 12911  		v.reset(OpConstBool)
 12912  		v.AuxInt = b2i(uint32(c) <= uint32(d))
 12913  		return true
 12914  	}
 12915  	return false
 12916  }
 12917  func rewriteValuegeneric_OpLeq64_0(v *Value) bool {
 12918  	// match: (Leq64 (Const64 [c]) (Const64 [d]))
 12919  	// cond:
 12920  	// result: (ConstBool [b2i(c <= d)])
 12921  	for {
 12922  		_ = v.Args[1]
 12923  		v_0 := v.Args[0]
 12924  		if v_0.Op != OpConst64 {
 12925  			break
 12926  		}
 12927  		c := v_0.AuxInt
 12928  		v_1 := v.Args[1]
 12929  		if v_1.Op != OpConst64 {
 12930  			break
 12931  		}
 12932  		d := v_1.AuxInt
 12933  		v.reset(OpConstBool)
 12934  		v.AuxInt = b2i(c <= d)
 12935  		return true
 12936  	}
 12937  	return false
 12938  }
 12939  func rewriteValuegeneric_OpLeq64F_0(v *Value) bool {
 12940  	// match: (Leq64F (Const64F [c]) (Const64F [d]))
 12941  	// cond:
 12942  	// result: (ConstBool [b2i(auxTo64F(c) <= auxTo64F(d))])
 12943  	for {
 12944  		_ = v.Args[1]
 12945  		v_0 := v.Args[0]
 12946  		if v_0.Op != OpConst64F {
 12947  			break
 12948  		}
 12949  		c := v_0.AuxInt
 12950  		v_1 := v.Args[1]
 12951  		if v_1.Op != OpConst64F {
 12952  			break
 12953  		}
 12954  		d := v_1.AuxInt
 12955  		v.reset(OpConstBool)
 12956  		v.AuxInt = b2i(auxTo64F(c) <= auxTo64F(d))
 12957  		return true
 12958  	}
 12959  	return false
 12960  }
 12961  func rewriteValuegeneric_OpLeq64U_0(v *Value) bool {
 12962  	// match: (Leq64U (Const64 [c]) (Const64 [d]))
 12963  	// cond:
 12964  	// result: (ConstBool [b2i(uint64(c) <= uint64(d))])
 12965  	for {
 12966  		_ = v.Args[1]
 12967  		v_0 := v.Args[0]
 12968  		if v_0.Op != OpConst64 {
 12969  			break
 12970  		}
 12971  		c := v_0.AuxInt
 12972  		v_1 := v.Args[1]
 12973  		if v_1.Op != OpConst64 {
 12974  			break
 12975  		}
 12976  		d := v_1.AuxInt
 12977  		v.reset(OpConstBool)
 12978  		v.AuxInt = b2i(uint64(c) <= uint64(d))
 12979  		return true
 12980  	}
 12981  	return false
 12982  }
 12983  func rewriteValuegeneric_OpLeq8_0(v *Value) bool {
 12984  	// match: (Leq8 (Const8 [c]) (Const8 [d]))
 12985  	// cond:
 12986  	// result: (ConstBool [b2i(c <= d)])
 12987  	for {
 12988  		_ = v.Args[1]
 12989  		v_0 := v.Args[0]
 12990  		if v_0.Op != OpConst8 {
 12991  			break
 12992  		}
 12993  		c := v_0.AuxInt
 12994  		v_1 := v.Args[1]
 12995  		if v_1.Op != OpConst8 {
 12996  			break
 12997  		}
 12998  		d := v_1.AuxInt
 12999  		v.reset(OpConstBool)
 13000  		v.AuxInt = b2i(c <= d)
 13001  		return true
 13002  	}
 13003  	return false
 13004  }
 13005  func rewriteValuegeneric_OpLeq8U_0(v *Value) bool {
 13006  	// match: (Leq8U (Const8 [c]) (Const8 [d]))
 13007  	// cond:
 13008  	// result: (ConstBool [b2i(uint8(c) <= uint8(d))])
 13009  	for {
 13010  		_ = v.Args[1]
 13011  		v_0 := v.Args[0]
 13012  		if v_0.Op != OpConst8 {
 13013  			break
 13014  		}
 13015  		c := v_0.AuxInt
 13016  		v_1 := v.Args[1]
 13017  		if v_1.Op != OpConst8 {
 13018  			break
 13019  		}
 13020  		d := v_1.AuxInt
 13021  		v.reset(OpConstBool)
 13022  		v.AuxInt = b2i(uint8(c) <= uint8(d))
 13023  		return true
 13024  	}
 13025  	return false
 13026  }
 13027  func rewriteValuegeneric_OpLess16_0(v *Value) bool {
 13028  	// match: (Less16 (Const16 [c]) (Const16 [d]))
 13029  	// cond:
 13030  	// result: (ConstBool [b2i(c < d)])
 13031  	for {
 13032  		_ = v.Args[1]
 13033  		v_0 := v.Args[0]
 13034  		if v_0.Op != OpConst16 {
 13035  			break
 13036  		}
 13037  		c := v_0.AuxInt
 13038  		v_1 := v.Args[1]
 13039  		if v_1.Op != OpConst16 {
 13040  			break
 13041  		}
 13042  		d := v_1.AuxInt
 13043  		v.reset(OpConstBool)
 13044  		v.AuxInt = b2i(c < d)
 13045  		return true
 13046  	}
 13047  	return false
 13048  }
 13049  func rewriteValuegeneric_OpLess16U_0(v *Value) bool {
 13050  	// match: (Less16U (Const16 [c]) (Const16 [d]))
 13051  	// cond:
 13052  	// result: (ConstBool [b2i(uint16(c) < uint16(d))])
 13053  	for {
 13054  		_ = v.Args[1]
 13055  		v_0 := v.Args[0]
 13056  		if v_0.Op != OpConst16 {
 13057  			break
 13058  		}
 13059  		c := v_0.AuxInt
 13060  		v_1 := v.Args[1]
 13061  		if v_1.Op != OpConst16 {
 13062  			break
 13063  		}
 13064  		d := v_1.AuxInt
 13065  		v.reset(OpConstBool)
 13066  		v.AuxInt = b2i(uint16(c) < uint16(d))
 13067  		return true
 13068  	}
 13069  	return false
 13070  }
 13071  func rewriteValuegeneric_OpLess32_0(v *Value) bool {
 13072  	// match: (Less32 (Const32 [c]) (Const32 [d]))
 13073  	// cond:
 13074  	// result: (ConstBool [b2i(c < d)])
 13075  	for {
 13076  		_ = v.Args[1]
 13077  		v_0 := v.Args[0]
 13078  		if v_0.Op != OpConst32 {
 13079  			break
 13080  		}
 13081  		c := v_0.AuxInt
 13082  		v_1 := v.Args[1]
 13083  		if v_1.Op != OpConst32 {
 13084  			break
 13085  		}
 13086  		d := v_1.AuxInt
 13087  		v.reset(OpConstBool)
 13088  		v.AuxInt = b2i(c < d)
 13089  		return true
 13090  	}
 13091  	return false
 13092  }
 13093  func rewriteValuegeneric_OpLess32F_0(v *Value) bool {
 13094  	// match: (Less32F (Const32F [c]) (Const32F [d]))
 13095  	// cond:
 13096  	// result: (ConstBool [b2i(auxTo32F(c) < auxTo32F(d))])
 13097  	for {
 13098  		_ = v.Args[1]
 13099  		v_0 := v.Args[0]
 13100  		if v_0.Op != OpConst32F {
 13101  			break
 13102  		}
 13103  		c := v_0.AuxInt
 13104  		v_1 := v.Args[1]
 13105  		if v_1.Op != OpConst32F {
 13106  			break
 13107  		}
 13108  		d := v_1.AuxInt
 13109  		v.reset(OpConstBool)
 13110  		v.AuxInt = b2i(auxTo32F(c) < auxTo32F(d))
 13111  		return true
 13112  	}
 13113  	return false
 13114  }
 13115  func rewriteValuegeneric_OpLess32U_0(v *Value) bool {
 13116  	// match: (Less32U (Const32 [c]) (Const32 [d]))
 13117  	// cond:
 13118  	// result: (ConstBool [b2i(uint32(c) < uint32(d))])
 13119  	for {
 13120  		_ = v.Args[1]
 13121  		v_0 := v.Args[0]
 13122  		if v_0.Op != OpConst32 {
 13123  			break
 13124  		}
 13125  		c := v_0.AuxInt
 13126  		v_1 := v.Args[1]
 13127  		if v_1.Op != OpConst32 {
 13128  			break
 13129  		}
 13130  		d := v_1.AuxInt
 13131  		v.reset(OpConstBool)
 13132  		v.AuxInt = b2i(uint32(c) < uint32(d))
 13133  		return true
 13134  	}
 13135  	return false
 13136  }
 13137  func rewriteValuegeneric_OpLess64_0(v *Value) bool {
 13138  	// match: (Less64 (Const64 [c]) (Const64 [d]))
 13139  	// cond:
 13140  	// result: (ConstBool [b2i(c < d)])
 13141  	for {
 13142  		_ = v.Args[1]
 13143  		v_0 := v.Args[0]
 13144  		if v_0.Op != OpConst64 {
 13145  			break
 13146  		}
 13147  		c := v_0.AuxInt
 13148  		v_1 := v.Args[1]
 13149  		if v_1.Op != OpConst64 {
 13150  			break
 13151  		}
 13152  		d := v_1.AuxInt
 13153  		v.reset(OpConstBool)
 13154  		v.AuxInt = b2i(c < d)
 13155  		return true
 13156  	}
 13157  	return false
 13158  }
 13159  func rewriteValuegeneric_OpLess64F_0(v *Value) bool {
 13160  	// match: (Less64F (Const64F [c]) (Const64F [d]))
 13161  	// cond:
 13162  	// result: (ConstBool [b2i(auxTo64F(c) < auxTo64F(d))])
 13163  	for {
 13164  		_ = v.Args[1]
 13165  		v_0 := v.Args[0]
 13166  		if v_0.Op != OpConst64F {
 13167  			break
 13168  		}
 13169  		c := v_0.AuxInt
 13170  		v_1 := v.Args[1]
 13171  		if v_1.Op != OpConst64F {
 13172  			break
 13173  		}
 13174  		d := v_1.AuxInt
 13175  		v.reset(OpConstBool)
 13176  		v.AuxInt = b2i(auxTo64F(c) < auxTo64F(d))
 13177  		return true
 13178  	}
 13179  	return false
 13180  }
 13181  func rewriteValuegeneric_OpLess64U_0(v *Value) bool {
 13182  	// match: (Less64U (Const64 [c]) (Const64 [d]))
 13183  	// cond:
 13184  	// result: (ConstBool [b2i(uint64(c) < uint64(d))])
 13185  	for {
 13186  		_ = v.Args[1]
 13187  		v_0 := v.Args[0]
 13188  		if v_0.Op != OpConst64 {
 13189  			break
 13190  		}
 13191  		c := v_0.AuxInt
 13192  		v_1 := v.Args[1]
 13193  		if v_1.Op != OpConst64 {
 13194  			break
 13195  		}
 13196  		d := v_1.AuxInt
 13197  		v.reset(OpConstBool)
 13198  		v.AuxInt = b2i(uint64(c) < uint64(d))
 13199  		return true
 13200  	}
 13201  	return false
 13202  }
 13203  func rewriteValuegeneric_OpLess8_0(v *Value) bool {
 13204  	// match: (Less8 (Const8 [c]) (Const8 [d]))
 13205  	// cond:
 13206  	// result: (ConstBool [b2i(c < d)])
 13207  	for {
 13208  		_ = v.Args[1]
 13209  		v_0 := v.Args[0]
 13210  		if v_0.Op != OpConst8 {
 13211  			break
 13212  		}
 13213  		c := v_0.AuxInt
 13214  		v_1 := v.Args[1]
 13215  		if v_1.Op != OpConst8 {
 13216  			break
 13217  		}
 13218  		d := v_1.AuxInt
 13219  		v.reset(OpConstBool)
 13220  		v.AuxInt = b2i(c < d)
 13221  		return true
 13222  	}
 13223  	return false
 13224  }
 13225  func rewriteValuegeneric_OpLess8U_0(v *Value) bool {
 13226  	// match: (Less8U (Const8 [c]) (Const8 [d]))
 13227  	// cond:
 13228  	// result: (ConstBool [b2i(uint8(c) < uint8(d))])
 13229  	for {
 13230  		_ = v.Args[1]
 13231  		v_0 := v.Args[0]
 13232  		if v_0.Op != OpConst8 {
 13233  			break
 13234  		}
 13235  		c := v_0.AuxInt
 13236  		v_1 := v.Args[1]
 13237  		if v_1.Op != OpConst8 {
 13238  			break
 13239  		}
 13240  		d := v_1.AuxInt
 13241  		v.reset(OpConstBool)
 13242  		v.AuxInt = b2i(uint8(c) < uint8(d))
 13243  		return true
 13244  	}
 13245  	return false
 13246  }
 13247  func rewriteValuegeneric_OpLoad_0(v *Value) bool {
 13248  	b := v.Block
 13249  	_ = b
 13250  	fe := b.Func.fe
 13251  	_ = fe
 13252  	// match: (Load <t1> p1 (Store {t2} p2 x _))
 13253  	// cond: isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2)
 13254  	// result: x
 13255  	for {
 13256  		t1 := v.Type
 13257  		_ = v.Args[1]
 13258  		p1 := v.Args[0]
 13259  		v_1 := v.Args[1]
 13260  		if v_1.Op != OpStore {
 13261  			break
 13262  		}
 13263  		t2 := v_1.Aux
 13264  		_ = v_1.Args[2]
 13265  		p2 := v_1.Args[0]
 13266  		x := v_1.Args[1]
 13267  		if !(isSamePtr(p1, p2) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2)) {
 13268  			break
 13269  		}
 13270  		v.reset(OpCopy)
 13271  		v.Type = x.Type
 13272  		v.AddArg(x)
 13273  		return true
 13274  	}
 13275  	// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 x _)))
 13276  	// cond: isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2))
 13277  	// result: x
 13278  	for {
 13279  		t1 := v.Type
 13280  		_ = v.Args[1]
 13281  		p1 := v.Args[0]
 13282  		v_1 := v.Args[1]
 13283  		if v_1.Op != OpStore {
 13284  			break
 13285  		}
 13286  		t2 := v_1.Aux
 13287  		_ = v_1.Args[2]
 13288  		p2 := v_1.Args[0]
 13289  		v_1_2 := v_1.Args[2]
 13290  		if v_1_2.Op != OpStore {
 13291  			break
 13292  		}
 13293  		t3 := v_1_2.Aux
 13294  		_ = v_1_2.Args[2]
 13295  		p3 := v_1_2.Args[0]
 13296  		x := v_1_2.Args[1]
 13297  		if !(isSamePtr(p1, p3) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p3, sizeof(t3), p2, sizeof(t2))) {
 13298  			break
 13299  		}
 13300  		v.reset(OpCopy)
 13301  		v.Type = x.Type
 13302  		v.AddArg(x)
 13303  		return true
 13304  	}
 13305  	// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 x _))))
 13306  	// cond: isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3))
 13307  	// result: x
 13308  	for {
 13309  		t1 := v.Type
 13310  		_ = v.Args[1]
 13311  		p1 := v.Args[0]
 13312  		v_1 := v.Args[1]
 13313  		if v_1.Op != OpStore {
 13314  			break
 13315  		}
 13316  		t2 := v_1.Aux
 13317  		_ = v_1.Args[2]
 13318  		p2 := v_1.Args[0]
 13319  		v_1_2 := v_1.Args[2]
 13320  		if v_1_2.Op != OpStore {
 13321  			break
 13322  		}
 13323  		t3 := v_1_2.Aux
 13324  		_ = v_1_2.Args[2]
 13325  		p3 := v_1_2.Args[0]
 13326  		v_1_2_2 := v_1_2.Args[2]
 13327  		if v_1_2_2.Op != OpStore {
 13328  			break
 13329  		}
 13330  		t4 := v_1_2_2.Aux
 13331  		_ = v_1_2_2.Args[2]
 13332  		p4 := v_1_2_2.Args[0]
 13333  		x := v_1_2_2.Args[1]
 13334  		if !(isSamePtr(p1, p4) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p4, sizeof(t4), p2, sizeof(t2)) && disjoint(p4, sizeof(t4), p3, sizeof(t3))) {
 13335  			break
 13336  		}
 13337  		v.reset(OpCopy)
 13338  		v.Type = x.Type
 13339  		v.AddArg(x)
 13340  		return true
 13341  	}
 13342  	// match: (Load <t1> p1 (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 x _)))))
 13343  	// cond: isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4))
 13344  	// result: x
 13345  	for {
 13346  		t1 := v.Type
 13347  		_ = v.Args[1]
 13348  		p1 := v.Args[0]
 13349  		v_1 := v.Args[1]
 13350  		if v_1.Op != OpStore {
 13351  			break
 13352  		}
 13353  		t2 := v_1.Aux
 13354  		_ = v_1.Args[2]
 13355  		p2 := v_1.Args[0]
 13356  		v_1_2 := v_1.Args[2]
 13357  		if v_1_2.Op != OpStore {
 13358  			break
 13359  		}
 13360  		t3 := v_1_2.Aux
 13361  		_ = v_1_2.Args[2]
 13362  		p3 := v_1_2.Args[0]
 13363  		v_1_2_2 := v_1_2.Args[2]
 13364  		if v_1_2_2.Op != OpStore {
 13365  			break
 13366  		}
 13367  		t4 := v_1_2_2.Aux
 13368  		_ = v_1_2_2.Args[2]
 13369  		p4 := v_1_2_2.Args[0]
 13370  		v_1_2_2_2 := v_1_2_2.Args[2]
 13371  		if v_1_2_2_2.Op != OpStore {
 13372  			break
 13373  		}
 13374  		t5 := v_1_2_2_2.Aux
 13375  		_ = v_1_2_2_2.Args[2]
 13376  		p5 := v_1_2_2_2.Args[0]
 13377  		x := v_1_2_2_2.Args[1]
 13378  		if !(isSamePtr(p1, p5) && t1.Compare(x.Type) == types.CMPeq && t1.Size() == sizeof(t2) && disjoint(p5, sizeof(t5), p2, sizeof(t2)) && disjoint(p5, sizeof(t5), p3, sizeof(t3)) && disjoint(p5, sizeof(t5), p4, sizeof(t4))) {
 13379  			break
 13380  		}
 13381  		v.reset(OpCopy)
 13382  		v.Type = x.Type
 13383  		v.AddArg(x)
 13384  		return true
 13385  	}
 13386  	// match: (Load <t1> p1 (Store {t2} p2 (Const64 [x]) _))
 13387  	// cond: isSamePtr(p1,p2) && sizeof(t2) == 8 && is64BitFloat(t1)
 13388  	// result: (Const64F [x])
 13389  	for {
 13390  		t1 := v.Type
 13391  		_ = v.Args[1]
 13392  		p1 := v.Args[0]
 13393  		v_1 := v.Args[1]
 13394  		if v_1.Op != OpStore {
 13395  			break
 13396  		}
 13397  		t2 := v_1.Aux
 13398  		_ = v_1.Args[2]
 13399  		p2 := v_1.Args[0]
 13400  		v_1_1 := v_1.Args[1]
 13401  		if v_1_1.Op != OpConst64 {
 13402  			break
 13403  		}
 13404  		x := v_1_1.AuxInt
 13405  		if !(isSamePtr(p1, p2) && sizeof(t2) == 8 && is64BitFloat(t1)) {
 13406  			break
 13407  		}
 13408  		v.reset(OpConst64F)
 13409  		v.AuxInt = x
 13410  		return true
 13411  	}
 13412  	// match: (Load <t1> p1 (Store {t2} p2 (Const32 [x]) _))
 13413  	// cond: isSamePtr(p1,p2) && sizeof(t2) == 4 && is32BitFloat(t1)
 13414  	// result: (Const32F [auxFrom32F(math.Float32frombits(uint32(x)))])
 13415  	for {
 13416  		t1 := v.Type
 13417  		_ = v.Args[1]
 13418  		p1 := v.Args[0]
 13419  		v_1 := v.Args[1]
 13420  		if v_1.Op != OpStore {
 13421  			break
 13422  		}
 13423  		t2 := v_1.Aux
 13424  		_ = v_1.Args[2]
 13425  		p2 := v_1.Args[0]
 13426  		v_1_1 := v_1.Args[1]
 13427  		if v_1_1.Op != OpConst32 {
 13428  			break
 13429  		}
 13430  		x := v_1_1.AuxInt
 13431  		if !(isSamePtr(p1, p2) && sizeof(t2) == 4 && is32BitFloat(t1)) {
 13432  			break
 13433  		}
 13434  		v.reset(OpConst32F)
 13435  		v.AuxInt = auxFrom32F(math.Float32frombits(uint32(x)))
 13436  		return true
 13437  	}
 13438  	// match: (Load <t1> p1 (Store {t2} p2 (Const64F [x]) _))
 13439  	// cond: isSamePtr(p1,p2) && sizeof(t2) == 8 && is64BitInt(t1)
 13440  	// result: (Const64 [x])
 13441  	for {
 13442  		t1 := v.Type
 13443  		_ = v.Args[1]
 13444  		p1 := v.Args[0]
 13445  		v_1 := v.Args[1]
 13446  		if v_1.Op != OpStore {
 13447  			break
 13448  		}
 13449  		t2 := v_1.Aux
 13450  		_ = v_1.Args[2]
 13451  		p2 := v_1.Args[0]
 13452  		v_1_1 := v_1.Args[1]
 13453  		if v_1_1.Op != OpConst64F {
 13454  			break
 13455  		}
 13456  		x := v_1_1.AuxInt
 13457  		if !(isSamePtr(p1, p2) && sizeof(t2) == 8 && is64BitInt(t1)) {
 13458  			break
 13459  		}
 13460  		v.reset(OpConst64)
 13461  		v.AuxInt = x
 13462  		return true
 13463  	}
 13464  	// match: (Load <t1> p1 (Store {t2} p2 (Const32F [x]) _))
 13465  	// cond: isSamePtr(p1,p2) && sizeof(t2) == 4 && is32BitInt(t1)
 13466  	// result: (Const32 [int64(int32(math.Float32bits(auxTo32F(x))))])
 13467  	for {
 13468  		t1 := v.Type
 13469  		_ = v.Args[1]
 13470  		p1 := v.Args[0]
 13471  		v_1 := v.Args[1]
 13472  		if v_1.Op != OpStore {
 13473  			break
 13474  		}
 13475  		t2 := v_1.Aux
 13476  		_ = v_1.Args[2]
 13477  		p2 := v_1.Args[0]
 13478  		v_1_1 := v_1.Args[1]
 13479  		if v_1_1.Op != OpConst32F {
 13480  			break
 13481  		}
 13482  		x := v_1_1.AuxInt
 13483  		if !(isSamePtr(p1, p2) && sizeof(t2) == 4 && is32BitInt(t1)) {
 13484  			break
 13485  		}
 13486  		v.reset(OpConst32)
 13487  		v.AuxInt = int64(int32(math.Float32bits(auxTo32F(x))))
 13488  		return true
 13489  	}
 13490  	// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ mem:(Zero [n] p3 _)))
 13491  	// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p3) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2))
 13492  	// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p3) mem)
 13493  	for {
 13494  		t1 := v.Type
 13495  		_ = v.Args[1]
 13496  		op := v.Args[0]
 13497  		if op.Op != OpOffPtr {
 13498  			break
 13499  		}
 13500  		o1 := op.AuxInt
 13501  		p1 := op.Args[0]
 13502  		v_1 := v.Args[1]
 13503  		if v_1.Op != OpStore {
 13504  			break
 13505  		}
 13506  		t2 := v_1.Aux
 13507  		_ = v_1.Args[2]
 13508  		p2 := v_1.Args[0]
 13509  		mem := v_1.Args[2]
 13510  		if mem.Op != OpZero {
 13511  			break
 13512  		}
 13513  		n := mem.AuxInt
 13514  		_ = mem.Args[1]
 13515  		p3 := mem.Args[0]
 13516  		if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p3) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2))) {
 13517  			break
 13518  		}
 13519  		b = mem.Block
 13520  		v0 := b.NewValue0(v.Pos, OpLoad, t1)
 13521  		v.reset(OpCopy)
 13522  		v.AddArg(v0)
 13523  		v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 13524  		v1.AuxInt = o1
 13525  		v1.AddArg(p3)
 13526  		v0.AddArg(v1)
 13527  		v0.AddArg(mem)
 13528  		return true
 13529  	}
 13530  	// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ mem:(Zero [n] p4 _))))
 13531  	// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p4) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3))
 13532  	// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p4) mem)
 13533  	for {
 13534  		t1 := v.Type
 13535  		_ = v.Args[1]
 13536  		op := v.Args[0]
 13537  		if op.Op != OpOffPtr {
 13538  			break
 13539  		}
 13540  		o1 := op.AuxInt
 13541  		p1 := op.Args[0]
 13542  		v_1 := v.Args[1]
 13543  		if v_1.Op != OpStore {
 13544  			break
 13545  		}
 13546  		t2 := v_1.Aux
 13547  		_ = v_1.Args[2]
 13548  		p2 := v_1.Args[0]
 13549  		v_1_2 := v_1.Args[2]
 13550  		if v_1_2.Op != OpStore {
 13551  			break
 13552  		}
 13553  		t3 := v_1_2.Aux
 13554  		_ = v_1_2.Args[2]
 13555  		p3 := v_1_2.Args[0]
 13556  		mem := v_1_2.Args[2]
 13557  		if mem.Op != OpZero {
 13558  			break
 13559  		}
 13560  		n := mem.AuxInt
 13561  		_ = mem.Args[1]
 13562  		p4 := mem.Args[0]
 13563  		if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p4) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3))) {
 13564  			break
 13565  		}
 13566  		b = mem.Block
 13567  		v0 := b.NewValue0(v.Pos, OpLoad, t1)
 13568  		v.reset(OpCopy)
 13569  		v.AddArg(v0)
 13570  		v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 13571  		v1.AuxInt = o1
 13572  		v1.AddArg(p4)
 13573  		v0.AddArg(v1)
 13574  		v0.AddArg(mem)
 13575  		return true
 13576  	}
 13577  	return false
 13578  }
 13579  func rewriteValuegeneric_OpLoad_10(v *Value) bool {
 13580  	b := v.Block
 13581  	_ = b
 13582  	fe := b.Func.fe
 13583  	_ = fe
 13584  	// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ mem:(Zero [n] p5 _)))))
 13585  	// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4))
 13586  	// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p5) mem)
 13587  	for {
 13588  		t1 := v.Type
 13589  		_ = v.Args[1]
 13590  		op := v.Args[0]
 13591  		if op.Op != OpOffPtr {
 13592  			break
 13593  		}
 13594  		o1 := op.AuxInt
 13595  		p1 := op.Args[0]
 13596  		v_1 := v.Args[1]
 13597  		if v_1.Op != OpStore {
 13598  			break
 13599  		}
 13600  		t2 := v_1.Aux
 13601  		_ = v_1.Args[2]
 13602  		p2 := v_1.Args[0]
 13603  		v_1_2 := v_1.Args[2]
 13604  		if v_1_2.Op != OpStore {
 13605  			break
 13606  		}
 13607  		t3 := v_1_2.Aux
 13608  		_ = v_1_2.Args[2]
 13609  		p3 := v_1_2.Args[0]
 13610  		v_1_2_2 := v_1_2.Args[2]
 13611  		if v_1_2_2.Op != OpStore {
 13612  			break
 13613  		}
 13614  		t4 := v_1_2_2.Aux
 13615  		_ = v_1_2_2.Args[2]
 13616  		p4 := v_1_2_2.Args[0]
 13617  		mem := v_1_2_2.Args[2]
 13618  		if mem.Op != OpZero {
 13619  			break
 13620  		}
 13621  		n := mem.AuxInt
 13622  		_ = mem.Args[1]
 13623  		p5 := mem.Args[0]
 13624  		if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4))) {
 13625  			break
 13626  		}
 13627  		b = mem.Block
 13628  		v0 := b.NewValue0(v.Pos, OpLoad, t1)
 13629  		v.reset(OpCopy)
 13630  		v.AddArg(v0)
 13631  		v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 13632  		v1.AuxInt = o1
 13633  		v1.AddArg(p5)
 13634  		v0.AddArg(v1)
 13635  		v0.AddArg(mem)
 13636  		return true
 13637  	}
 13638  	// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ mem:(Zero [n] p6 _))))))
 13639  	// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p6) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) && disjoint(op, t1.Size(), p5, sizeof(t5))
 13640  	// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p6) mem)
 13641  	for {
 13642  		t1 := v.Type
 13643  		_ = v.Args[1]
 13644  		op := v.Args[0]
 13645  		if op.Op != OpOffPtr {
 13646  			break
 13647  		}
 13648  		o1 := op.AuxInt
 13649  		p1 := op.Args[0]
 13650  		v_1 := v.Args[1]
 13651  		if v_1.Op != OpStore {
 13652  			break
 13653  		}
 13654  		t2 := v_1.Aux
 13655  		_ = v_1.Args[2]
 13656  		p2 := v_1.Args[0]
 13657  		v_1_2 := v_1.Args[2]
 13658  		if v_1_2.Op != OpStore {
 13659  			break
 13660  		}
 13661  		t3 := v_1_2.Aux
 13662  		_ = v_1_2.Args[2]
 13663  		p3 := v_1_2.Args[0]
 13664  		v_1_2_2 := v_1_2.Args[2]
 13665  		if v_1_2_2.Op != OpStore {
 13666  			break
 13667  		}
 13668  		t4 := v_1_2_2.Aux
 13669  		_ = v_1_2_2.Args[2]
 13670  		p4 := v_1_2_2.Args[0]
 13671  		v_1_2_2_2 := v_1_2_2.Args[2]
 13672  		if v_1_2_2_2.Op != OpStore {
 13673  			break
 13674  		}
 13675  		t5 := v_1_2_2_2.Aux
 13676  		_ = v_1_2_2_2.Args[2]
 13677  		p5 := v_1_2_2_2.Args[0]
 13678  		mem := v_1_2_2_2.Args[2]
 13679  		if mem.Op != OpZero {
 13680  			break
 13681  		}
 13682  		n := mem.AuxInt
 13683  		_ = mem.Args[1]
 13684  		p6 := mem.Args[0]
 13685  		if !(o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p6) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4)) && disjoint(op, t1.Size(), p5, sizeof(t5))) {
 13686  			break
 13687  		}
 13688  		b = mem.Block
 13689  		v0 := b.NewValue0(v.Pos, OpLoad, t1)
 13690  		v.reset(OpCopy)
 13691  		v.AddArg(v0)
 13692  		v1 := b.NewValue0(v.Pos, OpOffPtr, op.Type)
 13693  		v1.AuxInt = o1
 13694  		v1.AddArg(p6)
 13695  		v0.AddArg(v1)
 13696  		v0.AddArg(mem)
 13697  		return true
 13698  	}
 13699  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13700  	// cond: t1.IsBoolean() && isSamePtr(p1, p2) && n >= o + 1
 13701  	// result: (ConstBool [0])
 13702  	for {
 13703  		t1 := v.Type
 13704  		_ = v.Args[1]
 13705  		v_0 := v.Args[0]
 13706  		if v_0.Op != OpOffPtr {
 13707  			break
 13708  		}
 13709  		o := v_0.AuxInt
 13710  		p1 := v_0.Args[0]
 13711  		v_1 := v.Args[1]
 13712  		if v_1.Op != OpZero {
 13713  			break
 13714  		}
 13715  		n := v_1.AuxInt
 13716  		_ = v_1.Args[1]
 13717  		p2 := v_1.Args[0]
 13718  		if !(t1.IsBoolean() && isSamePtr(p1, p2) && n >= o+1) {
 13719  			break
 13720  		}
 13721  		v.reset(OpConstBool)
 13722  		v.AuxInt = 0
 13723  		return true
 13724  	}
 13725  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13726  	// cond: is8BitInt(t1) && isSamePtr(p1, p2) && n >= o + 1
 13727  	// result: (Const8 [0])
 13728  	for {
 13729  		t1 := v.Type
 13730  		_ = v.Args[1]
 13731  		v_0 := v.Args[0]
 13732  		if v_0.Op != OpOffPtr {
 13733  			break
 13734  		}
 13735  		o := v_0.AuxInt
 13736  		p1 := v_0.Args[0]
 13737  		v_1 := v.Args[1]
 13738  		if v_1.Op != OpZero {
 13739  			break
 13740  		}
 13741  		n := v_1.AuxInt
 13742  		_ = v_1.Args[1]
 13743  		p2 := v_1.Args[0]
 13744  		if !(is8BitInt(t1) && isSamePtr(p1, p2) && n >= o+1) {
 13745  			break
 13746  		}
 13747  		v.reset(OpConst8)
 13748  		v.AuxInt = 0
 13749  		return true
 13750  	}
 13751  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13752  	// cond: is16BitInt(t1) && isSamePtr(p1, p2) && n >= o + 2
 13753  	// result: (Const16 [0])
 13754  	for {
 13755  		t1 := v.Type
 13756  		_ = v.Args[1]
 13757  		v_0 := v.Args[0]
 13758  		if v_0.Op != OpOffPtr {
 13759  			break
 13760  		}
 13761  		o := v_0.AuxInt
 13762  		p1 := v_0.Args[0]
 13763  		v_1 := v.Args[1]
 13764  		if v_1.Op != OpZero {
 13765  			break
 13766  		}
 13767  		n := v_1.AuxInt
 13768  		_ = v_1.Args[1]
 13769  		p2 := v_1.Args[0]
 13770  		if !(is16BitInt(t1) && isSamePtr(p1, p2) && n >= o+2) {
 13771  			break
 13772  		}
 13773  		v.reset(OpConst16)
 13774  		v.AuxInt = 0
 13775  		return true
 13776  	}
 13777  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13778  	// cond: is32BitInt(t1) && isSamePtr(p1, p2) && n >= o + 4
 13779  	// result: (Const32 [0])
 13780  	for {
 13781  		t1 := v.Type
 13782  		_ = v.Args[1]
 13783  		v_0 := v.Args[0]
 13784  		if v_0.Op != OpOffPtr {
 13785  			break
 13786  		}
 13787  		o := v_0.AuxInt
 13788  		p1 := v_0.Args[0]
 13789  		v_1 := v.Args[1]
 13790  		if v_1.Op != OpZero {
 13791  			break
 13792  		}
 13793  		n := v_1.AuxInt
 13794  		_ = v_1.Args[1]
 13795  		p2 := v_1.Args[0]
 13796  		if !(is32BitInt(t1) && isSamePtr(p1, p2) && n >= o+4) {
 13797  			break
 13798  		}
 13799  		v.reset(OpConst32)
 13800  		v.AuxInt = 0
 13801  		return true
 13802  	}
 13803  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13804  	// cond: is64BitInt(t1) && isSamePtr(p1, p2) && n >= o + 8
 13805  	// result: (Const64 [0])
 13806  	for {
 13807  		t1 := v.Type
 13808  		_ = v.Args[1]
 13809  		v_0 := v.Args[0]
 13810  		if v_0.Op != OpOffPtr {
 13811  			break
 13812  		}
 13813  		o := v_0.AuxInt
 13814  		p1 := v_0.Args[0]
 13815  		v_1 := v.Args[1]
 13816  		if v_1.Op != OpZero {
 13817  			break
 13818  		}
 13819  		n := v_1.AuxInt
 13820  		_ = v_1.Args[1]
 13821  		p2 := v_1.Args[0]
 13822  		if !(is64BitInt(t1) && isSamePtr(p1, p2) && n >= o+8) {
 13823  			break
 13824  		}
 13825  		v.reset(OpConst64)
 13826  		v.AuxInt = 0
 13827  		return true
 13828  	}
 13829  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13830  	// cond: is32BitFloat(t1) && isSamePtr(p1, p2) && n >= o + 4
 13831  	// result: (Const32F [0])
 13832  	for {
 13833  		t1 := v.Type
 13834  		_ = v.Args[1]
 13835  		v_0 := v.Args[0]
 13836  		if v_0.Op != OpOffPtr {
 13837  			break
 13838  		}
 13839  		o := v_0.AuxInt
 13840  		p1 := v_0.Args[0]
 13841  		v_1 := v.Args[1]
 13842  		if v_1.Op != OpZero {
 13843  			break
 13844  		}
 13845  		n := v_1.AuxInt
 13846  		_ = v_1.Args[1]
 13847  		p2 := v_1.Args[0]
 13848  		if !(is32BitFloat(t1) && isSamePtr(p1, p2) && n >= o+4) {
 13849  			break
 13850  		}
 13851  		v.reset(OpConst32F)
 13852  		v.AuxInt = 0
 13853  		return true
 13854  	}
 13855  	// match: (Load <t1> (OffPtr [o] p1) (Zero [n] p2 _))
 13856  	// cond: is64BitFloat(t1) && isSamePtr(p1, p2) && n >= o + 8
 13857  	// result: (Const64F [0])
 13858  	for {
 13859  		t1 := v.Type
 13860  		_ = v.Args[1]
 13861  		v_0 := v.Args[0]
 13862  		if v_0.Op != OpOffPtr {
 13863  			break
 13864  		}
 13865  		o := v_0.AuxInt
 13866  		p1 := v_0.Args[0]
 13867  		v_1 := v.Args[1]
 13868  		if v_1.Op != OpZero {
 13869  			break
 13870  		}
 13871  		n := v_1.AuxInt
 13872  		_ = v_1.Args[1]
 13873  		p2 := v_1.Args[0]
 13874  		if !(is64BitFloat(t1) && isSamePtr(p1, p2) && n >= o+8) {
 13875  			break
 13876  		}
 13877  		v.reset(OpConst64F)
 13878  		v.AuxInt = 0
 13879  		return true
 13880  	}
 13881  	// match: (Load <t> _ _)
 13882  	// cond: t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)
 13883  	// result: (StructMake0)
 13884  	for {
 13885  		t := v.Type
 13886  		_ = v.Args[1]
 13887  		if !(t.IsStruct() && t.NumFields() == 0 && fe.CanSSA(t)) {
 13888  			break
 13889  		}
 13890  		v.reset(OpStructMake0)
 13891  		return true
 13892  	}
 13893  	return false
 13894  }
 13895  func rewriteValuegeneric_OpLoad_20(v *Value) bool {
 13896  	b := v.Block
 13897  	_ = b
 13898  	fe := b.Func.fe
 13899  	_ = fe
 13900  	// match: (Load <t> ptr mem)
 13901  	// cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)
 13902  	// result: (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem))
 13903  	for {
 13904  		t := v.Type
 13905  		_ = v.Args[1]
 13906  		ptr := v.Args[0]
 13907  		mem := v.Args[1]
 13908  		if !(t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)) {
 13909  			break
 13910  		}
 13911  		v.reset(OpStructMake1)
 13912  		v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 13913  		v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 13914  		v1.AuxInt = 0
 13915  		v1.AddArg(ptr)
 13916  		v0.AddArg(v1)
 13917  		v0.AddArg(mem)
 13918  		v.AddArg(v0)
 13919  		return true
 13920  	}
 13921  	// match: (Load <t> ptr mem)
 13922  	// cond: t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)
 13923  	// result: (StructMake2 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem))
 13924  	for {
 13925  		t := v.Type
 13926  		_ = v.Args[1]
 13927  		ptr := v.Args[0]
 13928  		mem := v.Args[1]
 13929  		if !(t.IsStruct() && t.NumFields() == 2 && fe.CanSSA(t)) {
 13930  			break
 13931  		}
 13932  		v.reset(OpStructMake2)
 13933  		v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 13934  		v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 13935  		v1.AuxInt = 0
 13936  		v1.AddArg(ptr)
 13937  		v0.AddArg(v1)
 13938  		v0.AddArg(mem)
 13939  		v.AddArg(v0)
 13940  		v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1))
 13941  		v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 13942  		v3.AuxInt = t.FieldOff(1)
 13943  		v3.AddArg(ptr)
 13944  		v2.AddArg(v3)
 13945  		v2.AddArg(mem)
 13946  		v.AddArg(v2)
 13947  		return true
 13948  	}
 13949  	// match: (Load <t> ptr mem)
 13950  	// cond: t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)
 13951  	// result: (StructMake3 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem))
 13952  	for {
 13953  		t := v.Type
 13954  		_ = v.Args[1]
 13955  		ptr := v.Args[0]
 13956  		mem := v.Args[1]
 13957  		if !(t.IsStruct() && t.NumFields() == 3 && fe.CanSSA(t)) {
 13958  			break
 13959  		}
 13960  		v.reset(OpStructMake3)
 13961  		v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 13962  		v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 13963  		v1.AuxInt = 0
 13964  		v1.AddArg(ptr)
 13965  		v0.AddArg(v1)
 13966  		v0.AddArg(mem)
 13967  		v.AddArg(v0)
 13968  		v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1))
 13969  		v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 13970  		v3.AuxInt = t.FieldOff(1)
 13971  		v3.AddArg(ptr)
 13972  		v2.AddArg(v3)
 13973  		v2.AddArg(mem)
 13974  		v.AddArg(v2)
 13975  		v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2))
 13976  		v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 13977  		v5.AuxInt = t.FieldOff(2)
 13978  		v5.AddArg(ptr)
 13979  		v4.AddArg(v5)
 13980  		v4.AddArg(mem)
 13981  		v.AddArg(v4)
 13982  		return true
 13983  	}
 13984  	// match: (Load <t> ptr mem)
 13985  	// cond: t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)
 13986  	// result: (StructMake4 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem))
 13987  	for {
 13988  		t := v.Type
 13989  		_ = v.Args[1]
 13990  		ptr := v.Args[0]
 13991  		mem := v.Args[1]
 13992  		if !(t.IsStruct() && t.NumFields() == 4 && fe.CanSSA(t)) {
 13993  			break
 13994  		}
 13995  		v.reset(OpStructMake4)
 13996  		v0 := b.NewValue0(v.Pos, OpLoad, t.FieldType(0))
 13997  		v1 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 13998  		v1.AuxInt = 0
 13999  		v1.AddArg(ptr)
 14000  		v0.AddArg(v1)
 14001  		v0.AddArg(mem)
 14002  		v.AddArg(v0)
 14003  		v2 := b.NewValue0(v.Pos, OpLoad, t.FieldType(1))
 14004  		v3 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 14005  		v3.AuxInt = t.FieldOff(1)
 14006  		v3.AddArg(ptr)
 14007  		v2.AddArg(v3)
 14008  		v2.AddArg(mem)
 14009  		v.AddArg(v2)
 14010  		v4 := b.NewValue0(v.Pos, OpLoad, t.FieldType(2))
 14011  		v5 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 14012  		v5.AuxInt = t.FieldOff(2)
 14013  		v5.AddArg(ptr)
 14014  		v4.AddArg(v5)
 14015  		v4.AddArg(mem)
 14016  		v.AddArg(v4)
 14017  		v6 := b.NewValue0(v.Pos, OpLoad, t.FieldType(3))
 14018  		v7 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo())
 14019  		v7.AuxInt = t.FieldOff(3)
 14020  		v7.AddArg(ptr)
 14021  		v6.AddArg(v7)
 14022  		v6.AddArg(mem)
 14023  		v.AddArg(v6)
 14024  		return true
 14025  	}
 14026  	// match: (Load <t> _ _)
 14027  	// cond: t.IsArray() && t.NumElem() == 0
 14028  	// result: (ArrayMake0)
 14029  	for {
 14030  		t := v.Type
 14031  		_ = v.Args[1]
 14032  		if !(t.IsArray() && t.NumElem() == 0) {
 14033  			break
 14034  		}
 14035  		v.reset(OpArrayMake0)
 14036  		return true
 14037  	}
 14038  	// match: (Load <t> ptr mem)
 14039  	// cond: t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)
 14040  	// result: (ArrayMake1 (Load <t.Elem()> ptr mem))
 14041  	for {
 14042  		t := v.Type
 14043  		_ = v.Args[1]
 14044  		ptr := v.Args[0]
 14045  		mem := v.Args[1]
 14046  		if !(t.IsArray() && t.NumElem() == 1 && fe.CanSSA(t)) {
 14047  			break
 14048  		}
 14049  		v.reset(OpArrayMake1)
 14050  		v0 := b.NewValue0(v.Pos, OpLoad, t.Elem())
 14051  		v0.AddArg(ptr)
 14052  		v0.AddArg(mem)
 14053  		v.AddArg(v0)
 14054  		return true
 14055  	}
 14056  	return false
 14057  }
 14058  func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool {
 14059  	b := v.Block
 14060  	_ = b
 14061  	// match: (Lsh16x16 <t> x (Const16 [c]))
 14062  	// cond:
 14063  	// result: (Lsh16x64 x (Const64 <t> [int64(uint16(c))]))
 14064  	for {
 14065  		t := v.Type
 14066  		_ = v.Args[1]
 14067  		x := v.Args[0]
 14068  		v_1 := v.Args[1]
 14069  		if v_1.Op != OpConst16 {
 14070  			break
 14071  		}
 14072  		c := v_1.AuxInt
 14073  		v.reset(OpLsh16x64)
 14074  		v.AddArg(x)
 14075  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14076  		v0.AuxInt = int64(uint16(c))
 14077  		v.AddArg(v0)
 14078  		return true
 14079  	}
 14080  	// match: (Lsh16x16 (Const16 [0]) _)
 14081  	// cond:
 14082  	// result: (Const16 [0])
 14083  	for {
 14084  		_ = v.Args[1]
 14085  		v_0 := v.Args[0]
 14086  		if v_0.Op != OpConst16 {
 14087  			break
 14088  		}
 14089  		if v_0.AuxInt != 0 {
 14090  			break
 14091  		}
 14092  		v.reset(OpConst16)
 14093  		v.AuxInt = 0
 14094  		return true
 14095  	}
 14096  	return false
 14097  }
 14098  func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool {
 14099  	b := v.Block
 14100  	_ = b
 14101  	// match: (Lsh16x32 <t> x (Const32 [c]))
 14102  	// cond:
 14103  	// result: (Lsh16x64 x (Const64 <t> [int64(uint32(c))]))
 14104  	for {
 14105  		t := v.Type
 14106  		_ = v.Args[1]
 14107  		x := v.Args[0]
 14108  		v_1 := v.Args[1]
 14109  		if v_1.Op != OpConst32 {
 14110  			break
 14111  		}
 14112  		c := v_1.AuxInt
 14113  		v.reset(OpLsh16x64)
 14114  		v.AddArg(x)
 14115  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14116  		v0.AuxInt = int64(uint32(c))
 14117  		v.AddArg(v0)
 14118  		return true
 14119  	}
 14120  	// match: (Lsh16x32 (Const16 [0]) _)
 14121  	// cond:
 14122  	// result: (Const16 [0])
 14123  	for {
 14124  		_ = v.Args[1]
 14125  		v_0 := v.Args[0]
 14126  		if v_0.Op != OpConst16 {
 14127  			break
 14128  		}
 14129  		if v_0.AuxInt != 0 {
 14130  			break
 14131  		}
 14132  		v.reset(OpConst16)
 14133  		v.AuxInt = 0
 14134  		return true
 14135  	}
 14136  	return false
 14137  }
 14138  func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool {
 14139  	b := v.Block
 14140  	_ = b
 14141  	typ := &b.Func.Config.Types
 14142  	_ = typ
 14143  	// match: (Lsh16x64 (Const16 [c]) (Const64 [d]))
 14144  	// cond:
 14145  	// result: (Const16 [int64(int16(c) << uint64(d))])
 14146  	for {
 14147  		_ = v.Args[1]
 14148  		v_0 := v.Args[0]
 14149  		if v_0.Op != OpConst16 {
 14150  			break
 14151  		}
 14152  		c := v_0.AuxInt
 14153  		v_1 := v.Args[1]
 14154  		if v_1.Op != OpConst64 {
 14155  			break
 14156  		}
 14157  		d := v_1.AuxInt
 14158  		v.reset(OpConst16)
 14159  		v.AuxInt = int64(int16(c) << uint64(d))
 14160  		return true
 14161  	}
 14162  	// match: (Lsh16x64 x (Const64 [0]))
 14163  	// cond:
 14164  	// result: x
 14165  	for {
 14166  		_ = v.Args[1]
 14167  		x := v.Args[0]
 14168  		v_1 := v.Args[1]
 14169  		if v_1.Op != OpConst64 {
 14170  			break
 14171  		}
 14172  		if v_1.AuxInt != 0 {
 14173  			break
 14174  		}
 14175  		v.reset(OpCopy)
 14176  		v.Type = x.Type
 14177  		v.AddArg(x)
 14178  		return true
 14179  	}
 14180  	// match: (Lsh16x64 (Const16 [0]) _)
 14181  	// cond:
 14182  	// result: (Const16 [0])
 14183  	for {
 14184  		_ = v.Args[1]
 14185  		v_0 := v.Args[0]
 14186  		if v_0.Op != OpConst16 {
 14187  			break
 14188  		}
 14189  		if v_0.AuxInt != 0 {
 14190  			break
 14191  		}
 14192  		v.reset(OpConst16)
 14193  		v.AuxInt = 0
 14194  		return true
 14195  	}
 14196  	// match: (Lsh16x64 _ (Const64 [c]))
 14197  	// cond: uint64(c) >= 16
 14198  	// result: (Const16 [0])
 14199  	for {
 14200  		_ = v.Args[1]
 14201  		v_1 := v.Args[1]
 14202  		if v_1.Op != OpConst64 {
 14203  			break
 14204  		}
 14205  		c := v_1.AuxInt
 14206  		if !(uint64(c) >= 16) {
 14207  			break
 14208  		}
 14209  		v.reset(OpConst16)
 14210  		v.AuxInt = 0
 14211  		return true
 14212  	}
 14213  	// match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d]))
 14214  	// cond: !uaddOvf(c,d)
 14215  	// result: (Lsh16x64 x (Const64 <t> [c+d]))
 14216  	for {
 14217  		t := v.Type
 14218  		_ = v.Args[1]
 14219  		v_0 := v.Args[0]
 14220  		if v_0.Op != OpLsh16x64 {
 14221  			break
 14222  		}
 14223  		_ = v_0.Args[1]
 14224  		x := v_0.Args[0]
 14225  		v_0_1 := v_0.Args[1]
 14226  		if v_0_1.Op != OpConst64 {
 14227  			break
 14228  		}
 14229  		c := v_0_1.AuxInt
 14230  		v_1 := v.Args[1]
 14231  		if v_1.Op != OpConst64 {
 14232  			break
 14233  		}
 14234  		d := v_1.AuxInt
 14235  		if !(!uaddOvf(c, d)) {
 14236  			break
 14237  		}
 14238  		v.reset(OpLsh16x64)
 14239  		v.AddArg(x)
 14240  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14241  		v0.AuxInt = c + d
 14242  		v.AddArg(v0)
 14243  		return true
 14244  	}
 14245  	// match: (Lsh16x64 (Rsh16Ux64 (Lsh16x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 14246  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 14247  	// result: (Lsh16x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 14248  	for {
 14249  		_ = v.Args[1]
 14250  		v_0 := v.Args[0]
 14251  		if v_0.Op != OpRsh16Ux64 {
 14252  			break
 14253  		}
 14254  		_ = v_0.Args[1]
 14255  		v_0_0 := v_0.Args[0]
 14256  		if v_0_0.Op != OpLsh16x64 {
 14257  			break
 14258  		}
 14259  		_ = v_0_0.Args[1]
 14260  		x := v_0_0.Args[0]
 14261  		v_0_0_1 := v_0_0.Args[1]
 14262  		if v_0_0_1.Op != OpConst64 {
 14263  			break
 14264  		}
 14265  		c1 := v_0_0_1.AuxInt
 14266  		v_0_1 := v_0.Args[1]
 14267  		if v_0_1.Op != OpConst64 {
 14268  			break
 14269  		}
 14270  		c2 := v_0_1.AuxInt
 14271  		v_1 := v.Args[1]
 14272  		if v_1.Op != OpConst64 {
 14273  			break
 14274  		}
 14275  		c3 := v_1.AuxInt
 14276  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 14277  			break
 14278  		}
 14279  		v.reset(OpLsh16x64)
 14280  		v.AddArg(x)
 14281  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 14282  		v0.AuxInt = c1 - c2 + c3
 14283  		v.AddArg(v0)
 14284  		return true
 14285  	}
 14286  	return false
 14287  }
 14288  func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool {
 14289  	b := v.Block
 14290  	_ = b
 14291  	// match: (Lsh16x8 <t> x (Const8 [c]))
 14292  	// cond:
 14293  	// result: (Lsh16x64 x (Const64 <t> [int64(uint8(c))]))
 14294  	for {
 14295  		t := v.Type
 14296  		_ = v.Args[1]
 14297  		x := v.Args[0]
 14298  		v_1 := v.Args[1]
 14299  		if v_1.Op != OpConst8 {
 14300  			break
 14301  		}
 14302  		c := v_1.AuxInt
 14303  		v.reset(OpLsh16x64)
 14304  		v.AddArg(x)
 14305  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14306  		v0.AuxInt = int64(uint8(c))
 14307  		v.AddArg(v0)
 14308  		return true
 14309  	}
 14310  	// match: (Lsh16x8 (Const16 [0]) _)
 14311  	// cond:
 14312  	// result: (Const16 [0])
 14313  	for {
 14314  		_ = v.Args[1]
 14315  		v_0 := v.Args[0]
 14316  		if v_0.Op != OpConst16 {
 14317  			break
 14318  		}
 14319  		if v_0.AuxInt != 0 {
 14320  			break
 14321  		}
 14322  		v.reset(OpConst16)
 14323  		v.AuxInt = 0
 14324  		return true
 14325  	}
 14326  	return false
 14327  }
 14328  func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool {
 14329  	b := v.Block
 14330  	_ = b
 14331  	// match: (Lsh32x16 <t> x (Const16 [c]))
 14332  	// cond:
 14333  	// result: (Lsh32x64 x (Const64 <t> [int64(uint16(c))]))
 14334  	for {
 14335  		t := v.Type
 14336  		_ = v.Args[1]
 14337  		x := v.Args[0]
 14338  		v_1 := v.Args[1]
 14339  		if v_1.Op != OpConst16 {
 14340  			break
 14341  		}
 14342  		c := v_1.AuxInt
 14343  		v.reset(OpLsh32x64)
 14344  		v.AddArg(x)
 14345  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14346  		v0.AuxInt = int64(uint16(c))
 14347  		v.AddArg(v0)
 14348  		return true
 14349  	}
 14350  	// match: (Lsh32x16 (Const32 [0]) _)
 14351  	// cond:
 14352  	// result: (Const32 [0])
 14353  	for {
 14354  		_ = v.Args[1]
 14355  		v_0 := v.Args[0]
 14356  		if v_0.Op != OpConst32 {
 14357  			break
 14358  		}
 14359  		if v_0.AuxInt != 0 {
 14360  			break
 14361  		}
 14362  		v.reset(OpConst32)
 14363  		v.AuxInt = 0
 14364  		return true
 14365  	}
 14366  	return false
 14367  }
 14368  func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool {
 14369  	b := v.Block
 14370  	_ = b
 14371  	// match: (Lsh32x32 <t> x (Const32 [c]))
 14372  	// cond:
 14373  	// result: (Lsh32x64 x (Const64 <t> [int64(uint32(c))]))
 14374  	for {
 14375  		t := v.Type
 14376  		_ = v.Args[1]
 14377  		x := v.Args[0]
 14378  		v_1 := v.Args[1]
 14379  		if v_1.Op != OpConst32 {
 14380  			break
 14381  		}
 14382  		c := v_1.AuxInt
 14383  		v.reset(OpLsh32x64)
 14384  		v.AddArg(x)
 14385  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14386  		v0.AuxInt = int64(uint32(c))
 14387  		v.AddArg(v0)
 14388  		return true
 14389  	}
 14390  	// match: (Lsh32x32 (Const32 [0]) _)
 14391  	// cond:
 14392  	// result: (Const32 [0])
 14393  	for {
 14394  		_ = v.Args[1]
 14395  		v_0 := v.Args[0]
 14396  		if v_0.Op != OpConst32 {
 14397  			break
 14398  		}
 14399  		if v_0.AuxInt != 0 {
 14400  			break
 14401  		}
 14402  		v.reset(OpConst32)
 14403  		v.AuxInt = 0
 14404  		return true
 14405  	}
 14406  	return false
 14407  }
 14408  func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool {
 14409  	b := v.Block
 14410  	_ = b
 14411  	typ := &b.Func.Config.Types
 14412  	_ = typ
 14413  	// match: (Lsh32x64 (Const32 [c]) (Const64 [d]))
 14414  	// cond:
 14415  	// result: (Const32 [int64(int32(c) << uint64(d))])
 14416  	for {
 14417  		_ = v.Args[1]
 14418  		v_0 := v.Args[0]
 14419  		if v_0.Op != OpConst32 {
 14420  			break
 14421  		}
 14422  		c := v_0.AuxInt
 14423  		v_1 := v.Args[1]
 14424  		if v_1.Op != OpConst64 {
 14425  			break
 14426  		}
 14427  		d := v_1.AuxInt
 14428  		v.reset(OpConst32)
 14429  		v.AuxInt = int64(int32(c) << uint64(d))
 14430  		return true
 14431  	}
 14432  	// match: (Lsh32x64 x (Const64 [0]))
 14433  	// cond:
 14434  	// result: x
 14435  	for {
 14436  		_ = v.Args[1]
 14437  		x := v.Args[0]
 14438  		v_1 := v.Args[1]
 14439  		if v_1.Op != OpConst64 {
 14440  			break
 14441  		}
 14442  		if v_1.AuxInt != 0 {
 14443  			break
 14444  		}
 14445  		v.reset(OpCopy)
 14446  		v.Type = x.Type
 14447  		v.AddArg(x)
 14448  		return true
 14449  	}
 14450  	// match: (Lsh32x64 (Const32 [0]) _)
 14451  	// cond:
 14452  	// result: (Const32 [0])
 14453  	for {
 14454  		_ = v.Args[1]
 14455  		v_0 := v.Args[0]
 14456  		if v_0.Op != OpConst32 {
 14457  			break
 14458  		}
 14459  		if v_0.AuxInt != 0 {
 14460  			break
 14461  		}
 14462  		v.reset(OpConst32)
 14463  		v.AuxInt = 0
 14464  		return true
 14465  	}
 14466  	// match: (Lsh32x64 _ (Const64 [c]))
 14467  	// cond: uint64(c) >= 32
 14468  	// result: (Const32 [0])
 14469  	for {
 14470  		_ = v.Args[1]
 14471  		v_1 := v.Args[1]
 14472  		if v_1.Op != OpConst64 {
 14473  			break
 14474  		}
 14475  		c := v_1.AuxInt
 14476  		if !(uint64(c) >= 32) {
 14477  			break
 14478  		}
 14479  		v.reset(OpConst32)
 14480  		v.AuxInt = 0
 14481  		return true
 14482  	}
 14483  	// match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d]))
 14484  	// cond: !uaddOvf(c,d)
 14485  	// result: (Lsh32x64 x (Const64 <t> [c+d]))
 14486  	for {
 14487  		t := v.Type
 14488  		_ = v.Args[1]
 14489  		v_0 := v.Args[0]
 14490  		if v_0.Op != OpLsh32x64 {
 14491  			break
 14492  		}
 14493  		_ = v_0.Args[1]
 14494  		x := v_0.Args[0]
 14495  		v_0_1 := v_0.Args[1]
 14496  		if v_0_1.Op != OpConst64 {
 14497  			break
 14498  		}
 14499  		c := v_0_1.AuxInt
 14500  		v_1 := v.Args[1]
 14501  		if v_1.Op != OpConst64 {
 14502  			break
 14503  		}
 14504  		d := v_1.AuxInt
 14505  		if !(!uaddOvf(c, d)) {
 14506  			break
 14507  		}
 14508  		v.reset(OpLsh32x64)
 14509  		v.AddArg(x)
 14510  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14511  		v0.AuxInt = c + d
 14512  		v.AddArg(v0)
 14513  		return true
 14514  	}
 14515  	// match: (Lsh32x64 (Rsh32Ux64 (Lsh32x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 14516  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 14517  	// result: (Lsh32x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 14518  	for {
 14519  		_ = v.Args[1]
 14520  		v_0 := v.Args[0]
 14521  		if v_0.Op != OpRsh32Ux64 {
 14522  			break
 14523  		}
 14524  		_ = v_0.Args[1]
 14525  		v_0_0 := v_0.Args[0]
 14526  		if v_0_0.Op != OpLsh32x64 {
 14527  			break
 14528  		}
 14529  		_ = v_0_0.Args[1]
 14530  		x := v_0_0.Args[0]
 14531  		v_0_0_1 := v_0_0.Args[1]
 14532  		if v_0_0_1.Op != OpConst64 {
 14533  			break
 14534  		}
 14535  		c1 := v_0_0_1.AuxInt
 14536  		v_0_1 := v_0.Args[1]
 14537  		if v_0_1.Op != OpConst64 {
 14538  			break
 14539  		}
 14540  		c2 := v_0_1.AuxInt
 14541  		v_1 := v.Args[1]
 14542  		if v_1.Op != OpConst64 {
 14543  			break
 14544  		}
 14545  		c3 := v_1.AuxInt
 14546  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 14547  			break
 14548  		}
 14549  		v.reset(OpLsh32x64)
 14550  		v.AddArg(x)
 14551  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 14552  		v0.AuxInt = c1 - c2 + c3
 14553  		v.AddArg(v0)
 14554  		return true
 14555  	}
 14556  	return false
 14557  }
 14558  func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool {
 14559  	b := v.Block
 14560  	_ = b
 14561  	// match: (Lsh32x8 <t> x (Const8 [c]))
 14562  	// cond:
 14563  	// result: (Lsh32x64 x (Const64 <t> [int64(uint8(c))]))
 14564  	for {
 14565  		t := v.Type
 14566  		_ = v.Args[1]
 14567  		x := v.Args[0]
 14568  		v_1 := v.Args[1]
 14569  		if v_1.Op != OpConst8 {
 14570  			break
 14571  		}
 14572  		c := v_1.AuxInt
 14573  		v.reset(OpLsh32x64)
 14574  		v.AddArg(x)
 14575  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14576  		v0.AuxInt = int64(uint8(c))
 14577  		v.AddArg(v0)
 14578  		return true
 14579  	}
 14580  	// match: (Lsh32x8 (Const32 [0]) _)
 14581  	// cond:
 14582  	// result: (Const32 [0])
 14583  	for {
 14584  		_ = v.Args[1]
 14585  		v_0 := v.Args[0]
 14586  		if v_0.Op != OpConst32 {
 14587  			break
 14588  		}
 14589  		if v_0.AuxInt != 0 {
 14590  			break
 14591  		}
 14592  		v.reset(OpConst32)
 14593  		v.AuxInt = 0
 14594  		return true
 14595  	}
 14596  	return false
 14597  }
 14598  func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool {
 14599  	b := v.Block
 14600  	_ = b
 14601  	// match: (Lsh64x16 <t> x (Const16 [c]))
 14602  	// cond:
 14603  	// result: (Lsh64x64 x (Const64 <t> [int64(uint16(c))]))
 14604  	for {
 14605  		t := v.Type
 14606  		_ = v.Args[1]
 14607  		x := v.Args[0]
 14608  		v_1 := v.Args[1]
 14609  		if v_1.Op != OpConst16 {
 14610  			break
 14611  		}
 14612  		c := v_1.AuxInt
 14613  		v.reset(OpLsh64x64)
 14614  		v.AddArg(x)
 14615  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14616  		v0.AuxInt = int64(uint16(c))
 14617  		v.AddArg(v0)
 14618  		return true
 14619  	}
 14620  	// match: (Lsh64x16 (Const64 [0]) _)
 14621  	// cond:
 14622  	// result: (Const64 [0])
 14623  	for {
 14624  		_ = v.Args[1]
 14625  		v_0 := v.Args[0]
 14626  		if v_0.Op != OpConst64 {
 14627  			break
 14628  		}
 14629  		if v_0.AuxInt != 0 {
 14630  			break
 14631  		}
 14632  		v.reset(OpConst64)
 14633  		v.AuxInt = 0
 14634  		return true
 14635  	}
 14636  	return false
 14637  }
 14638  func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool {
 14639  	b := v.Block
 14640  	_ = b
 14641  	// match: (Lsh64x32 <t> x (Const32 [c]))
 14642  	// cond:
 14643  	// result: (Lsh64x64 x (Const64 <t> [int64(uint32(c))]))
 14644  	for {
 14645  		t := v.Type
 14646  		_ = v.Args[1]
 14647  		x := v.Args[0]
 14648  		v_1 := v.Args[1]
 14649  		if v_1.Op != OpConst32 {
 14650  			break
 14651  		}
 14652  		c := v_1.AuxInt
 14653  		v.reset(OpLsh64x64)
 14654  		v.AddArg(x)
 14655  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14656  		v0.AuxInt = int64(uint32(c))
 14657  		v.AddArg(v0)
 14658  		return true
 14659  	}
 14660  	// match: (Lsh64x32 (Const64 [0]) _)
 14661  	// cond:
 14662  	// result: (Const64 [0])
 14663  	for {
 14664  		_ = v.Args[1]
 14665  		v_0 := v.Args[0]
 14666  		if v_0.Op != OpConst64 {
 14667  			break
 14668  		}
 14669  		if v_0.AuxInt != 0 {
 14670  			break
 14671  		}
 14672  		v.reset(OpConst64)
 14673  		v.AuxInt = 0
 14674  		return true
 14675  	}
 14676  	return false
 14677  }
 14678  func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool {
 14679  	b := v.Block
 14680  	_ = b
 14681  	typ := &b.Func.Config.Types
 14682  	_ = typ
 14683  	// match: (Lsh64x64 (Const64 [c]) (Const64 [d]))
 14684  	// cond:
 14685  	// result: (Const64 [c << uint64(d)])
 14686  	for {
 14687  		_ = v.Args[1]
 14688  		v_0 := v.Args[0]
 14689  		if v_0.Op != OpConst64 {
 14690  			break
 14691  		}
 14692  		c := v_0.AuxInt
 14693  		v_1 := v.Args[1]
 14694  		if v_1.Op != OpConst64 {
 14695  			break
 14696  		}
 14697  		d := v_1.AuxInt
 14698  		v.reset(OpConst64)
 14699  		v.AuxInt = c << uint64(d)
 14700  		return true
 14701  	}
 14702  	// match: (Lsh64x64 x (Const64 [0]))
 14703  	// cond:
 14704  	// result: x
 14705  	for {
 14706  		_ = v.Args[1]
 14707  		x := v.Args[0]
 14708  		v_1 := v.Args[1]
 14709  		if v_1.Op != OpConst64 {
 14710  			break
 14711  		}
 14712  		if v_1.AuxInt != 0 {
 14713  			break
 14714  		}
 14715  		v.reset(OpCopy)
 14716  		v.Type = x.Type
 14717  		v.AddArg(x)
 14718  		return true
 14719  	}
 14720  	// match: (Lsh64x64 (Const64 [0]) _)
 14721  	// cond:
 14722  	// result: (Const64 [0])
 14723  	for {
 14724  		_ = v.Args[1]
 14725  		v_0 := v.Args[0]
 14726  		if v_0.Op != OpConst64 {
 14727  			break
 14728  		}
 14729  		if v_0.AuxInt != 0 {
 14730  			break
 14731  		}
 14732  		v.reset(OpConst64)
 14733  		v.AuxInt = 0
 14734  		return true
 14735  	}
 14736  	// match: (Lsh64x64 _ (Const64 [c]))
 14737  	// cond: uint64(c) >= 64
 14738  	// result: (Const64 [0])
 14739  	for {
 14740  		_ = v.Args[1]
 14741  		v_1 := v.Args[1]
 14742  		if v_1.Op != OpConst64 {
 14743  			break
 14744  		}
 14745  		c := v_1.AuxInt
 14746  		if !(uint64(c) >= 64) {
 14747  			break
 14748  		}
 14749  		v.reset(OpConst64)
 14750  		v.AuxInt = 0
 14751  		return true
 14752  	}
 14753  	// match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d]))
 14754  	// cond: !uaddOvf(c,d)
 14755  	// result: (Lsh64x64 x (Const64 <t> [c+d]))
 14756  	for {
 14757  		t := v.Type
 14758  		_ = v.Args[1]
 14759  		v_0 := v.Args[0]
 14760  		if v_0.Op != OpLsh64x64 {
 14761  			break
 14762  		}
 14763  		_ = v_0.Args[1]
 14764  		x := v_0.Args[0]
 14765  		v_0_1 := v_0.Args[1]
 14766  		if v_0_1.Op != OpConst64 {
 14767  			break
 14768  		}
 14769  		c := v_0_1.AuxInt
 14770  		v_1 := v.Args[1]
 14771  		if v_1.Op != OpConst64 {
 14772  			break
 14773  		}
 14774  		d := v_1.AuxInt
 14775  		if !(!uaddOvf(c, d)) {
 14776  			break
 14777  		}
 14778  		v.reset(OpLsh64x64)
 14779  		v.AddArg(x)
 14780  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14781  		v0.AuxInt = c + d
 14782  		v.AddArg(v0)
 14783  		return true
 14784  	}
 14785  	// match: (Lsh64x64 (Rsh64Ux64 (Lsh64x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 14786  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 14787  	// result: (Lsh64x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 14788  	for {
 14789  		_ = v.Args[1]
 14790  		v_0 := v.Args[0]
 14791  		if v_0.Op != OpRsh64Ux64 {
 14792  			break
 14793  		}
 14794  		_ = v_0.Args[1]
 14795  		v_0_0 := v_0.Args[0]
 14796  		if v_0_0.Op != OpLsh64x64 {
 14797  			break
 14798  		}
 14799  		_ = v_0_0.Args[1]
 14800  		x := v_0_0.Args[0]
 14801  		v_0_0_1 := v_0_0.Args[1]
 14802  		if v_0_0_1.Op != OpConst64 {
 14803  			break
 14804  		}
 14805  		c1 := v_0_0_1.AuxInt
 14806  		v_0_1 := v_0.Args[1]
 14807  		if v_0_1.Op != OpConst64 {
 14808  			break
 14809  		}
 14810  		c2 := v_0_1.AuxInt
 14811  		v_1 := v.Args[1]
 14812  		if v_1.Op != OpConst64 {
 14813  			break
 14814  		}
 14815  		c3 := v_1.AuxInt
 14816  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 14817  			break
 14818  		}
 14819  		v.reset(OpLsh64x64)
 14820  		v.AddArg(x)
 14821  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 14822  		v0.AuxInt = c1 - c2 + c3
 14823  		v.AddArg(v0)
 14824  		return true
 14825  	}
 14826  	return false
 14827  }
 14828  func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool {
 14829  	b := v.Block
 14830  	_ = b
 14831  	// match: (Lsh64x8 <t> x (Const8 [c]))
 14832  	// cond:
 14833  	// result: (Lsh64x64 x (Const64 <t> [int64(uint8(c))]))
 14834  	for {
 14835  		t := v.Type
 14836  		_ = v.Args[1]
 14837  		x := v.Args[0]
 14838  		v_1 := v.Args[1]
 14839  		if v_1.Op != OpConst8 {
 14840  			break
 14841  		}
 14842  		c := v_1.AuxInt
 14843  		v.reset(OpLsh64x64)
 14844  		v.AddArg(x)
 14845  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14846  		v0.AuxInt = int64(uint8(c))
 14847  		v.AddArg(v0)
 14848  		return true
 14849  	}
 14850  	// match: (Lsh64x8 (Const64 [0]) _)
 14851  	// cond:
 14852  	// result: (Const64 [0])
 14853  	for {
 14854  		_ = v.Args[1]
 14855  		v_0 := v.Args[0]
 14856  		if v_0.Op != OpConst64 {
 14857  			break
 14858  		}
 14859  		if v_0.AuxInt != 0 {
 14860  			break
 14861  		}
 14862  		v.reset(OpConst64)
 14863  		v.AuxInt = 0
 14864  		return true
 14865  	}
 14866  	return false
 14867  }
 14868  func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool {
 14869  	b := v.Block
 14870  	_ = b
 14871  	// match: (Lsh8x16 <t> x (Const16 [c]))
 14872  	// cond:
 14873  	// result: (Lsh8x64 x (Const64 <t> [int64(uint16(c))]))
 14874  	for {
 14875  		t := v.Type
 14876  		_ = v.Args[1]
 14877  		x := v.Args[0]
 14878  		v_1 := v.Args[1]
 14879  		if v_1.Op != OpConst16 {
 14880  			break
 14881  		}
 14882  		c := v_1.AuxInt
 14883  		v.reset(OpLsh8x64)
 14884  		v.AddArg(x)
 14885  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14886  		v0.AuxInt = int64(uint16(c))
 14887  		v.AddArg(v0)
 14888  		return true
 14889  	}
 14890  	// match: (Lsh8x16 (Const8 [0]) _)
 14891  	// cond:
 14892  	// result: (Const8 [0])
 14893  	for {
 14894  		_ = v.Args[1]
 14895  		v_0 := v.Args[0]
 14896  		if v_0.Op != OpConst8 {
 14897  			break
 14898  		}
 14899  		if v_0.AuxInt != 0 {
 14900  			break
 14901  		}
 14902  		v.reset(OpConst8)
 14903  		v.AuxInt = 0
 14904  		return true
 14905  	}
 14906  	return false
 14907  }
 14908  func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool {
 14909  	b := v.Block
 14910  	_ = b
 14911  	// match: (Lsh8x32 <t> x (Const32 [c]))
 14912  	// cond:
 14913  	// result: (Lsh8x64 x (Const64 <t> [int64(uint32(c))]))
 14914  	for {
 14915  		t := v.Type
 14916  		_ = v.Args[1]
 14917  		x := v.Args[0]
 14918  		v_1 := v.Args[1]
 14919  		if v_1.Op != OpConst32 {
 14920  			break
 14921  		}
 14922  		c := v_1.AuxInt
 14923  		v.reset(OpLsh8x64)
 14924  		v.AddArg(x)
 14925  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 14926  		v0.AuxInt = int64(uint32(c))
 14927  		v.AddArg(v0)
 14928  		return true
 14929  	}
 14930  	// match: (Lsh8x32 (Const8 [0]) _)
 14931  	// cond:
 14932  	// result: (Const8 [0])
 14933  	for {
 14934  		_ = v.Args[1]
 14935  		v_0 := v.Args[0]
 14936  		if v_0.Op != OpConst8 {
 14937  			break
 14938  		}
 14939  		if v_0.AuxInt != 0 {
 14940  			break
 14941  		}
 14942  		v.reset(OpConst8)
 14943  		v.AuxInt = 0
 14944  		return true
 14945  	}
 14946  	return false
 14947  }
 14948  func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool {
 14949  	b := v.Block
 14950  	_ = b
 14951  	typ := &b.Func.Config.Types
 14952  	_ = typ
 14953  	// match: (Lsh8x64 (Const8 [c]) (Const64 [d]))
 14954  	// cond:
 14955  	// result: (Const8 [int64(int8(c) << uint64(d))])
 14956  	for {
 14957  		_ = v.Args[1]
 14958  		v_0 := v.Args[0]
 14959  		if v_0.Op != OpConst8 {
 14960  			break
 14961  		}
 14962  		c := v_0.AuxInt
 14963  		v_1 := v.Args[1]
 14964  		if v_1.Op != OpConst64 {
 14965  			break
 14966  		}
 14967  		d := v_1.AuxInt
 14968  		v.reset(OpConst8)
 14969  		v.AuxInt = int64(int8(c) << uint64(d))
 14970  		return true
 14971  	}
 14972  	// match: (Lsh8x64 x (Const64 [0]))
 14973  	// cond:
 14974  	// result: x
 14975  	for {
 14976  		_ = v.Args[1]
 14977  		x := v.Args[0]
 14978  		v_1 := v.Args[1]
 14979  		if v_1.Op != OpConst64 {
 14980  			break
 14981  		}
 14982  		if v_1.AuxInt != 0 {
 14983  			break
 14984  		}
 14985  		v.reset(OpCopy)
 14986  		v.Type = x.Type
 14987  		v.AddArg(x)
 14988  		return true
 14989  	}
 14990  	// match: (Lsh8x64 (Const8 [0]) _)
 14991  	// cond:
 14992  	// result: (Const8 [0])
 14993  	for {
 14994  		_ = v.Args[1]
 14995  		v_0 := v.Args[0]
 14996  		if v_0.Op != OpConst8 {
 14997  			break
 14998  		}
 14999  		if v_0.AuxInt != 0 {
 15000  			break
 15001  		}
 15002  		v.reset(OpConst8)
 15003  		v.AuxInt = 0
 15004  		return true
 15005  	}
 15006  	// match: (Lsh8x64 _ (Const64 [c]))
 15007  	// cond: uint64(c) >= 8
 15008  	// result: (Const8 [0])
 15009  	for {
 15010  		_ = v.Args[1]
 15011  		v_1 := v.Args[1]
 15012  		if v_1.Op != OpConst64 {
 15013  			break
 15014  		}
 15015  		c := v_1.AuxInt
 15016  		if !(uint64(c) >= 8) {
 15017  			break
 15018  		}
 15019  		v.reset(OpConst8)
 15020  		v.AuxInt = 0
 15021  		return true
 15022  	}
 15023  	// match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d]))
 15024  	// cond: !uaddOvf(c,d)
 15025  	// result: (Lsh8x64 x (Const64 <t> [c+d]))
 15026  	for {
 15027  		t := v.Type
 15028  		_ = v.Args[1]
 15029  		v_0 := v.Args[0]
 15030  		if v_0.Op != OpLsh8x64 {
 15031  			break
 15032  		}
 15033  		_ = v_0.Args[1]
 15034  		x := v_0.Args[0]
 15035  		v_0_1 := v_0.Args[1]
 15036  		if v_0_1.Op != OpConst64 {
 15037  			break
 15038  		}
 15039  		c := v_0_1.AuxInt
 15040  		v_1 := v.Args[1]
 15041  		if v_1.Op != OpConst64 {
 15042  			break
 15043  		}
 15044  		d := v_1.AuxInt
 15045  		if !(!uaddOvf(c, d)) {
 15046  			break
 15047  		}
 15048  		v.reset(OpLsh8x64)
 15049  		v.AddArg(x)
 15050  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 15051  		v0.AuxInt = c + d
 15052  		v.AddArg(v0)
 15053  		return true
 15054  	}
 15055  	// match: (Lsh8x64 (Rsh8Ux64 (Lsh8x64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 15056  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 15057  	// result: (Lsh8x64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 15058  	for {
 15059  		_ = v.Args[1]
 15060  		v_0 := v.Args[0]
 15061  		if v_0.Op != OpRsh8Ux64 {
 15062  			break
 15063  		}
 15064  		_ = v_0.Args[1]
 15065  		v_0_0 := v_0.Args[0]
 15066  		if v_0_0.Op != OpLsh8x64 {
 15067  			break
 15068  		}
 15069  		_ = v_0_0.Args[1]
 15070  		x := v_0_0.Args[0]
 15071  		v_0_0_1 := v_0_0.Args[1]
 15072  		if v_0_0_1.Op != OpConst64 {
 15073  			break
 15074  		}
 15075  		c1 := v_0_0_1.AuxInt
 15076  		v_0_1 := v_0.Args[1]
 15077  		if v_0_1.Op != OpConst64 {
 15078  			break
 15079  		}
 15080  		c2 := v_0_1.AuxInt
 15081  		v_1 := v.Args[1]
 15082  		if v_1.Op != OpConst64 {
 15083  			break
 15084  		}
 15085  		c3 := v_1.AuxInt
 15086  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 15087  			break
 15088  		}
 15089  		v.reset(OpLsh8x64)
 15090  		v.AddArg(x)
 15091  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 15092  		v0.AuxInt = c1 - c2 + c3
 15093  		v.AddArg(v0)
 15094  		return true
 15095  	}
 15096  	return false
 15097  }
 15098  func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool {
 15099  	b := v.Block
 15100  	_ = b
 15101  	// match: (Lsh8x8 <t> x (Const8 [c]))
 15102  	// cond:
 15103  	// result: (Lsh8x64 x (Const64 <t> [int64(uint8(c))]))
 15104  	for {
 15105  		t := v.Type
 15106  		_ = v.Args[1]
 15107  		x := v.Args[0]
 15108  		v_1 := v.Args[1]
 15109  		if v_1.Op != OpConst8 {
 15110  			break
 15111  		}
 15112  		c := v_1.AuxInt
 15113  		v.reset(OpLsh8x64)
 15114  		v.AddArg(x)
 15115  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 15116  		v0.AuxInt = int64(uint8(c))
 15117  		v.AddArg(v0)
 15118  		return true
 15119  	}
 15120  	// match: (Lsh8x8 (Const8 [0]) _)
 15121  	// cond:
 15122  	// result: (Const8 [0])
 15123  	for {
 15124  		_ = v.Args[1]
 15125  		v_0 := v.Args[0]
 15126  		if v_0.Op != OpConst8 {
 15127  			break
 15128  		}
 15129  		if v_0.AuxInt != 0 {
 15130  			break
 15131  		}
 15132  		v.reset(OpConst8)
 15133  		v.AuxInt = 0
 15134  		return true
 15135  	}
 15136  	return false
 15137  }
 15138  func rewriteValuegeneric_OpMod16_0(v *Value) bool {
 15139  	b := v.Block
 15140  	_ = b
 15141  	// match: (Mod16 (Const16 [c]) (Const16 [d]))
 15142  	// cond: d != 0
 15143  	// result: (Const16 [int64(int16(c % d))])
 15144  	for {
 15145  		_ = v.Args[1]
 15146  		v_0 := v.Args[0]
 15147  		if v_0.Op != OpConst16 {
 15148  			break
 15149  		}
 15150  		c := v_0.AuxInt
 15151  		v_1 := v.Args[1]
 15152  		if v_1.Op != OpConst16 {
 15153  			break
 15154  		}
 15155  		d := v_1.AuxInt
 15156  		if !(d != 0) {
 15157  			break
 15158  		}
 15159  		v.reset(OpConst16)
 15160  		v.AuxInt = int64(int16(c % d))
 15161  		return true
 15162  	}
 15163  	// match: (Mod16 <t> n (Const16 [c]))
 15164  	// cond: isNonNegative(n) && isPowerOfTwo(c&0xffff)
 15165  	// result: (And16 n (Const16 <t> [(c&0xffff)-1]))
 15166  	for {
 15167  		t := v.Type
 15168  		_ = v.Args[1]
 15169  		n := v.Args[0]
 15170  		v_1 := v.Args[1]
 15171  		if v_1.Op != OpConst16 {
 15172  			break
 15173  		}
 15174  		c := v_1.AuxInt
 15175  		if !(isNonNegative(n) && isPowerOfTwo(c&0xffff)) {
 15176  			break
 15177  		}
 15178  		v.reset(OpAnd16)
 15179  		v.AddArg(n)
 15180  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 15181  		v0.AuxInt = (c & 0xffff) - 1
 15182  		v.AddArg(v0)
 15183  		return true
 15184  	}
 15185  	// match: (Mod16 <t> n (Const16 [c]))
 15186  	// cond: c < 0 && c != -1<<15
 15187  	// result: (Mod16 <t> n (Const16 <t> [-c]))
 15188  	for {
 15189  		t := v.Type
 15190  		_ = v.Args[1]
 15191  		n := v.Args[0]
 15192  		v_1 := v.Args[1]
 15193  		if v_1.Op != OpConst16 {
 15194  			break
 15195  		}
 15196  		c := v_1.AuxInt
 15197  		if !(c < 0 && c != -1<<15) {
 15198  			break
 15199  		}
 15200  		v.reset(OpMod16)
 15201  		v.Type = t
 15202  		v.AddArg(n)
 15203  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 15204  		v0.AuxInt = -c
 15205  		v.AddArg(v0)
 15206  		return true
 15207  	}
 15208  	// match: (Mod16 <t> x (Const16 [c]))
 15209  	// cond: x.Op != OpConst16 && (c > 0 || c == -1<<15)
 15210  	// result: (Sub16 x (Mul16 <t> (Div16 <t> x (Const16 <t> [c])) (Const16 <t> [c])))
 15211  	for {
 15212  		t := v.Type
 15213  		_ = v.Args[1]
 15214  		x := v.Args[0]
 15215  		v_1 := v.Args[1]
 15216  		if v_1.Op != OpConst16 {
 15217  			break
 15218  		}
 15219  		c := v_1.AuxInt
 15220  		if !(x.Op != OpConst16 && (c > 0 || c == -1<<15)) {
 15221  			break
 15222  		}
 15223  		v.reset(OpSub16)
 15224  		v.AddArg(x)
 15225  		v0 := b.NewValue0(v.Pos, OpMul16, t)
 15226  		v1 := b.NewValue0(v.Pos, OpDiv16, t)
 15227  		v1.AddArg(x)
 15228  		v2 := b.NewValue0(v.Pos, OpConst16, t)
 15229  		v2.AuxInt = c
 15230  		v1.AddArg(v2)
 15231  		v0.AddArg(v1)
 15232  		v3 := b.NewValue0(v.Pos, OpConst16, t)
 15233  		v3.AuxInt = c
 15234  		v0.AddArg(v3)
 15235  		v.AddArg(v0)
 15236  		return true
 15237  	}
 15238  	return false
 15239  }
 15240  func rewriteValuegeneric_OpMod16u_0(v *Value) bool {
 15241  	b := v.Block
 15242  	_ = b
 15243  	// match: (Mod16u (Const16 [c]) (Const16 [d]))
 15244  	// cond: d != 0
 15245  	// result: (Const16 [int64(uint16(c) % uint16(d))])
 15246  	for {
 15247  		_ = v.Args[1]
 15248  		v_0 := v.Args[0]
 15249  		if v_0.Op != OpConst16 {
 15250  			break
 15251  		}
 15252  		c := v_0.AuxInt
 15253  		v_1 := v.Args[1]
 15254  		if v_1.Op != OpConst16 {
 15255  			break
 15256  		}
 15257  		d := v_1.AuxInt
 15258  		if !(d != 0) {
 15259  			break
 15260  		}
 15261  		v.reset(OpConst16)
 15262  		v.AuxInt = int64(uint16(c) % uint16(d))
 15263  		return true
 15264  	}
 15265  	// match: (Mod16u <t> n (Const16 [c]))
 15266  	// cond: isPowerOfTwo(c&0xffff)
 15267  	// result: (And16 n (Const16 <t> [(c&0xffff)-1]))
 15268  	for {
 15269  		t := v.Type
 15270  		_ = v.Args[1]
 15271  		n := v.Args[0]
 15272  		v_1 := v.Args[1]
 15273  		if v_1.Op != OpConst16 {
 15274  			break
 15275  		}
 15276  		c := v_1.AuxInt
 15277  		if !(isPowerOfTwo(c & 0xffff)) {
 15278  			break
 15279  		}
 15280  		v.reset(OpAnd16)
 15281  		v.AddArg(n)
 15282  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 15283  		v0.AuxInt = (c & 0xffff) - 1
 15284  		v.AddArg(v0)
 15285  		return true
 15286  	}
 15287  	// match: (Mod16u <t> x (Const16 [c]))
 15288  	// cond: x.Op != OpConst16 && c > 0 && umagicOK(16,c)
 15289  	// result: (Sub16 x (Mul16 <t> (Div16u <t> x (Const16 <t> [c])) (Const16 <t> [c])))
 15290  	for {
 15291  		t := v.Type
 15292  		_ = v.Args[1]
 15293  		x := v.Args[0]
 15294  		v_1 := v.Args[1]
 15295  		if v_1.Op != OpConst16 {
 15296  			break
 15297  		}
 15298  		c := v_1.AuxInt
 15299  		if !(x.Op != OpConst16 && c > 0 && umagicOK(16, c)) {
 15300  			break
 15301  		}
 15302  		v.reset(OpSub16)
 15303  		v.AddArg(x)
 15304  		v0 := b.NewValue0(v.Pos, OpMul16, t)
 15305  		v1 := b.NewValue0(v.Pos, OpDiv16u, t)
 15306  		v1.AddArg(x)
 15307  		v2 := b.NewValue0(v.Pos, OpConst16, t)
 15308  		v2.AuxInt = c
 15309  		v1.AddArg(v2)
 15310  		v0.AddArg(v1)
 15311  		v3 := b.NewValue0(v.Pos, OpConst16, t)
 15312  		v3.AuxInt = c
 15313  		v0.AddArg(v3)
 15314  		v.AddArg(v0)
 15315  		return true
 15316  	}
 15317  	return false
 15318  }
 15319  func rewriteValuegeneric_OpMod32_0(v *Value) bool {
 15320  	b := v.Block
 15321  	_ = b
 15322  	// match: (Mod32 (Const32 [c]) (Const32 [d]))
 15323  	// cond: d != 0
 15324  	// result: (Const32 [int64(int32(c % d))])
 15325  	for {
 15326  		_ = v.Args[1]
 15327  		v_0 := v.Args[0]
 15328  		if v_0.Op != OpConst32 {
 15329  			break
 15330  		}
 15331  		c := v_0.AuxInt
 15332  		v_1 := v.Args[1]
 15333  		if v_1.Op != OpConst32 {
 15334  			break
 15335  		}
 15336  		d := v_1.AuxInt
 15337  		if !(d != 0) {
 15338  			break
 15339  		}
 15340  		v.reset(OpConst32)
 15341  		v.AuxInt = int64(int32(c % d))
 15342  		return true
 15343  	}
 15344  	// match: (Mod32 <t> n (Const32 [c]))
 15345  	// cond: isNonNegative(n) && isPowerOfTwo(c&0xffffffff)
 15346  	// result: (And32 n (Const32 <t> [(c&0xffffffff)-1]))
 15347  	for {
 15348  		t := v.Type
 15349  		_ = v.Args[1]
 15350  		n := v.Args[0]
 15351  		v_1 := v.Args[1]
 15352  		if v_1.Op != OpConst32 {
 15353  			break
 15354  		}
 15355  		c := v_1.AuxInt
 15356  		if !(isNonNegative(n) && isPowerOfTwo(c&0xffffffff)) {
 15357  			break
 15358  		}
 15359  		v.reset(OpAnd32)
 15360  		v.AddArg(n)
 15361  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 15362  		v0.AuxInt = (c & 0xffffffff) - 1
 15363  		v.AddArg(v0)
 15364  		return true
 15365  	}
 15366  	// match: (Mod32 <t> n (Const32 [c]))
 15367  	// cond: c < 0 && c != -1<<31
 15368  	// result: (Mod32 <t> n (Const32 <t> [-c]))
 15369  	for {
 15370  		t := v.Type
 15371  		_ = v.Args[1]
 15372  		n := v.Args[0]
 15373  		v_1 := v.Args[1]
 15374  		if v_1.Op != OpConst32 {
 15375  			break
 15376  		}
 15377  		c := v_1.AuxInt
 15378  		if !(c < 0 && c != -1<<31) {
 15379  			break
 15380  		}
 15381  		v.reset(OpMod32)
 15382  		v.Type = t
 15383  		v.AddArg(n)
 15384  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 15385  		v0.AuxInt = -c
 15386  		v.AddArg(v0)
 15387  		return true
 15388  	}
 15389  	// match: (Mod32 <t> x (Const32 [c]))
 15390  	// cond: x.Op != OpConst32 && (c > 0 || c == -1<<31)
 15391  	// result: (Sub32 x (Mul32 <t> (Div32 <t> x (Const32 <t> [c])) (Const32 <t> [c])))
 15392  	for {
 15393  		t := v.Type
 15394  		_ = v.Args[1]
 15395  		x := v.Args[0]
 15396  		v_1 := v.Args[1]
 15397  		if v_1.Op != OpConst32 {
 15398  			break
 15399  		}
 15400  		c := v_1.AuxInt
 15401  		if !(x.Op != OpConst32 && (c > 0 || c == -1<<31)) {
 15402  			break
 15403  		}
 15404  		v.reset(OpSub32)
 15405  		v.AddArg(x)
 15406  		v0 := b.NewValue0(v.Pos, OpMul32, t)
 15407  		v1 := b.NewValue0(v.Pos, OpDiv32, t)
 15408  		v1.AddArg(x)
 15409  		v2 := b.NewValue0(v.Pos, OpConst32, t)
 15410  		v2.AuxInt = c
 15411  		v1.AddArg(v2)
 15412  		v0.AddArg(v1)
 15413  		v3 := b.NewValue0(v.Pos, OpConst32, t)
 15414  		v3.AuxInt = c
 15415  		v0.AddArg(v3)
 15416  		v.AddArg(v0)
 15417  		return true
 15418  	}
 15419  	return false
 15420  }
 15421  func rewriteValuegeneric_OpMod32u_0(v *Value) bool {
 15422  	b := v.Block
 15423  	_ = b
 15424  	// match: (Mod32u (Const32 [c]) (Const32 [d]))
 15425  	// cond: d != 0
 15426  	// result: (Const32 [int64(uint32(c) % uint32(d))])
 15427  	for {
 15428  		_ = v.Args[1]
 15429  		v_0 := v.Args[0]
 15430  		if v_0.Op != OpConst32 {
 15431  			break
 15432  		}
 15433  		c := v_0.AuxInt
 15434  		v_1 := v.Args[1]
 15435  		if v_1.Op != OpConst32 {
 15436  			break
 15437  		}
 15438  		d := v_1.AuxInt
 15439  		if !(d != 0) {
 15440  			break
 15441  		}
 15442  		v.reset(OpConst32)
 15443  		v.AuxInt = int64(uint32(c) % uint32(d))
 15444  		return true
 15445  	}
 15446  	// match: (Mod32u <t> n (Const32 [c]))
 15447  	// cond: isPowerOfTwo(c&0xffffffff)
 15448  	// result: (And32 n (Const32 <t> [(c&0xffffffff)-1]))
 15449  	for {
 15450  		t := v.Type
 15451  		_ = v.Args[1]
 15452  		n := v.Args[0]
 15453  		v_1 := v.Args[1]
 15454  		if v_1.Op != OpConst32 {
 15455  			break
 15456  		}
 15457  		c := v_1.AuxInt
 15458  		if !(isPowerOfTwo(c & 0xffffffff)) {
 15459  			break
 15460  		}
 15461  		v.reset(OpAnd32)
 15462  		v.AddArg(n)
 15463  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 15464  		v0.AuxInt = (c & 0xffffffff) - 1
 15465  		v.AddArg(v0)
 15466  		return true
 15467  	}
 15468  	// match: (Mod32u <t> x (Const32 [c]))
 15469  	// cond: x.Op != OpConst32 && c > 0 && umagicOK(32,c)
 15470  	// result: (Sub32 x (Mul32 <t> (Div32u <t> x (Const32 <t> [c])) (Const32 <t> [c])))
 15471  	for {
 15472  		t := v.Type
 15473  		_ = v.Args[1]
 15474  		x := v.Args[0]
 15475  		v_1 := v.Args[1]
 15476  		if v_1.Op != OpConst32 {
 15477  			break
 15478  		}
 15479  		c := v_1.AuxInt
 15480  		if !(x.Op != OpConst32 && c > 0 && umagicOK(32, c)) {
 15481  			break
 15482  		}
 15483  		v.reset(OpSub32)
 15484  		v.AddArg(x)
 15485  		v0 := b.NewValue0(v.Pos, OpMul32, t)
 15486  		v1 := b.NewValue0(v.Pos, OpDiv32u, t)
 15487  		v1.AddArg(x)
 15488  		v2 := b.NewValue0(v.Pos, OpConst32, t)
 15489  		v2.AuxInt = c
 15490  		v1.AddArg(v2)
 15491  		v0.AddArg(v1)
 15492  		v3 := b.NewValue0(v.Pos, OpConst32, t)
 15493  		v3.AuxInt = c
 15494  		v0.AddArg(v3)
 15495  		v.AddArg(v0)
 15496  		return true
 15497  	}
 15498  	return false
 15499  }
 15500  func rewriteValuegeneric_OpMod64_0(v *Value) bool {
 15501  	b := v.Block
 15502  	_ = b
 15503  	// match: (Mod64 (Const64 [c]) (Const64 [d]))
 15504  	// cond: d != 0
 15505  	// result: (Const64 [c % d])
 15506  	for {
 15507  		_ = v.Args[1]
 15508  		v_0 := v.Args[0]
 15509  		if v_0.Op != OpConst64 {
 15510  			break
 15511  		}
 15512  		c := v_0.AuxInt
 15513  		v_1 := v.Args[1]
 15514  		if v_1.Op != OpConst64 {
 15515  			break
 15516  		}
 15517  		d := v_1.AuxInt
 15518  		if !(d != 0) {
 15519  			break
 15520  		}
 15521  		v.reset(OpConst64)
 15522  		v.AuxInt = c % d
 15523  		return true
 15524  	}
 15525  	// match: (Mod64 <t> n (Const64 [c]))
 15526  	// cond: isNonNegative(n) && isPowerOfTwo(c)
 15527  	// result: (And64 n (Const64 <t> [c-1]))
 15528  	for {
 15529  		t := v.Type
 15530  		_ = v.Args[1]
 15531  		n := v.Args[0]
 15532  		v_1 := v.Args[1]
 15533  		if v_1.Op != OpConst64 {
 15534  			break
 15535  		}
 15536  		c := v_1.AuxInt
 15537  		if !(isNonNegative(n) && isPowerOfTwo(c)) {
 15538  			break
 15539  		}
 15540  		v.reset(OpAnd64)
 15541  		v.AddArg(n)
 15542  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 15543  		v0.AuxInt = c - 1
 15544  		v.AddArg(v0)
 15545  		return true
 15546  	}
 15547  	// match: (Mod64 n (Const64 [-1<<63]))
 15548  	// cond: isNonNegative(n)
 15549  	// result: n
 15550  	for {
 15551  		_ = v.Args[1]
 15552  		n := v.Args[0]
 15553  		v_1 := v.Args[1]
 15554  		if v_1.Op != OpConst64 {
 15555  			break
 15556  		}
 15557  		if v_1.AuxInt != -1<<63 {
 15558  			break
 15559  		}
 15560  		if !(isNonNegative(n)) {
 15561  			break
 15562  		}
 15563  		v.reset(OpCopy)
 15564  		v.Type = n.Type
 15565  		v.AddArg(n)
 15566  		return true
 15567  	}
 15568  	// match: (Mod64 <t> n (Const64 [c]))
 15569  	// cond: c < 0 && c != -1<<63
 15570  	// result: (Mod64 <t> n (Const64 <t> [-c]))
 15571  	for {
 15572  		t := v.Type
 15573  		_ = v.Args[1]
 15574  		n := v.Args[0]
 15575  		v_1 := v.Args[1]
 15576  		if v_1.Op != OpConst64 {
 15577  			break
 15578  		}
 15579  		c := v_1.AuxInt
 15580  		if !(c < 0 && c != -1<<63) {
 15581  			break
 15582  		}
 15583  		v.reset(OpMod64)
 15584  		v.Type = t
 15585  		v.AddArg(n)
 15586  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 15587  		v0.AuxInt = -c
 15588  		v.AddArg(v0)
 15589  		return true
 15590  	}
 15591  	// match: (Mod64 <t> x (Const64 [c]))
 15592  	// cond: x.Op != OpConst64 && (c > 0 || c == -1<<63)
 15593  	// result: (Sub64 x (Mul64 <t> (Div64 <t> x (Const64 <t> [c])) (Const64 <t> [c])))
 15594  	for {
 15595  		t := v.Type
 15596  		_ = v.Args[1]
 15597  		x := v.Args[0]
 15598  		v_1 := v.Args[1]
 15599  		if v_1.Op != OpConst64 {
 15600  			break
 15601  		}
 15602  		c := v_1.AuxInt
 15603  		if !(x.Op != OpConst64 && (c > 0 || c == -1<<63)) {
 15604  			break
 15605  		}
 15606  		v.reset(OpSub64)
 15607  		v.AddArg(x)
 15608  		v0 := b.NewValue0(v.Pos, OpMul64, t)
 15609  		v1 := b.NewValue0(v.Pos, OpDiv64, t)
 15610  		v1.AddArg(x)
 15611  		v2 := b.NewValue0(v.Pos, OpConst64, t)
 15612  		v2.AuxInt = c
 15613  		v1.AddArg(v2)
 15614  		v0.AddArg(v1)
 15615  		v3 := b.NewValue0(v.Pos, OpConst64, t)
 15616  		v3.AuxInt = c
 15617  		v0.AddArg(v3)
 15618  		v.AddArg(v0)
 15619  		return true
 15620  	}
 15621  	return false
 15622  }
 15623  func rewriteValuegeneric_OpMod64u_0(v *Value) bool {
 15624  	b := v.Block
 15625  	_ = b
 15626  	// match: (Mod64u (Const64 [c]) (Const64 [d]))
 15627  	// cond: d != 0
 15628  	// result: (Const64 [int64(uint64(c) % uint64(d))])
 15629  	for {
 15630  		_ = v.Args[1]
 15631  		v_0 := v.Args[0]
 15632  		if v_0.Op != OpConst64 {
 15633  			break
 15634  		}
 15635  		c := v_0.AuxInt
 15636  		v_1 := v.Args[1]
 15637  		if v_1.Op != OpConst64 {
 15638  			break
 15639  		}
 15640  		d := v_1.AuxInt
 15641  		if !(d != 0) {
 15642  			break
 15643  		}
 15644  		v.reset(OpConst64)
 15645  		v.AuxInt = int64(uint64(c) % uint64(d))
 15646  		return true
 15647  	}
 15648  	// match: (Mod64u <t> n (Const64 [c]))
 15649  	// cond: isPowerOfTwo(c)
 15650  	// result: (And64 n (Const64 <t> [c-1]))
 15651  	for {
 15652  		t := v.Type
 15653  		_ = v.Args[1]
 15654  		n := v.Args[0]
 15655  		v_1 := v.Args[1]
 15656  		if v_1.Op != OpConst64 {
 15657  			break
 15658  		}
 15659  		c := v_1.AuxInt
 15660  		if !(isPowerOfTwo(c)) {
 15661  			break
 15662  		}
 15663  		v.reset(OpAnd64)
 15664  		v.AddArg(n)
 15665  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 15666  		v0.AuxInt = c - 1
 15667  		v.AddArg(v0)
 15668  		return true
 15669  	}
 15670  	// match: (Mod64u <t> n (Const64 [-1<<63]))
 15671  	// cond:
 15672  	// result: (And64 n (Const64 <t> [1<<63-1]))
 15673  	for {
 15674  		t := v.Type
 15675  		_ = v.Args[1]
 15676  		n := v.Args[0]
 15677  		v_1 := v.Args[1]
 15678  		if v_1.Op != OpConst64 {
 15679  			break
 15680  		}
 15681  		if v_1.AuxInt != -1<<63 {
 15682  			break
 15683  		}
 15684  		v.reset(OpAnd64)
 15685  		v.AddArg(n)
 15686  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 15687  		v0.AuxInt = 1<<63 - 1
 15688  		v.AddArg(v0)
 15689  		return true
 15690  	}
 15691  	// match: (Mod64u <t> x (Const64 [c]))
 15692  	// cond: x.Op != OpConst64 && c > 0 && umagicOK(64,c)
 15693  	// result: (Sub64 x (Mul64 <t> (Div64u <t> x (Const64 <t> [c])) (Const64 <t> [c])))
 15694  	for {
 15695  		t := v.Type
 15696  		_ = v.Args[1]
 15697  		x := v.Args[0]
 15698  		v_1 := v.Args[1]
 15699  		if v_1.Op != OpConst64 {
 15700  			break
 15701  		}
 15702  		c := v_1.AuxInt
 15703  		if !(x.Op != OpConst64 && c > 0 && umagicOK(64, c)) {
 15704  			break
 15705  		}
 15706  		v.reset(OpSub64)
 15707  		v.AddArg(x)
 15708  		v0 := b.NewValue0(v.Pos, OpMul64, t)
 15709  		v1 := b.NewValue0(v.Pos, OpDiv64u, t)
 15710  		v1.AddArg(x)
 15711  		v2 := b.NewValue0(v.Pos, OpConst64, t)
 15712  		v2.AuxInt = c
 15713  		v1.AddArg(v2)
 15714  		v0.AddArg(v1)
 15715  		v3 := b.NewValue0(v.Pos, OpConst64, t)
 15716  		v3.AuxInt = c
 15717  		v0.AddArg(v3)
 15718  		v.AddArg(v0)
 15719  		return true
 15720  	}
 15721  	return false
 15722  }
 15723  func rewriteValuegeneric_OpMod8_0(v *Value) bool {
 15724  	b := v.Block
 15725  	_ = b
 15726  	// match: (Mod8 (Const8 [c]) (Const8 [d]))
 15727  	// cond: d != 0
 15728  	// result: (Const8 [int64(int8(c % d))])
 15729  	for {
 15730  		_ = v.Args[1]
 15731  		v_0 := v.Args[0]
 15732  		if v_0.Op != OpConst8 {
 15733  			break
 15734  		}
 15735  		c := v_0.AuxInt
 15736  		v_1 := v.Args[1]
 15737  		if v_1.Op != OpConst8 {
 15738  			break
 15739  		}
 15740  		d := v_1.AuxInt
 15741  		if !(d != 0) {
 15742  			break
 15743  		}
 15744  		v.reset(OpConst8)
 15745  		v.AuxInt = int64(int8(c % d))
 15746  		return true
 15747  	}
 15748  	// match: (Mod8 <t> n (Const8 [c]))
 15749  	// cond: isNonNegative(n) && isPowerOfTwo(c&0xff)
 15750  	// result: (And8 n (Const8 <t> [(c&0xff)-1]))
 15751  	for {
 15752  		t := v.Type
 15753  		_ = v.Args[1]
 15754  		n := v.Args[0]
 15755  		v_1 := v.Args[1]
 15756  		if v_1.Op != OpConst8 {
 15757  			break
 15758  		}
 15759  		c := v_1.AuxInt
 15760  		if !(isNonNegative(n) && isPowerOfTwo(c&0xff)) {
 15761  			break
 15762  		}
 15763  		v.reset(OpAnd8)
 15764  		v.AddArg(n)
 15765  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 15766  		v0.AuxInt = (c & 0xff) - 1
 15767  		v.AddArg(v0)
 15768  		return true
 15769  	}
 15770  	// match: (Mod8 <t> n (Const8 [c]))
 15771  	// cond: c < 0 && c != -1<<7
 15772  	// result: (Mod8 <t> n (Const8 <t> [-c]))
 15773  	for {
 15774  		t := v.Type
 15775  		_ = v.Args[1]
 15776  		n := v.Args[0]
 15777  		v_1 := v.Args[1]
 15778  		if v_1.Op != OpConst8 {
 15779  			break
 15780  		}
 15781  		c := v_1.AuxInt
 15782  		if !(c < 0 && c != -1<<7) {
 15783  			break
 15784  		}
 15785  		v.reset(OpMod8)
 15786  		v.Type = t
 15787  		v.AddArg(n)
 15788  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 15789  		v0.AuxInt = -c
 15790  		v.AddArg(v0)
 15791  		return true
 15792  	}
 15793  	// match: (Mod8 <t> x (Const8 [c]))
 15794  	// cond: x.Op != OpConst8 && (c > 0 || c == -1<<7)
 15795  	// result: (Sub8 x (Mul8 <t> (Div8 <t> x (Const8 <t> [c])) (Const8 <t> [c])))
 15796  	for {
 15797  		t := v.Type
 15798  		_ = v.Args[1]
 15799  		x := v.Args[0]
 15800  		v_1 := v.Args[1]
 15801  		if v_1.Op != OpConst8 {
 15802  			break
 15803  		}
 15804  		c := v_1.AuxInt
 15805  		if !(x.Op != OpConst8 && (c > 0 || c == -1<<7)) {
 15806  			break
 15807  		}
 15808  		v.reset(OpSub8)
 15809  		v.AddArg(x)
 15810  		v0 := b.NewValue0(v.Pos, OpMul8, t)
 15811  		v1 := b.NewValue0(v.Pos, OpDiv8, t)
 15812  		v1.AddArg(x)
 15813  		v2 := b.NewValue0(v.Pos, OpConst8, t)
 15814  		v2.AuxInt = c
 15815  		v1.AddArg(v2)
 15816  		v0.AddArg(v1)
 15817  		v3 := b.NewValue0(v.Pos, OpConst8, t)
 15818  		v3.AuxInt = c
 15819  		v0.AddArg(v3)
 15820  		v.AddArg(v0)
 15821  		return true
 15822  	}
 15823  	return false
 15824  }
 15825  func rewriteValuegeneric_OpMod8u_0(v *Value) bool {
 15826  	b := v.Block
 15827  	_ = b
 15828  	// match: (Mod8u (Const8 [c]) (Const8 [d]))
 15829  	// cond: d != 0
 15830  	// result: (Const8 [int64(uint8(c) % uint8(d))])
 15831  	for {
 15832  		_ = v.Args[1]
 15833  		v_0 := v.Args[0]
 15834  		if v_0.Op != OpConst8 {
 15835  			break
 15836  		}
 15837  		c := v_0.AuxInt
 15838  		v_1 := v.Args[1]
 15839  		if v_1.Op != OpConst8 {
 15840  			break
 15841  		}
 15842  		d := v_1.AuxInt
 15843  		if !(d != 0) {
 15844  			break
 15845  		}
 15846  		v.reset(OpConst8)
 15847  		v.AuxInt = int64(uint8(c) % uint8(d))
 15848  		return true
 15849  	}
 15850  	// match: (Mod8u <t> n (Const8 [c]))
 15851  	// cond: isPowerOfTwo(c&0xff)
 15852  	// result: (And8 n (Const8 <t> [(c&0xff)-1]))
 15853  	for {
 15854  		t := v.Type
 15855  		_ = v.Args[1]
 15856  		n := v.Args[0]
 15857  		v_1 := v.Args[1]
 15858  		if v_1.Op != OpConst8 {
 15859  			break
 15860  		}
 15861  		c := v_1.AuxInt
 15862  		if !(isPowerOfTwo(c & 0xff)) {
 15863  			break
 15864  		}
 15865  		v.reset(OpAnd8)
 15866  		v.AddArg(n)
 15867  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 15868  		v0.AuxInt = (c & 0xff) - 1
 15869  		v.AddArg(v0)
 15870  		return true
 15871  	}
 15872  	// match: (Mod8u <t> x (Const8 [c]))
 15873  	// cond: x.Op != OpConst8 && c > 0 && umagicOK(8 ,c)
 15874  	// result: (Sub8 x (Mul8 <t> (Div8u <t> x (Const8 <t> [c])) (Const8 <t> [c])))
 15875  	for {
 15876  		t := v.Type
 15877  		_ = v.Args[1]
 15878  		x := v.Args[0]
 15879  		v_1 := v.Args[1]
 15880  		if v_1.Op != OpConst8 {
 15881  			break
 15882  		}
 15883  		c := v_1.AuxInt
 15884  		if !(x.Op != OpConst8 && c > 0 && umagicOK(8, c)) {
 15885  			break
 15886  		}
 15887  		v.reset(OpSub8)
 15888  		v.AddArg(x)
 15889  		v0 := b.NewValue0(v.Pos, OpMul8, t)
 15890  		v1 := b.NewValue0(v.Pos, OpDiv8u, t)
 15891  		v1.AddArg(x)
 15892  		v2 := b.NewValue0(v.Pos, OpConst8, t)
 15893  		v2.AuxInt = c
 15894  		v1.AddArg(v2)
 15895  		v0.AddArg(v1)
 15896  		v3 := b.NewValue0(v.Pos, OpConst8, t)
 15897  		v3.AuxInt = c
 15898  		v0.AddArg(v3)
 15899  		v.AddArg(v0)
 15900  		return true
 15901  	}
 15902  	return false
 15903  }
 15904  func rewriteValuegeneric_OpMove_0(v *Value) bool {
 15905  	b := v.Block
 15906  	_ = b
 15907  	// match: (Move {t} [n] dst1 src mem:(Zero {t} [n] dst2 _))
 15908  	// cond: isSamePtr(src, dst2)
 15909  	// result: (Zero {t} [n] dst1 mem)
 15910  	for {
 15911  		n := v.AuxInt
 15912  		t := v.Aux
 15913  		_ = v.Args[2]
 15914  		dst1 := v.Args[0]
 15915  		src := v.Args[1]
 15916  		mem := v.Args[2]
 15917  		if mem.Op != OpZero {
 15918  			break
 15919  		}
 15920  		if mem.AuxInt != n {
 15921  			break
 15922  		}
 15923  		if mem.Aux != t {
 15924  			break
 15925  		}
 15926  		_ = mem.Args[1]
 15927  		dst2 := mem.Args[0]
 15928  		if !(isSamePtr(src, dst2)) {
 15929  			break
 15930  		}
 15931  		v.reset(OpZero)
 15932  		v.AuxInt = n
 15933  		v.Aux = t
 15934  		v.AddArg(dst1)
 15935  		v.AddArg(mem)
 15936  		return true
 15937  	}
 15938  	// match: (Move {t} [n] dst1 src mem:(VarDef (Zero {t} [n] dst0 _)))
 15939  	// cond: isSamePtr(src, dst0)
 15940  	// result: (Zero {t} [n] dst1 mem)
 15941  	for {
 15942  		n := v.AuxInt
 15943  		t := v.Aux
 15944  		_ = v.Args[2]
 15945  		dst1 := v.Args[0]
 15946  		src := v.Args[1]
 15947  		mem := v.Args[2]
 15948  		if mem.Op != OpVarDef {
 15949  			break
 15950  		}
 15951  		mem_0 := mem.Args[0]
 15952  		if mem_0.Op != OpZero {
 15953  			break
 15954  		}
 15955  		if mem_0.AuxInt != n {
 15956  			break
 15957  		}
 15958  		if mem_0.Aux != t {
 15959  			break
 15960  		}
 15961  		_ = mem_0.Args[1]
 15962  		dst0 := mem_0.Args[0]
 15963  		if !(isSamePtr(src, dst0)) {
 15964  			break
 15965  		}
 15966  		v.reset(OpZero)
 15967  		v.AuxInt = n
 15968  		v.Aux = t
 15969  		v.AddArg(dst1)
 15970  		v.AddArg(mem)
 15971  		return true
 15972  	}
 15973  	// match: (Move {t1} [n] dst1 src1 store:(Store {t2} op:(OffPtr [o2] dst2) _ mem))
 15974  	// cond: isSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2 + sizeof(t2) && disjoint(src1, n, op, sizeof(t2)) && clobber(store)
 15975  	// result: (Move {t1} [n] dst1 src1 mem)
 15976  	for {
 15977  		n := v.AuxInt
 15978  		t1 := v.Aux
 15979  		_ = v.Args[2]
 15980  		dst1 := v.Args[0]
 15981  		src1 := v.Args[1]
 15982  		store := v.Args[2]
 15983  		if store.Op != OpStore {
 15984  			break
 15985  		}
 15986  		t2 := store.Aux
 15987  		_ = store.Args[2]
 15988  		op := store.Args[0]
 15989  		if op.Op != OpOffPtr {
 15990  			break
 15991  		}
 15992  		o2 := op.AuxInt
 15993  		dst2 := op.Args[0]
 15994  		mem := store.Args[2]
 15995  		if !(isSamePtr(dst1, dst2) && store.Uses == 1 && n >= o2+sizeof(t2) && disjoint(src1, n, op, sizeof(t2)) && clobber(store)) {
 15996  			break
 15997  		}
 15998  		v.reset(OpMove)
 15999  		v.AuxInt = n
 16000  		v.Aux = t1
 16001  		v.AddArg(dst1)
 16002  		v.AddArg(src1)
 16003  		v.AddArg(mem)
 16004  		return true
 16005  	}
 16006  	// match: (Move {t} [n] dst1 src1 move:(Move {t} [n] dst2 _ mem))
 16007  	// cond: move.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move)
 16008  	// result: (Move {t} [n] dst1 src1 mem)
 16009  	for {
 16010  		n := v.AuxInt
 16011  		t := v.Aux
 16012  		_ = v.Args[2]
 16013  		dst1 := v.Args[0]
 16014  		src1 := v.Args[1]
 16015  		move := v.Args[2]
 16016  		if move.Op != OpMove {
 16017  			break
 16018  		}
 16019  		if move.AuxInt != n {
 16020  			break
 16021  		}
 16022  		if move.Aux != t {
 16023  			break
 16024  		}
 16025  		_ = move.Args[2]
 16026  		dst2 := move.Args[0]
 16027  		mem := move.Args[2]
 16028  		if !(move.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move)) {
 16029  			break
 16030  		}
 16031  		v.reset(OpMove)
 16032  		v.AuxInt = n
 16033  		v.Aux = t
 16034  		v.AddArg(dst1)
 16035  		v.AddArg(src1)
 16036  		v.AddArg(mem)
 16037  		return true
 16038  	}
 16039  	// match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem)))
 16040  	// cond: move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) && clobber(vardef)
 16041  	// result: (Move {t} [n] dst1 src1 (VarDef {x} mem))
 16042  	for {
 16043  		n := v.AuxInt
 16044  		t := v.Aux
 16045  		_ = v.Args[2]
 16046  		dst1 := v.Args[0]
 16047  		src1 := v.Args[1]
 16048  		vardef := v.Args[2]
 16049  		if vardef.Op != OpVarDef {
 16050  			break
 16051  		}
 16052  		x := vardef.Aux
 16053  		move := vardef.Args[0]
 16054  		if move.Op != OpMove {
 16055  			break
 16056  		}
 16057  		if move.AuxInt != n {
 16058  			break
 16059  		}
 16060  		if move.Aux != t {
 16061  			break
 16062  		}
 16063  		_ = move.Args[2]
 16064  		dst2 := move.Args[0]
 16065  		mem := move.Args[2]
 16066  		if !(move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(move) && clobber(vardef)) {
 16067  			break
 16068  		}
 16069  		v.reset(OpMove)
 16070  		v.AuxInt = n
 16071  		v.Aux = t
 16072  		v.AddArg(dst1)
 16073  		v.AddArg(src1)
 16074  		v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 16075  		v0.Aux = x
 16076  		v0.AddArg(mem)
 16077  		v.AddArg(v0)
 16078  		return true
 16079  	}
 16080  	// match: (Move {t} [n] dst1 src1 zero:(Zero {t} [n] dst2 mem))
 16081  	// cond: zero.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero)
 16082  	// result: (Move {t} [n] dst1 src1 mem)
 16083  	for {
 16084  		n := v.AuxInt
 16085  		t := v.Aux
 16086  		_ = v.Args[2]
 16087  		dst1 := v.Args[0]
 16088  		src1 := v.Args[1]
 16089  		zero := v.Args[2]
 16090  		if zero.Op != OpZero {
 16091  			break
 16092  		}
 16093  		if zero.AuxInt != n {
 16094  			break
 16095  		}
 16096  		if zero.Aux != t {
 16097  			break
 16098  		}
 16099  		_ = zero.Args[1]
 16100  		dst2 := zero.Args[0]
 16101  		mem := zero.Args[1]
 16102  		if !(zero.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero)) {
 16103  			break
 16104  		}
 16105  		v.reset(OpMove)
 16106  		v.AuxInt = n
 16107  		v.Aux = t
 16108  		v.AddArg(dst1)
 16109  		v.AddArg(src1)
 16110  		v.AddArg(mem)
 16111  		return true
 16112  	}
 16113  	// match: (Move {t} [n] dst1 src1 vardef:(VarDef {x} zero:(Zero {t} [n] dst2 mem)))
 16114  	// cond: zero.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) && clobber(vardef)
 16115  	// result: (Move {t} [n] dst1 src1 (VarDef {x} mem))
 16116  	for {
 16117  		n := v.AuxInt
 16118  		t := v.Aux
 16119  		_ = v.Args[2]
 16120  		dst1 := v.Args[0]
 16121  		src1 := v.Args[1]
 16122  		vardef := v.Args[2]
 16123  		if vardef.Op != OpVarDef {
 16124  			break
 16125  		}
 16126  		x := vardef.Aux
 16127  		zero := vardef.Args[0]
 16128  		if zero.Op != OpZero {
 16129  			break
 16130  		}
 16131  		if zero.AuxInt != n {
 16132  			break
 16133  		}
 16134  		if zero.Aux != t {
 16135  			break
 16136  		}
 16137  		_ = zero.Args[1]
 16138  		dst2 := zero.Args[0]
 16139  		mem := zero.Args[1]
 16140  		if !(zero.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && disjoint(src1, n, dst2, n) && clobber(zero) && clobber(vardef)) {
 16141  			break
 16142  		}
 16143  		v.reset(OpMove)
 16144  		v.AuxInt = n
 16145  		v.Aux = t
 16146  		v.AddArg(dst1)
 16147  		v.AddArg(src1)
 16148  		v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 16149  		v0.Aux = x
 16150  		v0.AddArg(mem)
 16151  		v.AddArg(v0)
 16152  		return true
 16153  	}
 16154  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _)))
 16155  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3)
 16156  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
 16157  	for {
 16158  		n := v.AuxInt
 16159  		t1 := v.Aux
 16160  		_ = v.Args[2]
 16161  		dst := v.Args[0]
 16162  		p1 := v.Args[1]
 16163  		mem := v.Args[2]
 16164  		if mem.Op != OpStore {
 16165  			break
 16166  		}
 16167  		t2 := mem.Aux
 16168  		_ = mem.Args[2]
 16169  		op2 := mem.Args[0]
 16170  		if op2.Op != OpOffPtr {
 16171  			break
 16172  		}
 16173  		tt2 := op2.Type
 16174  		o2 := op2.AuxInt
 16175  		p2 := op2.Args[0]
 16176  		d1 := mem.Args[1]
 16177  		mem_2 := mem.Args[2]
 16178  		if mem_2.Op != OpStore {
 16179  			break
 16180  		}
 16181  		t3 := mem_2.Aux
 16182  		_ = mem_2.Args[2]
 16183  		op3 := mem_2.Args[0]
 16184  		if op3.Op != OpOffPtr {
 16185  			break
 16186  		}
 16187  		tt3 := op3.Type
 16188  		if op3.AuxInt != 0 {
 16189  			break
 16190  		}
 16191  		p3 := op3.Args[0]
 16192  		d2 := mem_2.Args[1]
 16193  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)) {
 16194  			break
 16195  		}
 16196  		v.reset(OpStore)
 16197  		v.Aux = t2
 16198  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16199  		v0.AuxInt = o2
 16200  		v0.AddArg(dst)
 16201  		v.AddArg(v0)
 16202  		v.AddArg(d1)
 16203  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16204  		v1.Aux = t3
 16205  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16206  		v2.AuxInt = 0
 16207  		v2.AddArg(dst)
 16208  		v1.AddArg(v2)
 16209  		v1.AddArg(d2)
 16210  		v1.AddArg(mem)
 16211  		v.AddArg(v1)
 16212  		return true
 16213  	}
 16214  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _))))
 16215  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4)
 16216  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem)))
 16217  	for {
 16218  		n := v.AuxInt
 16219  		t1 := v.Aux
 16220  		_ = v.Args[2]
 16221  		dst := v.Args[0]
 16222  		p1 := v.Args[1]
 16223  		mem := v.Args[2]
 16224  		if mem.Op != OpStore {
 16225  			break
 16226  		}
 16227  		t2 := mem.Aux
 16228  		_ = mem.Args[2]
 16229  		op2 := mem.Args[0]
 16230  		if op2.Op != OpOffPtr {
 16231  			break
 16232  		}
 16233  		tt2 := op2.Type
 16234  		o2 := op2.AuxInt
 16235  		p2 := op2.Args[0]
 16236  		d1 := mem.Args[1]
 16237  		mem_2 := mem.Args[2]
 16238  		if mem_2.Op != OpStore {
 16239  			break
 16240  		}
 16241  		t3 := mem_2.Aux
 16242  		_ = mem_2.Args[2]
 16243  		op3 := mem_2.Args[0]
 16244  		if op3.Op != OpOffPtr {
 16245  			break
 16246  		}
 16247  		tt3 := op3.Type
 16248  		o3 := op3.AuxInt
 16249  		p3 := op3.Args[0]
 16250  		d2 := mem_2.Args[1]
 16251  		mem_2_2 := mem_2.Args[2]
 16252  		if mem_2_2.Op != OpStore {
 16253  			break
 16254  		}
 16255  		t4 := mem_2_2.Aux
 16256  		_ = mem_2_2.Args[2]
 16257  		op4 := mem_2_2.Args[0]
 16258  		if op4.Op != OpOffPtr {
 16259  			break
 16260  		}
 16261  		tt4 := op4.Type
 16262  		if op4.AuxInt != 0 {
 16263  			break
 16264  		}
 16265  		p4 := op4.Args[0]
 16266  		d3 := mem_2_2.Args[1]
 16267  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)) {
 16268  			break
 16269  		}
 16270  		v.reset(OpStore)
 16271  		v.Aux = t2
 16272  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16273  		v0.AuxInt = o2
 16274  		v0.AddArg(dst)
 16275  		v.AddArg(v0)
 16276  		v.AddArg(d1)
 16277  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16278  		v1.Aux = t3
 16279  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16280  		v2.AuxInt = o3
 16281  		v2.AddArg(dst)
 16282  		v1.AddArg(v2)
 16283  		v1.AddArg(d2)
 16284  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16285  		v3.Aux = t4
 16286  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 16287  		v4.AuxInt = 0
 16288  		v4.AddArg(dst)
 16289  		v3.AddArg(v4)
 16290  		v3.AddArg(d3)
 16291  		v3.AddArg(mem)
 16292  		v1.AddArg(v3)
 16293  		v.AddArg(v1)
 16294  		return true
 16295  	}
 16296  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _)))))
 16297  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) + sizeof(t5)
 16298  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem))))
 16299  	for {
 16300  		n := v.AuxInt
 16301  		t1 := v.Aux
 16302  		_ = v.Args[2]
 16303  		dst := v.Args[0]
 16304  		p1 := v.Args[1]
 16305  		mem := v.Args[2]
 16306  		if mem.Op != OpStore {
 16307  			break
 16308  		}
 16309  		t2 := mem.Aux
 16310  		_ = mem.Args[2]
 16311  		op2 := mem.Args[0]
 16312  		if op2.Op != OpOffPtr {
 16313  			break
 16314  		}
 16315  		tt2 := op2.Type
 16316  		o2 := op2.AuxInt
 16317  		p2 := op2.Args[0]
 16318  		d1 := mem.Args[1]
 16319  		mem_2 := mem.Args[2]
 16320  		if mem_2.Op != OpStore {
 16321  			break
 16322  		}
 16323  		t3 := mem_2.Aux
 16324  		_ = mem_2.Args[2]
 16325  		op3 := mem_2.Args[0]
 16326  		if op3.Op != OpOffPtr {
 16327  			break
 16328  		}
 16329  		tt3 := op3.Type
 16330  		o3 := op3.AuxInt
 16331  		p3 := op3.Args[0]
 16332  		d2 := mem_2.Args[1]
 16333  		mem_2_2 := mem_2.Args[2]
 16334  		if mem_2_2.Op != OpStore {
 16335  			break
 16336  		}
 16337  		t4 := mem_2_2.Aux
 16338  		_ = mem_2_2.Args[2]
 16339  		op4 := mem_2_2.Args[0]
 16340  		if op4.Op != OpOffPtr {
 16341  			break
 16342  		}
 16343  		tt4 := op4.Type
 16344  		o4 := op4.AuxInt
 16345  		p4 := op4.Args[0]
 16346  		d3 := mem_2_2.Args[1]
 16347  		mem_2_2_2 := mem_2_2.Args[2]
 16348  		if mem_2_2_2.Op != OpStore {
 16349  			break
 16350  		}
 16351  		t5 := mem_2_2_2.Aux
 16352  		_ = mem_2_2_2.Args[2]
 16353  		op5 := mem_2_2_2.Args[0]
 16354  		if op5.Op != OpOffPtr {
 16355  			break
 16356  		}
 16357  		tt5 := op5.Type
 16358  		if op5.AuxInt != 0 {
 16359  			break
 16360  		}
 16361  		p5 := op5.Args[0]
 16362  		d4 := mem_2_2_2.Args[1]
 16363  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)+sizeof(t5)) {
 16364  			break
 16365  		}
 16366  		v.reset(OpStore)
 16367  		v.Aux = t2
 16368  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16369  		v0.AuxInt = o2
 16370  		v0.AddArg(dst)
 16371  		v.AddArg(v0)
 16372  		v.AddArg(d1)
 16373  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16374  		v1.Aux = t3
 16375  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16376  		v2.AuxInt = o3
 16377  		v2.AddArg(dst)
 16378  		v1.AddArg(v2)
 16379  		v1.AddArg(d2)
 16380  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16381  		v3.Aux = t4
 16382  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 16383  		v4.AuxInt = o4
 16384  		v4.AddArg(dst)
 16385  		v3.AddArg(v4)
 16386  		v3.AddArg(d3)
 16387  		v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16388  		v5.Aux = t5
 16389  		v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 16390  		v6.AuxInt = 0
 16391  		v6.AddArg(dst)
 16392  		v5.AddArg(v6)
 16393  		v5.AddArg(d4)
 16394  		v5.AddArg(mem)
 16395  		v3.AddArg(v5)
 16396  		v1.AddArg(v3)
 16397  		v.AddArg(v1)
 16398  		return true
 16399  	}
 16400  	return false
 16401  }
 16402  func rewriteValuegeneric_OpMove_10(v *Value) bool {
 16403  	b := v.Block
 16404  	_ = b
 16405  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _))))
 16406  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3)
 16407  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
 16408  	for {
 16409  		n := v.AuxInt
 16410  		t1 := v.Aux
 16411  		_ = v.Args[2]
 16412  		dst := v.Args[0]
 16413  		p1 := v.Args[1]
 16414  		mem := v.Args[2]
 16415  		if mem.Op != OpVarDef {
 16416  			break
 16417  		}
 16418  		mem_0 := mem.Args[0]
 16419  		if mem_0.Op != OpStore {
 16420  			break
 16421  		}
 16422  		t2 := mem_0.Aux
 16423  		_ = mem_0.Args[2]
 16424  		op2 := mem_0.Args[0]
 16425  		if op2.Op != OpOffPtr {
 16426  			break
 16427  		}
 16428  		tt2 := op2.Type
 16429  		o2 := op2.AuxInt
 16430  		p2 := op2.Args[0]
 16431  		d1 := mem_0.Args[1]
 16432  		mem_0_2 := mem_0.Args[2]
 16433  		if mem_0_2.Op != OpStore {
 16434  			break
 16435  		}
 16436  		t3 := mem_0_2.Aux
 16437  		_ = mem_0_2.Args[2]
 16438  		op3 := mem_0_2.Args[0]
 16439  		if op3.Op != OpOffPtr {
 16440  			break
 16441  		}
 16442  		tt3 := op3.Type
 16443  		if op3.AuxInt != 0 {
 16444  			break
 16445  		}
 16446  		p3 := op3.Args[0]
 16447  		d2 := mem_0_2.Args[1]
 16448  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)) {
 16449  			break
 16450  		}
 16451  		v.reset(OpStore)
 16452  		v.Aux = t2
 16453  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16454  		v0.AuxInt = o2
 16455  		v0.AddArg(dst)
 16456  		v.AddArg(v0)
 16457  		v.AddArg(d1)
 16458  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16459  		v1.Aux = t3
 16460  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16461  		v2.AuxInt = 0
 16462  		v2.AddArg(dst)
 16463  		v1.AddArg(v2)
 16464  		v1.AddArg(d2)
 16465  		v1.AddArg(mem)
 16466  		v.AddArg(v1)
 16467  		return true
 16468  	}
 16469  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [0] p4) d3 _)))))
 16470  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4)
 16471  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [0] dst) d3 mem)))
 16472  	for {
 16473  		n := v.AuxInt
 16474  		t1 := v.Aux
 16475  		_ = v.Args[2]
 16476  		dst := v.Args[0]
 16477  		p1 := v.Args[1]
 16478  		mem := v.Args[2]
 16479  		if mem.Op != OpVarDef {
 16480  			break
 16481  		}
 16482  		mem_0 := mem.Args[0]
 16483  		if mem_0.Op != OpStore {
 16484  			break
 16485  		}
 16486  		t2 := mem_0.Aux
 16487  		_ = mem_0.Args[2]
 16488  		op2 := mem_0.Args[0]
 16489  		if op2.Op != OpOffPtr {
 16490  			break
 16491  		}
 16492  		tt2 := op2.Type
 16493  		o2 := op2.AuxInt
 16494  		p2 := op2.Args[0]
 16495  		d1 := mem_0.Args[1]
 16496  		mem_0_2 := mem_0.Args[2]
 16497  		if mem_0_2.Op != OpStore {
 16498  			break
 16499  		}
 16500  		t3 := mem_0_2.Aux
 16501  		_ = mem_0_2.Args[2]
 16502  		op3 := mem_0_2.Args[0]
 16503  		if op3.Op != OpOffPtr {
 16504  			break
 16505  		}
 16506  		tt3 := op3.Type
 16507  		o3 := op3.AuxInt
 16508  		p3 := op3.Args[0]
 16509  		d2 := mem_0_2.Args[1]
 16510  		mem_0_2_2 := mem_0_2.Args[2]
 16511  		if mem_0_2_2.Op != OpStore {
 16512  			break
 16513  		}
 16514  		t4 := mem_0_2_2.Aux
 16515  		_ = mem_0_2_2.Args[2]
 16516  		op4 := mem_0_2_2.Args[0]
 16517  		if op4.Op != OpOffPtr {
 16518  			break
 16519  		}
 16520  		tt4 := op4.Type
 16521  		if op4.AuxInt != 0 {
 16522  			break
 16523  		}
 16524  		p4 := op4.Args[0]
 16525  		d3 := mem_0_2_2.Args[1]
 16526  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)) {
 16527  			break
 16528  		}
 16529  		v.reset(OpStore)
 16530  		v.Aux = t2
 16531  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16532  		v0.AuxInt = o2
 16533  		v0.AddArg(dst)
 16534  		v.AddArg(v0)
 16535  		v.AddArg(d1)
 16536  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16537  		v1.Aux = t3
 16538  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16539  		v2.AuxInt = o3
 16540  		v2.AddArg(dst)
 16541  		v1.AddArg(v2)
 16542  		v1.AddArg(d2)
 16543  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16544  		v3.Aux = t4
 16545  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 16546  		v4.AuxInt = 0
 16547  		v4.AddArg(dst)
 16548  		v3.AddArg(v4)
 16549  		v3.AddArg(d3)
 16550  		v3.AddArg(mem)
 16551  		v1.AddArg(v3)
 16552  		v.AddArg(v1)
 16553  		return true
 16554  	}
 16555  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [o3] p3) d2 (Store {t4} op4:(OffPtr <tt4> [o4] p4) d3 (Store {t5} op5:(OffPtr <tt5> [0] p5) d4 _))))))
 16556  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2) + sizeof(t3) + sizeof(t4) + sizeof(t5)
 16557  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [0] dst) d4 mem))))
 16558  	for {
 16559  		n := v.AuxInt
 16560  		t1 := v.Aux
 16561  		_ = v.Args[2]
 16562  		dst := v.Args[0]
 16563  		p1 := v.Args[1]
 16564  		mem := v.Args[2]
 16565  		if mem.Op != OpVarDef {
 16566  			break
 16567  		}
 16568  		mem_0 := mem.Args[0]
 16569  		if mem_0.Op != OpStore {
 16570  			break
 16571  		}
 16572  		t2 := mem_0.Aux
 16573  		_ = mem_0.Args[2]
 16574  		op2 := mem_0.Args[0]
 16575  		if op2.Op != OpOffPtr {
 16576  			break
 16577  		}
 16578  		tt2 := op2.Type
 16579  		o2 := op2.AuxInt
 16580  		p2 := op2.Args[0]
 16581  		d1 := mem_0.Args[1]
 16582  		mem_0_2 := mem_0.Args[2]
 16583  		if mem_0_2.Op != OpStore {
 16584  			break
 16585  		}
 16586  		t3 := mem_0_2.Aux
 16587  		_ = mem_0_2.Args[2]
 16588  		op3 := mem_0_2.Args[0]
 16589  		if op3.Op != OpOffPtr {
 16590  			break
 16591  		}
 16592  		tt3 := op3.Type
 16593  		o3 := op3.AuxInt
 16594  		p3 := op3.Args[0]
 16595  		d2 := mem_0_2.Args[1]
 16596  		mem_0_2_2 := mem_0_2.Args[2]
 16597  		if mem_0_2_2.Op != OpStore {
 16598  			break
 16599  		}
 16600  		t4 := mem_0_2_2.Aux
 16601  		_ = mem_0_2_2.Args[2]
 16602  		op4 := mem_0_2_2.Args[0]
 16603  		if op4.Op != OpOffPtr {
 16604  			break
 16605  		}
 16606  		tt4 := op4.Type
 16607  		o4 := op4.AuxInt
 16608  		p4 := op4.Args[0]
 16609  		d3 := mem_0_2_2.Args[1]
 16610  		mem_0_2_2_2 := mem_0_2_2.Args[2]
 16611  		if mem_0_2_2_2.Op != OpStore {
 16612  			break
 16613  		}
 16614  		t5 := mem_0_2_2_2.Aux
 16615  		_ = mem_0_2_2_2.Args[2]
 16616  		op5 := mem_0_2_2_2.Args[0]
 16617  		if op5.Op != OpOffPtr {
 16618  			break
 16619  		}
 16620  		tt5 := op5.Type
 16621  		if op5.AuxInt != 0 {
 16622  			break
 16623  		}
 16624  		p5 := op5.Args[0]
 16625  		d4 := mem_0_2_2_2.Args[1]
 16626  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && o4 == sizeof(t5) && o3-o4 == sizeof(t4) && o2-o3 == sizeof(t3) && n == sizeof(t2)+sizeof(t3)+sizeof(t4)+sizeof(t5)) {
 16627  			break
 16628  		}
 16629  		v.reset(OpStore)
 16630  		v.Aux = t2
 16631  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16632  		v0.AuxInt = o2
 16633  		v0.AddArg(dst)
 16634  		v.AddArg(v0)
 16635  		v.AddArg(d1)
 16636  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16637  		v1.Aux = t3
 16638  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16639  		v2.AuxInt = o3
 16640  		v2.AddArg(dst)
 16641  		v1.AddArg(v2)
 16642  		v1.AddArg(d2)
 16643  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16644  		v3.Aux = t4
 16645  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 16646  		v4.AuxInt = o4
 16647  		v4.AddArg(dst)
 16648  		v3.AddArg(v4)
 16649  		v3.AddArg(d3)
 16650  		v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16651  		v5.Aux = t5
 16652  		v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 16653  		v6.AuxInt = 0
 16654  		v6.AddArg(dst)
 16655  		v5.AddArg(v6)
 16656  		v5.AddArg(d4)
 16657  		v5.AddArg(mem)
 16658  		v3.AddArg(v5)
 16659  		v1.AddArg(v3)
 16660  		v.AddArg(v1)
 16661  		return true
 16662  	}
 16663  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _)))
 16664  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2 + sizeof(t2)
 16665  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem))
 16666  	for {
 16667  		n := v.AuxInt
 16668  		t1 := v.Aux
 16669  		_ = v.Args[2]
 16670  		dst := v.Args[0]
 16671  		p1 := v.Args[1]
 16672  		mem := v.Args[2]
 16673  		if mem.Op != OpStore {
 16674  			break
 16675  		}
 16676  		t2 := mem.Aux
 16677  		_ = mem.Args[2]
 16678  		op2 := mem.Args[0]
 16679  		if op2.Op != OpOffPtr {
 16680  			break
 16681  		}
 16682  		tt2 := op2.Type
 16683  		o2 := op2.AuxInt
 16684  		p2 := op2.Args[0]
 16685  		d1 := mem.Args[1]
 16686  		mem_2 := mem.Args[2]
 16687  		if mem_2.Op != OpZero {
 16688  			break
 16689  		}
 16690  		if mem_2.AuxInt != n {
 16691  			break
 16692  		}
 16693  		t3 := mem_2.Aux
 16694  		_ = mem_2.Args[1]
 16695  		p3 := mem_2.Args[0]
 16696  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2+sizeof(t2)) {
 16697  			break
 16698  		}
 16699  		v.reset(OpStore)
 16700  		v.Aux = t2
 16701  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16702  		v0.AuxInt = o2
 16703  		v0.AddArg(dst)
 16704  		v.AddArg(v0)
 16705  		v.AddArg(d1)
 16706  		v1 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 16707  		v1.AuxInt = n
 16708  		v1.Aux = t1
 16709  		v1.AddArg(dst)
 16710  		v1.AddArg(mem)
 16711  		v.AddArg(v1)
 16712  		return true
 16713  	}
 16714  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _))))
 16715  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3)
 16716  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem)))
 16717  	for {
 16718  		n := v.AuxInt
 16719  		t1 := v.Aux
 16720  		_ = v.Args[2]
 16721  		dst := v.Args[0]
 16722  		p1 := v.Args[1]
 16723  		mem := v.Args[2]
 16724  		if mem.Op != OpStore {
 16725  			break
 16726  		}
 16727  		t2 := mem.Aux
 16728  		_ = mem.Args[2]
 16729  		mem_0 := mem.Args[0]
 16730  		if mem_0.Op != OpOffPtr {
 16731  			break
 16732  		}
 16733  		tt2 := mem_0.Type
 16734  		o2 := mem_0.AuxInt
 16735  		p2 := mem_0.Args[0]
 16736  		d1 := mem.Args[1]
 16737  		mem_2 := mem.Args[2]
 16738  		if mem_2.Op != OpStore {
 16739  			break
 16740  		}
 16741  		t3 := mem_2.Aux
 16742  		_ = mem_2.Args[2]
 16743  		mem_2_0 := mem_2.Args[0]
 16744  		if mem_2_0.Op != OpOffPtr {
 16745  			break
 16746  		}
 16747  		tt3 := mem_2_0.Type
 16748  		o3 := mem_2_0.AuxInt
 16749  		p3 := mem_2_0.Args[0]
 16750  		d2 := mem_2.Args[1]
 16751  		mem_2_2 := mem_2.Args[2]
 16752  		if mem_2_2.Op != OpZero {
 16753  			break
 16754  		}
 16755  		if mem_2_2.AuxInt != n {
 16756  			break
 16757  		}
 16758  		t4 := mem_2_2.Aux
 16759  		_ = mem_2_2.Args[1]
 16760  		p4 := mem_2_2.Args[0]
 16761  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3)) {
 16762  			break
 16763  		}
 16764  		v.reset(OpStore)
 16765  		v.Aux = t2
 16766  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16767  		v0.AuxInt = o2
 16768  		v0.AddArg(dst)
 16769  		v.AddArg(v0)
 16770  		v.AddArg(d1)
 16771  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16772  		v1.Aux = t3
 16773  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16774  		v2.AuxInt = o3
 16775  		v2.AddArg(dst)
 16776  		v1.AddArg(v2)
 16777  		v1.AddArg(d2)
 16778  		v3 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 16779  		v3.AuxInt = n
 16780  		v3.Aux = t1
 16781  		v3.AddArg(dst)
 16782  		v3.AddArg(mem)
 16783  		v1.AddArg(v3)
 16784  		v.AddArg(v1)
 16785  		return true
 16786  	}
 16787  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _)))))
 16788  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4)
 16789  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem))))
 16790  	for {
 16791  		n := v.AuxInt
 16792  		t1 := v.Aux
 16793  		_ = v.Args[2]
 16794  		dst := v.Args[0]
 16795  		p1 := v.Args[1]
 16796  		mem := v.Args[2]
 16797  		if mem.Op != OpStore {
 16798  			break
 16799  		}
 16800  		t2 := mem.Aux
 16801  		_ = mem.Args[2]
 16802  		mem_0 := mem.Args[0]
 16803  		if mem_0.Op != OpOffPtr {
 16804  			break
 16805  		}
 16806  		tt2 := mem_0.Type
 16807  		o2 := mem_0.AuxInt
 16808  		p2 := mem_0.Args[0]
 16809  		d1 := mem.Args[1]
 16810  		mem_2 := mem.Args[2]
 16811  		if mem_2.Op != OpStore {
 16812  			break
 16813  		}
 16814  		t3 := mem_2.Aux
 16815  		_ = mem_2.Args[2]
 16816  		mem_2_0 := mem_2.Args[0]
 16817  		if mem_2_0.Op != OpOffPtr {
 16818  			break
 16819  		}
 16820  		tt3 := mem_2_0.Type
 16821  		o3 := mem_2_0.AuxInt
 16822  		p3 := mem_2_0.Args[0]
 16823  		d2 := mem_2.Args[1]
 16824  		mem_2_2 := mem_2.Args[2]
 16825  		if mem_2_2.Op != OpStore {
 16826  			break
 16827  		}
 16828  		t4 := mem_2_2.Aux
 16829  		_ = mem_2_2.Args[2]
 16830  		mem_2_2_0 := mem_2_2.Args[0]
 16831  		if mem_2_2_0.Op != OpOffPtr {
 16832  			break
 16833  		}
 16834  		tt4 := mem_2_2_0.Type
 16835  		o4 := mem_2_2_0.AuxInt
 16836  		p4 := mem_2_2_0.Args[0]
 16837  		d3 := mem_2_2.Args[1]
 16838  		mem_2_2_2 := mem_2_2.Args[2]
 16839  		if mem_2_2_2.Op != OpZero {
 16840  			break
 16841  		}
 16842  		if mem_2_2_2.AuxInt != n {
 16843  			break
 16844  		}
 16845  		t5 := mem_2_2_2.Aux
 16846  		_ = mem_2_2_2.Args[1]
 16847  		p5 := mem_2_2_2.Args[0]
 16848  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4)) {
 16849  			break
 16850  		}
 16851  		v.reset(OpStore)
 16852  		v.Aux = t2
 16853  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16854  		v0.AuxInt = o2
 16855  		v0.AddArg(dst)
 16856  		v.AddArg(v0)
 16857  		v.AddArg(d1)
 16858  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16859  		v1.Aux = t3
 16860  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16861  		v2.AuxInt = o3
 16862  		v2.AddArg(dst)
 16863  		v1.AddArg(v2)
 16864  		v1.AddArg(d2)
 16865  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16866  		v3.Aux = t4
 16867  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 16868  		v4.AuxInt = o4
 16869  		v4.AddArg(dst)
 16870  		v3.AddArg(v4)
 16871  		v3.AddArg(d3)
 16872  		v5 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 16873  		v5.AuxInt = n
 16874  		v5.Aux = t1
 16875  		v5.AddArg(dst)
 16876  		v5.AddArg(mem)
 16877  		v3.AddArg(v5)
 16878  		v1.AddArg(v3)
 16879  		v.AddArg(v1)
 16880  		return true
 16881  	}
 16882  	// match: (Move {t1} [n] dst p1 mem:(Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _))))))
 16883  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5)
 16884  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
 16885  	for {
 16886  		n := v.AuxInt
 16887  		t1 := v.Aux
 16888  		_ = v.Args[2]
 16889  		dst := v.Args[0]
 16890  		p1 := v.Args[1]
 16891  		mem := v.Args[2]
 16892  		if mem.Op != OpStore {
 16893  			break
 16894  		}
 16895  		t2 := mem.Aux
 16896  		_ = mem.Args[2]
 16897  		mem_0 := mem.Args[0]
 16898  		if mem_0.Op != OpOffPtr {
 16899  			break
 16900  		}
 16901  		tt2 := mem_0.Type
 16902  		o2 := mem_0.AuxInt
 16903  		p2 := mem_0.Args[0]
 16904  		d1 := mem.Args[1]
 16905  		mem_2 := mem.Args[2]
 16906  		if mem_2.Op != OpStore {
 16907  			break
 16908  		}
 16909  		t3 := mem_2.Aux
 16910  		_ = mem_2.Args[2]
 16911  		mem_2_0 := mem_2.Args[0]
 16912  		if mem_2_0.Op != OpOffPtr {
 16913  			break
 16914  		}
 16915  		tt3 := mem_2_0.Type
 16916  		o3 := mem_2_0.AuxInt
 16917  		p3 := mem_2_0.Args[0]
 16918  		d2 := mem_2.Args[1]
 16919  		mem_2_2 := mem_2.Args[2]
 16920  		if mem_2_2.Op != OpStore {
 16921  			break
 16922  		}
 16923  		t4 := mem_2_2.Aux
 16924  		_ = mem_2_2.Args[2]
 16925  		mem_2_2_0 := mem_2_2.Args[0]
 16926  		if mem_2_2_0.Op != OpOffPtr {
 16927  			break
 16928  		}
 16929  		tt4 := mem_2_2_0.Type
 16930  		o4 := mem_2_2_0.AuxInt
 16931  		p4 := mem_2_2_0.Args[0]
 16932  		d3 := mem_2_2.Args[1]
 16933  		mem_2_2_2 := mem_2_2.Args[2]
 16934  		if mem_2_2_2.Op != OpStore {
 16935  			break
 16936  		}
 16937  		t5 := mem_2_2_2.Aux
 16938  		_ = mem_2_2_2.Args[2]
 16939  		mem_2_2_2_0 := mem_2_2_2.Args[0]
 16940  		if mem_2_2_2_0.Op != OpOffPtr {
 16941  			break
 16942  		}
 16943  		tt5 := mem_2_2_2_0.Type
 16944  		o5 := mem_2_2_2_0.AuxInt
 16945  		p5 := mem_2_2_2_0.Args[0]
 16946  		d4 := mem_2_2_2.Args[1]
 16947  		mem_2_2_2_2 := mem_2_2_2.Args[2]
 16948  		if mem_2_2_2_2.Op != OpZero {
 16949  			break
 16950  		}
 16951  		if mem_2_2_2_2.AuxInt != n {
 16952  			break
 16953  		}
 16954  		t6 := mem_2_2_2_2.Aux
 16955  		_ = mem_2_2_2_2.Args[1]
 16956  		p6 := mem_2_2_2_2.Args[0]
 16957  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4) && n >= o5+sizeof(t5)) {
 16958  			break
 16959  		}
 16960  		v.reset(OpStore)
 16961  		v.Aux = t2
 16962  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 16963  		v0.AuxInt = o2
 16964  		v0.AddArg(dst)
 16965  		v.AddArg(v0)
 16966  		v.AddArg(d1)
 16967  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16968  		v1.Aux = t3
 16969  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 16970  		v2.AuxInt = o3
 16971  		v2.AddArg(dst)
 16972  		v1.AddArg(v2)
 16973  		v1.AddArg(d2)
 16974  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16975  		v3.Aux = t4
 16976  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 16977  		v4.AuxInt = o4
 16978  		v4.AddArg(dst)
 16979  		v3.AddArg(v4)
 16980  		v3.AddArg(d3)
 16981  		v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 16982  		v5.Aux = t5
 16983  		v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 16984  		v6.AuxInt = o5
 16985  		v6.AddArg(dst)
 16986  		v5.AddArg(v6)
 16987  		v5.AddArg(d4)
 16988  		v7 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 16989  		v7.AuxInt = n
 16990  		v7.Aux = t1
 16991  		v7.AddArg(dst)
 16992  		v7.AddArg(mem)
 16993  		v5.AddArg(v7)
 16994  		v3.AddArg(v5)
 16995  		v1.AddArg(v3)
 16996  		v.AddArg(v1)
 16997  		return true
 16998  	}
 16999  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Zero {t3} [n] p3 _))))
 17000  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2 + sizeof(t2)
 17001  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Zero {t1} [n] dst mem))
 17002  	for {
 17003  		n := v.AuxInt
 17004  		t1 := v.Aux
 17005  		_ = v.Args[2]
 17006  		dst := v.Args[0]
 17007  		p1 := v.Args[1]
 17008  		mem := v.Args[2]
 17009  		if mem.Op != OpVarDef {
 17010  			break
 17011  		}
 17012  		mem_0 := mem.Args[0]
 17013  		if mem_0.Op != OpStore {
 17014  			break
 17015  		}
 17016  		t2 := mem_0.Aux
 17017  		_ = mem_0.Args[2]
 17018  		op2 := mem_0.Args[0]
 17019  		if op2.Op != OpOffPtr {
 17020  			break
 17021  		}
 17022  		tt2 := op2.Type
 17023  		o2 := op2.AuxInt
 17024  		p2 := op2.Args[0]
 17025  		d1 := mem_0.Args[1]
 17026  		mem_0_2 := mem_0.Args[2]
 17027  		if mem_0_2.Op != OpZero {
 17028  			break
 17029  		}
 17030  		if mem_0_2.AuxInt != n {
 17031  			break
 17032  		}
 17033  		t3 := mem_0_2.Aux
 17034  		_ = mem_0_2.Args[1]
 17035  		p3 := mem_0_2.Args[0]
 17036  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && n >= o2+sizeof(t2)) {
 17037  			break
 17038  		}
 17039  		v.reset(OpStore)
 17040  		v.Aux = t2
 17041  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 17042  		v0.AuxInt = o2
 17043  		v0.AddArg(dst)
 17044  		v.AddArg(v0)
 17045  		v.AddArg(d1)
 17046  		v1 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 17047  		v1.AuxInt = n
 17048  		v1.Aux = t1
 17049  		v1.AddArg(dst)
 17050  		v1.AddArg(mem)
 17051  		v.AddArg(v1)
 17052  		return true
 17053  	}
 17054  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Zero {t4} [n] p4 _)))))
 17055  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3)
 17056  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Zero {t1} [n] dst mem)))
 17057  	for {
 17058  		n := v.AuxInt
 17059  		t1 := v.Aux
 17060  		_ = v.Args[2]
 17061  		dst := v.Args[0]
 17062  		p1 := v.Args[1]
 17063  		mem := v.Args[2]
 17064  		if mem.Op != OpVarDef {
 17065  			break
 17066  		}
 17067  		mem_0 := mem.Args[0]
 17068  		if mem_0.Op != OpStore {
 17069  			break
 17070  		}
 17071  		t2 := mem_0.Aux
 17072  		_ = mem_0.Args[2]
 17073  		mem_0_0 := mem_0.Args[0]
 17074  		if mem_0_0.Op != OpOffPtr {
 17075  			break
 17076  		}
 17077  		tt2 := mem_0_0.Type
 17078  		o2 := mem_0_0.AuxInt
 17079  		p2 := mem_0_0.Args[0]
 17080  		d1 := mem_0.Args[1]
 17081  		mem_0_2 := mem_0.Args[2]
 17082  		if mem_0_2.Op != OpStore {
 17083  			break
 17084  		}
 17085  		t3 := mem_0_2.Aux
 17086  		_ = mem_0_2.Args[2]
 17087  		mem_0_2_0 := mem_0_2.Args[0]
 17088  		if mem_0_2_0.Op != OpOffPtr {
 17089  			break
 17090  		}
 17091  		tt3 := mem_0_2_0.Type
 17092  		o3 := mem_0_2_0.AuxInt
 17093  		p3 := mem_0_2_0.Args[0]
 17094  		d2 := mem_0_2.Args[1]
 17095  		mem_0_2_2 := mem_0_2.Args[2]
 17096  		if mem_0_2_2.Op != OpZero {
 17097  			break
 17098  		}
 17099  		if mem_0_2_2.AuxInt != n {
 17100  			break
 17101  		}
 17102  		t4 := mem_0_2_2.Aux
 17103  		_ = mem_0_2_2.Args[1]
 17104  		p4 := mem_0_2_2.Args[0]
 17105  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3)) {
 17106  			break
 17107  		}
 17108  		v.reset(OpStore)
 17109  		v.Aux = t2
 17110  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 17111  		v0.AuxInt = o2
 17112  		v0.AddArg(dst)
 17113  		v.AddArg(v0)
 17114  		v.AddArg(d1)
 17115  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 17116  		v1.Aux = t3
 17117  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 17118  		v2.AuxInt = o3
 17119  		v2.AddArg(dst)
 17120  		v1.AddArg(v2)
 17121  		v1.AddArg(d2)
 17122  		v3 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 17123  		v3.AuxInt = n
 17124  		v3.Aux = t1
 17125  		v3.AddArg(dst)
 17126  		v3.AddArg(mem)
 17127  		v1.AddArg(v3)
 17128  		v.AddArg(v1)
 17129  		return true
 17130  	}
 17131  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Zero {t5} [n] p5 _))))))
 17132  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4)
 17133  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Zero {t1} [n] dst mem))))
 17134  	for {
 17135  		n := v.AuxInt
 17136  		t1 := v.Aux
 17137  		_ = v.Args[2]
 17138  		dst := v.Args[0]
 17139  		p1 := v.Args[1]
 17140  		mem := v.Args[2]
 17141  		if mem.Op != OpVarDef {
 17142  			break
 17143  		}
 17144  		mem_0 := mem.Args[0]
 17145  		if mem_0.Op != OpStore {
 17146  			break
 17147  		}
 17148  		t2 := mem_0.Aux
 17149  		_ = mem_0.Args[2]
 17150  		mem_0_0 := mem_0.Args[0]
 17151  		if mem_0_0.Op != OpOffPtr {
 17152  			break
 17153  		}
 17154  		tt2 := mem_0_0.Type
 17155  		o2 := mem_0_0.AuxInt
 17156  		p2 := mem_0_0.Args[0]
 17157  		d1 := mem_0.Args[1]
 17158  		mem_0_2 := mem_0.Args[2]
 17159  		if mem_0_2.Op != OpStore {
 17160  			break
 17161  		}
 17162  		t3 := mem_0_2.Aux
 17163  		_ = mem_0_2.Args[2]
 17164  		mem_0_2_0 := mem_0_2.Args[0]
 17165  		if mem_0_2_0.Op != OpOffPtr {
 17166  			break
 17167  		}
 17168  		tt3 := mem_0_2_0.Type
 17169  		o3 := mem_0_2_0.AuxInt
 17170  		p3 := mem_0_2_0.Args[0]
 17171  		d2 := mem_0_2.Args[1]
 17172  		mem_0_2_2 := mem_0_2.Args[2]
 17173  		if mem_0_2_2.Op != OpStore {
 17174  			break
 17175  		}
 17176  		t4 := mem_0_2_2.Aux
 17177  		_ = mem_0_2_2.Args[2]
 17178  		mem_0_2_2_0 := mem_0_2_2.Args[0]
 17179  		if mem_0_2_2_0.Op != OpOffPtr {
 17180  			break
 17181  		}
 17182  		tt4 := mem_0_2_2_0.Type
 17183  		o4 := mem_0_2_2_0.AuxInt
 17184  		p4 := mem_0_2_2_0.Args[0]
 17185  		d3 := mem_0_2_2.Args[1]
 17186  		mem_0_2_2_2 := mem_0_2_2.Args[2]
 17187  		if mem_0_2_2_2.Op != OpZero {
 17188  			break
 17189  		}
 17190  		if mem_0_2_2_2.AuxInt != n {
 17191  			break
 17192  		}
 17193  		t5 := mem_0_2_2_2.Aux
 17194  		_ = mem_0_2_2_2.Args[1]
 17195  		p5 := mem_0_2_2_2.Args[0]
 17196  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4)) {
 17197  			break
 17198  		}
 17199  		v.reset(OpStore)
 17200  		v.Aux = t2
 17201  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 17202  		v0.AuxInt = o2
 17203  		v0.AddArg(dst)
 17204  		v.AddArg(v0)
 17205  		v.AddArg(d1)
 17206  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 17207  		v1.Aux = t3
 17208  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 17209  		v2.AuxInt = o3
 17210  		v2.AddArg(dst)
 17211  		v1.AddArg(v2)
 17212  		v1.AddArg(d2)
 17213  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 17214  		v3.Aux = t4
 17215  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 17216  		v4.AuxInt = o4
 17217  		v4.AddArg(dst)
 17218  		v3.AddArg(v4)
 17219  		v3.AddArg(d3)
 17220  		v5 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 17221  		v5.AuxInt = n
 17222  		v5.Aux = t1
 17223  		v5.AddArg(dst)
 17224  		v5.AddArg(mem)
 17225  		v3.AddArg(v5)
 17226  		v1.AddArg(v3)
 17227  		v.AddArg(v1)
 17228  		return true
 17229  	}
 17230  	return false
 17231  }
 17232  func rewriteValuegeneric_OpMove_20(v *Value) bool {
 17233  	b := v.Block
 17234  	_ = b
 17235  	// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _)))))))
 17236  	// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5)
 17237  	// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
 17238  	for {
 17239  		n := v.AuxInt
 17240  		t1 := v.Aux
 17241  		_ = v.Args[2]
 17242  		dst := v.Args[0]
 17243  		p1 := v.Args[1]
 17244  		mem := v.Args[2]
 17245  		if mem.Op != OpVarDef {
 17246  			break
 17247  		}
 17248  		mem_0 := mem.Args[0]
 17249  		if mem_0.Op != OpStore {
 17250  			break
 17251  		}
 17252  		t2 := mem_0.Aux
 17253  		_ = mem_0.Args[2]
 17254  		mem_0_0 := mem_0.Args[0]
 17255  		if mem_0_0.Op != OpOffPtr {
 17256  			break
 17257  		}
 17258  		tt2 := mem_0_0.Type
 17259  		o2 := mem_0_0.AuxInt
 17260  		p2 := mem_0_0.Args[0]
 17261  		d1 := mem_0.Args[1]
 17262  		mem_0_2 := mem_0.Args[2]
 17263  		if mem_0_2.Op != OpStore {
 17264  			break
 17265  		}
 17266  		t3 := mem_0_2.Aux
 17267  		_ = mem_0_2.Args[2]
 17268  		mem_0_2_0 := mem_0_2.Args[0]
 17269  		if mem_0_2_0.Op != OpOffPtr {
 17270  			break
 17271  		}
 17272  		tt3 := mem_0_2_0.Type
 17273  		o3 := mem_0_2_0.AuxInt
 17274  		p3 := mem_0_2_0.Args[0]
 17275  		d2 := mem_0_2.Args[1]
 17276  		mem_0_2_2 := mem_0_2.Args[2]
 17277  		if mem_0_2_2.Op != OpStore {
 17278  			break
 17279  		}
 17280  		t4 := mem_0_2_2.Aux
 17281  		_ = mem_0_2_2.Args[2]
 17282  		mem_0_2_2_0 := mem_0_2_2.Args[0]
 17283  		if mem_0_2_2_0.Op != OpOffPtr {
 17284  			break
 17285  		}
 17286  		tt4 := mem_0_2_2_0.Type
 17287  		o4 := mem_0_2_2_0.AuxInt
 17288  		p4 := mem_0_2_2_0.Args[0]
 17289  		d3 := mem_0_2_2.Args[1]
 17290  		mem_0_2_2_2 := mem_0_2_2.Args[2]
 17291  		if mem_0_2_2_2.Op != OpStore {
 17292  			break
 17293  		}
 17294  		t5 := mem_0_2_2_2.Aux
 17295  		_ = mem_0_2_2_2.Args[2]
 17296  		mem_0_2_2_2_0 := mem_0_2_2_2.Args[0]
 17297  		if mem_0_2_2_2_0.Op != OpOffPtr {
 17298  			break
 17299  		}
 17300  		tt5 := mem_0_2_2_2_0.Type
 17301  		o5 := mem_0_2_2_2_0.AuxInt
 17302  		p5 := mem_0_2_2_2_0.Args[0]
 17303  		d4 := mem_0_2_2_2.Args[1]
 17304  		mem_0_2_2_2_2 := mem_0_2_2_2.Args[2]
 17305  		if mem_0_2_2_2_2.Op != OpZero {
 17306  			break
 17307  		}
 17308  		if mem_0_2_2_2_2.AuxInt != n {
 17309  			break
 17310  		}
 17311  		t6 := mem_0_2_2_2_2.Aux
 17312  		_ = mem_0_2_2_2_2.Args[1]
 17313  		p6 := mem_0_2_2_2_2.Args[0]
 17314  		if !(isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2+sizeof(t2) && n >= o3+sizeof(t3) && n >= o4+sizeof(t4) && n >= o5+sizeof(t5)) {
 17315  			break
 17316  		}
 17317  		v.reset(OpStore)
 17318  		v.Aux = t2
 17319  		v0 := b.NewValue0(v.Pos, OpOffPtr, tt2)
 17320  		v0.AuxInt = o2
 17321  		v0.AddArg(dst)
 17322  		v.AddArg(v0)
 17323  		v.AddArg(d1)
 17324  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 17325  		v1.Aux = t3
 17326  		v2 := b.NewValue0(v.Pos, OpOffPtr, tt3)
 17327  		v2.AuxInt = o3
 17328  		v2.AddArg(dst)
 17329  		v1.AddArg(v2)
 17330  		v1.AddArg(d2)
 17331  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 17332  		v3.Aux = t4
 17333  		v4 := b.NewValue0(v.Pos, OpOffPtr, tt4)
 17334  		v4.AuxInt = o4
 17335  		v4.AddArg(dst)
 17336  		v3.AddArg(v4)
 17337  		v3.AddArg(d3)
 17338  		v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 17339  		v5.Aux = t5
 17340  		v6 := b.NewValue0(v.Pos, OpOffPtr, tt5)
 17341  		v6.AuxInt = o5
 17342  		v6.AddArg(dst)
 17343  		v5.AddArg(v6)
 17344  		v5.AddArg(d4)
 17345  		v7 := b.NewValue0(v.Pos, OpZero, types.TypeMem)
 17346  		v7.AuxInt = n
 17347  		v7.Aux = t1
 17348  		v7.AddArg(dst)
 17349  		v7.AddArg(mem)
 17350  		v5.AddArg(v7)
 17351  		v3.AddArg(v5)
 17352  		v1.AddArg(v3)
 17353  		v.AddArg(v1)
 17354  		return true
 17355  	}
 17356  	// match: (Move {t1} [s1] dst tmp1 midmem:(Move {t2} [s2] tmp2 src _))
 17357  	// cond: s1 == s2 && t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2)
 17358  	// result: (Move {t1} [s1] dst src midmem)
 17359  	for {
 17360  		s1 := v.AuxInt
 17361  		t1 := v.Aux
 17362  		_ = v.Args[2]
 17363  		dst := v.Args[0]
 17364  		tmp1 := v.Args[1]
 17365  		midmem := v.Args[2]
 17366  		if midmem.Op != OpMove {
 17367  			break
 17368  		}
 17369  		s2 := midmem.AuxInt
 17370  		t2 := midmem.Aux
 17371  		_ = midmem.Args[2]
 17372  		tmp2 := midmem.Args[0]
 17373  		src := midmem.Args[1]
 17374  		if !(s1 == s2 && t1.(*types.Type).Compare(t2.(*types.Type)) == types.CMPeq && isSamePtr(tmp1, tmp2)) {
 17375  			break
 17376  		}
 17377  		v.reset(OpMove)
 17378  		v.AuxInt = s1
 17379  		v.Aux = t1
 17380  		v.AddArg(dst)
 17381  		v.AddArg(src)
 17382  		v.AddArg(midmem)
 17383  		return true
 17384  	}
 17385  	// match: (Move dst src mem)
 17386  	// cond: isSamePtr(dst, src)
 17387  	// result: mem
 17388  	for {
 17389  		_ = v.Args[2]
 17390  		dst := v.Args[0]
 17391  		src := v.Args[1]
 17392  		mem := v.Args[2]
 17393  		if !(isSamePtr(dst, src)) {
 17394  			break
 17395  		}
 17396  		v.reset(OpCopy)
 17397  		v.Type = mem.Type
 17398  		v.AddArg(mem)
 17399  		return true
 17400  	}
 17401  	return false
 17402  }
 17403  func rewriteValuegeneric_OpMul16_0(v *Value) bool {
 17404  	b := v.Block
 17405  	_ = b
 17406  	typ := &b.Func.Config.Types
 17407  	_ = typ
 17408  	// match: (Mul16 (Const16 [c]) (Const16 [d]))
 17409  	// cond:
 17410  	// result: (Const16 [int64(int16(c*d))])
 17411  	for {
 17412  		_ = v.Args[1]
 17413  		v_0 := v.Args[0]
 17414  		if v_0.Op != OpConst16 {
 17415  			break
 17416  		}
 17417  		c := v_0.AuxInt
 17418  		v_1 := v.Args[1]
 17419  		if v_1.Op != OpConst16 {
 17420  			break
 17421  		}
 17422  		d := v_1.AuxInt
 17423  		v.reset(OpConst16)
 17424  		v.AuxInt = int64(int16(c * d))
 17425  		return true
 17426  	}
 17427  	// match: (Mul16 (Const16 [d]) (Const16 [c]))
 17428  	// cond:
 17429  	// result: (Const16 [int64(int16(c*d))])
 17430  	for {
 17431  		_ = v.Args[1]
 17432  		v_0 := v.Args[0]
 17433  		if v_0.Op != OpConst16 {
 17434  			break
 17435  		}
 17436  		d := v_0.AuxInt
 17437  		v_1 := v.Args[1]
 17438  		if v_1.Op != OpConst16 {
 17439  			break
 17440  		}
 17441  		c := v_1.AuxInt
 17442  		v.reset(OpConst16)
 17443  		v.AuxInt = int64(int16(c * d))
 17444  		return true
 17445  	}
 17446  	// match: (Mul16 (Const16 [1]) x)
 17447  	// cond:
 17448  	// result: x
 17449  	for {
 17450  		_ = v.Args[1]
 17451  		v_0 := v.Args[0]
 17452  		if v_0.Op != OpConst16 {
 17453  			break
 17454  		}
 17455  		if v_0.AuxInt != 1 {
 17456  			break
 17457  		}
 17458  		x := v.Args[1]
 17459  		v.reset(OpCopy)
 17460  		v.Type = x.Type
 17461  		v.AddArg(x)
 17462  		return true
 17463  	}
 17464  	// match: (Mul16 x (Const16 [1]))
 17465  	// cond:
 17466  	// result: x
 17467  	for {
 17468  		_ = v.Args[1]
 17469  		x := v.Args[0]
 17470  		v_1 := v.Args[1]
 17471  		if v_1.Op != OpConst16 {
 17472  			break
 17473  		}
 17474  		if v_1.AuxInt != 1 {
 17475  			break
 17476  		}
 17477  		v.reset(OpCopy)
 17478  		v.Type = x.Type
 17479  		v.AddArg(x)
 17480  		return true
 17481  	}
 17482  	// match: (Mul16 (Const16 [-1]) x)
 17483  	// cond:
 17484  	// result: (Neg16 x)
 17485  	for {
 17486  		_ = v.Args[1]
 17487  		v_0 := v.Args[0]
 17488  		if v_0.Op != OpConst16 {
 17489  			break
 17490  		}
 17491  		if v_0.AuxInt != -1 {
 17492  			break
 17493  		}
 17494  		x := v.Args[1]
 17495  		v.reset(OpNeg16)
 17496  		v.AddArg(x)
 17497  		return true
 17498  	}
 17499  	// match: (Mul16 x (Const16 [-1]))
 17500  	// cond:
 17501  	// result: (Neg16 x)
 17502  	for {
 17503  		_ = v.Args[1]
 17504  		x := v.Args[0]
 17505  		v_1 := v.Args[1]
 17506  		if v_1.Op != OpConst16 {
 17507  			break
 17508  		}
 17509  		if v_1.AuxInt != -1 {
 17510  			break
 17511  		}
 17512  		v.reset(OpNeg16)
 17513  		v.AddArg(x)
 17514  		return true
 17515  	}
 17516  	// match: (Mul16 <t> n (Const16 [c]))
 17517  	// cond: isPowerOfTwo(c)
 17518  	// result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 17519  	for {
 17520  		t := v.Type
 17521  		_ = v.Args[1]
 17522  		n := v.Args[0]
 17523  		v_1 := v.Args[1]
 17524  		if v_1.Op != OpConst16 {
 17525  			break
 17526  		}
 17527  		c := v_1.AuxInt
 17528  		if !(isPowerOfTwo(c)) {
 17529  			break
 17530  		}
 17531  		v.reset(OpLsh16x64)
 17532  		v.Type = t
 17533  		v.AddArg(n)
 17534  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17535  		v0.AuxInt = log2(c)
 17536  		v.AddArg(v0)
 17537  		return true
 17538  	}
 17539  	// match: (Mul16 <t> (Const16 [c]) n)
 17540  	// cond: isPowerOfTwo(c)
 17541  	// result: (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 17542  	for {
 17543  		t := v.Type
 17544  		_ = v.Args[1]
 17545  		v_0 := v.Args[0]
 17546  		if v_0.Op != OpConst16 {
 17547  			break
 17548  		}
 17549  		c := v_0.AuxInt
 17550  		n := v.Args[1]
 17551  		if !(isPowerOfTwo(c)) {
 17552  			break
 17553  		}
 17554  		v.reset(OpLsh16x64)
 17555  		v.Type = t
 17556  		v.AddArg(n)
 17557  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17558  		v0.AuxInt = log2(c)
 17559  		v.AddArg(v0)
 17560  		return true
 17561  	}
 17562  	// match: (Mul16 <t> n (Const16 [c]))
 17563  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 17564  	// result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 17565  	for {
 17566  		t := v.Type
 17567  		_ = v.Args[1]
 17568  		n := v.Args[0]
 17569  		v_1 := v.Args[1]
 17570  		if v_1.Op != OpConst16 {
 17571  			break
 17572  		}
 17573  		c := v_1.AuxInt
 17574  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 17575  			break
 17576  		}
 17577  		v.reset(OpNeg16)
 17578  		v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
 17579  		v0.AddArg(n)
 17580  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17581  		v1.AuxInt = log2(-c)
 17582  		v0.AddArg(v1)
 17583  		v.AddArg(v0)
 17584  		return true
 17585  	}
 17586  	// match: (Mul16 <t> (Const16 [c]) n)
 17587  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 17588  	// result: (Neg16 (Lsh16x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 17589  	for {
 17590  		t := v.Type
 17591  		_ = v.Args[1]
 17592  		v_0 := v.Args[0]
 17593  		if v_0.Op != OpConst16 {
 17594  			break
 17595  		}
 17596  		c := v_0.AuxInt
 17597  		n := v.Args[1]
 17598  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 17599  			break
 17600  		}
 17601  		v.reset(OpNeg16)
 17602  		v0 := b.NewValue0(v.Pos, OpLsh16x64, t)
 17603  		v0.AddArg(n)
 17604  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17605  		v1.AuxInt = log2(-c)
 17606  		v0.AddArg(v1)
 17607  		v.AddArg(v0)
 17608  		return true
 17609  	}
 17610  	return false
 17611  }
 17612  func rewriteValuegeneric_OpMul16_10(v *Value) bool {
 17613  	b := v.Block
 17614  	_ = b
 17615  	// match: (Mul16 (Const16 [0]) _)
 17616  	// cond:
 17617  	// result: (Const16 [0])
 17618  	for {
 17619  		_ = v.Args[1]
 17620  		v_0 := v.Args[0]
 17621  		if v_0.Op != OpConst16 {
 17622  			break
 17623  		}
 17624  		if v_0.AuxInt != 0 {
 17625  			break
 17626  		}
 17627  		v.reset(OpConst16)
 17628  		v.AuxInt = 0
 17629  		return true
 17630  	}
 17631  	// match: (Mul16 _ (Const16 [0]))
 17632  	// cond:
 17633  	// result: (Const16 [0])
 17634  	for {
 17635  		_ = v.Args[1]
 17636  		v_1 := v.Args[1]
 17637  		if v_1.Op != OpConst16 {
 17638  			break
 17639  		}
 17640  		if v_1.AuxInt != 0 {
 17641  			break
 17642  		}
 17643  		v.reset(OpConst16)
 17644  		v.AuxInt = 0
 17645  		return true
 17646  	}
 17647  	// match: (Mul16 (Const16 <t> [c]) (Mul16 (Const16 <t> [d]) x))
 17648  	// cond:
 17649  	// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 17650  	for {
 17651  		_ = v.Args[1]
 17652  		v_0 := v.Args[0]
 17653  		if v_0.Op != OpConst16 {
 17654  			break
 17655  		}
 17656  		t := v_0.Type
 17657  		c := v_0.AuxInt
 17658  		v_1 := v.Args[1]
 17659  		if v_1.Op != OpMul16 {
 17660  			break
 17661  		}
 17662  		_ = v_1.Args[1]
 17663  		v_1_0 := v_1.Args[0]
 17664  		if v_1_0.Op != OpConst16 {
 17665  			break
 17666  		}
 17667  		if v_1_0.Type != t {
 17668  			break
 17669  		}
 17670  		d := v_1_0.AuxInt
 17671  		x := v_1.Args[1]
 17672  		v.reset(OpMul16)
 17673  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 17674  		v0.AuxInt = int64(int16(c * d))
 17675  		v.AddArg(v0)
 17676  		v.AddArg(x)
 17677  		return true
 17678  	}
 17679  	// match: (Mul16 (Const16 <t> [c]) (Mul16 x (Const16 <t> [d])))
 17680  	// cond:
 17681  	// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 17682  	for {
 17683  		_ = v.Args[1]
 17684  		v_0 := v.Args[0]
 17685  		if v_0.Op != OpConst16 {
 17686  			break
 17687  		}
 17688  		t := v_0.Type
 17689  		c := v_0.AuxInt
 17690  		v_1 := v.Args[1]
 17691  		if v_1.Op != OpMul16 {
 17692  			break
 17693  		}
 17694  		_ = v_1.Args[1]
 17695  		x := v_1.Args[0]
 17696  		v_1_1 := v_1.Args[1]
 17697  		if v_1_1.Op != OpConst16 {
 17698  			break
 17699  		}
 17700  		if v_1_1.Type != t {
 17701  			break
 17702  		}
 17703  		d := v_1_1.AuxInt
 17704  		v.reset(OpMul16)
 17705  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 17706  		v0.AuxInt = int64(int16(c * d))
 17707  		v.AddArg(v0)
 17708  		v.AddArg(x)
 17709  		return true
 17710  	}
 17711  	// match: (Mul16 (Mul16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 17712  	// cond:
 17713  	// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 17714  	for {
 17715  		_ = v.Args[1]
 17716  		v_0 := v.Args[0]
 17717  		if v_0.Op != OpMul16 {
 17718  			break
 17719  		}
 17720  		_ = v_0.Args[1]
 17721  		v_0_0 := v_0.Args[0]
 17722  		if v_0_0.Op != OpConst16 {
 17723  			break
 17724  		}
 17725  		t := v_0_0.Type
 17726  		d := v_0_0.AuxInt
 17727  		x := v_0.Args[1]
 17728  		v_1 := v.Args[1]
 17729  		if v_1.Op != OpConst16 {
 17730  			break
 17731  		}
 17732  		if v_1.Type != t {
 17733  			break
 17734  		}
 17735  		c := v_1.AuxInt
 17736  		v.reset(OpMul16)
 17737  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 17738  		v0.AuxInt = int64(int16(c * d))
 17739  		v.AddArg(v0)
 17740  		v.AddArg(x)
 17741  		return true
 17742  	}
 17743  	// match: (Mul16 (Mul16 x (Const16 <t> [d])) (Const16 <t> [c]))
 17744  	// cond:
 17745  	// result: (Mul16 (Const16 <t> [int64(int16(c*d))]) x)
 17746  	for {
 17747  		_ = v.Args[1]
 17748  		v_0 := v.Args[0]
 17749  		if v_0.Op != OpMul16 {
 17750  			break
 17751  		}
 17752  		_ = v_0.Args[1]
 17753  		x := v_0.Args[0]
 17754  		v_0_1 := v_0.Args[1]
 17755  		if v_0_1.Op != OpConst16 {
 17756  			break
 17757  		}
 17758  		t := v_0_1.Type
 17759  		d := v_0_1.AuxInt
 17760  		v_1 := v.Args[1]
 17761  		if v_1.Op != OpConst16 {
 17762  			break
 17763  		}
 17764  		if v_1.Type != t {
 17765  			break
 17766  		}
 17767  		c := v_1.AuxInt
 17768  		v.reset(OpMul16)
 17769  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 17770  		v0.AuxInt = int64(int16(c * d))
 17771  		v.AddArg(v0)
 17772  		v.AddArg(x)
 17773  		return true
 17774  	}
 17775  	return false
 17776  }
 17777  func rewriteValuegeneric_OpMul32_0(v *Value) bool {
 17778  	b := v.Block
 17779  	_ = b
 17780  	typ := &b.Func.Config.Types
 17781  	_ = typ
 17782  	// match: (Mul32 (Const32 [c]) (Const32 [d]))
 17783  	// cond:
 17784  	// result: (Const32 [int64(int32(c*d))])
 17785  	for {
 17786  		_ = v.Args[1]
 17787  		v_0 := v.Args[0]
 17788  		if v_0.Op != OpConst32 {
 17789  			break
 17790  		}
 17791  		c := v_0.AuxInt
 17792  		v_1 := v.Args[1]
 17793  		if v_1.Op != OpConst32 {
 17794  			break
 17795  		}
 17796  		d := v_1.AuxInt
 17797  		v.reset(OpConst32)
 17798  		v.AuxInt = int64(int32(c * d))
 17799  		return true
 17800  	}
 17801  	// match: (Mul32 (Const32 [d]) (Const32 [c]))
 17802  	// cond:
 17803  	// result: (Const32 [int64(int32(c*d))])
 17804  	for {
 17805  		_ = v.Args[1]
 17806  		v_0 := v.Args[0]
 17807  		if v_0.Op != OpConst32 {
 17808  			break
 17809  		}
 17810  		d := v_0.AuxInt
 17811  		v_1 := v.Args[1]
 17812  		if v_1.Op != OpConst32 {
 17813  			break
 17814  		}
 17815  		c := v_1.AuxInt
 17816  		v.reset(OpConst32)
 17817  		v.AuxInt = int64(int32(c * d))
 17818  		return true
 17819  	}
 17820  	// match: (Mul32 (Const32 [1]) x)
 17821  	// cond:
 17822  	// result: x
 17823  	for {
 17824  		_ = v.Args[1]
 17825  		v_0 := v.Args[0]
 17826  		if v_0.Op != OpConst32 {
 17827  			break
 17828  		}
 17829  		if v_0.AuxInt != 1 {
 17830  			break
 17831  		}
 17832  		x := v.Args[1]
 17833  		v.reset(OpCopy)
 17834  		v.Type = x.Type
 17835  		v.AddArg(x)
 17836  		return true
 17837  	}
 17838  	// match: (Mul32 x (Const32 [1]))
 17839  	// cond:
 17840  	// result: x
 17841  	for {
 17842  		_ = v.Args[1]
 17843  		x := v.Args[0]
 17844  		v_1 := v.Args[1]
 17845  		if v_1.Op != OpConst32 {
 17846  			break
 17847  		}
 17848  		if v_1.AuxInt != 1 {
 17849  			break
 17850  		}
 17851  		v.reset(OpCopy)
 17852  		v.Type = x.Type
 17853  		v.AddArg(x)
 17854  		return true
 17855  	}
 17856  	// match: (Mul32 (Const32 [-1]) x)
 17857  	// cond:
 17858  	// result: (Neg32 x)
 17859  	for {
 17860  		_ = v.Args[1]
 17861  		v_0 := v.Args[0]
 17862  		if v_0.Op != OpConst32 {
 17863  			break
 17864  		}
 17865  		if v_0.AuxInt != -1 {
 17866  			break
 17867  		}
 17868  		x := v.Args[1]
 17869  		v.reset(OpNeg32)
 17870  		v.AddArg(x)
 17871  		return true
 17872  	}
 17873  	// match: (Mul32 x (Const32 [-1]))
 17874  	// cond:
 17875  	// result: (Neg32 x)
 17876  	for {
 17877  		_ = v.Args[1]
 17878  		x := v.Args[0]
 17879  		v_1 := v.Args[1]
 17880  		if v_1.Op != OpConst32 {
 17881  			break
 17882  		}
 17883  		if v_1.AuxInt != -1 {
 17884  			break
 17885  		}
 17886  		v.reset(OpNeg32)
 17887  		v.AddArg(x)
 17888  		return true
 17889  	}
 17890  	// match: (Mul32 <t> n (Const32 [c]))
 17891  	// cond: isPowerOfTwo(c)
 17892  	// result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 17893  	for {
 17894  		t := v.Type
 17895  		_ = v.Args[1]
 17896  		n := v.Args[0]
 17897  		v_1 := v.Args[1]
 17898  		if v_1.Op != OpConst32 {
 17899  			break
 17900  		}
 17901  		c := v_1.AuxInt
 17902  		if !(isPowerOfTwo(c)) {
 17903  			break
 17904  		}
 17905  		v.reset(OpLsh32x64)
 17906  		v.Type = t
 17907  		v.AddArg(n)
 17908  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17909  		v0.AuxInt = log2(c)
 17910  		v.AddArg(v0)
 17911  		return true
 17912  	}
 17913  	// match: (Mul32 <t> (Const32 [c]) n)
 17914  	// cond: isPowerOfTwo(c)
 17915  	// result: (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 17916  	for {
 17917  		t := v.Type
 17918  		_ = v.Args[1]
 17919  		v_0 := v.Args[0]
 17920  		if v_0.Op != OpConst32 {
 17921  			break
 17922  		}
 17923  		c := v_0.AuxInt
 17924  		n := v.Args[1]
 17925  		if !(isPowerOfTwo(c)) {
 17926  			break
 17927  		}
 17928  		v.reset(OpLsh32x64)
 17929  		v.Type = t
 17930  		v.AddArg(n)
 17931  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17932  		v0.AuxInt = log2(c)
 17933  		v.AddArg(v0)
 17934  		return true
 17935  	}
 17936  	// match: (Mul32 <t> n (Const32 [c]))
 17937  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 17938  	// result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 17939  	for {
 17940  		t := v.Type
 17941  		_ = v.Args[1]
 17942  		n := v.Args[0]
 17943  		v_1 := v.Args[1]
 17944  		if v_1.Op != OpConst32 {
 17945  			break
 17946  		}
 17947  		c := v_1.AuxInt
 17948  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 17949  			break
 17950  		}
 17951  		v.reset(OpNeg32)
 17952  		v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
 17953  		v0.AddArg(n)
 17954  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17955  		v1.AuxInt = log2(-c)
 17956  		v0.AddArg(v1)
 17957  		v.AddArg(v0)
 17958  		return true
 17959  	}
 17960  	// match: (Mul32 <t> (Const32 [c]) n)
 17961  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 17962  	// result: (Neg32 (Lsh32x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 17963  	for {
 17964  		t := v.Type
 17965  		_ = v.Args[1]
 17966  		v_0 := v.Args[0]
 17967  		if v_0.Op != OpConst32 {
 17968  			break
 17969  		}
 17970  		c := v_0.AuxInt
 17971  		n := v.Args[1]
 17972  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 17973  			break
 17974  		}
 17975  		v.reset(OpNeg32)
 17976  		v0 := b.NewValue0(v.Pos, OpLsh32x64, t)
 17977  		v0.AddArg(n)
 17978  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 17979  		v1.AuxInt = log2(-c)
 17980  		v0.AddArg(v1)
 17981  		v.AddArg(v0)
 17982  		return true
 17983  	}
 17984  	return false
 17985  }
 17986  func rewriteValuegeneric_OpMul32_10(v *Value) bool {
 17987  	b := v.Block
 17988  	_ = b
 17989  	// match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
 17990  	// cond:
 17991  	// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 17992  	for {
 17993  		_ = v.Args[1]
 17994  		v_0 := v.Args[0]
 17995  		if v_0.Op != OpConst32 {
 17996  			break
 17997  		}
 17998  		t := v_0.Type
 17999  		c := v_0.AuxInt
 18000  		v_1 := v.Args[1]
 18001  		if v_1.Op != OpAdd32 {
 18002  			break
 18003  		}
 18004  		if v_1.Type != t {
 18005  			break
 18006  		}
 18007  		_ = v_1.Args[1]
 18008  		v_1_0 := v_1.Args[0]
 18009  		if v_1_0.Op != OpConst32 {
 18010  			break
 18011  		}
 18012  		if v_1_0.Type != t {
 18013  			break
 18014  		}
 18015  		d := v_1_0.AuxInt
 18016  		x := v_1.Args[1]
 18017  		v.reset(OpAdd32)
 18018  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18019  		v0.AuxInt = int64(int32(c * d))
 18020  		v.AddArg(v0)
 18021  		v1 := b.NewValue0(v.Pos, OpMul32, t)
 18022  		v2 := b.NewValue0(v.Pos, OpConst32, t)
 18023  		v2.AuxInt = c
 18024  		v1.AddArg(v2)
 18025  		v1.AddArg(x)
 18026  		v.AddArg(v1)
 18027  		return true
 18028  	}
 18029  	// match: (Mul32 (Const32 <t> [c]) (Add32 <t> x (Const32 <t> [d])))
 18030  	// cond:
 18031  	// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 18032  	for {
 18033  		_ = v.Args[1]
 18034  		v_0 := v.Args[0]
 18035  		if v_0.Op != OpConst32 {
 18036  			break
 18037  		}
 18038  		t := v_0.Type
 18039  		c := v_0.AuxInt
 18040  		v_1 := v.Args[1]
 18041  		if v_1.Op != OpAdd32 {
 18042  			break
 18043  		}
 18044  		if v_1.Type != t {
 18045  			break
 18046  		}
 18047  		_ = v_1.Args[1]
 18048  		x := v_1.Args[0]
 18049  		v_1_1 := v_1.Args[1]
 18050  		if v_1_1.Op != OpConst32 {
 18051  			break
 18052  		}
 18053  		if v_1_1.Type != t {
 18054  			break
 18055  		}
 18056  		d := v_1_1.AuxInt
 18057  		v.reset(OpAdd32)
 18058  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18059  		v0.AuxInt = int64(int32(c * d))
 18060  		v.AddArg(v0)
 18061  		v1 := b.NewValue0(v.Pos, OpMul32, t)
 18062  		v2 := b.NewValue0(v.Pos, OpConst32, t)
 18063  		v2.AuxInt = c
 18064  		v1.AddArg(v2)
 18065  		v1.AddArg(x)
 18066  		v.AddArg(v1)
 18067  		return true
 18068  	}
 18069  	// match: (Mul32 (Add32 <t> (Const32 <t> [d]) x) (Const32 <t> [c]))
 18070  	// cond:
 18071  	// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 18072  	for {
 18073  		_ = v.Args[1]
 18074  		v_0 := v.Args[0]
 18075  		if v_0.Op != OpAdd32 {
 18076  			break
 18077  		}
 18078  		t := v_0.Type
 18079  		_ = v_0.Args[1]
 18080  		v_0_0 := v_0.Args[0]
 18081  		if v_0_0.Op != OpConst32 {
 18082  			break
 18083  		}
 18084  		if v_0_0.Type != t {
 18085  			break
 18086  		}
 18087  		d := v_0_0.AuxInt
 18088  		x := v_0.Args[1]
 18089  		v_1 := v.Args[1]
 18090  		if v_1.Op != OpConst32 {
 18091  			break
 18092  		}
 18093  		if v_1.Type != t {
 18094  			break
 18095  		}
 18096  		c := v_1.AuxInt
 18097  		v.reset(OpAdd32)
 18098  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18099  		v0.AuxInt = int64(int32(c * d))
 18100  		v.AddArg(v0)
 18101  		v1 := b.NewValue0(v.Pos, OpMul32, t)
 18102  		v2 := b.NewValue0(v.Pos, OpConst32, t)
 18103  		v2.AuxInt = c
 18104  		v1.AddArg(v2)
 18105  		v1.AddArg(x)
 18106  		v.AddArg(v1)
 18107  		return true
 18108  	}
 18109  	// match: (Mul32 (Add32 <t> x (Const32 <t> [d])) (Const32 <t> [c]))
 18110  	// cond:
 18111  	// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
 18112  	for {
 18113  		_ = v.Args[1]
 18114  		v_0 := v.Args[0]
 18115  		if v_0.Op != OpAdd32 {
 18116  			break
 18117  		}
 18118  		t := v_0.Type
 18119  		_ = v_0.Args[1]
 18120  		x := v_0.Args[0]
 18121  		v_0_1 := v_0.Args[1]
 18122  		if v_0_1.Op != OpConst32 {
 18123  			break
 18124  		}
 18125  		if v_0_1.Type != t {
 18126  			break
 18127  		}
 18128  		d := v_0_1.AuxInt
 18129  		v_1 := v.Args[1]
 18130  		if v_1.Op != OpConst32 {
 18131  			break
 18132  		}
 18133  		if v_1.Type != t {
 18134  			break
 18135  		}
 18136  		c := v_1.AuxInt
 18137  		v.reset(OpAdd32)
 18138  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18139  		v0.AuxInt = int64(int32(c * d))
 18140  		v.AddArg(v0)
 18141  		v1 := b.NewValue0(v.Pos, OpMul32, t)
 18142  		v2 := b.NewValue0(v.Pos, OpConst32, t)
 18143  		v2.AuxInt = c
 18144  		v1.AddArg(v2)
 18145  		v1.AddArg(x)
 18146  		v.AddArg(v1)
 18147  		return true
 18148  	}
 18149  	// match: (Mul32 (Const32 [0]) _)
 18150  	// cond:
 18151  	// result: (Const32 [0])
 18152  	for {
 18153  		_ = v.Args[1]
 18154  		v_0 := v.Args[0]
 18155  		if v_0.Op != OpConst32 {
 18156  			break
 18157  		}
 18158  		if v_0.AuxInt != 0 {
 18159  			break
 18160  		}
 18161  		v.reset(OpConst32)
 18162  		v.AuxInt = 0
 18163  		return true
 18164  	}
 18165  	// match: (Mul32 _ (Const32 [0]))
 18166  	// cond:
 18167  	// result: (Const32 [0])
 18168  	for {
 18169  		_ = v.Args[1]
 18170  		v_1 := v.Args[1]
 18171  		if v_1.Op != OpConst32 {
 18172  			break
 18173  		}
 18174  		if v_1.AuxInt != 0 {
 18175  			break
 18176  		}
 18177  		v.reset(OpConst32)
 18178  		v.AuxInt = 0
 18179  		return true
 18180  	}
 18181  	// match: (Mul32 (Const32 <t> [c]) (Mul32 (Const32 <t> [d]) x))
 18182  	// cond:
 18183  	// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 18184  	for {
 18185  		_ = v.Args[1]
 18186  		v_0 := v.Args[0]
 18187  		if v_0.Op != OpConst32 {
 18188  			break
 18189  		}
 18190  		t := v_0.Type
 18191  		c := v_0.AuxInt
 18192  		v_1 := v.Args[1]
 18193  		if v_1.Op != OpMul32 {
 18194  			break
 18195  		}
 18196  		_ = v_1.Args[1]
 18197  		v_1_0 := v_1.Args[0]
 18198  		if v_1_0.Op != OpConst32 {
 18199  			break
 18200  		}
 18201  		if v_1_0.Type != t {
 18202  			break
 18203  		}
 18204  		d := v_1_0.AuxInt
 18205  		x := v_1.Args[1]
 18206  		v.reset(OpMul32)
 18207  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18208  		v0.AuxInt = int64(int32(c * d))
 18209  		v.AddArg(v0)
 18210  		v.AddArg(x)
 18211  		return true
 18212  	}
 18213  	// match: (Mul32 (Const32 <t> [c]) (Mul32 x (Const32 <t> [d])))
 18214  	// cond:
 18215  	// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 18216  	for {
 18217  		_ = v.Args[1]
 18218  		v_0 := v.Args[0]
 18219  		if v_0.Op != OpConst32 {
 18220  			break
 18221  		}
 18222  		t := v_0.Type
 18223  		c := v_0.AuxInt
 18224  		v_1 := v.Args[1]
 18225  		if v_1.Op != OpMul32 {
 18226  			break
 18227  		}
 18228  		_ = v_1.Args[1]
 18229  		x := v_1.Args[0]
 18230  		v_1_1 := v_1.Args[1]
 18231  		if v_1_1.Op != OpConst32 {
 18232  			break
 18233  		}
 18234  		if v_1_1.Type != t {
 18235  			break
 18236  		}
 18237  		d := v_1_1.AuxInt
 18238  		v.reset(OpMul32)
 18239  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18240  		v0.AuxInt = int64(int32(c * d))
 18241  		v.AddArg(v0)
 18242  		v.AddArg(x)
 18243  		return true
 18244  	}
 18245  	// match: (Mul32 (Mul32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 18246  	// cond:
 18247  	// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 18248  	for {
 18249  		_ = v.Args[1]
 18250  		v_0 := v.Args[0]
 18251  		if v_0.Op != OpMul32 {
 18252  			break
 18253  		}
 18254  		_ = v_0.Args[1]
 18255  		v_0_0 := v_0.Args[0]
 18256  		if v_0_0.Op != OpConst32 {
 18257  			break
 18258  		}
 18259  		t := v_0_0.Type
 18260  		d := v_0_0.AuxInt
 18261  		x := v_0.Args[1]
 18262  		v_1 := v.Args[1]
 18263  		if v_1.Op != OpConst32 {
 18264  			break
 18265  		}
 18266  		if v_1.Type != t {
 18267  			break
 18268  		}
 18269  		c := v_1.AuxInt
 18270  		v.reset(OpMul32)
 18271  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18272  		v0.AuxInt = int64(int32(c * d))
 18273  		v.AddArg(v0)
 18274  		v.AddArg(x)
 18275  		return true
 18276  	}
 18277  	// match: (Mul32 (Mul32 x (Const32 <t> [d])) (Const32 <t> [c]))
 18278  	// cond:
 18279  	// result: (Mul32 (Const32 <t> [int64(int32(c*d))]) x)
 18280  	for {
 18281  		_ = v.Args[1]
 18282  		v_0 := v.Args[0]
 18283  		if v_0.Op != OpMul32 {
 18284  			break
 18285  		}
 18286  		_ = v_0.Args[1]
 18287  		x := v_0.Args[0]
 18288  		v_0_1 := v_0.Args[1]
 18289  		if v_0_1.Op != OpConst32 {
 18290  			break
 18291  		}
 18292  		t := v_0_1.Type
 18293  		d := v_0_1.AuxInt
 18294  		v_1 := v.Args[1]
 18295  		if v_1.Op != OpConst32 {
 18296  			break
 18297  		}
 18298  		if v_1.Type != t {
 18299  			break
 18300  		}
 18301  		c := v_1.AuxInt
 18302  		v.reset(OpMul32)
 18303  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 18304  		v0.AuxInt = int64(int32(c * d))
 18305  		v.AddArg(v0)
 18306  		v.AddArg(x)
 18307  		return true
 18308  	}
 18309  	return false
 18310  }
 18311  func rewriteValuegeneric_OpMul32F_0(v *Value) bool {
 18312  	// match: (Mul32F (Const32F [c]) (Const32F [d]))
 18313  	// cond:
 18314  	// result: (Const32F [auxFrom32F(auxTo32F(c) * auxTo32F(d))])
 18315  	for {
 18316  		_ = v.Args[1]
 18317  		v_0 := v.Args[0]
 18318  		if v_0.Op != OpConst32F {
 18319  			break
 18320  		}
 18321  		c := v_0.AuxInt
 18322  		v_1 := v.Args[1]
 18323  		if v_1.Op != OpConst32F {
 18324  			break
 18325  		}
 18326  		d := v_1.AuxInt
 18327  		v.reset(OpConst32F)
 18328  		v.AuxInt = auxFrom32F(auxTo32F(c) * auxTo32F(d))
 18329  		return true
 18330  	}
 18331  	// match: (Mul32F (Const32F [d]) (Const32F [c]))
 18332  	// cond:
 18333  	// result: (Const32F [auxFrom32F(auxTo32F(c) * auxTo32F(d))])
 18334  	for {
 18335  		_ = v.Args[1]
 18336  		v_0 := v.Args[0]
 18337  		if v_0.Op != OpConst32F {
 18338  			break
 18339  		}
 18340  		d := v_0.AuxInt
 18341  		v_1 := v.Args[1]
 18342  		if v_1.Op != OpConst32F {
 18343  			break
 18344  		}
 18345  		c := v_1.AuxInt
 18346  		v.reset(OpConst32F)
 18347  		v.AuxInt = auxFrom32F(auxTo32F(c) * auxTo32F(d))
 18348  		return true
 18349  	}
 18350  	// match: (Mul32F x (Const32F [auxFrom64F(1)]))
 18351  	// cond:
 18352  	// result: x
 18353  	for {
 18354  		_ = v.Args[1]
 18355  		x := v.Args[0]
 18356  		v_1 := v.Args[1]
 18357  		if v_1.Op != OpConst32F {
 18358  			break
 18359  		}
 18360  		if v_1.AuxInt != auxFrom64F(1) {
 18361  			break
 18362  		}
 18363  		v.reset(OpCopy)
 18364  		v.Type = x.Type
 18365  		v.AddArg(x)
 18366  		return true
 18367  	}
 18368  	// match: (Mul32F (Const32F [auxFrom64F(1)]) x)
 18369  	// cond:
 18370  	// result: x
 18371  	for {
 18372  		_ = v.Args[1]
 18373  		v_0 := v.Args[0]
 18374  		if v_0.Op != OpConst32F {
 18375  			break
 18376  		}
 18377  		if v_0.AuxInt != auxFrom64F(1) {
 18378  			break
 18379  		}
 18380  		x := v.Args[1]
 18381  		v.reset(OpCopy)
 18382  		v.Type = x.Type
 18383  		v.AddArg(x)
 18384  		return true
 18385  	}
 18386  	// match: (Mul32F x (Const32F [auxFrom32F(-1)]))
 18387  	// cond:
 18388  	// result: (Neg32F x)
 18389  	for {
 18390  		_ = v.Args[1]
 18391  		x := v.Args[0]
 18392  		v_1 := v.Args[1]
 18393  		if v_1.Op != OpConst32F {
 18394  			break
 18395  		}
 18396  		if v_1.AuxInt != auxFrom32F(-1) {
 18397  			break
 18398  		}
 18399  		v.reset(OpNeg32F)
 18400  		v.AddArg(x)
 18401  		return true
 18402  	}
 18403  	// match: (Mul32F (Const32F [auxFrom32F(-1)]) x)
 18404  	// cond:
 18405  	// result: (Neg32F x)
 18406  	for {
 18407  		_ = v.Args[1]
 18408  		v_0 := v.Args[0]
 18409  		if v_0.Op != OpConst32F {
 18410  			break
 18411  		}
 18412  		if v_0.AuxInt != auxFrom32F(-1) {
 18413  			break
 18414  		}
 18415  		x := v.Args[1]
 18416  		v.reset(OpNeg32F)
 18417  		v.AddArg(x)
 18418  		return true
 18419  	}
 18420  	// match: (Mul32F x (Const32F [auxFrom32F(2)]))
 18421  	// cond:
 18422  	// result: (Add32F x x)
 18423  	for {
 18424  		_ = v.Args[1]
 18425  		x := v.Args[0]
 18426  		v_1 := v.Args[1]
 18427  		if v_1.Op != OpConst32F {
 18428  			break
 18429  		}
 18430  		if v_1.AuxInt != auxFrom32F(2) {
 18431  			break
 18432  		}
 18433  		v.reset(OpAdd32F)
 18434  		v.AddArg(x)
 18435  		v.AddArg(x)
 18436  		return true
 18437  	}
 18438  	// match: (Mul32F (Const32F [auxFrom32F(2)]) x)
 18439  	// cond:
 18440  	// result: (Add32F x x)
 18441  	for {
 18442  		_ = v.Args[1]
 18443  		v_0 := v.Args[0]
 18444  		if v_0.Op != OpConst32F {
 18445  			break
 18446  		}
 18447  		if v_0.AuxInt != auxFrom32F(2) {
 18448  			break
 18449  		}
 18450  		x := v.Args[1]
 18451  		v.reset(OpAdd32F)
 18452  		v.AddArg(x)
 18453  		v.AddArg(x)
 18454  		return true
 18455  	}
 18456  	return false
 18457  }
 18458  func rewriteValuegeneric_OpMul64_0(v *Value) bool {
 18459  	b := v.Block
 18460  	_ = b
 18461  	typ := &b.Func.Config.Types
 18462  	_ = typ
 18463  	// match: (Mul64 (Const64 [c]) (Const64 [d]))
 18464  	// cond:
 18465  	// result: (Const64 [c*d])
 18466  	for {
 18467  		_ = v.Args[1]
 18468  		v_0 := v.Args[0]
 18469  		if v_0.Op != OpConst64 {
 18470  			break
 18471  		}
 18472  		c := v_0.AuxInt
 18473  		v_1 := v.Args[1]
 18474  		if v_1.Op != OpConst64 {
 18475  			break
 18476  		}
 18477  		d := v_1.AuxInt
 18478  		v.reset(OpConst64)
 18479  		v.AuxInt = c * d
 18480  		return true
 18481  	}
 18482  	// match: (Mul64 (Const64 [d]) (Const64 [c]))
 18483  	// cond:
 18484  	// result: (Const64 [c*d])
 18485  	for {
 18486  		_ = v.Args[1]
 18487  		v_0 := v.Args[0]
 18488  		if v_0.Op != OpConst64 {
 18489  			break
 18490  		}
 18491  		d := v_0.AuxInt
 18492  		v_1 := v.Args[1]
 18493  		if v_1.Op != OpConst64 {
 18494  			break
 18495  		}
 18496  		c := v_1.AuxInt
 18497  		v.reset(OpConst64)
 18498  		v.AuxInt = c * d
 18499  		return true
 18500  	}
 18501  	// match: (Mul64 (Const64 [1]) x)
 18502  	// cond:
 18503  	// result: x
 18504  	for {
 18505  		_ = v.Args[1]
 18506  		v_0 := v.Args[0]
 18507  		if v_0.Op != OpConst64 {
 18508  			break
 18509  		}
 18510  		if v_0.AuxInt != 1 {
 18511  			break
 18512  		}
 18513  		x := v.Args[1]
 18514  		v.reset(OpCopy)
 18515  		v.Type = x.Type
 18516  		v.AddArg(x)
 18517  		return true
 18518  	}
 18519  	// match: (Mul64 x (Const64 [1]))
 18520  	// cond:
 18521  	// result: x
 18522  	for {
 18523  		_ = v.Args[1]
 18524  		x := v.Args[0]
 18525  		v_1 := v.Args[1]
 18526  		if v_1.Op != OpConst64 {
 18527  			break
 18528  		}
 18529  		if v_1.AuxInt != 1 {
 18530  			break
 18531  		}
 18532  		v.reset(OpCopy)
 18533  		v.Type = x.Type
 18534  		v.AddArg(x)
 18535  		return true
 18536  	}
 18537  	// match: (Mul64 (Const64 [-1]) x)
 18538  	// cond:
 18539  	// result: (Neg64 x)
 18540  	for {
 18541  		_ = v.Args[1]
 18542  		v_0 := v.Args[0]
 18543  		if v_0.Op != OpConst64 {
 18544  			break
 18545  		}
 18546  		if v_0.AuxInt != -1 {
 18547  			break
 18548  		}
 18549  		x := v.Args[1]
 18550  		v.reset(OpNeg64)
 18551  		v.AddArg(x)
 18552  		return true
 18553  	}
 18554  	// match: (Mul64 x (Const64 [-1]))
 18555  	// cond:
 18556  	// result: (Neg64 x)
 18557  	for {
 18558  		_ = v.Args[1]
 18559  		x := v.Args[0]
 18560  		v_1 := v.Args[1]
 18561  		if v_1.Op != OpConst64 {
 18562  			break
 18563  		}
 18564  		if v_1.AuxInt != -1 {
 18565  			break
 18566  		}
 18567  		v.reset(OpNeg64)
 18568  		v.AddArg(x)
 18569  		return true
 18570  	}
 18571  	// match: (Mul64 <t> n (Const64 [c]))
 18572  	// cond: isPowerOfTwo(c)
 18573  	// result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 18574  	for {
 18575  		t := v.Type
 18576  		_ = v.Args[1]
 18577  		n := v.Args[0]
 18578  		v_1 := v.Args[1]
 18579  		if v_1.Op != OpConst64 {
 18580  			break
 18581  		}
 18582  		c := v_1.AuxInt
 18583  		if !(isPowerOfTwo(c)) {
 18584  			break
 18585  		}
 18586  		v.reset(OpLsh64x64)
 18587  		v.Type = t
 18588  		v.AddArg(n)
 18589  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 18590  		v0.AuxInt = log2(c)
 18591  		v.AddArg(v0)
 18592  		return true
 18593  	}
 18594  	// match: (Mul64 <t> (Const64 [c]) n)
 18595  	// cond: isPowerOfTwo(c)
 18596  	// result: (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 18597  	for {
 18598  		t := v.Type
 18599  		_ = v.Args[1]
 18600  		v_0 := v.Args[0]
 18601  		if v_0.Op != OpConst64 {
 18602  			break
 18603  		}
 18604  		c := v_0.AuxInt
 18605  		n := v.Args[1]
 18606  		if !(isPowerOfTwo(c)) {
 18607  			break
 18608  		}
 18609  		v.reset(OpLsh64x64)
 18610  		v.Type = t
 18611  		v.AddArg(n)
 18612  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 18613  		v0.AuxInt = log2(c)
 18614  		v.AddArg(v0)
 18615  		return true
 18616  	}
 18617  	// match: (Mul64 <t> n (Const64 [c]))
 18618  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 18619  	// result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 18620  	for {
 18621  		t := v.Type
 18622  		_ = v.Args[1]
 18623  		n := v.Args[0]
 18624  		v_1 := v.Args[1]
 18625  		if v_1.Op != OpConst64 {
 18626  			break
 18627  		}
 18628  		c := v_1.AuxInt
 18629  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 18630  			break
 18631  		}
 18632  		v.reset(OpNeg64)
 18633  		v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
 18634  		v0.AddArg(n)
 18635  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 18636  		v1.AuxInt = log2(-c)
 18637  		v0.AddArg(v1)
 18638  		v.AddArg(v0)
 18639  		return true
 18640  	}
 18641  	// match: (Mul64 <t> (Const64 [c]) n)
 18642  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 18643  	// result: (Neg64 (Lsh64x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 18644  	for {
 18645  		t := v.Type
 18646  		_ = v.Args[1]
 18647  		v_0 := v.Args[0]
 18648  		if v_0.Op != OpConst64 {
 18649  			break
 18650  		}
 18651  		c := v_0.AuxInt
 18652  		n := v.Args[1]
 18653  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 18654  			break
 18655  		}
 18656  		v.reset(OpNeg64)
 18657  		v0 := b.NewValue0(v.Pos, OpLsh64x64, t)
 18658  		v0.AddArg(n)
 18659  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 18660  		v1.AuxInt = log2(-c)
 18661  		v0.AddArg(v1)
 18662  		v.AddArg(v0)
 18663  		return true
 18664  	}
 18665  	return false
 18666  }
 18667  func rewriteValuegeneric_OpMul64_10(v *Value) bool {
 18668  	b := v.Block
 18669  	_ = b
 18670  	// match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
 18671  	// cond:
 18672  	// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 18673  	for {
 18674  		_ = v.Args[1]
 18675  		v_0 := v.Args[0]
 18676  		if v_0.Op != OpConst64 {
 18677  			break
 18678  		}
 18679  		t := v_0.Type
 18680  		c := v_0.AuxInt
 18681  		v_1 := v.Args[1]
 18682  		if v_1.Op != OpAdd64 {
 18683  			break
 18684  		}
 18685  		if v_1.Type != t {
 18686  			break
 18687  		}
 18688  		_ = v_1.Args[1]
 18689  		v_1_0 := v_1.Args[0]
 18690  		if v_1_0.Op != OpConst64 {
 18691  			break
 18692  		}
 18693  		if v_1_0.Type != t {
 18694  			break
 18695  		}
 18696  		d := v_1_0.AuxInt
 18697  		x := v_1.Args[1]
 18698  		v.reset(OpAdd64)
 18699  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18700  		v0.AuxInt = c * d
 18701  		v.AddArg(v0)
 18702  		v1 := b.NewValue0(v.Pos, OpMul64, t)
 18703  		v2 := b.NewValue0(v.Pos, OpConst64, t)
 18704  		v2.AuxInt = c
 18705  		v1.AddArg(v2)
 18706  		v1.AddArg(x)
 18707  		v.AddArg(v1)
 18708  		return true
 18709  	}
 18710  	// match: (Mul64 (Const64 <t> [c]) (Add64 <t> x (Const64 <t> [d])))
 18711  	// cond:
 18712  	// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 18713  	for {
 18714  		_ = v.Args[1]
 18715  		v_0 := v.Args[0]
 18716  		if v_0.Op != OpConst64 {
 18717  			break
 18718  		}
 18719  		t := v_0.Type
 18720  		c := v_0.AuxInt
 18721  		v_1 := v.Args[1]
 18722  		if v_1.Op != OpAdd64 {
 18723  			break
 18724  		}
 18725  		if v_1.Type != t {
 18726  			break
 18727  		}
 18728  		_ = v_1.Args[1]
 18729  		x := v_1.Args[0]
 18730  		v_1_1 := v_1.Args[1]
 18731  		if v_1_1.Op != OpConst64 {
 18732  			break
 18733  		}
 18734  		if v_1_1.Type != t {
 18735  			break
 18736  		}
 18737  		d := v_1_1.AuxInt
 18738  		v.reset(OpAdd64)
 18739  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18740  		v0.AuxInt = c * d
 18741  		v.AddArg(v0)
 18742  		v1 := b.NewValue0(v.Pos, OpMul64, t)
 18743  		v2 := b.NewValue0(v.Pos, OpConst64, t)
 18744  		v2.AuxInt = c
 18745  		v1.AddArg(v2)
 18746  		v1.AddArg(x)
 18747  		v.AddArg(v1)
 18748  		return true
 18749  	}
 18750  	// match: (Mul64 (Add64 <t> (Const64 <t> [d]) x) (Const64 <t> [c]))
 18751  	// cond:
 18752  	// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 18753  	for {
 18754  		_ = v.Args[1]
 18755  		v_0 := v.Args[0]
 18756  		if v_0.Op != OpAdd64 {
 18757  			break
 18758  		}
 18759  		t := v_0.Type
 18760  		_ = v_0.Args[1]
 18761  		v_0_0 := v_0.Args[0]
 18762  		if v_0_0.Op != OpConst64 {
 18763  			break
 18764  		}
 18765  		if v_0_0.Type != t {
 18766  			break
 18767  		}
 18768  		d := v_0_0.AuxInt
 18769  		x := v_0.Args[1]
 18770  		v_1 := v.Args[1]
 18771  		if v_1.Op != OpConst64 {
 18772  			break
 18773  		}
 18774  		if v_1.Type != t {
 18775  			break
 18776  		}
 18777  		c := v_1.AuxInt
 18778  		v.reset(OpAdd64)
 18779  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18780  		v0.AuxInt = c * d
 18781  		v.AddArg(v0)
 18782  		v1 := b.NewValue0(v.Pos, OpMul64, t)
 18783  		v2 := b.NewValue0(v.Pos, OpConst64, t)
 18784  		v2.AuxInt = c
 18785  		v1.AddArg(v2)
 18786  		v1.AddArg(x)
 18787  		v.AddArg(v1)
 18788  		return true
 18789  	}
 18790  	// match: (Mul64 (Add64 <t> x (Const64 <t> [d])) (Const64 <t> [c]))
 18791  	// cond:
 18792  	// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
 18793  	for {
 18794  		_ = v.Args[1]
 18795  		v_0 := v.Args[0]
 18796  		if v_0.Op != OpAdd64 {
 18797  			break
 18798  		}
 18799  		t := v_0.Type
 18800  		_ = v_0.Args[1]
 18801  		x := v_0.Args[0]
 18802  		v_0_1 := v_0.Args[1]
 18803  		if v_0_1.Op != OpConst64 {
 18804  			break
 18805  		}
 18806  		if v_0_1.Type != t {
 18807  			break
 18808  		}
 18809  		d := v_0_1.AuxInt
 18810  		v_1 := v.Args[1]
 18811  		if v_1.Op != OpConst64 {
 18812  			break
 18813  		}
 18814  		if v_1.Type != t {
 18815  			break
 18816  		}
 18817  		c := v_1.AuxInt
 18818  		v.reset(OpAdd64)
 18819  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18820  		v0.AuxInt = c * d
 18821  		v.AddArg(v0)
 18822  		v1 := b.NewValue0(v.Pos, OpMul64, t)
 18823  		v2 := b.NewValue0(v.Pos, OpConst64, t)
 18824  		v2.AuxInt = c
 18825  		v1.AddArg(v2)
 18826  		v1.AddArg(x)
 18827  		v.AddArg(v1)
 18828  		return true
 18829  	}
 18830  	// match: (Mul64 (Const64 [0]) _)
 18831  	// cond:
 18832  	// result: (Const64 [0])
 18833  	for {
 18834  		_ = v.Args[1]
 18835  		v_0 := v.Args[0]
 18836  		if v_0.Op != OpConst64 {
 18837  			break
 18838  		}
 18839  		if v_0.AuxInt != 0 {
 18840  			break
 18841  		}
 18842  		v.reset(OpConst64)
 18843  		v.AuxInt = 0
 18844  		return true
 18845  	}
 18846  	// match: (Mul64 _ (Const64 [0]))
 18847  	// cond:
 18848  	// result: (Const64 [0])
 18849  	for {
 18850  		_ = v.Args[1]
 18851  		v_1 := v.Args[1]
 18852  		if v_1.Op != OpConst64 {
 18853  			break
 18854  		}
 18855  		if v_1.AuxInt != 0 {
 18856  			break
 18857  		}
 18858  		v.reset(OpConst64)
 18859  		v.AuxInt = 0
 18860  		return true
 18861  	}
 18862  	// match: (Mul64 (Const64 <t> [c]) (Mul64 (Const64 <t> [d]) x))
 18863  	// cond:
 18864  	// result: (Mul64 (Const64 <t> [c*d]) x)
 18865  	for {
 18866  		_ = v.Args[1]
 18867  		v_0 := v.Args[0]
 18868  		if v_0.Op != OpConst64 {
 18869  			break
 18870  		}
 18871  		t := v_0.Type
 18872  		c := v_0.AuxInt
 18873  		v_1 := v.Args[1]
 18874  		if v_1.Op != OpMul64 {
 18875  			break
 18876  		}
 18877  		_ = v_1.Args[1]
 18878  		v_1_0 := v_1.Args[0]
 18879  		if v_1_0.Op != OpConst64 {
 18880  			break
 18881  		}
 18882  		if v_1_0.Type != t {
 18883  			break
 18884  		}
 18885  		d := v_1_0.AuxInt
 18886  		x := v_1.Args[1]
 18887  		v.reset(OpMul64)
 18888  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18889  		v0.AuxInt = c * d
 18890  		v.AddArg(v0)
 18891  		v.AddArg(x)
 18892  		return true
 18893  	}
 18894  	// match: (Mul64 (Const64 <t> [c]) (Mul64 x (Const64 <t> [d])))
 18895  	// cond:
 18896  	// result: (Mul64 (Const64 <t> [c*d]) x)
 18897  	for {
 18898  		_ = v.Args[1]
 18899  		v_0 := v.Args[0]
 18900  		if v_0.Op != OpConst64 {
 18901  			break
 18902  		}
 18903  		t := v_0.Type
 18904  		c := v_0.AuxInt
 18905  		v_1 := v.Args[1]
 18906  		if v_1.Op != OpMul64 {
 18907  			break
 18908  		}
 18909  		_ = v_1.Args[1]
 18910  		x := v_1.Args[0]
 18911  		v_1_1 := v_1.Args[1]
 18912  		if v_1_1.Op != OpConst64 {
 18913  			break
 18914  		}
 18915  		if v_1_1.Type != t {
 18916  			break
 18917  		}
 18918  		d := v_1_1.AuxInt
 18919  		v.reset(OpMul64)
 18920  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18921  		v0.AuxInt = c * d
 18922  		v.AddArg(v0)
 18923  		v.AddArg(x)
 18924  		return true
 18925  	}
 18926  	// match: (Mul64 (Mul64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 18927  	// cond:
 18928  	// result: (Mul64 (Const64 <t> [c*d]) x)
 18929  	for {
 18930  		_ = v.Args[1]
 18931  		v_0 := v.Args[0]
 18932  		if v_0.Op != OpMul64 {
 18933  			break
 18934  		}
 18935  		_ = v_0.Args[1]
 18936  		v_0_0 := v_0.Args[0]
 18937  		if v_0_0.Op != OpConst64 {
 18938  			break
 18939  		}
 18940  		t := v_0_0.Type
 18941  		d := v_0_0.AuxInt
 18942  		x := v_0.Args[1]
 18943  		v_1 := v.Args[1]
 18944  		if v_1.Op != OpConst64 {
 18945  			break
 18946  		}
 18947  		if v_1.Type != t {
 18948  			break
 18949  		}
 18950  		c := v_1.AuxInt
 18951  		v.reset(OpMul64)
 18952  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18953  		v0.AuxInt = c * d
 18954  		v.AddArg(v0)
 18955  		v.AddArg(x)
 18956  		return true
 18957  	}
 18958  	// match: (Mul64 (Mul64 x (Const64 <t> [d])) (Const64 <t> [c]))
 18959  	// cond:
 18960  	// result: (Mul64 (Const64 <t> [c*d]) x)
 18961  	for {
 18962  		_ = v.Args[1]
 18963  		v_0 := v.Args[0]
 18964  		if v_0.Op != OpMul64 {
 18965  			break
 18966  		}
 18967  		_ = v_0.Args[1]
 18968  		x := v_0.Args[0]
 18969  		v_0_1 := v_0.Args[1]
 18970  		if v_0_1.Op != OpConst64 {
 18971  			break
 18972  		}
 18973  		t := v_0_1.Type
 18974  		d := v_0_1.AuxInt
 18975  		v_1 := v.Args[1]
 18976  		if v_1.Op != OpConst64 {
 18977  			break
 18978  		}
 18979  		if v_1.Type != t {
 18980  			break
 18981  		}
 18982  		c := v_1.AuxInt
 18983  		v.reset(OpMul64)
 18984  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 18985  		v0.AuxInt = c * d
 18986  		v.AddArg(v0)
 18987  		v.AddArg(x)
 18988  		return true
 18989  	}
 18990  	return false
 18991  }
 18992  func rewriteValuegeneric_OpMul64F_0(v *Value) bool {
 18993  	// match: (Mul64F (Const64F [c]) (Const64F [d]))
 18994  	// cond:
 18995  	// result: (Const64F [auxFrom64F(auxTo64F(c) * auxTo64F(d))])
 18996  	for {
 18997  		_ = v.Args[1]
 18998  		v_0 := v.Args[0]
 18999  		if v_0.Op != OpConst64F {
 19000  			break
 19001  		}
 19002  		c := v_0.AuxInt
 19003  		v_1 := v.Args[1]
 19004  		if v_1.Op != OpConst64F {
 19005  			break
 19006  		}
 19007  		d := v_1.AuxInt
 19008  		v.reset(OpConst64F)
 19009  		v.AuxInt = auxFrom64F(auxTo64F(c) * auxTo64F(d))
 19010  		return true
 19011  	}
 19012  	// match: (Mul64F (Const64F [d]) (Const64F [c]))
 19013  	// cond:
 19014  	// result: (Const64F [auxFrom64F(auxTo64F(c) * auxTo64F(d))])
 19015  	for {
 19016  		_ = v.Args[1]
 19017  		v_0 := v.Args[0]
 19018  		if v_0.Op != OpConst64F {
 19019  			break
 19020  		}
 19021  		d := v_0.AuxInt
 19022  		v_1 := v.Args[1]
 19023  		if v_1.Op != OpConst64F {
 19024  			break
 19025  		}
 19026  		c := v_1.AuxInt
 19027  		v.reset(OpConst64F)
 19028  		v.AuxInt = auxFrom64F(auxTo64F(c) * auxTo64F(d))
 19029  		return true
 19030  	}
 19031  	// match: (Mul64F x (Const64F [auxFrom64F(1)]))
 19032  	// cond:
 19033  	// result: x
 19034  	for {
 19035  		_ = v.Args[1]
 19036  		x := v.Args[0]
 19037  		v_1 := v.Args[1]
 19038  		if v_1.Op != OpConst64F {
 19039  			break
 19040  		}
 19041  		if v_1.AuxInt != auxFrom64F(1) {
 19042  			break
 19043  		}
 19044  		v.reset(OpCopy)
 19045  		v.Type = x.Type
 19046  		v.AddArg(x)
 19047  		return true
 19048  	}
 19049  	// match: (Mul64F (Const64F [auxFrom64F(1)]) x)
 19050  	// cond:
 19051  	// result: x
 19052  	for {
 19053  		_ = v.Args[1]
 19054  		v_0 := v.Args[0]
 19055  		if v_0.Op != OpConst64F {
 19056  			break
 19057  		}
 19058  		if v_0.AuxInt != auxFrom64F(1) {
 19059  			break
 19060  		}
 19061  		x := v.Args[1]
 19062  		v.reset(OpCopy)
 19063  		v.Type = x.Type
 19064  		v.AddArg(x)
 19065  		return true
 19066  	}
 19067  	// match: (Mul64F x (Const64F [auxFrom64F(-1)]))
 19068  	// cond:
 19069  	// result: (Neg64F x)
 19070  	for {
 19071  		_ = v.Args[1]
 19072  		x := v.Args[0]
 19073  		v_1 := v.Args[1]
 19074  		if v_1.Op != OpConst64F {
 19075  			break
 19076  		}
 19077  		if v_1.AuxInt != auxFrom64F(-1) {
 19078  			break
 19079  		}
 19080  		v.reset(OpNeg64F)
 19081  		v.AddArg(x)
 19082  		return true
 19083  	}
 19084  	// match: (Mul64F (Const64F [auxFrom64F(-1)]) x)
 19085  	// cond:
 19086  	// result: (Neg64F x)
 19087  	for {
 19088  		_ = v.Args[1]
 19089  		v_0 := v.Args[0]
 19090  		if v_0.Op != OpConst64F {
 19091  			break
 19092  		}
 19093  		if v_0.AuxInt != auxFrom64F(-1) {
 19094  			break
 19095  		}
 19096  		x := v.Args[1]
 19097  		v.reset(OpNeg64F)
 19098  		v.AddArg(x)
 19099  		return true
 19100  	}
 19101  	// match: (Mul64F x (Const64F [auxFrom64F(2)]))
 19102  	// cond:
 19103  	// result: (Add64F x x)
 19104  	for {
 19105  		_ = v.Args[1]
 19106  		x := v.Args[0]
 19107  		v_1 := v.Args[1]
 19108  		if v_1.Op != OpConst64F {
 19109  			break
 19110  		}
 19111  		if v_1.AuxInt != auxFrom64F(2) {
 19112  			break
 19113  		}
 19114  		v.reset(OpAdd64F)
 19115  		v.AddArg(x)
 19116  		v.AddArg(x)
 19117  		return true
 19118  	}
 19119  	// match: (Mul64F (Const64F [auxFrom64F(2)]) x)
 19120  	// cond:
 19121  	// result: (Add64F x x)
 19122  	for {
 19123  		_ = v.Args[1]
 19124  		v_0 := v.Args[0]
 19125  		if v_0.Op != OpConst64F {
 19126  			break
 19127  		}
 19128  		if v_0.AuxInt != auxFrom64F(2) {
 19129  			break
 19130  		}
 19131  		x := v.Args[1]
 19132  		v.reset(OpAdd64F)
 19133  		v.AddArg(x)
 19134  		v.AddArg(x)
 19135  		return true
 19136  	}
 19137  	return false
 19138  }
 19139  func rewriteValuegeneric_OpMul8_0(v *Value) bool {
 19140  	b := v.Block
 19141  	_ = b
 19142  	typ := &b.Func.Config.Types
 19143  	_ = typ
 19144  	// match: (Mul8 (Const8 [c]) (Const8 [d]))
 19145  	// cond:
 19146  	// result: (Const8 [int64(int8(c*d))])
 19147  	for {
 19148  		_ = v.Args[1]
 19149  		v_0 := v.Args[0]
 19150  		if v_0.Op != OpConst8 {
 19151  			break
 19152  		}
 19153  		c := v_0.AuxInt
 19154  		v_1 := v.Args[1]
 19155  		if v_1.Op != OpConst8 {
 19156  			break
 19157  		}
 19158  		d := v_1.AuxInt
 19159  		v.reset(OpConst8)
 19160  		v.AuxInt = int64(int8(c * d))
 19161  		return true
 19162  	}
 19163  	// match: (Mul8 (Const8 [d]) (Const8 [c]))
 19164  	// cond:
 19165  	// result: (Const8 [int64(int8(c*d))])
 19166  	for {
 19167  		_ = v.Args[1]
 19168  		v_0 := v.Args[0]
 19169  		if v_0.Op != OpConst8 {
 19170  			break
 19171  		}
 19172  		d := v_0.AuxInt
 19173  		v_1 := v.Args[1]
 19174  		if v_1.Op != OpConst8 {
 19175  			break
 19176  		}
 19177  		c := v_1.AuxInt
 19178  		v.reset(OpConst8)
 19179  		v.AuxInt = int64(int8(c * d))
 19180  		return true
 19181  	}
 19182  	// match: (Mul8 (Const8 [1]) x)
 19183  	// cond:
 19184  	// result: x
 19185  	for {
 19186  		_ = v.Args[1]
 19187  		v_0 := v.Args[0]
 19188  		if v_0.Op != OpConst8 {
 19189  			break
 19190  		}
 19191  		if v_0.AuxInt != 1 {
 19192  			break
 19193  		}
 19194  		x := v.Args[1]
 19195  		v.reset(OpCopy)
 19196  		v.Type = x.Type
 19197  		v.AddArg(x)
 19198  		return true
 19199  	}
 19200  	// match: (Mul8 x (Const8 [1]))
 19201  	// cond:
 19202  	// result: x
 19203  	for {
 19204  		_ = v.Args[1]
 19205  		x := v.Args[0]
 19206  		v_1 := v.Args[1]
 19207  		if v_1.Op != OpConst8 {
 19208  			break
 19209  		}
 19210  		if v_1.AuxInt != 1 {
 19211  			break
 19212  		}
 19213  		v.reset(OpCopy)
 19214  		v.Type = x.Type
 19215  		v.AddArg(x)
 19216  		return true
 19217  	}
 19218  	// match: (Mul8 (Const8 [-1]) x)
 19219  	// cond:
 19220  	// result: (Neg8 x)
 19221  	for {
 19222  		_ = v.Args[1]
 19223  		v_0 := v.Args[0]
 19224  		if v_0.Op != OpConst8 {
 19225  			break
 19226  		}
 19227  		if v_0.AuxInt != -1 {
 19228  			break
 19229  		}
 19230  		x := v.Args[1]
 19231  		v.reset(OpNeg8)
 19232  		v.AddArg(x)
 19233  		return true
 19234  	}
 19235  	// match: (Mul8 x (Const8 [-1]))
 19236  	// cond:
 19237  	// result: (Neg8 x)
 19238  	for {
 19239  		_ = v.Args[1]
 19240  		x := v.Args[0]
 19241  		v_1 := v.Args[1]
 19242  		if v_1.Op != OpConst8 {
 19243  			break
 19244  		}
 19245  		if v_1.AuxInt != -1 {
 19246  			break
 19247  		}
 19248  		v.reset(OpNeg8)
 19249  		v.AddArg(x)
 19250  		return true
 19251  	}
 19252  	// match: (Mul8 <t> n (Const8 [c]))
 19253  	// cond: isPowerOfTwo(c)
 19254  	// result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 19255  	for {
 19256  		t := v.Type
 19257  		_ = v.Args[1]
 19258  		n := v.Args[0]
 19259  		v_1 := v.Args[1]
 19260  		if v_1.Op != OpConst8 {
 19261  			break
 19262  		}
 19263  		c := v_1.AuxInt
 19264  		if !(isPowerOfTwo(c)) {
 19265  			break
 19266  		}
 19267  		v.reset(OpLsh8x64)
 19268  		v.Type = t
 19269  		v.AddArg(n)
 19270  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19271  		v0.AuxInt = log2(c)
 19272  		v.AddArg(v0)
 19273  		return true
 19274  	}
 19275  	// match: (Mul8 <t> (Const8 [c]) n)
 19276  	// cond: isPowerOfTwo(c)
 19277  	// result: (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(c)]))
 19278  	for {
 19279  		t := v.Type
 19280  		_ = v.Args[1]
 19281  		v_0 := v.Args[0]
 19282  		if v_0.Op != OpConst8 {
 19283  			break
 19284  		}
 19285  		c := v_0.AuxInt
 19286  		n := v.Args[1]
 19287  		if !(isPowerOfTwo(c)) {
 19288  			break
 19289  		}
 19290  		v.reset(OpLsh8x64)
 19291  		v.Type = t
 19292  		v.AddArg(n)
 19293  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19294  		v0.AuxInt = log2(c)
 19295  		v.AddArg(v0)
 19296  		return true
 19297  	}
 19298  	// match: (Mul8 <t> n (Const8 [c]))
 19299  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 19300  	// result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 19301  	for {
 19302  		t := v.Type
 19303  		_ = v.Args[1]
 19304  		n := v.Args[0]
 19305  		v_1 := v.Args[1]
 19306  		if v_1.Op != OpConst8 {
 19307  			break
 19308  		}
 19309  		c := v_1.AuxInt
 19310  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 19311  			break
 19312  		}
 19313  		v.reset(OpNeg8)
 19314  		v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
 19315  		v0.AddArg(n)
 19316  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19317  		v1.AuxInt = log2(-c)
 19318  		v0.AddArg(v1)
 19319  		v.AddArg(v0)
 19320  		return true
 19321  	}
 19322  	// match: (Mul8 <t> (Const8 [c]) n)
 19323  	// cond: t.IsSigned() && isPowerOfTwo(-c)
 19324  	// result: (Neg8 (Lsh8x64 <t> n (Const64 <typ.UInt64> [log2(-c)])))
 19325  	for {
 19326  		t := v.Type
 19327  		_ = v.Args[1]
 19328  		v_0 := v.Args[0]
 19329  		if v_0.Op != OpConst8 {
 19330  			break
 19331  		}
 19332  		c := v_0.AuxInt
 19333  		n := v.Args[1]
 19334  		if !(t.IsSigned() && isPowerOfTwo(-c)) {
 19335  			break
 19336  		}
 19337  		v.reset(OpNeg8)
 19338  		v0 := b.NewValue0(v.Pos, OpLsh8x64, t)
 19339  		v0.AddArg(n)
 19340  		v1 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 19341  		v1.AuxInt = log2(-c)
 19342  		v0.AddArg(v1)
 19343  		v.AddArg(v0)
 19344  		return true
 19345  	}
 19346  	return false
 19347  }
 19348  func rewriteValuegeneric_OpMul8_10(v *Value) bool {
 19349  	b := v.Block
 19350  	_ = b
 19351  	// match: (Mul8 (Const8 [0]) _)
 19352  	// cond:
 19353  	// result: (Const8 [0])
 19354  	for {
 19355  		_ = v.Args[1]
 19356  		v_0 := v.Args[0]
 19357  		if v_0.Op != OpConst8 {
 19358  			break
 19359  		}
 19360  		if v_0.AuxInt != 0 {
 19361  			break
 19362  		}
 19363  		v.reset(OpConst8)
 19364  		v.AuxInt = 0
 19365  		return true
 19366  	}
 19367  	// match: (Mul8 _ (Const8 [0]))
 19368  	// cond:
 19369  	// result: (Const8 [0])
 19370  	for {
 19371  		_ = v.Args[1]
 19372  		v_1 := v.Args[1]
 19373  		if v_1.Op != OpConst8 {
 19374  			break
 19375  		}
 19376  		if v_1.AuxInt != 0 {
 19377  			break
 19378  		}
 19379  		v.reset(OpConst8)
 19380  		v.AuxInt = 0
 19381  		return true
 19382  	}
 19383  	// match: (Mul8 (Const8 <t> [c]) (Mul8 (Const8 <t> [d]) x))
 19384  	// cond:
 19385  	// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 19386  	for {
 19387  		_ = v.Args[1]
 19388  		v_0 := v.Args[0]
 19389  		if v_0.Op != OpConst8 {
 19390  			break
 19391  		}
 19392  		t := v_0.Type
 19393  		c := v_0.AuxInt
 19394  		v_1 := v.Args[1]
 19395  		if v_1.Op != OpMul8 {
 19396  			break
 19397  		}
 19398  		_ = v_1.Args[1]
 19399  		v_1_0 := v_1.Args[0]
 19400  		if v_1_0.Op != OpConst8 {
 19401  			break
 19402  		}
 19403  		if v_1_0.Type != t {
 19404  			break
 19405  		}
 19406  		d := v_1_0.AuxInt
 19407  		x := v_1.Args[1]
 19408  		v.reset(OpMul8)
 19409  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 19410  		v0.AuxInt = int64(int8(c * d))
 19411  		v.AddArg(v0)
 19412  		v.AddArg(x)
 19413  		return true
 19414  	}
 19415  	// match: (Mul8 (Const8 <t> [c]) (Mul8 x (Const8 <t> [d])))
 19416  	// cond:
 19417  	// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 19418  	for {
 19419  		_ = v.Args[1]
 19420  		v_0 := v.Args[0]
 19421  		if v_0.Op != OpConst8 {
 19422  			break
 19423  		}
 19424  		t := v_0.Type
 19425  		c := v_0.AuxInt
 19426  		v_1 := v.Args[1]
 19427  		if v_1.Op != OpMul8 {
 19428  			break
 19429  		}
 19430  		_ = v_1.Args[1]
 19431  		x := v_1.Args[0]
 19432  		v_1_1 := v_1.Args[1]
 19433  		if v_1_1.Op != OpConst8 {
 19434  			break
 19435  		}
 19436  		if v_1_1.Type != t {
 19437  			break
 19438  		}
 19439  		d := v_1_1.AuxInt
 19440  		v.reset(OpMul8)
 19441  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 19442  		v0.AuxInt = int64(int8(c * d))
 19443  		v.AddArg(v0)
 19444  		v.AddArg(x)
 19445  		return true
 19446  	}
 19447  	// match: (Mul8 (Mul8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 19448  	// cond:
 19449  	// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 19450  	for {
 19451  		_ = v.Args[1]
 19452  		v_0 := v.Args[0]
 19453  		if v_0.Op != OpMul8 {
 19454  			break
 19455  		}
 19456  		_ = v_0.Args[1]
 19457  		v_0_0 := v_0.Args[0]
 19458  		if v_0_0.Op != OpConst8 {
 19459  			break
 19460  		}
 19461  		t := v_0_0.Type
 19462  		d := v_0_0.AuxInt
 19463  		x := v_0.Args[1]
 19464  		v_1 := v.Args[1]
 19465  		if v_1.Op != OpConst8 {
 19466  			break
 19467  		}
 19468  		if v_1.Type != t {
 19469  			break
 19470  		}
 19471  		c := v_1.AuxInt
 19472  		v.reset(OpMul8)
 19473  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 19474  		v0.AuxInt = int64(int8(c * d))
 19475  		v.AddArg(v0)
 19476  		v.AddArg(x)
 19477  		return true
 19478  	}
 19479  	// match: (Mul8 (Mul8 x (Const8 <t> [d])) (Const8 <t> [c]))
 19480  	// cond:
 19481  	// result: (Mul8 (Const8 <t> [int64(int8(c*d))]) x)
 19482  	for {
 19483  		_ = v.Args[1]
 19484  		v_0 := v.Args[0]
 19485  		if v_0.Op != OpMul8 {
 19486  			break
 19487  		}
 19488  		_ = v_0.Args[1]
 19489  		x := v_0.Args[0]
 19490  		v_0_1 := v_0.Args[1]
 19491  		if v_0_1.Op != OpConst8 {
 19492  			break
 19493  		}
 19494  		t := v_0_1.Type
 19495  		d := v_0_1.AuxInt
 19496  		v_1 := v.Args[1]
 19497  		if v_1.Op != OpConst8 {
 19498  			break
 19499  		}
 19500  		if v_1.Type != t {
 19501  			break
 19502  		}
 19503  		c := v_1.AuxInt
 19504  		v.reset(OpMul8)
 19505  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 19506  		v0.AuxInt = int64(int8(c * d))
 19507  		v.AddArg(v0)
 19508  		v.AddArg(x)
 19509  		return true
 19510  	}
 19511  	return false
 19512  }
 19513  func rewriteValuegeneric_OpNeg16_0(v *Value) bool {
 19514  	// match: (Neg16 (Const16 [c]))
 19515  	// cond:
 19516  	// result: (Const16 [int64(-int16(c))])
 19517  	for {
 19518  		v_0 := v.Args[0]
 19519  		if v_0.Op != OpConst16 {
 19520  			break
 19521  		}
 19522  		c := v_0.AuxInt
 19523  		v.reset(OpConst16)
 19524  		v.AuxInt = int64(-int16(c))
 19525  		return true
 19526  	}
 19527  	// match: (Neg16 (Sub16 x y))
 19528  	// cond:
 19529  	// result: (Sub16 y x)
 19530  	for {
 19531  		v_0 := v.Args[0]
 19532  		if v_0.Op != OpSub16 {
 19533  			break
 19534  		}
 19535  		_ = v_0.Args[1]
 19536  		x := v_0.Args[0]
 19537  		y := v_0.Args[1]
 19538  		v.reset(OpSub16)
 19539  		v.AddArg(y)
 19540  		v.AddArg(x)
 19541  		return true
 19542  	}
 19543  	return false
 19544  }
 19545  func rewriteValuegeneric_OpNeg32_0(v *Value) bool {
 19546  	// match: (Neg32 (Const32 [c]))
 19547  	// cond:
 19548  	// result: (Const32 [int64(-int32(c))])
 19549  	for {
 19550  		v_0 := v.Args[0]
 19551  		if v_0.Op != OpConst32 {
 19552  			break
 19553  		}
 19554  		c := v_0.AuxInt
 19555  		v.reset(OpConst32)
 19556  		v.AuxInt = int64(-int32(c))
 19557  		return true
 19558  	}
 19559  	// match: (Neg32 (Sub32 x y))
 19560  	// cond:
 19561  	// result: (Sub32 y x)
 19562  	for {
 19563  		v_0 := v.Args[0]
 19564  		if v_0.Op != OpSub32 {
 19565  			break
 19566  		}
 19567  		_ = v_0.Args[1]
 19568  		x := v_0.Args[0]
 19569  		y := v_0.Args[1]
 19570  		v.reset(OpSub32)
 19571  		v.AddArg(y)
 19572  		v.AddArg(x)
 19573  		return true
 19574  	}
 19575  	return false
 19576  }
 19577  func rewriteValuegeneric_OpNeg32F_0(v *Value) bool {
 19578  	// match: (Neg32F (Const32F [c]))
 19579  	// cond: auxTo32F(c) != 0
 19580  	// result: (Const32F [auxFrom32F(-auxTo32F(c))])
 19581  	for {
 19582  		v_0 := v.Args[0]
 19583  		if v_0.Op != OpConst32F {
 19584  			break
 19585  		}
 19586  		c := v_0.AuxInt
 19587  		if !(auxTo32F(c) != 0) {
 19588  			break
 19589  		}
 19590  		v.reset(OpConst32F)
 19591  		v.AuxInt = auxFrom32F(-auxTo32F(c))
 19592  		return true
 19593  	}
 19594  	return false
 19595  }
 19596  func rewriteValuegeneric_OpNeg64_0(v *Value) bool {
 19597  	// match: (Neg64 (Const64 [c]))
 19598  	// cond:
 19599  	// result: (Const64 [-c])
 19600  	for {
 19601  		v_0 := v.Args[0]
 19602  		if v_0.Op != OpConst64 {
 19603  			break
 19604  		}
 19605  		c := v_0.AuxInt
 19606  		v.reset(OpConst64)
 19607  		v.AuxInt = -c
 19608  		return true
 19609  	}
 19610  	// match: (Neg64 (Sub64 x y))
 19611  	// cond:
 19612  	// result: (Sub64 y x)
 19613  	for {
 19614  		v_0 := v.Args[0]
 19615  		if v_0.Op != OpSub64 {
 19616  			break
 19617  		}
 19618  		_ = v_0.Args[1]
 19619  		x := v_0.Args[0]
 19620  		y := v_0.Args[1]
 19621  		v.reset(OpSub64)
 19622  		v.AddArg(y)
 19623  		v.AddArg(x)
 19624  		return true
 19625  	}
 19626  	return false
 19627  }
 19628  func rewriteValuegeneric_OpNeg64F_0(v *Value) bool {
 19629  	// match: (Neg64F (Const64F [c]))
 19630  	// cond: auxTo64F(c) != 0
 19631  	// result: (Const64F [auxFrom64F(-auxTo64F(c))])
 19632  	for {
 19633  		v_0 := v.Args[0]
 19634  		if v_0.Op != OpConst64F {
 19635  			break
 19636  		}
 19637  		c := v_0.AuxInt
 19638  		if !(auxTo64F(c) != 0) {
 19639  			break
 19640  		}
 19641  		v.reset(OpConst64F)
 19642  		v.AuxInt = auxFrom64F(-auxTo64F(c))
 19643  		return true
 19644  	}
 19645  	return false
 19646  }
 19647  func rewriteValuegeneric_OpNeg8_0(v *Value) bool {
 19648  	// match: (Neg8 (Const8 [c]))
 19649  	// cond:
 19650  	// result: (Const8 [int64( -int8(c))])
 19651  	for {
 19652  		v_0 := v.Args[0]
 19653  		if v_0.Op != OpConst8 {
 19654  			break
 19655  		}
 19656  		c := v_0.AuxInt
 19657  		v.reset(OpConst8)
 19658  		v.AuxInt = int64(-int8(c))
 19659  		return true
 19660  	}
 19661  	// match: (Neg8 (Sub8 x y))
 19662  	// cond:
 19663  	// result: (Sub8 y x)
 19664  	for {
 19665  		v_0 := v.Args[0]
 19666  		if v_0.Op != OpSub8 {
 19667  			break
 19668  		}
 19669  		_ = v_0.Args[1]
 19670  		x := v_0.Args[0]
 19671  		y := v_0.Args[1]
 19672  		v.reset(OpSub8)
 19673  		v.AddArg(y)
 19674  		v.AddArg(x)
 19675  		return true
 19676  	}
 19677  	return false
 19678  }
 19679  func rewriteValuegeneric_OpNeq16_0(v *Value) bool {
 19680  	b := v.Block
 19681  	_ = b
 19682  	// match: (Neq16 x x)
 19683  	// cond:
 19684  	// result: (ConstBool [0])
 19685  	for {
 19686  		_ = v.Args[1]
 19687  		x := v.Args[0]
 19688  		if x != v.Args[1] {
 19689  			break
 19690  		}
 19691  		v.reset(OpConstBool)
 19692  		v.AuxInt = 0
 19693  		return true
 19694  	}
 19695  	// match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
 19696  	// cond:
 19697  	// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 19698  	for {
 19699  		_ = v.Args[1]
 19700  		v_0 := v.Args[0]
 19701  		if v_0.Op != OpConst16 {
 19702  			break
 19703  		}
 19704  		t := v_0.Type
 19705  		c := v_0.AuxInt
 19706  		v_1 := v.Args[1]
 19707  		if v_1.Op != OpAdd16 {
 19708  			break
 19709  		}
 19710  		_ = v_1.Args[1]
 19711  		v_1_0 := v_1.Args[0]
 19712  		if v_1_0.Op != OpConst16 {
 19713  			break
 19714  		}
 19715  		if v_1_0.Type != t {
 19716  			break
 19717  		}
 19718  		d := v_1_0.AuxInt
 19719  		x := v_1.Args[1]
 19720  		v.reset(OpNeq16)
 19721  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 19722  		v0.AuxInt = int64(int16(c - d))
 19723  		v.AddArg(v0)
 19724  		v.AddArg(x)
 19725  		return true
 19726  	}
 19727  	// match: (Neq16 (Const16 <t> [c]) (Add16 x (Const16 <t> [d])))
 19728  	// cond:
 19729  	// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 19730  	for {
 19731  		_ = v.Args[1]
 19732  		v_0 := v.Args[0]
 19733  		if v_0.Op != OpConst16 {
 19734  			break
 19735  		}
 19736  		t := v_0.Type
 19737  		c := v_0.AuxInt
 19738  		v_1 := v.Args[1]
 19739  		if v_1.Op != OpAdd16 {
 19740  			break
 19741  		}
 19742  		_ = v_1.Args[1]
 19743  		x := v_1.Args[0]
 19744  		v_1_1 := v_1.Args[1]
 19745  		if v_1_1.Op != OpConst16 {
 19746  			break
 19747  		}
 19748  		if v_1_1.Type != t {
 19749  			break
 19750  		}
 19751  		d := v_1_1.AuxInt
 19752  		v.reset(OpNeq16)
 19753  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 19754  		v0.AuxInt = int64(int16(c - d))
 19755  		v.AddArg(v0)
 19756  		v.AddArg(x)
 19757  		return true
 19758  	}
 19759  	// match: (Neq16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 19760  	// cond:
 19761  	// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 19762  	for {
 19763  		_ = v.Args[1]
 19764  		v_0 := v.Args[0]
 19765  		if v_0.Op != OpAdd16 {
 19766  			break
 19767  		}
 19768  		_ = v_0.Args[1]
 19769  		v_0_0 := v_0.Args[0]
 19770  		if v_0_0.Op != OpConst16 {
 19771  			break
 19772  		}
 19773  		t := v_0_0.Type
 19774  		d := v_0_0.AuxInt
 19775  		x := v_0.Args[1]
 19776  		v_1 := v.Args[1]
 19777  		if v_1.Op != OpConst16 {
 19778  			break
 19779  		}
 19780  		if v_1.Type != t {
 19781  			break
 19782  		}
 19783  		c := v_1.AuxInt
 19784  		v.reset(OpNeq16)
 19785  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 19786  		v0.AuxInt = int64(int16(c - d))
 19787  		v.AddArg(v0)
 19788  		v.AddArg(x)
 19789  		return true
 19790  	}
 19791  	// match: (Neq16 (Add16 x (Const16 <t> [d])) (Const16 <t> [c]))
 19792  	// cond:
 19793  	// result: (Neq16 (Const16 <t> [int64(int16(c-d))]) x)
 19794  	for {
 19795  		_ = v.Args[1]
 19796  		v_0 := v.Args[0]
 19797  		if v_0.Op != OpAdd16 {
 19798  			break
 19799  		}
 19800  		_ = v_0.Args[1]
 19801  		x := v_0.Args[0]
 19802  		v_0_1 := v_0.Args[1]
 19803  		if v_0_1.Op != OpConst16 {
 19804  			break
 19805  		}
 19806  		t := v_0_1.Type
 19807  		d := v_0_1.AuxInt
 19808  		v_1 := v.Args[1]
 19809  		if v_1.Op != OpConst16 {
 19810  			break
 19811  		}
 19812  		if v_1.Type != t {
 19813  			break
 19814  		}
 19815  		c := v_1.AuxInt
 19816  		v.reset(OpNeq16)
 19817  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 19818  		v0.AuxInt = int64(int16(c - d))
 19819  		v.AddArg(v0)
 19820  		v.AddArg(x)
 19821  		return true
 19822  	}
 19823  	// match: (Neq16 (Const16 [c]) (Const16 [d]))
 19824  	// cond:
 19825  	// result: (ConstBool [b2i(c != d)])
 19826  	for {
 19827  		_ = v.Args[1]
 19828  		v_0 := v.Args[0]
 19829  		if v_0.Op != OpConst16 {
 19830  			break
 19831  		}
 19832  		c := v_0.AuxInt
 19833  		v_1 := v.Args[1]
 19834  		if v_1.Op != OpConst16 {
 19835  			break
 19836  		}
 19837  		d := v_1.AuxInt
 19838  		v.reset(OpConstBool)
 19839  		v.AuxInt = b2i(c != d)
 19840  		return true
 19841  	}
 19842  	// match: (Neq16 (Const16 [d]) (Const16 [c]))
 19843  	// cond:
 19844  	// result: (ConstBool [b2i(c != d)])
 19845  	for {
 19846  		_ = v.Args[1]
 19847  		v_0 := v.Args[0]
 19848  		if v_0.Op != OpConst16 {
 19849  			break
 19850  		}
 19851  		d := v_0.AuxInt
 19852  		v_1 := v.Args[1]
 19853  		if v_1.Op != OpConst16 {
 19854  			break
 19855  		}
 19856  		c := v_1.AuxInt
 19857  		v.reset(OpConstBool)
 19858  		v.AuxInt = b2i(c != d)
 19859  		return true
 19860  	}
 19861  	// match: (Neq16 s:(Sub16 x y) (Const16 [0]))
 19862  	// cond: s.Uses == 1
 19863  	// result: (Neq16 x y)
 19864  	for {
 19865  		_ = v.Args[1]
 19866  		s := v.Args[0]
 19867  		if s.Op != OpSub16 {
 19868  			break
 19869  		}
 19870  		_ = s.Args[1]
 19871  		x := s.Args[0]
 19872  		y := s.Args[1]
 19873  		v_1 := v.Args[1]
 19874  		if v_1.Op != OpConst16 {
 19875  			break
 19876  		}
 19877  		if v_1.AuxInt != 0 {
 19878  			break
 19879  		}
 19880  		if !(s.Uses == 1) {
 19881  			break
 19882  		}
 19883  		v.reset(OpNeq16)
 19884  		v.AddArg(x)
 19885  		v.AddArg(y)
 19886  		return true
 19887  	}
 19888  	// match: (Neq16 (Const16 [0]) s:(Sub16 x y))
 19889  	// cond: s.Uses == 1
 19890  	// result: (Neq16 x y)
 19891  	for {
 19892  		_ = v.Args[1]
 19893  		v_0 := v.Args[0]
 19894  		if v_0.Op != OpConst16 {
 19895  			break
 19896  		}
 19897  		if v_0.AuxInt != 0 {
 19898  			break
 19899  		}
 19900  		s := v.Args[1]
 19901  		if s.Op != OpSub16 {
 19902  			break
 19903  		}
 19904  		_ = s.Args[1]
 19905  		x := s.Args[0]
 19906  		y := s.Args[1]
 19907  		if !(s.Uses == 1) {
 19908  			break
 19909  		}
 19910  		v.reset(OpNeq16)
 19911  		v.AddArg(x)
 19912  		v.AddArg(y)
 19913  		return true
 19914  	}
 19915  	return false
 19916  }
 19917  func rewriteValuegeneric_OpNeq32_0(v *Value) bool {
 19918  	b := v.Block
 19919  	_ = b
 19920  	// match: (Neq32 x x)
 19921  	// cond:
 19922  	// result: (ConstBool [0])
 19923  	for {
 19924  		_ = v.Args[1]
 19925  		x := v.Args[0]
 19926  		if x != v.Args[1] {
 19927  			break
 19928  		}
 19929  		v.reset(OpConstBool)
 19930  		v.AuxInt = 0
 19931  		return true
 19932  	}
 19933  	// match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
 19934  	// cond:
 19935  	// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 19936  	for {
 19937  		_ = v.Args[1]
 19938  		v_0 := v.Args[0]
 19939  		if v_0.Op != OpConst32 {
 19940  			break
 19941  		}
 19942  		t := v_0.Type
 19943  		c := v_0.AuxInt
 19944  		v_1 := v.Args[1]
 19945  		if v_1.Op != OpAdd32 {
 19946  			break
 19947  		}
 19948  		_ = v_1.Args[1]
 19949  		v_1_0 := v_1.Args[0]
 19950  		if v_1_0.Op != OpConst32 {
 19951  			break
 19952  		}
 19953  		if v_1_0.Type != t {
 19954  			break
 19955  		}
 19956  		d := v_1_0.AuxInt
 19957  		x := v_1.Args[1]
 19958  		v.reset(OpNeq32)
 19959  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 19960  		v0.AuxInt = int64(int32(c - d))
 19961  		v.AddArg(v0)
 19962  		v.AddArg(x)
 19963  		return true
 19964  	}
 19965  	// match: (Neq32 (Const32 <t> [c]) (Add32 x (Const32 <t> [d])))
 19966  	// cond:
 19967  	// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 19968  	for {
 19969  		_ = v.Args[1]
 19970  		v_0 := v.Args[0]
 19971  		if v_0.Op != OpConst32 {
 19972  			break
 19973  		}
 19974  		t := v_0.Type
 19975  		c := v_0.AuxInt
 19976  		v_1 := v.Args[1]
 19977  		if v_1.Op != OpAdd32 {
 19978  			break
 19979  		}
 19980  		_ = v_1.Args[1]
 19981  		x := v_1.Args[0]
 19982  		v_1_1 := v_1.Args[1]
 19983  		if v_1_1.Op != OpConst32 {
 19984  			break
 19985  		}
 19986  		if v_1_1.Type != t {
 19987  			break
 19988  		}
 19989  		d := v_1_1.AuxInt
 19990  		v.reset(OpNeq32)
 19991  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 19992  		v0.AuxInt = int64(int32(c - d))
 19993  		v.AddArg(v0)
 19994  		v.AddArg(x)
 19995  		return true
 19996  	}
 19997  	// match: (Neq32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 19998  	// cond:
 19999  	// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 20000  	for {
 20001  		_ = v.Args[1]
 20002  		v_0 := v.Args[0]
 20003  		if v_0.Op != OpAdd32 {
 20004  			break
 20005  		}
 20006  		_ = v_0.Args[1]
 20007  		v_0_0 := v_0.Args[0]
 20008  		if v_0_0.Op != OpConst32 {
 20009  			break
 20010  		}
 20011  		t := v_0_0.Type
 20012  		d := v_0_0.AuxInt
 20013  		x := v_0.Args[1]
 20014  		v_1 := v.Args[1]
 20015  		if v_1.Op != OpConst32 {
 20016  			break
 20017  		}
 20018  		if v_1.Type != t {
 20019  			break
 20020  		}
 20021  		c := v_1.AuxInt
 20022  		v.reset(OpNeq32)
 20023  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 20024  		v0.AuxInt = int64(int32(c - d))
 20025  		v.AddArg(v0)
 20026  		v.AddArg(x)
 20027  		return true
 20028  	}
 20029  	// match: (Neq32 (Add32 x (Const32 <t> [d])) (Const32 <t> [c]))
 20030  	// cond:
 20031  	// result: (Neq32 (Const32 <t> [int64(int32(c-d))]) x)
 20032  	for {
 20033  		_ = v.Args[1]
 20034  		v_0 := v.Args[0]
 20035  		if v_0.Op != OpAdd32 {
 20036  			break
 20037  		}
 20038  		_ = v_0.Args[1]
 20039  		x := v_0.Args[0]
 20040  		v_0_1 := v_0.Args[1]
 20041  		if v_0_1.Op != OpConst32 {
 20042  			break
 20043  		}
 20044  		t := v_0_1.Type
 20045  		d := v_0_1.AuxInt
 20046  		v_1 := v.Args[1]
 20047  		if v_1.Op != OpConst32 {
 20048  			break
 20049  		}
 20050  		if v_1.Type != t {
 20051  			break
 20052  		}
 20053  		c := v_1.AuxInt
 20054  		v.reset(OpNeq32)
 20055  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 20056  		v0.AuxInt = int64(int32(c - d))
 20057  		v.AddArg(v0)
 20058  		v.AddArg(x)
 20059  		return true
 20060  	}
 20061  	// match: (Neq32 (Const32 [c]) (Const32 [d]))
 20062  	// cond:
 20063  	// result: (ConstBool [b2i(c != d)])
 20064  	for {
 20065  		_ = v.Args[1]
 20066  		v_0 := v.Args[0]
 20067  		if v_0.Op != OpConst32 {
 20068  			break
 20069  		}
 20070  		c := v_0.AuxInt
 20071  		v_1 := v.Args[1]
 20072  		if v_1.Op != OpConst32 {
 20073  			break
 20074  		}
 20075  		d := v_1.AuxInt
 20076  		v.reset(OpConstBool)
 20077  		v.AuxInt = b2i(c != d)
 20078  		return true
 20079  	}
 20080  	// match: (Neq32 (Const32 [d]) (Const32 [c]))
 20081  	// cond:
 20082  	// result: (ConstBool [b2i(c != d)])
 20083  	for {
 20084  		_ = v.Args[1]
 20085  		v_0 := v.Args[0]
 20086  		if v_0.Op != OpConst32 {
 20087  			break
 20088  		}
 20089  		d := v_0.AuxInt
 20090  		v_1 := v.Args[1]
 20091  		if v_1.Op != OpConst32 {
 20092  			break
 20093  		}
 20094  		c := v_1.AuxInt
 20095  		v.reset(OpConstBool)
 20096  		v.AuxInt = b2i(c != d)
 20097  		return true
 20098  	}
 20099  	// match: (Neq32 s:(Sub32 x y) (Const32 [0]))
 20100  	// cond: s.Uses == 1
 20101  	// result: (Neq32 x y)
 20102  	for {
 20103  		_ = v.Args[1]
 20104  		s := v.Args[0]
 20105  		if s.Op != OpSub32 {
 20106  			break
 20107  		}
 20108  		_ = s.Args[1]
 20109  		x := s.Args[0]
 20110  		y := s.Args[1]
 20111  		v_1 := v.Args[1]
 20112  		if v_1.Op != OpConst32 {
 20113  			break
 20114  		}
 20115  		if v_1.AuxInt != 0 {
 20116  			break
 20117  		}
 20118  		if !(s.Uses == 1) {
 20119  			break
 20120  		}
 20121  		v.reset(OpNeq32)
 20122  		v.AddArg(x)
 20123  		v.AddArg(y)
 20124  		return true
 20125  	}
 20126  	// match: (Neq32 (Const32 [0]) s:(Sub32 x y))
 20127  	// cond: s.Uses == 1
 20128  	// result: (Neq32 x y)
 20129  	for {
 20130  		_ = v.Args[1]
 20131  		v_0 := v.Args[0]
 20132  		if v_0.Op != OpConst32 {
 20133  			break
 20134  		}
 20135  		if v_0.AuxInt != 0 {
 20136  			break
 20137  		}
 20138  		s := v.Args[1]
 20139  		if s.Op != OpSub32 {
 20140  			break
 20141  		}
 20142  		_ = s.Args[1]
 20143  		x := s.Args[0]
 20144  		y := s.Args[1]
 20145  		if !(s.Uses == 1) {
 20146  			break
 20147  		}
 20148  		v.reset(OpNeq32)
 20149  		v.AddArg(x)
 20150  		v.AddArg(y)
 20151  		return true
 20152  	}
 20153  	return false
 20154  }
 20155  func rewriteValuegeneric_OpNeq32F_0(v *Value) bool {
 20156  	// match: (Neq32F (Const32F [c]) (Const32F [d]))
 20157  	// cond:
 20158  	// result: (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))])
 20159  	for {
 20160  		_ = v.Args[1]
 20161  		v_0 := v.Args[0]
 20162  		if v_0.Op != OpConst32F {
 20163  			break
 20164  		}
 20165  		c := v_0.AuxInt
 20166  		v_1 := v.Args[1]
 20167  		if v_1.Op != OpConst32F {
 20168  			break
 20169  		}
 20170  		d := v_1.AuxInt
 20171  		v.reset(OpConstBool)
 20172  		v.AuxInt = b2i(auxTo32F(c) != auxTo32F(d))
 20173  		return true
 20174  	}
 20175  	// match: (Neq32F (Const32F [d]) (Const32F [c]))
 20176  	// cond:
 20177  	// result: (ConstBool [b2i(auxTo32F(c) != auxTo32F(d))])
 20178  	for {
 20179  		_ = v.Args[1]
 20180  		v_0 := v.Args[0]
 20181  		if v_0.Op != OpConst32F {
 20182  			break
 20183  		}
 20184  		d := v_0.AuxInt
 20185  		v_1 := v.Args[1]
 20186  		if v_1.Op != OpConst32F {
 20187  			break
 20188  		}
 20189  		c := v_1.AuxInt
 20190  		v.reset(OpConstBool)
 20191  		v.AuxInt = b2i(auxTo32F(c) != auxTo32F(d))
 20192  		return true
 20193  	}
 20194  	return false
 20195  }
 20196  func rewriteValuegeneric_OpNeq64_0(v *Value) bool {
 20197  	b := v.Block
 20198  	_ = b
 20199  	// match: (Neq64 x x)
 20200  	// cond:
 20201  	// result: (ConstBool [0])
 20202  	for {
 20203  		_ = v.Args[1]
 20204  		x := v.Args[0]
 20205  		if x != v.Args[1] {
 20206  			break
 20207  		}
 20208  		v.reset(OpConstBool)
 20209  		v.AuxInt = 0
 20210  		return true
 20211  	}
 20212  	// match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
 20213  	// cond:
 20214  	// result: (Neq64 (Const64 <t> [c-d]) x)
 20215  	for {
 20216  		_ = v.Args[1]
 20217  		v_0 := v.Args[0]
 20218  		if v_0.Op != OpConst64 {
 20219  			break
 20220  		}
 20221  		t := v_0.Type
 20222  		c := v_0.AuxInt
 20223  		v_1 := v.Args[1]
 20224  		if v_1.Op != OpAdd64 {
 20225  			break
 20226  		}
 20227  		_ = v_1.Args[1]
 20228  		v_1_0 := v_1.Args[0]
 20229  		if v_1_0.Op != OpConst64 {
 20230  			break
 20231  		}
 20232  		if v_1_0.Type != t {
 20233  			break
 20234  		}
 20235  		d := v_1_0.AuxInt
 20236  		x := v_1.Args[1]
 20237  		v.reset(OpNeq64)
 20238  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 20239  		v0.AuxInt = c - d
 20240  		v.AddArg(v0)
 20241  		v.AddArg(x)
 20242  		return true
 20243  	}
 20244  	// match: (Neq64 (Const64 <t> [c]) (Add64 x (Const64 <t> [d])))
 20245  	// cond:
 20246  	// result: (Neq64 (Const64 <t> [c-d]) x)
 20247  	for {
 20248  		_ = v.Args[1]
 20249  		v_0 := v.Args[0]
 20250  		if v_0.Op != OpConst64 {
 20251  			break
 20252  		}
 20253  		t := v_0.Type
 20254  		c := v_0.AuxInt
 20255  		v_1 := v.Args[1]
 20256  		if v_1.Op != OpAdd64 {
 20257  			break
 20258  		}
 20259  		_ = v_1.Args[1]
 20260  		x := v_1.Args[0]
 20261  		v_1_1 := v_1.Args[1]
 20262  		if v_1_1.Op != OpConst64 {
 20263  			break
 20264  		}
 20265  		if v_1_1.Type != t {
 20266  			break
 20267  		}
 20268  		d := v_1_1.AuxInt
 20269  		v.reset(OpNeq64)
 20270  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 20271  		v0.AuxInt = c - d
 20272  		v.AddArg(v0)
 20273  		v.AddArg(x)
 20274  		return true
 20275  	}
 20276  	// match: (Neq64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 20277  	// cond:
 20278  	// result: (Neq64 (Const64 <t> [c-d]) x)
 20279  	for {
 20280  		_ = v.Args[1]
 20281  		v_0 := v.Args[0]
 20282  		if v_0.Op != OpAdd64 {
 20283  			break
 20284  		}
 20285  		_ = v_0.Args[1]
 20286  		v_0_0 := v_0.Args[0]
 20287  		if v_0_0.Op != OpConst64 {
 20288  			break
 20289  		}
 20290  		t := v_0_0.Type
 20291  		d := v_0_0.AuxInt
 20292  		x := v_0.Args[1]
 20293  		v_1 := v.Args[1]
 20294  		if v_1.Op != OpConst64 {
 20295  			break
 20296  		}
 20297  		if v_1.Type != t {
 20298  			break
 20299  		}
 20300  		c := v_1.AuxInt
 20301  		v.reset(OpNeq64)
 20302  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 20303  		v0.AuxInt = c - d
 20304  		v.AddArg(v0)
 20305  		v.AddArg(x)
 20306  		return true
 20307  	}
 20308  	// match: (Neq64 (Add64 x (Const64 <t> [d])) (Const64 <t> [c]))
 20309  	// cond:
 20310  	// result: (Neq64 (Const64 <t> [c-d]) x)
 20311  	for {
 20312  		_ = v.Args[1]
 20313  		v_0 := v.Args[0]
 20314  		if v_0.Op != OpAdd64 {
 20315  			break
 20316  		}
 20317  		_ = v_0.Args[1]
 20318  		x := v_0.Args[0]
 20319  		v_0_1 := v_0.Args[1]
 20320  		if v_0_1.Op != OpConst64 {
 20321  			break
 20322  		}
 20323  		t := v_0_1.Type
 20324  		d := v_0_1.AuxInt
 20325  		v_1 := v.Args[1]
 20326  		if v_1.Op != OpConst64 {
 20327  			break
 20328  		}
 20329  		if v_1.Type != t {
 20330  			break
 20331  		}
 20332  		c := v_1.AuxInt
 20333  		v.reset(OpNeq64)
 20334  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 20335  		v0.AuxInt = c - d
 20336  		v.AddArg(v0)
 20337  		v.AddArg(x)
 20338  		return true
 20339  	}
 20340  	// match: (Neq64 (Const64 [c]) (Const64 [d]))
 20341  	// cond:
 20342  	// result: (ConstBool [b2i(c != d)])
 20343  	for {
 20344  		_ = v.Args[1]
 20345  		v_0 := v.Args[0]
 20346  		if v_0.Op != OpConst64 {
 20347  			break
 20348  		}
 20349  		c := v_0.AuxInt
 20350  		v_1 := v.Args[1]
 20351  		if v_1.Op != OpConst64 {
 20352  			break
 20353  		}
 20354  		d := v_1.AuxInt
 20355  		v.reset(OpConstBool)
 20356  		v.AuxInt = b2i(c != d)
 20357  		return true
 20358  	}
 20359  	// match: (Neq64 (Const64 [d]) (Const64 [c]))
 20360  	// cond:
 20361  	// result: (ConstBool [b2i(c != d)])
 20362  	for {
 20363  		_ = v.Args[1]
 20364  		v_0 := v.Args[0]
 20365  		if v_0.Op != OpConst64 {
 20366  			break
 20367  		}
 20368  		d := v_0.AuxInt
 20369  		v_1 := v.Args[1]
 20370  		if v_1.Op != OpConst64 {
 20371  			break
 20372  		}
 20373  		c := v_1.AuxInt
 20374  		v.reset(OpConstBool)
 20375  		v.AuxInt = b2i(c != d)
 20376  		return true
 20377  	}
 20378  	// match: (Neq64 s:(Sub64 x y) (Const64 [0]))
 20379  	// cond: s.Uses == 1
 20380  	// result: (Neq64 x y)
 20381  	for {
 20382  		_ = v.Args[1]
 20383  		s := v.Args[0]
 20384  		if s.Op != OpSub64 {
 20385  			break
 20386  		}
 20387  		_ = s.Args[1]
 20388  		x := s.Args[0]
 20389  		y := s.Args[1]
 20390  		v_1 := v.Args[1]
 20391  		if v_1.Op != OpConst64 {
 20392  			break
 20393  		}
 20394  		if v_1.AuxInt != 0 {
 20395  			break
 20396  		}
 20397  		if !(s.Uses == 1) {
 20398  			break
 20399  		}
 20400  		v.reset(OpNeq64)
 20401  		v.AddArg(x)
 20402  		v.AddArg(y)
 20403  		return true
 20404  	}
 20405  	// match: (Neq64 (Const64 [0]) s:(Sub64 x y))
 20406  	// cond: s.Uses == 1
 20407  	// result: (Neq64 x y)
 20408  	for {
 20409  		_ = v.Args[1]
 20410  		v_0 := v.Args[0]
 20411  		if v_0.Op != OpConst64 {
 20412  			break
 20413  		}
 20414  		if v_0.AuxInt != 0 {
 20415  			break
 20416  		}
 20417  		s := v.Args[1]
 20418  		if s.Op != OpSub64 {
 20419  			break
 20420  		}
 20421  		_ = s.Args[1]
 20422  		x := s.Args[0]
 20423  		y := s.Args[1]
 20424  		if !(s.Uses == 1) {
 20425  			break
 20426  		}
 20427  		v.reset(OpNeq64)
 20428  		v.AddArg(x)
 20429  		v.AddArg(y)
 20430  		return true
 20431  	}
 20432  	return false
 20433  }
 20434  func rewriteValuegeneric_OpNeq64F_0(v *Value) bool {
 20435  	// match: (Neq64F (Const64F [c]) (Const64F [d]))
 20436  	// cond:
 20437  	// result: (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))])
 20438  	for {
 20439  		_ = v.Args[1]
 20440  		v_0 := v.Args[0]
 20441  		if v_0.Op != OpConst64F {
 20442  			break
 20443  		}
 20444  		c := v_0.AuxInt
 20445  		v_1 := v.Args[1]
 20446  		if v_1.Op != OpConst64F {
 20447  			break
 20448  		}
 20449  		d := v_1.AuxInt
 20450  		v.reset(OpConstBool)
 20451  		v.AuxInt = b2i(auxTo64F(c) != auxTo64F(d))
 20452  		return true
 20453  	}
 20454  	// match: (Neq64F (Const64F [d]) (Const64F [c]))
 20455  	// cond:
 20456  	// result: (ConstBool [b2i(auxTo64F(c) != auxTo64F(d))])
 20457  	for {
 20458  		_ = v.Args[1]
 20459  		v_0 := v.Args[0]
 20460  		if v_0.Op != OpConst64F {
 20461  			break
 20462  		}
 20463  		d := v_0.AuxInt
 20464  		v_1 := v.Args[1]
 20465  		if v_1.Op != OpConst64F {
 20466  			break
 20467  		}
 20468  		c := v_1.AuxInt
 20469  		v.reset(OpConstBool)
 20470  		v.AuxInt = b2i(auxTo64F(c) != auxTo64F(d))
 20471  		return true
 20472  	}
 20473  	return false
 20474  }
 20475  func rewriteValuegeneric_OpNeq8_0(v *Value) bool {
 20476  	b := v.Block
 20477  	_ = b
 20478  	// match: (Neq8 x x)
 20479  	// cond:
 20480  	// result: (ConstBool [0])
 20481  	for {
 20482  		_ = v.Args[1]
 20483  		x := v.Args[0]
 20484  		if x != v.Args[1] {
 20485  			break
 20486  		}
 20487  		v.reset(OpConstBool)
 20488  		v.AuxInt = 0
 20489  		return true
 20490  	}
 20491  	// match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
 20492  	// cond:
 20493  	// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 20494  	for {
 20495  		_ = v.Args[1]
 20496  		v_0 := v.Args[0]
 20497  		if v_0.Op != OpConst8 {
 20498  			break
 20499  		}
 20500  		t := v_0.Type
 20501  		c := v_0.AuxInt
 20502  		v_1 := v.Args[1]
 20503  		if v_1.Op != OpAdd8 {
 20504  			break
 20505  		}
 20506  		_ = v_1.Args[1]
 20507  		v_1_0 := v_1.Args[0]
 20508  		if v_1_0.Op != OpConst8 {
 20509  			break
 20510  		}
 20511  		if v_1_0.Type != t {
 20512  			break
 20513  		}
 20514  		d := v_1_0.AuxInt
 20515  		x := v_1.Args[1]
 20516  		v.reset(OpNeq8)
 20517  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 20518  		v0.AuxInt = int64(int8(c - d))
 20519  		v.AddArg(v0)
 20520  		v.AddArg(x)
 20521  		return true
 20522  	}
 20523  	// match: (Neq8 (Const8 <t> [c]) (Add8 x (Const8 <t> [d])))
 20524  	// cond:
 20525  	// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 20526  	for {
 20527  		_ = v.Args[1]
 20528  		v_0 := v.Args[0]
 20529  		if v_0.Op != OpConst8 {
 20530  			break
 20531  		}
 20532  		t := v_0.Type
 20533  		c := v_0.AuxInt
 20534  		v_1 := v.Args[1]
 20535  		if v_1.Op != OpAdd8 {
 20536  			break
 20537  		}
 20538  		_ = v_1.Args[1]
 20539  		x := v_1.Args[0]
 20540  		v_1_1 := v_1.Args[1]
 20541  		if v_1_1.Op != OpConst8 {
 20542  			break
 20543  		}
 20544  		if v_1_1.Type != t {
 20545  			break
 20546  		}
 20547  		d := v_1_1.AuxInt
 20548  		v.reset(OpNeq8)
 20549  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 20550  		v0.AuxInt = int64(int8(c - d))
 20551  		v.AddArg(v0)
 20552  		v.AddArg(x)
 20553  		return true
 20554  	}
 20555  	// match: (Neq8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 20556  	// cond:
 20557  	// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 20558  	for {
 20559  		_ = v.Args[1]
 20560  		v_0 := v.Args[0]
 20561  		if v_0.Op != OpAdd8 {
 20562  			break
 20563  		}
 20564  		_ = v_0.Args[1]
 20565  		v_0_0 := v_0.Args[0]
 20566  		if v_0_0.Op != OpConst8 {
 20567  			break
 20568  		}
 20569  		t := v_0_0.Type
 20570  		d := v_0_0.AuxInt
 20571  		x := v_0.Args[1]
 20572  		v_1 := v.Args[1]
 20573  		if v_1.Op != OpConst8 {
 20574  			break
 20575  		}
 20576  		if v_1.Type != t {
 20577  			break
 20578  		}
 20579  		c := v_1.AuxInt
 20580  		v.reset(OpNeq8)
 20581  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 20582  		v0.AuxInt = int64(int8(c - d))
 20583  		v.AddArg(v0)
 20584  		v.AddArg(x)
 20585  		return true
 20586  	}
 20587  	// match: (Neq8 (Add8 x (Const8 <t> [d])) (Const8 <t> [c]))
 20588  	// cond:
 20589  	// result: (Neq8 (Const8 <t> [int64(int8(c-d))]) x)
 20590  	for {
 20591  		_ = v.Args[1]
 20592  		v_0 := v.Args[0]
 20593  		if v_0.Op != OpAdd8 {
 20594  			break
 20595  		}
 20596  		_ = v_0.Args[1]
 20597  		x := v_0.Args[0]
 20598  		v_0_1 := v_0.Args[1]
 20599  		if v_0_1.Op != OpConst8 {
 20600  			break
 20601  		}
 20602  		t := v_0_1.Type
 20603  		d := v_0_1.AuxInt
 20604  		v_1 := v.Args[1]
 20605  		if v_1.Op != OpConst8 {
 20606  			break
 20607  		}
 20608  		if v_1.Type != t {
 20609  			break
 20610  		}
 20611  		c := v_1.AuxInt
 20612  		v.reset(OpNeq8)
 20613  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 20614  		v0.AuxInt = int64(int8(c - d))
 20615  		v.AddArg(v0)
 20616  		v.AddArg(x)
 20617  		return true
 20618  	}
 20619  	// match: (Neq8 (Const8 [c]) (Const8 [d]))
 20620  	// cond:
 20621  	// result: (ConstBool [b2i(c != d)])
 20622  	for {
 20623  		_ = v.Args[1]
 20624  		v_0 := v.Args[0]
 20625  		if v_0.Op != OpConst8 {
 20626  			break
 20627  		}
 20628  		c := v_0.AuxInt
 20629  		v_1 := v.Args[1]
 20630  		if v_1.Op != OpConst8 {
 20631  			break
 20632  		}
 20633  		d := v_1.AuxInt
 20634  		v.reset(OpConstBool)
 20635  		v.AuxInt = b2i(c != d)
 20636  		return true
 20637  	}
 20638  	// match: (Neq8 (Const8 [d]) (Const8 [c]))
 20639  	// cond:
 20640  	// result: (ConstBool [b2i(c != d)])
 20641  	for {
 20642  		_ = v.Args[1]
 20643  		v_0 := v.Args[0]
 20644  		if v_0.Op != OpConst8 {
 20645  			break
 20646  		}
 20647  		d := v_0.AuxInt
 20648  		v_1 := v.Args[1]
 20649  		if v_1.Op != OpConst8 {
 20650  			break
 20651  		}
 20652  		c := v_1.AuxInt
 20653  		v.reset(OpConstBool)
 20654  		v.AuxInt = b2i(c != d)
 20655  		return true
 20656  	}
 20657  	// match: (Neq8 s:(Sub8 x y) (Const8 [0]))
 20658  	// cond: s.Uses == 1
 20659  	// result: (Neq8 x y)
 20660  	for {
 20661  		_ = v.Args[1]
 20662  		s := v.Args[0]
 20663  		if s.Op != OpSub8 {
 20664  			break
 20665  		}
 20666  		_ = s.Args[1]
 20667  		x := s.Args[0]
 20668  		y := s.Args[1]
 20669  		v_1 := v.Args[1]
 20670  		if v_1.Op != OpConst8 {
 20671  			break
 20672  		}
 20673  		if v_1.AuxInt != 0 {
 20674  			break
 20675  		}
 20676  		if !(s.Uses == 1) {
 20677  			break
 20678  		}
 20679  		v.reset(OpNeq8)
 20680  		v.AddArg(x)
 20681  		v.AddArg(y)
 20682  		return true
 20683  	}
 20684  	// match: (Neq8 (Const8 [0]) s:(Sub8 x y))
 20685  	// cond: s.Uses == 1
 20686  	// result: (Neq8 x y)
 20687  	for {
 20688  		_ = v.Args[1]
 20689  		v_0 := v.Args[0]
 20690  		if v_0.Op != OpConst8 {
 20691  			break
 20692  		}
 20693  		if v_0.AuxInt != 0 {
 20694  			break
 20695  		}
 20696  		s := v.Args[1]
 20697  		if s.Op != OpSub8 {
 20698  			break
 20699  		}
 20700  		_ = s.Args[1]
 20701  		x := s.Args[0]
 20702  		y := s.Args[1]
 20703  		if !(s.Uses == 1) {
 20704  			break
 20705  		}
 20706  		v.reset(OpNeq8)
 20707  		v.AddArg(x)
 20708  		v.AddArg(y)
 20709  		return true
 20710  	}
 20711  	return false
 20712  }
 20713  func rewriteValuegeneric_OpNeqB_0(v *Value) bool {
 20714  	// match: (NeqB (ConstBool [c]) (ConstBool [d]))
 20715  	// cond:
 20716  	// result: (ConstBool [b2i(c != d)])
 20717  	for {
 20718  		_ = v.Args[1]
 20719  		v_0 := v.Args[0]
 20720  		if v_0.Op != OpConstBool {
 20721  			break
 20722  		}
 20723  		c := v_0.AuxInt
 20724  		v_1 := v.Args[1]
 20725  		if v_1.Op != OpConstBool {
 20726  			break
 20727  		}
 20728  		d := v_1.AuxInt
 20729  		v.reset(OpConstBool)
 20730  		v.AuxInt = b2i(c != d)
 20731  		return true
 20732  	}
 20733  	// match: (NeqB (ConstBool [d]) (ConstBool [c]))
 20734  	// cond:
 20735  	// result: (ConstBool [b2i(c != d)])
 20736  	for {
 20737  		_ = v.Args[1]
 20738  		v_0 := v.Args[0]
 20739  		if v_0.Op != OpConstBool {
 20740  			break
 20741  		}
 20742  		d := v_0.AuxInt
 20743  		v_1 := v.Args[1]
 20744  		if v_1.Op != OpConstBool {
 20745  			break
 20746  		}
 20747  		c := v_1.AuxInt
 20748  		v.reset(OpConstBool)
 20749  		v.AuxInt = b2i(c != d)
 20750  		return true
 20751  	}
 20752  	// match: (NeqB (ConstBool [0]) x)
 20753  	// cond:
 20754  	// result: x
 20755  	for {
 20756  		_ = v.Args[1]
 20757  		v_0 := v.Args[0]
 20758  		if v_0.Op != OpConstBool {
 20759  			break
 20760  		}
 20761  		if v_0.AuxInt != 0 {
 20762  			break
 20763  		}
 20764  		x := v.Args[1]
 20765  		v.reset(OpCopy)
 20766  		v.Type = x.Type
 20767  		v.AddArg(x)
 20768  		return true
 20769  	}
 20770  	// match: (NeqB x (ConstBool [0]))
 20771  	// cond:
 20772  	// result: x
 20773  	for {
 20774  		_ = v.Args[1]
 20775  		x := v.Args[0]
 20776  		v_1 := v.Args[1]
 20777  		if v_1.Op != OpConstBool {
 20778  			break
 20779  		}
 20780  		if v_1.AuxInt != 0 {
 20781  			break
 20782  		}
 20783  		v.reset(OpCopy)
 20784  		v.Type = x.Type
 20785  		v.AddArg(x)
 20786  		return true
 20787  	}
 20788  	// match: (NeqB (ConstBool [1]) x)
 20789  	// cond:
 20790  	// result: (Not x)
 20791  	for {
 20792  		_ = v.Args[1]
 20793  		v_0 := v.Args[0]
 20794  		if v_0.Op != OpConstBool {
 20795  			break
 20796  		}
 20797  		if v_0.AuxInt != 1 {
 20798  			break
 20799  		}
 20800  		x := v.Args[1]
 20801  		v.reset(OpNot)
 20802  		v.AddArg(x)
 20803  		return true
 20804  	}
 20805  	// match: (NeqB x (ConstBool [1]))
 20806  	// cond:
 20807  	// result: (Not x)
 20808  	for {
 20809  		_ = v.Args[1]
 20810  		x := v.Args[0]
 20811  		v_1 := v.Args[1]
 20812  		if v_1.Op != OpConstBool {
 20813  			break
 20814  		}
 20815  		if v_1.AuxInt != 1 {
 20816  			break
 20817  		}
 20818  		v.reset(OpNot)
 20819  		v.AddArg(x)
 20820  		return true
 20821  	}
 20822  	// match: (NeqB (Not x) (Not y))
 20823  	// cond:
 20824  	// result: (NeqB x y)
 20825  	for {
 20826  		_ = v.Args[1]
 20827  		v_0 := v.Args[0]
 20828  		if v_0.Op != OpNot {
 20829  			break
 20830  		}
 20831  		x := v_0.Args[0]
 20832  		v_1 := v.Args[1]
 20833  		if v_1.Op != OpNot {
 20834  			break
 20835  		}
 20836  		y := v_1.Args[0]
 20837  		v.reset(OpNeqB)
 20838  		v.AddArg(x)
 20839  		v.AddArg(y)
 20840  		return true
 20841  	}
 20842  	// match: (NeqB (Not y) (Not x))
 20843  	// cond:
 20844  	// result: (NeqB x y)
 20845  	for {
 20846  		_ = v.Args[1]
 20847  		v_0 := v.Args[0]
 20848  		if v_0.Op != OpNot {
 20849  			break
 20850  		}
 20851  		y := v_0.Args[0]
 20852  		v_1 := v.Args[1]
 20853  		if v_1.Op != OpNot {
 20854  			break
 20855  		}
 20856  		x := v_1.Args[0]
 20857  		v.reset(OpNeqB)
 20858  		v.AddArg(x)
 20859  		v.AddArg(y)
 20860  		return true
 20861  	}
 20862  	return false
 20863  }
 20864  func rewriteValuegeneric_OpNeqInter_0(v *Value) bool {
 20865  	b := v.Block
 20866  	_ = b
 20867  	typ := &b.Func.Config.Types
 20868  	_ = typ
 20869  	// match: (NeqInter x y)
 20870  	// cond:
 20871  	// result: (NeqPtr (ITab x) (ITab y))
 20872  	for {
 20873  		_ = v.Args[1]
 20874  		x := v.Args[0]
 20875  		y := v.Args[1]
 20876  		v.reset(OpNeqPtr)
 20877  		v0 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 20878  		v0.AddArg(x)
 20879  		v.AddArg(v0)
 20880  		v1 := b.NewValue0(v.Pos, OpITab, typ.Uintptr)
 20881  		v1.AddArg(y)
 20882  		v.AddArg(v1)
 20883  		return true
 20884  	}
 20885  }
 20886  func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool {
 20887  	// match: (NeqPtr x x)
 20888  	// cond:
 20889  	// result: (ConstBool [0])
 20890  	for {
 20891  		_ = v.Args[1]
 20892  		x := v.Args[0]
 20893  		if x != v.Args[1] {
 20894  			break
 20895  		}
 20896  		v.reset(OpConstBool)
 20897  		v.AuxInt = 0
 20898  		return true
 20899  	}
 20900  	// match: (NeqPtr (Addr {a} _) (Addr {b} _))
 20901  	// cond:
 20902  	// result: (ConstBool [b2i(a != b)])
 20903  	for {
 20904  		_ = v.Args[1]
 20905  		v_0 := v.Args[0]
 20906  		if v_0.Op != OpAddr {
 20907  			break
 20908  		}
 20909  		a := v_0.Aux
 20910  		v_1 := v.Args[1]
 20911  		if v_1.Op != OpAddr {
 20912  			break
 20913  		}
 20914  		b := v_1.Aux
 20915  		v.reset(OpConstBool)
 20916  		v.AuxInt = b2i(a != b)
 20917  		return true
 20918  	}
 20919  	// match: (NeqPtr (Addr {b} _) (Addr {a} _))
 20920  	// cond:
 20921  	// result: (ConstBool [b2i(a != b)])
 20922  	for {
 20923  		_ = v.Args[1]
 20924  		v_0 := v.Args[0]
 20925  		if v_0.Op != OpAddr {
 20926  			break
 20927  		}
 20928  		b := v_0.Aux
 20929  		v_1 := v.Args[1]
 20930  		if v_1.Op != OpAddr {
 20931  			break
 20932  		}
 20933  		a := v_1.Aux
 20934  		v.reset(OpConstBool)
 20935  		v.AuxInt = b2i(a != b)
 20936  		return true
 20937  	}
 20938  	// match: (NeqPtr (LocalAddr {a} _ _) (LocalAddr {b} _ _))
 20939  	// cond:
 20940  	// result: (ConstBool [b2i(a != b)])
 20941  	for {
 20942  		_ = v.Args[1]
 20943  		v_0 := v.Args[0]
 20944  		if v_0.Op != OpLocalAddr {
 20945  			break
 20946  		}
 20947  		a := v_0.Aux
 20948  		_ = v_0.Args[1]
 20949  		v_1 := v.Args[1]
 20950  		if v_1.Op != OpLocalAddr {
 20951  			break
 20952  		}
 20953  		b := v_1.Aux
 20954  		_ = v_1.Args[1]
 20955  		v.reset(OpConstBool)
 20956  		v.AuxInt = b2i(a != b)
 20957  		return true
 20958  	}
 20959  	// match: (NeqPtr (LocalAddr {b} _ _) (LocalAddr {a} _ _))
 20960  	// cond:
 20961  	// result: (ConstBool [b2i(a != b)])
 20962  	for {
 20963  		_ = v.Args[1]
 20964  		v_0 := v.Args[0]
 20965  		if v_0.Op != OpLocalAddr {
 20966  			break
 20967  		}
 20968  		b := v_0.Aux
 20969  		_ = v_0.Args[1]
 20970  		v_1 := v.Args[1]
 20971  		if v_1.Op != OpLocalAddr {
 20972  			break
 20973  		}
 20974  		a := v_1.Aux
 20975  		_ = v_1.Args[1]
 20976  		v.reset(OpConstBool)
 20977  		v.AuxInt = b2i(a != b)
 20978  		return true
 20979  	}
 20980  	// match: (NeqPtr (OffPtr [o1] p1) p2)
 20981  	// cond: isSamePtr(p1, p2)
 20982  	// result: (ConstBool [b2i(o1 != 0)])
 20983  	for {
 20984  		_ = v.Args[1]
 20985  		v_0 := v.Args[0]
 20986  		if v_0.Op != OpOffPtr {
 20987  			break
 20988  		}
 20989  		o1 := v_0.AuxInt
 20990  		p1 := v_0.Args[0]
 20991  		p2 := v.Args[1]
 20992  		if !(isSamePtr(p1, p2)) {
 20993  			break
 20994  		}
 20995  		v.reset(OpConstBool)
 20996  		v.AuxInt = b2i(o1 != 0)
 20997  		return true
 20998  	}
 20999  	// match: (NeqPtr p2 (OffPtr [o1] p1))
 21000  	// cond: isSamePtr(p1, p2)
 21001  	// result: (ConstBool [b2i(o1 != 0)])
 21002  	for {
 21003  		_ = v.Args[1]
 21004  		p2 := v.Args[0]
 21005  		v_1 := v.Args[1]
 21006  		if v_1.Op != OpOffPtr {
 21007  			break
 21008  		}
 21009  		o1 := v_1.AuxInt
 21010  		p1 := v_1.Args[0]
 21011  		if !(isSamePtr(p1, p2)) {
 21012  			break
 21013  		}
 21014  		v.reset(OpConstBool)
 21015  		v.AuxInt = b2i(o1 != 0)
 21016  		return true
 21017  	}
 21018  	// match: (NeqPtr (OffPtr [o1] p1) (OffPtr [o2] p2))
 21019  	// cond: isSamePtr(p1, p2)
 21020  	// result: (ConstBool [b2i(o1 != o2)])
 21021  	for {
 21022  		_ = v.Args[1]
 21023  		v_0 := v.Args[0]
 21024  		if v_0.Op != OpOffPtr {
 21025  			break
 21026  		}
 21027  		o1 := v_0.AuxInt
 21028  		p1 := v_0.Args[0]
 21029  		v_1 := v.Args[1]
 21030  		if v_1.Op != OpOffPtr {
 21031  			break
 21032  		}
 21033  		o2 := v_1.AuxInt
 21034  		p2 := v_1.Args[0]
 21035  		if !(isSamePtr(p1, p2)) {
 21036  			break
 21037  		}
 21038  		v.reset(OpConstBool)
 21039  		v.AuxInt = b2i(o1 != o2)
 21040  		return true
 21041  	}
 21042  	// match: (NeqPtr (OffPtr [o2] p2) (OffPtr [o1] p1))
 21043  	// cond: isSamePtr(p1, p2)
 21044  	// result: (ConstBool [b2i(o1 != o2)])
 21045  	for {
 21046  		_ = v.Args[1]
 21047  		v_0 := v.Args[0]
 21048  		if v_0.Op != OpOffPtr {
 21049  			break
 21050  		}
 21051  		o2 := v_0.AuxInt
 21052  		p2 := v_0.Args[0]
 21053  		v_1 := v.Args[1]
 21054  		if v_1.Op != OpOffPtr {
 21055  			break
 21056  		}
 21057  		o1 := v_1.AuxInt
 21058  		p1 := v_1.Args[0]
 21059  		if !(isSamePtr(p1, p2)) {
 21060  			break
 21061  		}
 21062  		v.reset(OpConstBool)
 21063  		v.AuxInt = b2i(o1 != o2)
 21064  		return true
 21065  	}
 21066  	// match: (NeqPtr (Const32 [c]) (Const32 [d]))
 21067  	// cond:
 21068  	// result: (ConstBool [b2i(c != d)])
 21069  	for {
 21070  		_ = v.Args[1]
 21071  		v_0 := v.Args[0]
 21072  		if v_0.Op != OpConst32 {
 21073  			break
 21074  		}
 21075  		c := v_0.AuxInt
 21076  		v_1 := v.Args[1]
 21077  		if v_1.Op != OpConst32 {
 21078  			break
 21079  		}
 21080  		d := v_1.AuxInt
 21081  		v.reset(OpConstBool)
 21082  		v.AuxInt = b2i(c != d)
 21083  		return true
 21084  	}
 21085  	return false
 21086  }
 21087  func rewriteValuegeneric_OpNeqPtr_10(v *Value) bool {
 21088  	// match: (NeqPtr (Const32 [d]) (Const32 [c]))
 21089  	// cond:
 21090  	// result: (ConstBool [b2i(c != d)])
 21091  	for {
 21092  		_ = v.Args[1]
 21093  		v_0 := v.Args[0]
 21094  		if v_0.Op != OpConst32 {
 21095  			break
 21096  		}
 21097  		d := v_0.AuxInt
 21098  		v_1 := v.Args[1]
 21099  		if v_1.Op != OpConst32 {
 21100  			break
 21101  		}
 21102  		c := v_1.AuxInt
 21103  		v.reset(OpConstBool)
 21104  		v.AuxInt = b2i(c != d)
 21105  		return true
 21106  	}
 21107  	// match: (NeqPtr (Const64 [c]) (Const64 [d]))
 21108  	// cond:
 21109  	// result: (ConstBool [b2i(c != d)])
 21110  	for {
 21111  		_ = v.Args[1]
 21112  		v_0 := v.Args[0]
 21113  		if v_0.Op != OpConst64 {
 21114  			break
 21115  		}
 21116  		c := v_0.AuxInt
 21117  		v_1 := v.Args[1]
 21118  		if v_1.Op != OpConst64 {
 21119  			break
 21120  		}
 21121  		d := v_1.AuxInt
 21122  		v.reset(OpConstBool)
 21123  		v.AuxInt = b2i(c != d)
 21124  		return true
 21125  	}
 21126  	// match: (NeqPtr (Const64 [d]) (Const64 [c]))
 21127  	// cond:
 21128  	// result: (ConstBool [b2i(c != d)])
 21129  	for {
 21130  		_ = v.Args[1]
 21131  		v_0 := v.Args[0]
 21132  		if v_0.Op != OpConst64 {
 21133  			break
 21134  		}
 21135  		d := v_0.AuxInt
 21136  		v_1 := v.Args[1]
 21137  		if v_1.Op != OpConst64 {
 21138  			break
 21139  		}
 21140  		c := v_1.AuxInt
 21141  		v.reset(OpConstBool)
 21142  		v.AuxInt = b2i(c != d)
 21143  		return true
 21144  	}
 21145  	// match: (NeqPtr (LocalAddr _ _) (Addr _))
 21146  	// cond:
 21147  	// result: (ConstBool [1])
 21148  	for {
 21149  		_ = v.Args[1]
 21150  		v_0 := v.Args[0]
 21151  		if v_0.Op != OpLocalAddr {
 21152  			break
 21153  		}
 21154  		_ = v_0.Args[1]
 21155  		v_1 := v.Args[1]
 21156  		if v_1.Op != OpAddr {
 21157  			break
 21158  		}
 21159  		v.reset(OpConstBool)
 21160  		v.AuxInt = 1
 21161  		return true
 21162  	}
 21163  	// match: (NeqPtr (Addr _) (LocalAddr _ _))
 21164  	// cond:
 21165  	// result: (ConstBool [1])
 21166  	for {
 21167  		_ = v.Args[1]
 21168  		v_0 := v.Args[0]
 21169  		if v_0.Op != OpAddr {
 21170  			break
 21171  		}
 21172  		v_1 := v.Args[1]
 21173  		if v_1.Op != OpLocalAddr {
 21174  			break
 21175  		}
 21176  		_ = v_1.Args[1]
 21177  		v.reset(OpConstBool)
 21178  		v.AuxInt = 1
 21179  		return true
 21180  	}
 21181  	// match: (NeqPtr (Addr _) (LocalAddr _ _))
 21182  	// cond:
 21183  	// result: (ConstBool [1])
 21184  	for {
 21185  		_ = v.Args[1]
 21186  		v_0 := v.Args[0]
 21187  		if v_0.Op != OpAddr {
 21188  			break
 21189  		}
 21190  		v_1 := v.Args[1]
 21191  		if v_1.Op != OpLocalAddr {
 21192  			break
 21193  		}
 21194  		_ = v_1.Args[1]
 21195  		v.reset(OpConstBool)
 21196  		v.AuxInt = 1
 21197  		return true
 21198  	}
 21199  	// match: (NeqPtr (LocalAddr _ _) (Addr _))
 21200  	// cond:
 21201  	// result: (ConstBool [1])
 21202  	for {
 21203  		_ = v.Args[1]
 21204  		v_0 := v.Args[0]
 21205  		if v_0.Op != OpLocalAddr {
 21206  			break
 21207  		}
 21208  		_ = v_0.Args[1]
 21209  		v_1 := v.Args[1]
 21210  		if v_1.Op != OpAddr {
 21211  			break
 21212  		}
 21213  		v.reset(OpConstBool)
 21214  		v.AuxInt = 1
 21215  		return true
 21216  	}
 21217  	// match: (NeqPtr (AddPtr p1 o1) p2)
 21218  	// cond: isSamePtr(p1, p2)
 21219  	// result: (IsNonNil o1)
 21220  	for {
 21221  		_ = v.Args[1]
 21222  		v_0 := v.Args[0]
 21223  		if v_0.Op != OpAddPtr {
 21224  			break
 21225  		}
 21226  		_ = v_0.Args[1]
 21227  		p1 := v_0.Args[0]
 21228  		o1 := v_0.Args[1]
 21229  		p2 := v.Args[1]
 21230  		if !(isSamePtr(p1, p2)) {
 21231  			break
 21232  		}
 21233  		v.reset(OpIsNonNil)
 21234  		v.AddArg(o1)
 21235  		return true
 21236  	}
 21237  	// match: (NeqPtr p2 (AddPtr p1 o1))
 21238  	// cond: isSamePtr(p1, p2)
 21239  	// result: (IsNonNil o1)
 21240  	for {
 21241  		_ = v.Args[1]
 21242  		p2 := v.Args[0]
 21243  		v_1 := v.Args[1]
 21244  		if v_1.Op != OpAddPtr {
 21245  			break
 21246  		}
 21247  		_ = v_1.Args[1]
 21248  		p1 := v_1.Args[0]
 21249  		o1 := v_1.Args[1]
 21250  		if !(isSamePtr(p1, p2)) {
 21251  			break
 21252  		}
 21253  		v.reset(OpIsNonNil)
 21254  		v.AddArg(o1)
 21255  		return true
 21256  	}
 21257  	// match: (NeqPtr (Const32 [0]) p)
 21258  	// cond:
 21259  	// result: (IsNonNil p)
 21260  	for {
 21261  		_ = v.Args[1]
 21262  		v_0 := v.Args[0]
 21263  		if v_0.Op != OpConst32 {
 21264  			break
 21265  		}
 21266  		if v_0.AuxInt != 0 {
 21267  			break
 21268  		}
 21269  		p := v.Args[1]
 21270  		v.reset(OpIsNonNil)
 21271  		v.AddArg(p)
 21272  		return true
 21273  	}
 21274  	return false
 21275  }
 21276  func rewriteValuegeneric_OpNeqPtr_20(v *Value) bool {
 21277  	// match: (NeqPtr p (Const32 [0]))
 21278  	// cond:
 21279  	// result: (IsNonNil p)
 21280  	for {
 21281  		_ = v.Args[1]
 21282  		p := v.Args[0]
 21283  		v_1 := v.Args[1]
 21284  		if v_1.Op != OpConst32 {
 21285  			break
 21286  		}
 21287  		if v_1.AuxInt != 0 {
 21288  			break
 21289  		}
 21290  		v.reset(OpIsNonNil)
 21291  		v.AddArg(p)
 21292  		return true
 21293  	}
 21294  	// match: (NeqPtr (Const64 [0]) p)
 21295  	// cond:
 21296  	// result: (IsNonNil p)
 21297  	for {
 21298  		_ = v.Args[1]
 21299  		v_0 := v.Args[0]
 21300  		if v_0.Op != OpConst64 {
 21301  			break
 21302  		}
 21303  		if v_0.AuxInt != 0 {
 21304  			break
 21305  		}
 21306  		p := v.Args[1]
 21307  		v.reset(OpIsNonNil)
 21308  		v.AddArg(p)
 21309  		return true
 21310  	}
 21311  	// match: (NeqPtr p (Const64 [0]))
 21312  	// cond:
 21313  	// result: (IsNonNil p)
 21314  	for {
 21315  		_ = v.Args[1]
 21316  		p := v.Args[0]
 21317  		v_1 := v.Args[1]
 21318  		if v_1.Op != OpConst64 {
 21319  			break
 21320  		}
 21321  		if v_1.AuxInt != 0 {
 21322  			break
 21323  		}
 21324  		v.reset(OpIsNonNil)
 21325  		v.AddArg(p)
 21326  		return true
 21327  	}
 21328  	// match: (NeqPtr (ConstNil) p)
 21329  	// cond:
 21330  	// result: (IsNonNil p)
 21331  	for {
 21332  		_ = v.Args[1]
 21333  		v_0 := v.Args[0]
 21334  		if v_0.Op != OpConstNil {
 21335  			break
 21336  		}
 21337  		p := v.Args[1]
 21338  		v.reset(OpIsNonNil)
 21339  		v.AddArg(p)
 21340  		return true
 21341  	}
 21342  	// match: (NeqPtr p (ConstNil))
 21343  	// cond:
 21344  	// result: (IsNonNil p)
 21345  	for {
 21346  		_ = v.Args[1]
 21347  		p := v.Args[0]
 21348  		v_1 := v.Args[1]
 21349  		if v_1.Op != OpConstNil {
 21350  			break
 21351  		}
 21352  		v.reset(OpIsNonNil)
 21353  		v.AddArg(p)
 21354  		return true
 21355  	}
 21356  	return false
 21357  }
 21358  func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool {
 21359  	b := v.Block
 21360  	_ = b
 21361  	typ := &b.Func.Config.Types
 21362  	_ = typ
 21363  	// match: (NeqSlice x y)
 21364  	// cond:
 21365  	// result: (NeqPtr (SlicePtr x) (SlicePtr y))
 21366  	for {
 21367  		_ = v.Args[1]
 21368  		x := v.Args[0]
 21369  		y := v.Args[1]
 21370  		v.reset(OpNeqPtr)
 21371  		v0 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 21372  		v0.AddArg(x)
 21373  		v.AddArg(v0)
 21374  		v1 := b.NewValue0(v.Pos, OpSlicePtr, typ.BytePtr)
 21375  		v1.AddArg(y)
 21376  		v.AddArg(v1)
 21377  		return true
 21378  	}
 21379  }
 21380  func rewriteValuegeneric_OpNilCheck_0(v *Value) bool {
 21381  	b := v.Block
 21382  	_ = b
 21383  	config := b.Func.Config
 21384  	_ = config
 21385  	fe := b.Func.fe
 21386  	_ = fe
 21387  	// match: (NilCheck (GetG mem) mem)
 21388  	// cond:
 21389  	// result: mem
 21390  	for {
 21391  		_ = v.Args[1]
 21392  		v_0 := v.Args[0]
 21393  		if v_0.Op != OpGetG {
 21394  			break
 21395  		}
 21396  		mem := v_0.Args[0]
 21397  		if mem != v.Args[1] {
 21398  			break
 21399  		}
 21400  		v.reset(OpCopy)
 21401  		v.Type = mem.Type
 21402  		v.AddArg(mem)
 21403  		return true
 21404  	}
 21405  	// match: (NilCheck (Load (OffPtr [c] (SP)) (StaticCall {sym} _)) _)
 21406  	// cond: isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")
 21407  	// result: (Invalid)
 21408  	for {
 21409  		_ = v.Args[1]
 21410  		v_0 := v.Args[0]
 21411  		if v_0.Op != OpLoad {
 21412  			break
 21413  		}
 21414  		_ = v_0.Args[1]
 21415  		v_0_0 := v_0.Args[0]
 21416  		if v_0_0.Op != OpOffPtr {
 21417  			break
 21418  		}
 21419  		c := v_0_0.AuxInt
 21420  		v_0_0_0 := v_0_0.Args[0]
 21421  		if v_0_0_0.Op != OpSP {
 21422  			break
 21423  		}
 21424  		v_0_1 := v_0.Args[1]
 21425  		if v_0_1.Op != OpStaticCall {
 21426  			break
 21427  		}
 21428  		sym := v_0_1.Aux
 21429  		if !(isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
 21430  			break
 21431  		}
 21432  		v.reset(OpInvalid)
 21433  		return true
 21434  	}
 21435  	// match: (NilCheck (OffPtr (Load (OffPtr [c] (SP)) (StaticCall {sym} _))) _)
 21436  	// cond: isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")
 21437  	// result: (Invalid)
 21438  	for {
 21439  		_ = v.Args[1]
 21440  		v_0 := v.Args[0]
 21441  		if v_0.Op != OpOffPtr {
 21442  			break
 21443  		}
 21444  		v_0_0 := v_0.Args[0]
 21445  		if v_0_0.Op != OpLoad {
 21446  			break
 21447  		}
 21448  		_ = v_0_0.Args[1]
 21449  		v_0_0_0 := v_0_0.Args[0]
 21450  		if v_0_0_0.Op != OpOffPtr {
 21451  			break
 21452  		}
 21453  		c := v_0_0_0.AuxInt
 21454  		v_0_0_0_0 := v_0_0_0.Args[0]
 21455  		if v_0_0_0_0.Op != OpSP {
 21456  			break
 21457  		}
 21458  		v_0_0_1 := v_0_0.Args[1]
 21459  		if v_0_0_1.Op != OpStaticCall {
 21460  			break
 21461  		}
 21462  		sym := v_0_0_1.Aux
 21463  		if !(isSameSym(sym, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize && warnRule(fe.Debug_checknil(), v, "removed nil check")) {
 21464  			break
 21465  		}
 21466  		v.reset(OpInvalid)
 21467  		return true
 21468  	}
 21469  	return false
 21470  }
 21471  func rewriteValuegeneric_OpNot_0(v *Value) bool {
 21472  	// match: (Not (ConstBool [c]))
 21473  	// cond:
 21474  	// result: (ConstBool [1-c])
 21475  	for {
 21476  		v_0 := v.Args[0]
 21477  		if v_0.Op != OpConstBool {
 21478  			break
 21479  		}
 21480  		c := v_0.AuxInt
 21481  		v.reset(OpConstBool)
 21482  		v.AuxInt = 1 - c
 21483  		return true
 21484  	}
 21485  	// match: (Not (Eq64 x y))
 21486  	// cond:
 21487  	// result: (Neq64 x y)
 21488  	for {
 21489  		v_0 := v.Args[0]
 21490  		if v_0.Op != OpEq64 {
 21491  			break
 21492  		}
 21493  		_ = v_0.Args[1]
 21494  		x := v_0.Args[0]
 21495  		y := v_0.Args[1]
 21496  		v.reset(OpNeq64)
 21497  		v.AddArg(x)
 21498  		v.AddArg(y)
 21499  		return true
 21500  	}
 21501  	// match: (Not (Eq32 x y))
 21502  	// cond:
 21503  	// result: (Neq32 x y)
 21504  	for {
 21505  		v_0 := v.Args[0]
 21506  		if v_0.Op != OpEq32 {
 21507  			break
 21508  		}
 21509  		_ = v_0.Args[1]
 21510  		x := v_0.Args[0]
 21511  		y := v_0.Args[1]
 21512  		v.reset(OpNeq32)
 21513  		v.AddArg(x)
 21514  		v.AddArg(y)
 21515  		return true
 21516  	}
 21517  	// match: (Not (Eq16 x y))
 21518  	// cond:
 21519  	// result: (Neq16 x y)
 21520  	for {
 21521  		v_0 := v.Args[0]
 21522  		if v_0.Op != OpEq16 {
 21523  			break
 21524  		}
 21525  		_ = v_0.Args[1]
 21526  		x := v_0.Args[0]
 21527  		y := v_0.Args[1]
 21528  		v.reset(OpNeq16)
 21529  		v.AddArg(x)
 21530  		v.AddArg(y)
 21531  		return true
 21532  	}
 21533  	// match: (Not (Eq8 x y))
 21534  	// cond:
 21535  	// result: (Neq8 x y)
 21536  	for {
 21537  		v_0 := v.Args[0]
 21538  		if v_0.Op != OpEq8 {
 21539  			break
 21540  		}
 21541  		_ = v_0.Args[1]
 21542  		x := v_0.Args[0]
 21543  		y := v_0.Args[1]
 21544  		v.reset(OpNeq8)
 21545  		v.AddArg(x)
 21546  		v.AddArg(y)
 21547  		return true
 21548  	}
 21549  	// match: (Not (EqB x y))
 21550  	// cond:
 21551  	// result: (NeqB x y)
 21552  	for {
 21553  		v_0 := v.Args[0]
 21554  		if v_0.Op != OpEqB {
 21555  			break
 21556  		}
 21557  		_ = v_0.Args[1]
 21558  		x := v_0.Args[0]
 21559  		y := v_0.Args[1]
 21560  		v.reset(OpNeqB)
 21561  		v.AddArg(x)
 21562  		v.AddArg(y)
 21563  		return true
 21564  	}
 21565  	// match: (Not (Neq64 x y))
 21566  	// cond:
 21567  	// result: (Eq64 x y)
 21568  	for {
 21569  		v_0 := v.Args[0]
 21570  		if v_0.Op != OpNeq64 {
 21571  			break
 21572  		}
 21573  		_ = v_0.Args[1]
 21574  		x := v_0.Args[0]
 21575  		y := v_0.Args[1]
 21576  		v.reset(OpEq64)
 21577  		v.AddArg(x)
 21578  		v.AddArg(y)
 21579  		return true
 21580  	}
 21581  	// match: (Not (Neq32 x y))
 21582  	// cond:
 21583  	// result: (Eq32 x y)
 21584  	for {
 21585  		v_0 := v.Args[0]
 21586  		if v_0.Op != OpNeq32 {
 21587  			break
 21588  		}
 21589  		_ = v_0.Args[1]
 21590  		x := v_0.Args[0]
 21591  		y := v_0.Args[1]
 21592  		v.reset(OpEq32)
 21593  		v.AddArg(x)
 21594  		v.AddArg(y)
 21595  		return true
 21596  	}
 21597  	// match: (Not (Neq16 x y))
 21598  	// cond:
 21599  	// result: (Eq16 x y)
 21600  	for {
 21601  		v_0 := v.Args[0]
 21602  		if v_0.Op != OpNeq16 {
 21603  			break
 21604  		}
 21605  		_ = v_0.Args[1]
 21606  		x := v_0.Args[0]
 21607  		y := v_0.Args[1]
 21608  		v.reset(OpEq16)
 21609  		v.AddArg(x)
 21610  		v.AddArg(y)
 21611  		return true
 21612  	}
 21613  	// match: (Not (Neq8 x y))
 21614  	// cond:
 21615  	// result: (Eq8 x y)
 21616  	for {
 21617  		v_0 := v.Args[0]
 21618  		if v_0.Op != OpNeq8 {
 21619  			break
 21620  		}
 21621  		_ = v_0.Args[1]
 21622  		x := v_0.Args[0]
 21623  		y := v_0.Args[1]
 21624  		v.reset(OpEq8)
 21625  		v.AddArg(x)
 21626  		v.AddArg(y)
 21627  		return true
 21628  	}
 21629  	return false
 21630  }
 21631  func rewriteValuegeneric_OpNot_10(v *Value) bool {
 21632  	// match: (Not (NeqB x y))
 21633  	// cond:
 21634  	// result: (EqB x y)
 21635  	for {
 21636  		v_0 := v.Args[0]
 21637  		if v_0.Op != OpNeqB {
 21638  			break
 21639  		}
 21640  		_ = v_0.Args[1]
 21641  		x := v_0.Args[0]
 21642  		y := v_0.Args[1]
 21643  		v.reset(OpEqB)
 21644  		v.AddArg(x)
 21645  		v.AddArg(y)
 21646  		return true
 21647  	}
 21648  	// match: (Not (Greater64 x y))
 21649  	// cond:
 21650  	// result: (Leq64 x y)
 21651  	for {
 21652  		v_0 := v.Args[0]
 21653  		if v_0.Op != OpGreater64 {
 21654  			break
 21655  		}
 21656  		_ = v_0.Args[1]
 21657  		x := v_0.Args[0]
 21658  		y := v_0.Args[1]
 21659  		v.reset(OpLeq64)
 21660  		v.AddArg(x)
 21661  		v.AddArg(y)
 21662  		return true
 21663  	}
 21664  	// match: (Not (Greater32 x y))
 21665  	// cond:
 21666  	// result: (Leq32 x y)
 21667  	for {
 21668  		v_0 := v.Args[0]
 21669  		if v_0.Op != OpGreater32 {
 21670  			break
 21671  		}
 21672  		_ = v_0.Args[1]
 21673  		x := v_0.Args[0]
 21674  		y := v_0.Args[1]
 21675  		v.reset(OpLeq32)
 21676  		v.AddArg(x)
 21677  		v.AddArg(y)
 21678  		return true
 21679  	}
 21680  	// match: (Not (Greater16 x y))
 21681  	// cond:
 21682  	// result: (Leq16 x y)
 21683  	for {
 21684  		v_0 := v.Args[0]
 21685  		if v_0.Op != OpGreater16 {
 21686  			break
 21687  		}
 21688  		_ = v_0.Args[1]
 21689  		x := v_0.Args[0]
 21690  		y := v_0.Args[1]
 21691  		v.reset(OpLeq16)
 21692  		v.AddArg(x)
 21693  		v.AddArg(y)
 21694  		return true
 21695  	}
 21696  	// match: (Not (Greater8 x y))
 21697  	// cond:
 21698  	// result: (Leq8 x y)
 21699  	for {
 21700  		v_0 := v.Args[0]
 21701  		if v_0.Op != OpGreater8 {
 21702  			break
 21703  		}
 21704  		_ = v_0.Args[1]
 21705  		x := v_0.Args[0]
 21706  		y := v_0.Args[1]
 21707  		v.reset(OpLeq8)
 21708  		v.AddArg(x)
 21709  		v.AddArg(y)
 21710  		return true
 21711  	}
 21712  	// match: (Not (Greater64U x y))
 21713  	// cond:
 21714  	// result: (Leq64U x y)
 21715  	for {
 21716  		v_0 := v.Args[0]
 21717  		if v_0.Op != OpGreater64U {
 21718  			break
 21719  		}
 21720  		_ = v_0.Args[1]
 21721  		x := v_0.Args[0]
 21722  		y := v_0.Args[1]
 21723  		v.reset(OpLeq64U)
 21724  		v.AddArg(x)
 21725  		v.AddArg(y)
 21726  		return true
 21727  	}
 21728  	// match: (Not (Greater32U x y))
 21729  	// cond:
 21730  	// result: (Leq32U x y)
 21731  	for {
 21732  		v_0 := v.Args[0]
 21733  		if v_0.Op != OpGreater32U {
 21734  			break
 21735  		}
 21736  		_ = v_0.Args[1]
 21737  		x := v_0.Args[0]
 21738  		y := v_0.Args[1]
 21739  		v.reset(OpLeq32U)
 21740  		v.AddArg(x)
 21741  		v.AddArg(y)
 21742  		return true
 21743  	}
 21744  	// match: (Not (Greater16U x y))
 21745  	// cond:
 21746  	// result: (Leq16U x y)
 21747  	for {
 21748  		v_0 := v.Args[0]
 21749  		if v_0.Op != OpGreater16U {
 21750  			break
 21751  		}
 21752  		_ = v_0.Args[1]
 21753  		x := v_0.Args[0]
 21754  		y := v_0.Args[1]
 21755  		v.reset(OpLeq16U)
 21756  		v.AddArg(x)
 21757  		v.AddArg(y)
 21758  		return true
 21759  	}
 21760  	// match: (Not (Greater8U x y))
 21761  	// cond:
 21762  	// result: (Leq8U x y)
 21763  	for {
 21764  		v_0 := v.Args[0]
 21765  		if v_0.Op != OpGreater8U {
 21766  			break
 21767  		}
 21768  		_ = v_0.Args[1]
 21769  		x := v_0.Args[0]
 21770  		y := v_0.Args[1]
 21771  		v.reset(OpLeq8U)
 21772  		v.AddArg(x)
 21773  		v.AddArg(y)
 21774  		return true
 21775  	}
 21776  	// match: (Not (Geq64 x y))
 21777  	// cond:
 21778  	// result: (Less64 x y)
 21779  	for {
 21780  		v_0 := v.Args[0]
 21781  		if v_0.Op != OpGeq64 {
 21782  			break
 21783  		}
 21784  		_ = v_0.Args[1]
 21785  		x := v_0.Args[0]
 21786  		y := v_0.Args[1]
 21787  		v.reset(OpLess64)
 21788  		v.AddArg(x)
 21789  		v.AddArg(y)
 21790  		return true
 21791  	}
 21792  	return false
 21793  }
 21794  func rewriteValuegeneric_OpNot_20(v *Value) bool {
 21795  	// match: (Not (Geq32 x y))
 21796  	// cond:
 21797  	// result: (Less32 x y)
 21798  	for {
 21799  		v_0 := v.Args[0]
 21800  		if v_0.Op != OpGeq32 {
 21801  			break
 21802  		}
 21803  		_ = v_0.Args[1]
 21804  		x := v_0.Args[0]
 21805  		y := v_0.Args[1]
 21806  		v.reset(OpLess32)
 21807  		v.AddArg(x)
 21808  		v.AddArg(y)
 21809  		return true
 21810  	}
 21811  	// match: (Not (Geq16 x y))
 21812  	// cond:
 21813  	// result: (Less16 x y)
 21814  	for {
 21815  		v_0 := v.Args[0]
 21816  		if v_0.Op != OpGeq16 {
 21817  			break
 21818  		}
 21819  		_ = v_0.Args[1]
 21820  		x := v_0.Args[0]
 21821  		y := v_0.Args[1]
 21822  		v.reset(OpLess16)
 21823  		v.AddArg(x)
 21824  		v.AddArg(y)
 21825  		return true
 21826  	}
 21827  	// match: (Not (Geq8 x y))
 21828  	// cond:
 21829  	// result: (Less8 x y)
 21830  	for {
 21831  		v_0 := v.Args[0]
 21832  		if v_0.Op != OpGeq8 {
 21833  			break
 21834  		}
 21835  		_ = v_0.Args[1]
 21836  		x := v_0.Args[0]
 21837  		y := v_0.Args[1]
 21838  		v.reset(OpLess8)
 21839  		v.AddArg(x)
 21840  		v.AddArg(y)
 21841  		return true
 21842  	}
 21843  	// match: (Not (Geq64U x y))
 21844  	// cond:
 21845  	// result: (Less64U x y)
 21846  	for {
 21847  		v_0 := v.Args[0]
 21848  		if v_0.Op != OpGeq64U {
 21849  			break
 21850  		}
 21851  		_ = v_0.Args[1]
 21852  		x := v_0.Args[0]
 21853  		y := v_0.Args[1]
 21854  		v.reset(OpLess64U)
 21855  		v.AddArg(x)
 21856  		v.AddArg(y)
 21857  		return true
 21858  	}
 21859  	// match: (Not (Geq32U x y))
 21860  	// cond:
 21861  	// result: (Less32U x y)
 21862  	for {
 21863  		v_0 := v.Args[0]
 21864  		if v_0.Op != OpGeq32U {
 21865  			break
 21866  		}
 21867  		_ = v_0.Args[1]
 21868  		x := v_0.Args[0]
 21869  		y := v_0.Args[1]
 21870  		v.reset(OpLess32U)
 21871  		v.AddArg(x)
 21872  		v.AddArg(y)
 21873  		return true
 21874  	}
 21875  	// match: (Not (Geq16U x y))
 21876  	// cond:
 21877  	// result: (Less16U x y)
 21878  	for {
 21879  		v_0 := v.Args[0]
 21880  		if v_0.Op != OpGeq16U {
 21881  			break
 21882  		}
 21883  		_ = v_0.Args[1]
 21884  		x := v_0.Args[0]
 21885  		y := v_0.Args[1]
 21886  		v.reset(OpLess16U)
 21887  		v.AddArg(x)
 21888  		v.AddArg(y)
 21889  		return true
 21890  	}
 21891  	// match: (Not (Geq8U x y))
 21892  	// cond:
 21893  	// result: (Less8U x y)
 21894  	for {
 21895  		v_0 := v.Args[0]
 21896  		if v_0.Op != OpGeq8U {
 21897  			break
 21898  		}
 21899  		_ = v_0.Args[1]
 21900  		x := v_0.Args[0]
 21901  		y := v_0.Args[1]
 21902  		v.reset(OpLess8U)
 21903  		v.AddArg(x)
 21904  		v.AddArg(y)
 21905  		return true
 21906  	}
 21907  	// match: (Not (Less64 x y))
 21908  	// cond:
 21909  	// result: (Geq64 x y)
 21910  	for {
 21911  		v_0 := v.Args[0]
 21912  		if v_0.Op != OpLess64 {
 21913  			break
 21914  		}
 21915  		_ = v_0.Args[1]
 21916  		x := v_0.Args[0]
 21917  		y := v_0.Args[1]
 21918  		v.reset(OpGeq64)
 21919  		v.AddArg(x)
 21920  		v.AddArg(y)
 21921  		return true
 21922  	}
 21923  	// match: (Not (Less32 x y))
 21924  	// cond:
 21925  	// result: (Geq32 x y)
 21926  	for {
 21927  		v_0 := v.Args[0]
 21928  		if v_0.Op != OpLess32 {
 21929  			break
 21930  		}
 21931  		_ = v_0.Args[1]
 21932  		x := v_0.Args[0]
 21933  		y := v_0.Args[1]
 21934  		v.reset(OpGeq32)
 21935  		v.AddArg(x)
 21936  		v.AddArg(y)
 21937  		return true
 21938  	}
 21939  	// match: (Not (Less16 x y))
 21940  	// cond:
 21941  	// result: (Geq16 x y)
 21942  	for {
 21943  		v_0 := v.Args[0]
 21944  		if v_0.Op != OpLess16 {
 21945  			break
 21946  		}
 21947  		_ = v_0.Args[1]
 21948  		x := v_0.Args[0]
 21949  		y := v_0.Args[1]
 21950  		v.reset(OpGeq16)
 21951  		v.AddArg(x)
 21952  		v.AddArg(y)
 21953  		return true
 21954  	}
 21955  	return false
 21956  }
 21957  func rewriteValuegeneric_OpNot_30(v *Value) bool {
 21958  	// match: (Not (Less8 x y))
 21959  	// cond:
 21960  	// result: (Geq8 x y)
 21961  	for {
 21962  		v_0 := v.Args[0]
 21963  		if v_0.Op != OpLess8 {
 21964  			break
 21965  		}
 21966  		_ = v_0.Args[1]
 21967  		x := v_0.Args[0]
 21968  		y := v_0.Args[1]
 21969  		v.reset(OpGeq8)
 21970  		v.AddArg(x)
 21971  		v.AddArg(y)
 21972  		return true
 21973  	}
 21974  	// match: (Not (Less64U x y))
 21975  	// cond:
 21976  	// result: (Geq64U x y)
 21977  	for {
 21978  		v_0 := v.Args[0]
 21979  		if v_0.Op != OpLess64U {
 21980  			break
 21981  		}
 21982  		_ = v_0.Args[1]
 21983  		x := v_0.Args[0]
 21984  		y := v_0.Args[1]
 21985  		v.reset(OpGeq64U)
 21986  		v.AddArg(x)
 21987  		v.AddArg(y)
 21988  		return true
 21989  	}
 21990  	// match: (Not (Less32U x y))
 21991  	// cond:
 21992  	// result: (Geq32U x y)
 21993  	for {
 21994  		v_0 := v.Args[0]
 21995  		if v_0.Op != OpLess32U {
 21996  			break
 21997  		}
 21998  		_ = v_0.Args[1]
 21999  		x := v_0.Args[0]
 22000  		y := v_0.Args[1]
 22001  		v.reset(OpGeq32U)
 22002  		v.AddArg(x)
 22003  		v.AddArg(y)
 22004  		return true
 22005  	}
 22006  	// match: (Not (Less16U x y))
 22007  	// cond:
 22008  	// result: (Geq16U x y)
 22009  	for {
 22010  		v_0 := v.Args[0]
 22011  		if v_0.Op != OpLess16U {
 22012  			break
 22013  		}
 22014  		_ = v_0.Args[1]
 22015  		x := v_0.Args[0]
 22016  		y := v_0.Args[1]
 22017  		v.reset(OpGeq16U)
 22018  		v.AddArg(x)
 22019  		v.AddArg(y)
 22020  		return true
 22021  	}
 22022  	// match: (Not (Less8U x y))
 22023  	// cond:
 22024  	// result: (Geq8U x y)
 22025  	for {
 22026  		v_0 := v.Args[0]
 22027  		if v_0.Op != OpLess8U {
 22028  			break
 22029  		}
 22030  		_ = v_0.Args[1]
 22031  		x := v_0.Args[0]
 22032  		y := v_0.Args[1]
 22033  		v.reset(OpGeq8U)
 22034  		v.AddArg(x)
 22035  		v.AddArg(y)
 22036  		return true
 22037  	}
 22038  	// match: (Not (Leq64 x y))
 22039  	// cond:
 22040  	// result: (Greater64 x y)
 22041  	for {
 22042  		v_0 := v.Args[0]
 22043  		if v_0.Op != OpLeq64 {
 22044  			break
 22045  		}
 22046  		_ = v_0.Args[1]
 22047  		x := v_0.Args[0]
 22048  		y := v_0.Args[1]
 22049  		v.reset(OpGreater64)
 22050  		v.AddArg(x)
 22051  		v.AddArg(y)
 22052  		return true
 22053  	}
 22054  	// match: (Not (Leq32 x y))
 22055  	// cond:
 22056  	// result: (Greater32 x y)
 22057  	for {
 22058  		v_0 := v.Args[0]
 22059  		if v_0.Op != OpLeq32 {
 22060  			break
 22061  		}
 22062  		_ = v_0.Args[1]
 22063  		x := v_0.Args[0]
 22064  		y := v_0.Args[1]
 22065  		v.reset(OpGreater32)
 22066  		v.AddArg(x)
 22067  		v.AddArg(y)
 22068  		return true
 22069  	}
 22070  	// match: (Not (Leq16 x y))
 22071  	// cond:
 22072  	// result: (Greater16 x y)
 22073  	for {
 22074  		v_0 := v.Args[0]
 22075  		if v_0.Op != OpLeq16 {
 22076  			break
 22077  		}
 22078  		_ = v_0.Args[1]
 22079  		x := v_0.Args[0]
 22080  		y := v_0.Args[1]
 22081  		v.reset(OpGreater16)
 22082  		v.AddArg(x)
 22083  		v.AddArg(y)
 22084  		return true
 22085  	}
 22086  	// match: (Not (Leq8 x y))
 22087  	// cond:
 22088  	// result: (Greater8 x y)
 22089  	for {
 22090  		v_0 := v.Args[0]
 22091  		if v_0.Op != OpLeq8 {
 22092  			break
 22093  		}
 22094  		_ = v_0.Args[1]
 22095  		x := v_0.Args[0]
 22096  		y := v_0.Args[1]
 22097  		v.reset(OpGreater8)
 22098  		v.AddArg(x)
 22099  		v.AddArg(y)
 22100  		return true
 22101  	}
 22102  	// match: (Not (Leq64U x y))
 22103  	// cond:
 22104  	// result: (Greater64U x y)
 22105  	for {
 22106  		v_0 := v.Args[0]
 22107  		if v_0.Op != OpLeq64U {
 22108  			break
 22109  		}
 22110  		_ = v_0.Args[1]
 22111  		x := v_0.Args[0]
 22112  		y := v_0.Args[1]
 22113  		v.reset(OpGreater64U)
 22114  		v.AddArg(x)
 22115  		v.AddArg(y)
 22116  		return true
 22117  	}
 22118  	return false
 22119  }
 22120  func rewriteValuegeneric_OpNot_40(v *Value) bool {
 22121  	// match: (Not (Leq32U x y))
 22122  	// cond:
 22123  	// result: (Greater32U x y)
 22124  	for {
 22125  		v_0 := v.Args[0]
 22126  		if v_0.Op != OpLeq32U {
 22127  			break
 22128  		}
 22129  		_ = v_0.Args[1]
 22130  		x := v_0.Args[0]
 22131  		y := v_0.Args[1]
 22132  		v.reset(OpGreater32U)
 22133  		v.AddArg(x)
 22134  		v.AddArg(y)
 22135  		return true
 22136  	}
 22137  	// match: (Not (Leq16U x y))
 22138  	// cond:
 22139  	// result: (Greater16U x y)
 22140  	for {
 22141  		v_0 := v.Args[0]
 22142  		if v_0.Op != OpLeq16U {
 22143  			break
 22144  		}
 22145  		_ = v_0.Args[1]
 22146  		x := v_0.Args[0]
 22147  		y := v_0.Args[1]
 22148  		v.reset(OpGreater16U)
 22149  		v.AddArg(x)
 22150  		v.AddArg(y)
 22151  		return true
 22152  	}
 22153  	// match: (Not (Leq8U x y))
 22154  	// cond:
 22155  	// result: (Greater8U x y)
 22156  	for {
 22157  		v_0 := v.Args[0]
 22158  		if v_0.Op != OpLeq8U {
 22159  			break
 22160  		}
 22161  		_ = v_0.Args[1]
 22162  		x := v_0.Args[0]
 22163  		y := v_0.Args[1]
 22164  		v.reset(OpGreater8U)
 22165  		v.AddArg(x)
 22166  		v.AddArg(y)
 22167  		return true
 22168  	}
 22169  	return false
 22170  }
 22171  func rewriteValuegeneric_OpOffPtr_0(v *Value) bool {
 22172  	// match: (OffPtr (OffPtr p [b]) [a])
 22173  	// cond:
 22174  	// result: (OffPtr p [a+b])
 22175  	for {
 22176  		a := v.AuxInt
 22177  		v_0 := v.Args[0]
 22178  		if v_0.Op != OpOffPtr {
 22179  			break
 22180  		}
 22181  		b := v_0.AuxInt
 22182  		p := v_0.Args[0]
 22183  		v.reset(OpOffPtr)
 22184  		v.AuxInt = a + b
 22185  		v.AddArg(p)
 22186  		return true
 22187  	}
 22188  	// match: (OffPtr p [0])
 22189  	// cond: v.Type.Compare(p.Type) == types.CMPeq
 22190  	// result: p
 22191  	for {
 22192  		if v.AuxInt != 0 {
 22193  			break
 22194  		}
 22195  		p := v.Args[0]
 22196  		if !(v.Type.Compare(p.Type) == types.CMPeq) {
 22197  			break
 22198  		}
 22199  		v.reset(OpCopy)
 22200  		v.Type = p.Type
 22201  		v.AddArg(p)
 22202  		return true
 22203  	}
 22204  	return false
 22205  }
 22206  func rewriteValuegeneric_OpOr16_0(v *Value) bool {
 22207  	// match: (Or16 (Const16 [c]) (Const16 [d]))
 22208  	// cond:
 22209  	// result: (Const16 [int64(int16(c|d))])
 22210  	for {
 22211  		_ = v.Args[1]
 22212  		v_0 := v.Args[0]
 22213  		if v_0.Op != OpConst16 {
 22214  			break
 22215  		}
 22216  		c := v_0.AuxInt
 22217  		v_1 := v.Args[1]
 22218  		if v_1.Op != OpConst16 {
 22219  			break
 22220  		}
 22221  		d := v_1.AuxInt
 22222  		v.reset(OpConst16)
 22223  		v.AuxInt = int64(int16(c | d))
 22224  		return true
 22225  	}
 22226  	// match: (Or16 (Const16 [d]) (Const16 [c]))
 22227  	// cond:
 22228  	// result: (Const16 [int64(int16(c|d))])
 22229  	for {
 22230  		_ = v.Args[1]
 22231  		v_0 := v.Args[0]
 22232  		if v_0.Op != OpConst16 {
 22233  			break
 22234  		}
 22235  		d := v_0.AuxInt
 22236  		v_1 := v.Args[1]
 22237  		if v_1.Op != OpConst16 {
 22238  			break
 22239  		}
 22240  		c := v_1.AuxInt
 22241  		v.reset(OpConst16)
 22242  		v.AuxInt = int64(int16(c | d))
 22243  		return true
 22244  	}
 22245  	// match: (Or16 x x)
 22246  	// cond:
 22247  	// result: x
 22248  	for {
 22249  		_ = v.Args[1]
 22250  		x := v.Args[0]
 22251  		if x != v.Args[1] {
 22252  			break
 22253  		}
 22254  		v.reset(OpCopy)
 22255  		v.Type = x.Type
 22256  		v.AddArg(x)
 22257  		return true
 22258  	}
 22259  	// match: (Or16 (Const16 [0]) x)
 22260  	// cond:
 22261  	// result: x
 22262  	for {
 22263  		_ = v.Args[1]
 22264  		v_0 := v.Args[0]
 22265  		if v_0.Op != OpConst16 {
 22266  			break
 22267  		}
 22268  		if v_0.AuxInt != 0 {
 22269  			break
 22270  		}
 22271  		x := v.Args[1]
 22272  		v.reset(OpCopy)
 22273  		v.Type = x.Type
 22274  		v.AddArg(x)
 22275  		return true
 22276  	}
 22277  	// match: (Or16 x (Const16 [0]))
 22278  	// cond:
 22279  	// result: x
 22280  	for {
 22281  		_ = v.Args[1]
 22282  		x := v.Args[0]
 22283  		v_1 := v.Args[1]
 22284  		if v_1.Op != OpConst16 {
 22285  			break
 22286  		}
 22287  		if v_1.AuxInt != 0 {
 22288  			break
 22289  		}
 22290  		v.reset(OpCopy)
 22291  		v.Type = x.Type
 22292  		v.AddArg(x)
 22293  		return true
 22294  	}
 22295  	// match: (Or16 (Const16 [-1]) _)
 22296  	// cond:
 22297  	// result: (Const16 [-1])
 22298  	for {
 22299  		_ = v.Args[1]
 22300  		v_0 := v.Args[0]
 22301  		if v_0.Op != OpConst16 {
 22302  			break
 22303  		}
 22304  		if v_0.AuxInt != -1 {
 22305  			break
 22306  		}
 22307  		v.reset(OpConst16)
 22308  		v.AuxInt = -1
 22309  		return true
 22310  	}
 22311  	// match: (Or16 _ (Const16 [-1]))
 22312  	// cond:
 22313  	// result: (Const16 [-1])
 22314  	for {
 22315  		_ = v.Args[1]
 22316  		v_1 := v.Args[1]
 22317  		if v_1.Op != OpConst16 {
 22318  			break
 22319  		}
 22320  		if v_1.AuxInt != -1 {
 22321  			break
 22322  		}
 22323  		v.reset(OpConst16)
 22324  		v.AuxInt = -1
 22325  		return true
 22326  	}
 22327  	// match: (Or16 x (Or16 x y))
 22328  	// cond:
 22329  	// result: (Or16 x y)
 22330  	for {
 22331  		_ = v.Args[1]
 22332  		x := v.Args[0]
 22333  		v_1 := v.Args[1]
 22334  		if v_1.Op != OpOr16 {
 22335  			break
 22336  		}
 22337  		_ = v_1.Args[1]
 22338  		if x != v_1.Args[0] {
 22339  			break
 22340  		}
 22341  		y := v_1.Args[1]
 22342  		v.reset(OpOr16)
 22343  		v.AddArg(x)
 22344  		v.AddArg(y)
 22345  		return true
 22346  	}
 22347  	// match: (Or16 x (Or16 y x))
 22348  	// cond:
 22349  	// result: (Or16 x y)
 22350  	for {
 22351  		_ = v.Args[1]
 22352  		x := v.Args[0]
 22353  		v_1 := v.Args[1]
 22354  		if v_1.Op != OpOr16 {
 22355  			break
 22356  		}
 22357  		_ = v_1.Args[1]
 22358  		y := v_1.Args[0]
 22359  		if x != v_1.Args[1] {
 22360  			break
 22361  		}
 22362  		v.reset(OpOr16)
 22363  		v.AddArg(x)
 22364  		v.AddArg(y)
 22365  		return true
 22366  	}
 22367  	// match: (Or16 (Or16 x y) x)
 22368  	// cond:
 22369  	// result: (Or16 x y)
 22370  	for {
 22371  		_ = v.Args[1]
 22372  		v_0 := v.Args[0]
 22373  		if v_0.Op != OpOr16 {
 22374  			break
 22375  		}
 22376  		_ = v_0.Args[1]
 22377  		x := v_0.Args[0]
 22378  		y := v_0.Args[1]
 22379  		if x != v.Args[1] {
 22380  			break
 22381  		}
 22382  		v.reset(OpOr16)
 22383  		v.AddArg(x)
 22384  		v.AddArg(y)
 22385  		return true
 22386  	}
 22387  	return false
 22388  }
 22389  func rewriteValuegeneric_OpOr16_10(v *Value) bool {
 22390  	b := v.Block
 22391  	_ = b
 22392  	// match: (Or16 (Or16 y x) x)
 22393  	// cond:
 22394  	// result: (Or16 x y)
 22395  	for {
 22396  		_ = v.Args[1]
 22397  		v_0 := v.Args[0]
 22398  		if v_0.Op != OpOr16 {
 22399  			break
 22400  		}
 22401  		_ = v_0.Args[1]
 22402  		y := v_0.Args[0]
 22403  		x := v_0.Args[1]
 22404  		if x != v.Args[1] {
 22405  			break
 22406  		}
 22407  		v.reset(OpOr16)
 22408  		v.AddArg(x)
 22409  		v.AddArg(y)
 22410  		return true
 22411  	}
 22412  	// match: (Or16 (And16 x (Const16 [c2])) (Const16 <t> [c1]))
 22413  	// cond: ^(c1 | c2) == 0
 22414  	// result: (Or16 (Const16 <t> [c1]) x)
 22415  	for {
 22416  		_ = v.Args[1]
 22417  		v_0 := v.Args[0]
 22418  		if v_0.Op != OpAnd16 {
 22419  			break
 22420  		}
 22421  		_ = v_0.Args[1]
 22422  		x := v_0.Args[0]
 22423  		v_0_1 := v_0.Args[1]
 22424  		if v_0_1.Op != OpConst16 {
 22425  			break
 22426  		}
 22427  		c2 := v_0_1.AuxInt
 22428  		v_1 := v.Args[1]
 22429  		if v_1.Op != OpConst16 {
 22430  			break
 22431  		}
 22432  		t := v_1.Type
 22433  		c1 := v_1.AuxInt
 22434  		if !(^(c1 | c2) == 0) {
 22435  			break
 22436  		}
 22437  		v.reset(OpOr16)
 22438  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22439  		v0.AuxInt = c1
 22440  		v.AddArg(v0)
 22441  		v.AddArg(x)
 22442  		return true
 22443  	}
 22444  	// match: (Or16 (And16 (Const16 [c2]) x) (Const16 <t> [c1]))
 22445  	// cond: ^(c1 | c2) == 0
 22446  	// result: (Or16 (Const16 <t> [c1]) x)
 22447  	for {
 22448  		_ = v.Args[1]
 22449  		v_0 := v.Args[0]
 22450  		if v_0.Op != OpAnd16 {
 22451  			break
 22452  		}
 22453  		_ = v_0.Args[1]
 22454  		v_0_0 := v_0.Args[0]
 22455  		if v_0_0.Op != OpConst16 {
 22456  			break
 22457  		}
 22458  		c2 := v_0_0.AuxInt
 22459  		x := v_0.Args[1]
 22460  		v_1 := v.Args[1]
 22461  		if v_1.Op != OpConst16 {
 22462  			break
 22463  		}
 22464  		t := v_1.Type
 22465  		c1 := v_1.AuxInt
 22466  		if !(^(c1 | c2) == 0) {
 22467  			break
 22468  		}
 22469  		v.reset(OpOr16)
 22470  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22471  		v0.AuxInt = c1
 22472  		v.AddArg(v0)
 22473  		v.AddArg(x)
 22474  		return true
 22475  	}
 22476  	// match: (Or16 (Const16 <t> [c1]) (And16 x (Const16 [c2])))
 22477  	// cond: ^(c1 | c2) == 0
 22478  	// result: (Or16 (Const16 <t> [c1]) x)
 22479  	for {
 22480  		_ = v.Args[1]
 22481  		v_0 := v.Args[0]
 22482  		if v_0.Op != OpConst16 {
 22483  			break
 22484  		}
 22485  		t := v_0.Type
 22486  		c1 := v_0.AuxInt
 22487  		v_1 := v.Args[1]
 22488  		if v_1.Op != OpAnd16 {
 22489  			break
 22490  		}
 22491  		_ = v_1.Args[1]
 22492  		x := v_1.Args[0]
 22493  		v_1_1 := v_1.Args[1]
 22494  		if v_1_1.Op != OpConst16 {
 22495  			break
 22496  		}
 22497  		c2 := v_1_1.AuxInt
 22498  		if !(^(c1 | c2) == 0) {
 22499  			break
 22500  		}
 22501  		v.reset(OpOr16)
 22502  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22503  		v0.AuxInt = c1
 22504  		v.AddArg(v0)
 22505  		v.AddArg(x)
 22506  		return true
 22507  	}
 22508  	// match: (Or16 (Const16 <t> [c1]) (And16 (Const16 [c2]) x))
 22509  	// cond: ^(c1 | c2) == 0
 22510  	// result: (Or16 (Const16 <t> [c1]) x)
 22511  	for {
 22512  		_ = v.Args[1]
 22513  		v_0 := v.Args[0]
 22514  		if v_0.Op != OpConst16 {
 22515  			break
 22516  		}
 22517  		t := v_0.Type
 22518  		c1 := v_0.AuxInt
 22519  		v_1 := v.Args[1]
 22520  		if v_1.Op != OpAnd16 {
 22521  			break
 22522  		}
 22523  		_ = v_1.Args[1]
 22524  		v_1_0 := v_1.Args[0]
 22525  		if v_1_0.Op != OpConst16 {
 22526  			break
 22527  		}
 22528  		c2 := v_1_0.AuxInt
 22529  		x := v_1.Args[1]
 22530  		if !(^(c1 | c2) == 0) {
 22531  			break
 22532  		}
 22533  		v.reset(OpOr16)
 22534  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22535  		v0.AuxInt = c1
 22536  		v.AddArg(v0)
 22537  		v.AddArg(x)
 22538  		return true
 22539  	}
 22540  	// match: (Or16 (Or16 i:(Const16 <t>) z) x)
 22541  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 22542  	// result: (Or16 i (Or16 <t> z x))
 22543  	for {
 22544  		_ = v.Args[1]
 22545  		v_0 := v.Args[0]
 22546  		if v_0.Op != OpOr16 {
 22547  			break
 22548  		}
 22549  		_ = v_0.Args[1]
 22550  		i := v_0.Args[0]
 22551  		if i.Op != OpConst16 {
 22552  			break
 22553  		}
 22554  		t := i.Type
 22555  		z := v_0.Args[1]
 22556  		x := v.Args[1]
 22557  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 22558  			break
 22559  		}
 22560  		v.reset(OpOr16)
 22561  		v.AddArg(i)
 22562  		v0 := b.NewValue0(v.Pos, OpOr16, t)
 22563  		v0.AddArg(z)
 22564  		v0.AddArg(x)
 22565  		v.AddArg(v0)
 22566  		return true
 22567  	}
 22568  	// match: (Or16 (Or16 z i:(Const16 <t>)) x)
 22569  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 22570  	// result: (Or16 i (Or16 <t> z x))
 22571  	for {
 22572  		_ = v.Args[1]
 22573  		v_0 := v.Args[0]
 22574  		if v_0.Op != OpOr16 {
 22575  			break
 22576  		}
 22577  		_ = v_0.Args[1]
 22578  		z := v_0.Args[0]
 22579  		i := v_0.Args[1]
 22580  		if i.Op != OpConst16 {
 22581  			break
 22582  		}
 22583  		t := i.Type
 22584  		x := v.Args[1]
 22585  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 22586  			break
 22587  		}
 22588  		v.reset(OpOr16)
 22589  		v.AddArg(i)
 22590  		v0 := b.NewValue0(v.Pos, OpOr16, t)
 22591  		v0.AddArg(z)
 22592  		v0.AddArg(x)
 22593  		v.AddArg(v0)
 22594  		return true
 22595  	}
 22596  	// match: (Or16 x (Or16 i:(Const16 <t>) z))
 22597  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 22598  	// result: (Or16 i (Or16 <t> z x))
 22599  	for {
 22600  		_ = v.Args[1]
 22601  		x := v.Args[0]
 22602  		v_1 := v.Args[1]
 22603  		if v_1.Op != OpOr16 {
 22604  			break
 22605  		}
 22606  		_ = v_1.Args[1]
 22607  		i := v_1.Args[0]
 22608  		if i.Op != OpConst16 {
 22609  			break
 22610  		}
 22611  		t := i.Type
 22612  		z := v_1.Args[1]
 22613  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 22614  			break
 22615  		}
 22616  		v.reset(OpOr16)
 22617  		v.AddArg(i)
 22618  		v0 := b.NewValue0(v.Pos, OpOr16, t)
 22619  		v0.AddArg(z)
 22620  		v0.AddArg(x)
 22621  		v.AddArg(v0)
 22622  		return true
 22623  	}
 22624  	// match: (Or16 x (Or16 z i:(Const16 <t>)))
 22625  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 22626  	// result: (Or16 i (Or16 <t> z x))
 22627  	for {
 22628  		_ = v.Args[1]
 22629  		x := v.Args[0]
 22630  		v_1 := v.Args[1]
 22631  		if v_1.Op != OpOr16 {
 22632  			break
 22633  		}
 22634  		_ = v_1.Args[1]
 22635  		z := v_1.Args[0]
 22636  		i := v_1.Args[1]
 22637  		if i.Op != OpConst16 {
 22638  			break
 22639  		}
 22640  		t := i.Type
 22641  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 22642  			break
 22643  		}
 22644  		v.reset(OpOr16)
 22645  		v.AddArg(i)
 22646  		v0 := b.NewValue0(v.Pos, OpOr16, t)
 22647  		v0.AddArg(z)
 22648  		v0.AddArg(x)
 22649  		v.AddArg(v0)
 22650  		return true
 22651  	}
 22652  	// match: (Or16 (Const16 <t> [c]) (Or16 (Const16 <t> [d]) x))
 22653  	// cond:
 22654  	// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 22655  	for {
 22656  		_ = v.Args[1]
 22657  		v_0 := v.Args[0]
 22658  		if v_0.Op != OpConst16 {
 22659  			break
 22660  		}
 22661  		t := v_0.Type
 22662  		c := v_0.AuxInt
 22663  		v_1 := v.Args[1]
 22664  		if v_1.Op != OpOr16 {
 22665  			break
 22666  		}
 22667  		_ = v_1.Args[1]
 22668  		v_1_0 := v_1.Args[0]
 22669  		if v_1_0.Op != OpConst16 {
 22670  			break
 22671  		}
 22672  		if v_1_0.Type != t {
 22673  			break
 22674  		}
 22675  		d := v_1_0.AuxInt
 22676  		x := v_1.Args[1]
 22677  		v.reset(OpOr16)
 22678  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22679  		v0.AuxInt = int64(int16(c | d))
 22680  		v.AddArg(v0)
 22681  		v.AddArg(x)
 22682  		return true
 22683  	}
 22684  	return false
 22685  }
 22686  func rewriteValuegeneric_OpOr16_20(v *Value) bool {
 22687  	b := v.Block
 22688  	_ = b
 22689  	// match: (Or16 (Const16 <t> [c]) (Or16 x (Const16 <t> [d])))
 22690  	// cond:
 22691  	// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 22692  	for {
 22693  		_ = v.Args[1]
 22694  		v_0 := v.Args[0]
 22695  		if v_0.Op != OpConst16 {
 22696  			break
 22697  		}
 22698  		t := v_0.Type
 22699  		c := v_0.AuxInt
 22700  		v_1 := v.Args[1]
 22701  		if v_1.Op != OpOr16 {
 22702  			break
 22703  		}
 22704  		_ = v_1.Args[1]
 22705  		x := v_1.Args[0]
 22706  		v_1_1 := v_1.Args[1]
 22707  		if v_1_1.Op != OpConst16 {
 22708  			break
 22709  		}
 22710  		if v_1_1.Type != t {
 22711  			break
 22712  		}
 22713  		d := v_1_1.AuxInt
 22714  		v.reset(OpOr16)
 22715  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22716  		v0.AuxInt = int64(int16(c | d))
 22717  		v.AddArg(v0)
 22718  		v.AddArg(x)
 22719  		return true
 22720  	}
 22721  	// match: (Or16 (Or16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 22722  	// cond:
 22723  	// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 22724  	for {
 22725  		_ = v.Args[1]
 22726  		v_0 := v.Args[0]
 22727  		if v_0.Op != OpOr16 {
 22728  			break
 22729  		}
 22730  		_ = v_0.Args[1]
 22731  		v_0_0 := v_0.Args[0]
 22732  		if v_0_0.Op != OpConst16 {
 22733  			break
 22734  		}
 22735  		t := v_0_0.Type
 22736  		d := v_0_0.AuxInt
 22737  		x := v_0.Args[1]
 22738  		v_1 := v.Args[1]
 22739  		if v_1.Op != OpConst16 {
 22740  			break
 22741  		}
 22742  		if v_1.Type != t {
 22743  			break
 22744  		}
 22745  		c := v_1.AuxInt
 22746  		v.reset(OpOr16)
 22747  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22748  		v0.AuxInt = int64(int16(c | d))
 22749  		v.AddArg(v0)
 22750  		v.AddArg(x)
 22751  		return true
 22752  	}
 22753  	// match: (Or16 (Or16 x (Const16 <t> [d])) (Const16 <t> [c]))
 22754  	// cond:
 22755  	// result: (Or16 (Const16 <t> [int64(int16(c|d))]) x)
 22756  	for {
 22757  		_ = v.Args[1]
 22758  		v_0 := v.Args[0]
 22759  		if v_0.Op != OpOr16 {
 22760  			break
 22761  		}
 22762  		_ = v_0.Args[1]
 22763  		x := v_0.Args[0]
 22764  		v_0_1 := v_0.Args[1]
 22765  		if v_0_1.Op != OpConst16 {
 22766  			break
 22767  		}
 22768  		t := v_0_1.Type
 22769  		d := v_0_1.AuxInt
 22770  		v_1 := v.Args[1]
 22771  		if v_1.Op != OpConst16 {
 22772  			break
 22773  		}
 22774  		if v_1.Type != t {
 22775  			break
 22776  		}
 22777  		c := v_1.AuxInt
 22778  		v.reset(OpOr16)
 22779  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 22780  		v0.AuxInt = int64(int16(c | d))
 22781  		v.AddArg(v0)
 22782  		v.AddArg(x)
 22783  		return true
 22784  	}
 22785  	return false
 22786  }
 22787  func rewriteValuegeneric_OpOr32_0(v *Value) bool {
 22788  	// match: (Or32 (Const32 [c]) (Const32 [d]))
 22789  	// cond:
 22790  	// result: (Const32 [int64(int32(c|d))])
 22791  	for {
 22792  		_ = v.Args[1]
 22793  		v_0 := v.Args[0]
 22794  		if v_0.Op != OpConst32 {
 22795  			break
 22796  		}
 22797  		c := v_0.AuxInt
 22798  		v_1 := v.Args[1]
 22799  		if v_1.Op != OpConst32 {
 22800  			break
 22801  		}
 22802  		d := v_1.AuxInt
 22803  		v.reset(OpConst32)
 22804  		v.AuxInt = int64(int32(c | d))
 22805  		return true
 22806  	}
 22807  	// match: (Or32 (Const32 [d]) (Const32 [c]))
 22808  	// cond:
 22809  	// result: (Const32 [int64(int32(c|d))])
 22810  	for {
 22811  		_ = v.Args[1]
 22812  		v_0 := v.Args[0]
 22813  		if v_0.Op != OpConst32 {
 22814  			break
 22815  		}
 22816  		d := v_0.AuxInt
 22817  		v_1 := v.Args[1]
 22818  		if v_1.Op != OpConst32 {
 22819  			break
 22820  		}
 22821  		c := v_1.AuxInt
 22822  		v.reset(OpConst32)
 22823  		v.AuxInt = int64(int32(c | d))
 22824  		return true
 22825  	}
 22826  	// match: (Or32 x x)
 22827  	// cond:
 22828  	// result: x
 22829  	for {
 22830  		_ = v.Args[1]
 22831  		x := v.Args[0]
 22832  		if x != v.Args[1] {
 22833  			break
 22834  		}
 22835  		v.reset(OpCopy)
 22836  		v.Type = x.Type
 22837  		v.AddArg(x)
 22838  		return true
 22839  	}
 22840  	// match: (Or32 (Const32 [0]) x)
 22841  	// cond:
 22842  	// result: x
 22843  	for {
 22844  		_ = v.Args[1]
 22845  		v_0 := v.Args[0]
 22846  		if v_0.Op != OpConst32 {
 22847  			break
 22848  		}
 22849  		if v_0.AuxInt != 0 {
 22850  			break
 22851  		}
 22852  		x := v.Args[1]
 22853  		v.reset(OpCopy)
 22854  		v.Type = x.Type
 22855  		v.AddArg(x)
 22856  		return true
 22857  	}
 22858  	// match: (Or32 x (Const32 [0]))
 22859  	// cond:
 22860  	// result: x
 22861  	for {
 22862  		_ = v.Args[1]
 22863  		x := v.Args[0]
 22864  		v_1 := v.Args[1]
 22865  		if v_1.Op != OpConst32 {
 22866  			break
 22867  		}
 22868  		if v_1.AuxInt != 0 {
 22869  			break
 22870  		}
 22871  		v.reset(OpCopy)
 22872  		v.Type = x.Type
 22873  		v.AddArg(x)
 22874  		return true
 22875  	}
 22876  	// match: (Or32 (Const32 [-1]) _)
 22877  	// cond:
 22878  	// result: (Const32 [-1])
 22879  	for {
 22880  		_ = v.Args[1]
 22881  		v_0 := v.Args[0]
 22882  		if v_0.Op != OpConst32 {
 22883  			break
 22884  		}
 22885  		if v_0.AuxInt != -1 {
 22886  			break
 22887  		}
 22888  		v.reset(OpConst32)
 22889  		v.AuxInt = -1
 22890  		return true
 22891  	}
 22892  	// match: (Or32 _ (Const32 [-1]))
 22893  	// cond:
 22894  	// result: (Const32 [-1])
 22895  	for {
 22896  		_ = v.Args[1]
 22897  		v_1 := v.Args[1]
 22898  		if v_1.Op != OpConst32 {
 22899  			break
 22900  		}
 22901  		if v_1.AuxInt != -1 {
 22902  			break
 22903  		}
 22904  		v.reset(OpConst32)
 22905  		v.AuxInt = -1
 22906  		return true
 22907  	}
 22908  	// match: (Or32 x (Or32 x y))
 22909  	// cond:
 22910  	// result: (Or32 x y)
 22911  	for {
 22912  		_ = v.Args[1]
 22913  		x := v.Args[0]
 22914  		v_1 := v.Args[1]
 22915  		if v_1.Op != OpOr32 {
 22916  			break
 22917  		}
 22918  		_ = v_1.Args[1]
 22919  		if x != v_1.Args[0] {
 22920  			break
 22921  		}
 22922  		y := v_1.Args[1]
 22923  		v.reset(OpOr32)
 22924  		v.AddArg(x)
 22925  		v.AddArg(y)
 22926  		return true
 22927  	}
 22928  	// match: (Or32 x (Or32 y x))
 22929  	// cond:
 22930  	// result: (Or32 x y)
 22931  	for {
 22932  		_ = v.Args[1]
 22933  		x := v.Args[0]
 22934  		v_1 := v.Args[1]
 22935  		if v_1.Op != OpOr32 {
 22936  			break
 22937  		}
 22938  		_ = v_1.Args[1]
 22939  		y := v_1.Args[0]
 22940  		if x != v_1.Args[1] {
 22941  			break
 22942  		}
 22943  		v.reset(OpOr32)
 22944  		v.AddArg(x)
 22945  		v.AddArg(y)
 22946  		return true
 22947  	}
 22948  	// match: (Or32 (Or32 x y) x)
 22949  	// cond:
 22950  	// result: (Or32 x y)
 22951  	for {
 22952  		_ = v.Args[1]
 22953  		v_0 := v.Args[0]
 22954  		if v_0.Op != OpOr32 {
 22955  			break
 22956  		}
 22957  		_ = v_0.Args[1]
 22958  		x := v_0.Args[0]
 22959  		y := v_0.Args[1]
 22960  		if x != v.Args[1] {
 22961  			break
 22962  		}
 22963  		v.reset(OpOr32)
 22964  		v.AddArg(x)
 22965  		v.AddArg(y)
 22966  		return true
 22967  	}
 22968  	return false
 22969  }
 22970  func rewriteValuegeneric_OpOr32_10(v *Value) bool {
 22971  	b := v.Block
 22972  	_ = b
 22973  	// match: (Or32 (Or32 y x) x)
 22974  	// cond:
 22975  	// result: (Or32 x y)
 22976  	for {
 22977  		_ = v.Args[1]
 22978  		v_0 := v.Args[0]
 22979  		if v_0.Op != OpOr32 {
 22980  			break
 22981  		}
 22982  		_ = v_0.Args[1]
 22983  		y := v_0.Args[0]
 22984  		x := v_0.Args[1]
 22985  		if x != v.Args[1] {
 22986  			break
 22987  		}
 22988  		v.reset(OpOr32)
 22989  		v.AddArg(x)
 22990  		v.AddArg(y)
 22991  		return true
 22992  	}
 22993  	// match: (Or32 (And32 x (Const32 [c2])) (Const32 <t> [c1]))
 22994  	// cond: ^(c1 | c2) == 0
 22995  	// result: (Or32 (Const32 <t> [c1]) x)
 22996  	for {
 22997  		_ = v.Args[1]
 22998  		v_0 := v.Args[0]
 22999  		if v_0.Op != OpAnd32 {
 23000  			break
 23001  		}
 23002  		_ = v_0.Args[1]
 23003  		x := v_0.Args[0]
 23004  		v_0_1 := v_0.Args[1]
 23005  		if v_0_1.Op != OpConst32 {
 23006  			break
 23007  		}
 23008  		c2 := v_0_1.AuxInt
 23009  		v_1 := v.Args[1]
 23010  		if v_1.Op != OpConst32 {
 23011  			break
 23012  		}
 23013  		t := v_1.Type
 23014  		c1 := v_1.AuxInt
 23015  		if !(^(c1 | c2) == 0) {
 23016  			break
 23017  		}
 23018  		v.reset(OpOr32)
 23019  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23020  		v0.AuxInt = c1
 23021  		v.AddArg(v0)
 23022  		v.AddArg(x)
 23023  		return true
 23024  	}
 23025  	// match: (Or32 (And32 (Const32 [c2]) x) (Const32 <t> [c1]))
 23026  	// cond: ^(c1 | c2) == 0
 23027  	// result: (Or32 (Const32 <t> [c1]) x)
 23028  	for {
 23029  		_ = v.Args[1]
 23030  		v_0 := v.Args[0]
 23031  		if v_0.Op != OpAnd32 {
 23032  			break
 23033  		}
 23034  		_ = v_0.Args[1]
 23035  		v_0_0 := v_0.Args[0]
 23036  		if v_0_0.Op != OpConst32 {
 23037  			break
 23038  		}
 23039  		c2 := v_0_0.AuxInt
 23040  		x := v_0.Args[1]
 23041  		v_1 := v.Args[1]
 23042  		if v_1.Op != OpConst32 {
 23043  			break
 23044  		}
 23045  		t := v_1.Type
 23046  		c1 := v_1.AuxInt
 23047  		if !(^(c1 | c2) == 0) {
 23048  			break
 23049  		}
 23050  		v.reset(OpOr32)
 23051  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23052  		v0.AuxInt = c1
 23053  		v.AddArg(v0)
 23054  		v.AddArg(x)
 23055  		return true
 23056  	}
 23057  	// match: (Or32 (Const32 <t> [c1]) (And32 x (Const32 [c2])))
 23058  	// cond: ^(c1 | c2) == 0
 23059  	// result: (Or32 (Const32 <t> [c1]) x)
 23060  	for {
 23061  		_ = v.Args[1]
 23062  		v_0 := v.Args[0]
 23063  		if v_0.Op != OpConst32 {
 23064  			break
 23065  		}
 23066  		t := v_0.Type
 23067  		c1 := v_0.AuxInt
 23068  		v_1 := v.Args[1]
 23069  		if v_1.Op != OpAnd32 {
 23070  			break
 23071  		}
 23072  		_ = v_1.Args[1]
 23073  		x := v_1.Args[0]
 23074  		v_1_1 := v_1.Args[1]
 23075  		if v_1_1.Op != OpConst32 {
 23076  			break
 23077  		}
 23078  		c2 := v_1_1.AuxInt
 23079  		if !(^(c1 | c2) == 0) {
 23080  			break
 23081  		}
 23082  		v.reset(OpOr32)
 23083  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23084  		v0.AuxInt = c1
 23085  		v.AddArg(v0)
 23086  		v.AddArg(x)
 23087  		return true
 23088  	}
 23089  	// match: (Or32 (Const32 <t> [c1]) (And32 (Const32 [c2]) x))
 23090  	// cond: ^(c1 | c2) == 0
 23091  	// result: (Or32 (Const32 <t> [c1]) x)
 23092  	for {
 23093  		_ = v.Args[1]
 23094  		v_0 := v.Args[0]
 23095  		if v_0.Op != OpConst32 {
 23096  			break
 23097  		}
 23098  		t := v_0.Type
 23099  		c1 := v_0.AuxInt
 23100  		v_1 := v.Args[1]
 23101  		if v_1.Op != OpAnd32 {
 23102  			break
 23103  		}
 23104  		_ = v_1.Args[1]
 23105  		v_1_0 := v_1.Args[0]
 23106  		if v_1_0.Op != OpConst32 {
 23107  			break
 23108  		}
 23109  		c2 := v_1_0.AuxInt
 23110  		x := v_1.Args[1]
 23111  		if !(^(c1 | c2) == 0) {
 23112  			break
 23113  		}
 23114  		v.reset(OpOr32)
 23115  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23116  		v0.AuxInt = c1
 23117  		v.AddArg(v0)
 23118  		v.AddArg(x)
 23119  		return true
 23120  	}
 23121  	// match: (Or32 (Or32 i:(Const32 <t>) z) x)
 23122  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 23123  	// result: (Or32 i (Or32 <t> z x))
 23124  	for {
 23125  		_ = v.Args[1]
 23126  		v_0 := v.Args[0]
 23127  		if v_0.Op != OpOr32 {
 23128  			break
 23129  		}
 23130  		_ = v_0.Args[1]
 23131  		i := v_0.Args[0]
 23132  		if i.Op != OpConst32 {
 23133  			break
 23134  		}
 23135  		t := i.Type
 23136  		z := v_0.Args[1]
 23137  		x := v.Args[1]
 23138  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 23139  			break
 23140  		}
 23141  		v.reset(OpOr32)
 23142  		v.AddArg(i)
 23143  		v0 := b.NewValue0(v.Pos, OpOr32, t)
 23144  		v0.AddArg(z)
 23145  		v0.AddArg(x)
 23146  		v.AddArg(v0)
 23147  		return true
 23148  	}
 23149  	// match: (Or32 (Or32 z i:(Const32 <t>)) x)
 23150  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 23151  	// result: (Or32 i (Or32 <t> z x))
 23152  	for {
 23153  		_ = v.Args[1]
 23154  		v_0 := v.Args[0]
 23155  		if v_0.Op != OpOr32 {
 23156  			break
 23157  		}
 23158  		_ = v_0.Args[1]
 23159  		z := v_0.Args[0]
 23160  		i := v_0.Args[1]
 23161  		if i.Op != OpConst32 {
 23162  			break
 23163  		}
 23164  		t := i.Type
 23165  		x := v.Args[1]
 23166  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 23167  			break
 23168  		}
 23169  		v.reset(OpOr32)
 23170  		v.AddArg(i)
 23171  		v0 := b.NewValue0(v.Pos, OpOr32, t)
 23172  		v0.AddArg(z)
 23173  		v0.AddArg(x)
 23174  		v.AddArg(v0)
 23175  		return true
 23176  	}
 23177  	// match: (Or32 x (Or32 i:(Const32 <t>) z))
 23178  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 23179  	// result: (Or32 i (Or32 <t> z x))
 23180  	for {
 23181  		_ = v.Args[1]
 23182  		x := v.Args[0]
 23183  		v_1 := v.Args[1]
 23184  		if v_1.Op != OpOr32 {
 23185  			break
 23186  		}
 23187  		_ = v_1.Args[1]
 23188  		i := v_1.Args[0]
 23189  		if i.Op != OpConst32 {
 23190  			break
 23191  		}
 23192  		t := i.Type
 23193  		z := v_1.Args[1]
 23194  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 23195  			break
 23196  		}
 23197  		v.reset(OpOr32)
 23198  		v.AddArg(i)
 23199  		v0 := b.NewValue0(v.Pos, OpOr32, t)
 23200  		v0.AddArg(z)
 23201  		v0.AddArg(x)
 23202  		v.AddArg(v0)
 23203  		return true
 23204  	}
 23205  	// match: (Or32 x (Or32 z i:(Const32 <t>)))
 23206  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 23207  	// result: (Or32 i (Or32 <t> z x))
 23208  	for {
 23209  		_ = v.Args[1]
 23210  		x := v.Args[0]
 23211  		v_1 := v.Args[1]
 23212  		if v_1.Op != OpOr32 {
 23213  			break
 23214  		}
 23215  		_ = v_1.Args[1]
 23216  		z := v_1.Args[0]
 23217  		i := v_1.Args[1]
 23218  		if i.Op != OpConst32 {
 23219  			break
 23220  		}
 23221  		t := i.Type
 23222  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 23223  			break
 23224  		}
 23225  		v.reset(OpOr32)
 23226  		v.AddArg(i)
 23227  		v0 := b.NewValue0(v.Pos, OpOr32, t)
 23228  		v0.AddArg(z)
 23229  		v0.AddArg(x)
 23230  		v.AddArg(v0)
 23231  		return true
 23232  	}
 23233  	// match: (Or32 (Const32 <t> [c]) (Or32 (Const32 <t> [d]) x))
 23234  	// cond:
 23235  	// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 23236  	for {
 23237  		_ = v.Args[1]
 23238  		v_0 := v.Args[0]
 23239  		if v_0.Op != OpConst32 {
 23240  			break
 23241  		}
 23242  		t := v_0.Type
 23243  		c := v_0.AuxInt
 23244  		v_1 := v.Args[1]
 23245  		if v_1.Op != OpOr32 {
 23246  			break
 23247  		}
 23248  		_ = v_1.Args[1]
 23249  		v_1_0 := v_1.Args[0]
 23250  		if v_1_0.Op != OpConst32 {
 23251  			break
 23252  		}
 23253  		if v_1_0.Type != t {
 23254  			break
 23255  		}
 23256  		d := v_1_0.AuxInt
 23257  		x := v_1.Args[1]
 23258  		v.reset(OpOr32)
 23259  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23260  		v0.AuxInt = int64(int32(c | d))
 23261  		v.AddArg(v0)
 23262  		v.AddArg(x)
 23263  		return true
 23264  	}
 23265  	return false
 23266  }
 23267  func rewriteValuegeneric_OpOr32_20(v *Value) bool {
 23268  	b := v.Block
 23269  	_ = b
 23270  	// match: (Or32 (Const32 <t> [c]) (Or32 x (Const32 <t> [d])))
 23271  	// cond:
 23272  	// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 23273  	for {
 23274  		_ = v.Args[1]
 23275  		v_0 := v.Args[0]
 23276  		if v_0.Op != OpConst32 {
 23277  			break
 23278  		}
 23279  		t := v_0.Type
 23280  		c := v_0.AuxInt
 23281  		v_1 := v.Args[1]
 23282  		if v_1.Op != OpOr32 {
 23283  			break
 23284  		}
 23285  		_ = v_1.Args[1]
 23286  		x := v_1.Args[0]
 23287  		v_1_1 := v_1.Args[1]
 23288  		if v_1_1.Op != OpConst32 {
 23289  			break
 23290  		}
 23291  		if v_1_1.Type != t {
 23292  			break
 23293  		}
 23294  		d := v_1_1.AuxInt
 23295  		v.reset(OpOr32)
 23296  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23297  		v0.AuxInt = int64(int32(c | d))
 23298  		v.AddArg(v0)
 23299  		v.AddArg(x)
 23300  		return true
 23301  	}
 23302  	// match: (Or32 (Or32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 23303  	// cond:
 23304  	// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 23305  	for {
 23306  		_ = v.Args[1]
 23307  		v_0 := v.Args[0]
 23308  		if v_0.Op != OpOr32 {
 23309  			break
 23310  		}
 23311  		_ = v_0.Args[1]
 23312  		v_0_0 := v_0.Args[0]
 23313  		if v_0_0.Op != OpConst32 {
 23314  			break
 23315  		}
 23316  		t := v_0_0.Type
 23317  		d := v_0_0.AuxInt
 23318  		x := v_0.Args[1]
 23319  		v_1 := v.Args[1]
 23320  		if v_1.Op != OpConst32 {
 23321  			break
 23322  		}
 23323  		if v_1.Type != t {
 23324  			break
 23325  		}
 23326  		c := v_1.AuxInt
 23327  		v.reset(OpOr32)
 23328  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23329  		v0.AuxInt = int64(int32(c | d))
 23330  		v.AddArg(v0)
 23331  		v.AddArg(x)
 23332  		return true
 23333  	}
 23334  	// match: (Or32 (Or32 x (Const32 <t> [d])) (Const32 <t> [c]))
 23335  	// cond:
 23336  	// result: (Or32 (Const32 <t> [int64(int32(c|d))]) x)
 23337  	for {
 23338  		_ = v.Args[1]
 23339  		v_0 := v.Args[0]
 23340  		if v_0.Op != OpOr32 {
 23341  			break
 23342  		}
 23343  		_ = v_0.Args[1]
 23344  		x := v_0.Args[0]
 23345  		v_0_1 := v_0.Args[1]
 23346  		if v_0_1.Op != OpConst32 {
 23347  			break
 23348  		}
 23349  		t := v_0_1.Type
 23350  		d := v_0_1.AuxInt
 23351  		v_1 := v.Args[1]
 23352  		if v_1.Op != OpConst32 {
 23353  			break
 23354  		}
 23355  		if v_1.Type != t {
 23356  			break
 23357  		}
 23358  		c := v_1.AuxInt
 23359  		v.reset(OpOr32)
 23360  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 23361  		v0.AuxInt = int64(int32(c | d))
 23362  		v.AddArg(v0)
 23363  		v.AddArg(x)
 23364  		return true
 23365  	}
 23366  	return false
 23367  }
 23368  func rewriteValuegeneric_OpOr64_0(v *Value) bool {
 23369  	// match: (Or64 (Const64 [c]) (Const64 [d]))
 23370  	// cond:
 23371  	// result: (Const64 [c|d])
 23372  	for {
 23373  		_ = v.Args[1]
 23374  		v_0 := v.Args[0]
 23375  		if v_0.Op != OpConst64 {
 23376  			break
 23377  		}
 23378  		c := v_0.AuxInt
 23379  		v_1 := v.Args[1]
 23380  		if v_1.Op != OpConst64 {
 23381  			break
 23382  		}
 23383  		d := v_1.AuxInt
 23384  		v.reset(OpConst64)
 23385  		v.AuxInt = c | d
 23386  		return true
 23387  	}
 23388  	// match: (Or64 (Const64 [d]) (Const64 [c]))
 23389  	// cond:
 23390  	// result: (Const64 [c|d])
 23391  	for {
 23392  		_ = v.Args[1]
 23393  		v_0 := v.Args[0]
 23394  		if v_0.Op != OpConst64 {
 23395  			break
 23396  		}
 23397  		d := v_0.AuxInt
 23398  		v_1 := v.Args[1]
 23399  		if v_1.Op != OpConst64 {
 23400  			break
 23401  		}
 23402  		c := v_1.AuxInt
 23403  		v.reset(OpConst64)
 23404  		v.AuxInt = c | d
 23405  		return true
 23406  	}
 23407  	// match: (Or64 x x)
 23408  	// cond:
 23409  	// result: x
 23410  	for {
 23411  		_ = v.Args[1]
 23412  		x := v.Args[0]
 23413  		if x != v.Args[1] {
 23414  			break
 23415  		}
 23416  		v.reset(OpCopy)
 23417  		v.Type = x.Type
 23418  		v.AddArg(x)
 23419  		return true
 23420  	}
 23421  	// match: (Or64 (Const64 [0]) x)
 23422  	// cond:
 23423  	// result: x
 23424  	for {
 23425  		_ = v.Args[1]
 23426  		v_0 := v.Args[0]
 23427  		if v_0.Op != OpConst64 {
 23428  			break
 23429  		}
 23430  		if v_0.AuxInt != 0 {
 23431  			break
 23432  		}
 23433  		x := v.Args[1]
 23434  		v.reset(OpCopy)
 23435  		v.Type = x.Type
 23436  		v.AddArg(x)
 23437  		return true
 23438  	}
 23439  	// match: (Or64 x (Const64 [0]))
 23440  	// cond:
 23441  	// result: x
 23442  	for {
 23443  		_ = v.Args[1]
 23444  		x := v.Args[0]
 23445  		v_1 := v.Args[1]
 23446  		if v_1.Op != OpConst64 {
 23447  			break
 23448  		}
 23449  		if v_1.AuxInt != 0 {
 23450  			break
 23451  		}
 23452  		v.reset(OpCopy)
 23453  		v.Type = x.Type
 23454  		v.AddArg(x)
 23455  		return true
 23456  	}
 23457  	// match: (Or64 (Const64 [-1]) _)
 23458  	// cond:
 23459  	// result: (Const64 [-1])
 23460  	for {
 23461  		_ = v.Args[1]
 23462  		v_0 := v.Args[0]
 23463  		if v_0.Op != OpConst64 {
 23464  			break
 23465  		}
 23466  		if v_0.AuxInt != -1 {
 23467  			break
 23468  		}
 23469  		v.reset(OpConst64)
 23470  		v.AuxInt = -1
 23471  		return true
 23472  	}
 23473  	// match: (Or64 _ (Const64 [-1]))
 23474  	// cond:
 23475  	// result: (Const64 [-1])
 23476  	for {
 23477  		_ = v.Args[1]
 23478  		v_1 := v.Args[1]
 23479  		if v_1.Op != OpConst64 {
 23480  			break
 23481  		}
 23482  		if v_1.AuxInt != -1 {
 23483  			break
 23484  		}
 23485  		v.reset(OpConst64)
 23486  		v.AuxInt = -1
 23487  		return true
 23488  	}
 23489  	// match: (Or64 x (Or64 x y))
 23490  	// cond:
 23491  	// result: (Or64 x y)
 23492  	for {
 23493  		_ = v.Args[1]
 23494  		x := v.Args[0]
 23495  		v_1 := v.Args[1]
 23496  		if v_1.Op != OpOr64 {
 23497  			break
 23498  		}
 23499  		_ = v_1.Args[1]
 23500  		if x != v_1.Args[0] {
 23501  			break
 23502  		}
 23503  		y := v_1.Args[1]
 23504  		v.reset(OpOr64)
 23505  		v.AddArg(x)
 23506  		v.AddArg(y)
 23507  		return true
 23508  	}
 23509  	// match: (Or64 x (Or64 y x))
 23510  	// cond:
 23511  	// result: (Or64 x y)
 23512  	for {
 23513  		_ = v.Args[1]
 23514  		x := v.Args[0]
 23515  		v_1 := v.Args[1]
 23516  		if v_1.Op != OpOr64 {
 23517  			break
 23518  		}
 23519  		_ = v_1.Args[1]
 23520  		y := v_1.Args[0]
 23521  		if x != v_1.Args[1] {
 23522  			break
 23523  		}
 23524  		v.reset(OpOr64)
 23525  		v.AddArg(x)
 23526  		v.AddArg(y)
 23527  		return true
 23528  	}
 23529  	// match: (Or64 (Or64 x y) x)
 23530  	// cond:
 23531  	// result: (Or64 x y)
 23532  	for {
 23533  		_ = v.Args[1]
 23534  		v_0 := v.Args[0]
 23535  		if v_0.Op != OpOr64 {
 23536  			break
 23537  		}
 23538  		_ = v_0.Args[1]
 23539  		x := v_0.Args[0]
 23540  		y := v_0.Args[1]
 23541  		if x != v.Args[1] {
 23542  			break
 23543  		}
 23544  		v.reset(OpOr64)
 23545  		v.AddArg(x)
 23546  		v.AddArg(y)
 23547  		return true
 23548  	}
 23549  	return false
 23550  }
 23551  func rewriteValuegeneric_OpOr64_10(v *Value) bool {
 23552  	b := v.Block
 23553  	_ = b
 23554  	// match: (Or64 (Or64 y x) x)
 23555  	// cond:
 23556  	// result: (Or64 x y)
 23557  	for {
 23558  		_ = v.Args[1]
 23559  		v_0 := v.Args[0]
 23560  		if v_0.Op != OpOr64 {
 23561  			break
 23562  		}
 23563  		_ = v_0.Args[1]
 23564  		y := v_0.Args[0]
 23565  		x := v_0.Args[1]
 23566  		if x != v.Args[1] {
 23567  			break
 23568  		}
 23569  		v.reset(OpOr64)
 23570  		v.AddArg(x)
 23571  		v.AddArg(y)
 23572  		return true
 23573  	}
 23574  	// match: (Or64 (And64 x (Const64 [c2])) (Const64 <t> [c1]))
 23575  	// cond: ^(c1 | c2) == 0
 23576  	// result: (Or64 (Const64 <t> [c1]) x)
 23577  	for {
 23578  		_ = v.Args[1]
 23579  		v_0 := v.Args[0]
 23580  		if v_0.Op != OpAnd64 {
 23581  			break
 23582  		}
 23583  		_ = v_0.Args[1]
 23584  		x := v_0.Args[0]
 23585  		v_0_1 := v_0.Args[1]
 23586  		if v_0_1.Op != OpConst64 {
 23587  			break
 23588  		}
 23589  		c2 := v_0_1.AuxInt
 23590  		v_1 := v.Args[1]
 23591  		if v_1.Op != OpConst64 {
 23592  			break
 23593  		}
 23594  		t := v_1.Type
 23595  		c1 := v_1.AuxInt
 23596  		if !(^(c1 | c2) == 0) {
 23597  			break
 23598  		}
 23599  		v.reset(OpOr64)
 23600  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23601  		v0.AuxInt = c1
 23602  		v.AddArg(v0)
 23603  		v.AddArg(x)
 23604  		return true
 23605  	}
 23606  	// match: (Or64 (And64 (Const64 [c2]) x) (Const64 <t> [c1]))
 23607  	// cond: ^(c1 | c2) == 0
 23608  	// result: (Or64 (Const64 <t> [c1]) x)
 23609  	for {
 23610  		_ = v.Args[1]
 23611  		v_0 := v.Args[0]
 23612  		if v_0.Op != OpAnd64 {
 23613  			break
 23614  		}
 23615  		_ = v_0.Args[1]
 23616  		v_0_0 := v_0.Args[0]
 23617  		if v_0_0.Op != OpConst64 {
 23618  			break
 23619  		}
 23620  		c2 := v_0_0.AuxInt
 23621  		x := v_0.Args[1]
 23622  		v_1 := v.Args[1]
 23623  		if v_1.Op != OpConst64 {
 23624  			break
 23625  		}
 23626  		t := v_1.Type
 23627  		c1 := v_1.AuxInt
 23628  		if !(^(c1 | c2) == 0) {
 23629  			break
 23630  		}
 23631  		v.reset(OpOr64)
 23632  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23633  		v0.AuxInt = c1
 23634  		v.AddArg(v0)
 23635  		v.AddArg(x)
 23636  		return true
 23637  	}
 23638  	// match: (Or64 (Const64 <t> [c1]) (And64 x (Const64 [c2])))
 23639  	// cond: ^(c1 | c2) == 0
 23640  	// result: (Or64 (Const64 <t> [c1]) x)
 23641  	for {
 23642  		_ = v.Args[1]
 23643  		v_0 := v.Args[0]
 23644  		if v_0.Op != OpConst64 {
 23645  			break
 23646  		}
 23647  		t := v_0.Type
 23648  		c1 := v_0.AuxInt
 23649  		v_1 := v.Args[1]
 23650  		if v_1.Op != OpAnd64 {
 23651  			break
 23652  		}
 23653  		_ = v_1.Args[1]
 23654  		x := v_1.Args[0]
 23655  		v_1_1 := v_1.Args[1]
 23656  		if v_1_1.Op != OpConst64 {
 23657  			break
 23658  		}
 23659  		c2 := v_1_1.AuxInt
 23660  		if !(^(c1 | c2) == 0) {
 23661  			break
 23662  		}
 23663  		v.reset(OpOr64)
 23664  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23665  		v0.AuxInt = c1
 23666  		v.AddArg(v0)
 23667  		v.AddArg(x)
 23668  		return true
 23669  	}
 23670  	// match: (Or64 (Const64 <t> [c1]) (And64 (Const64 [c2]) x))
 23671  	// cond: ^(c1 | c2) == 0
 23672  	// result: (Or64 (Const64 <t> [c1]) x)
 23673  	for {
 23674  		_ = v.Args[1]
 23675  		v_0 := v.Args[0]
 23676  		if v_0.Op != OpConst64 {
 23677  			break
 23678  		}
 23679  		t := v_0.Type
 23680  		c1 := v_0.AuxInt
 23681  		v_1 := v.Args[1]
 23682  		if v_1.Op != OpAnd64 {
 23683  			break
 23684  		}
 23685  		_ = v_1.Args[1]
 23686  		v_1_0 := v_1.Args[0]
 23687  		if v_1_0.Op != OpConst64 {
 23688  			break
 23689  		}
 23690  		c2 := v_1_0.AuxInt
 23691  		x := v_1.Args[1]
 23692  		if !(^(c1 | c2) == 0) {
 23693  			break
 23694  		}
 23695  		v.reset(OpOr64)
 23696  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23697  		v0.AuxInt = c1
 23698  		v.AddArg(v0)
 23699  		v.AddArg(x)
 23700  		return true
 23701  	}
 23702  	// match: (Or64 (Or64 i:(Const64 <t>) z) x)
 23703  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 23704  	// result: (Or64 i (Or64 <t> z x))
 23705  	for {
 23706  		_ = v.Args[1]
 23707  		v_0 := v.Args[0]
 23708  		if v_0.Op != OpOr64 {
 23709  			break
 23710  		}
 23711  		_ = v_0.Args[1]
 23712  		i := v_0.Args[0]
 23713  		if i.Op != OpConst64 {
 23714  			break
 23715  		}
 23716  		t := i.Type
 23717  		z := v_0.Args[1]
 23718  		x := v.Args[1]
 23719  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 23720  			break
 23721  		}
 23722  		v.reset(OpOr64)
 23723  		v.AddArg(i)
 23724  		v0 := b.NewValue0(v.Pos, OpOr64, t)
 23725  		v0.AddArg(z)
 23726  		v0.AddArg(x)
 23727  		v.AddArg(v0)
 23728  		return true
 23729  	}
 23730  	// match: (Or64 (Or64 z i:(Const64 <t>)) x)
 23731  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 23732  	// result: (Or64 i (Or64 <t> z x))
 23733  	for {
 23734  		_ = v.Args[1]
 23735  		v_0 := v.Args[0]
 23736  		if v_0.Op != OpOr64 {
 23737  			break
 23738  		}
 23739  		_ = v_0.Args[1]
 23740  		z := v_0.Args[0]
 23741  		i := v_0.Args[1]
 23742  		if i.Op != OpConst64 {
 23743  			break
 23744  		}
 23745  		t := i.Type
 23746  		x := v.Args[1]
 23747  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 23748  			break
 23749  		}
 23750  		v.reset(OpOr64)
 23751  		v.AddArg(i)
 23752  		v0 := b.NewValue0(v.Pos, OpOr64, t)
 23753  		v0.AddArg(z)
 23754  		v0.AddArg(x)
 23755  		v.AddArg(v0)
 23756  		return true
 23757  	}
 23758  	// match: (Or64 x (Or64 i:(Const64 <t>) z))
 23759  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 23760  	// result: (Or64 i (Or64 <t> z x))
 23761  	for {
 23762  		_ = v.Args[1]
 23763  		x := v.Args[0]
 23764  		v_1 := v.Args[1]
 23765  		if v_1.Op != OpOr64 {
 23766  			break
 23767  		}
 23768  		_ = v_1.Args[1]
 23769  		i := v_1.Args[0]
 23770  		if i.Op != OpConst64 {
 23771  			break
 23772  		}
 23773  		t := i.Type
 23774  		z := v_1.Args[1]
 23775  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 23776  			break
 23777  		}
 23778  		v.reset(OpOr64)
 23779  		v.AddArg(i)
 23780  		v0 := b.NewValue0(v.Pos, OpOr64, t)
 23781  		v0.AddArg(z)
 23782  		v0.AddArg(x)
 23783  		v.AddArg(v0)
 23784  		return true
 23785  	}
 23786  	// match: (Or64 x (Or64 z i:(Const64 <t>)))
 23787  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 23788  	// result: (Or64 i (Or64 <t> z x))
 23789  	for {
 23790  		_ = v.Args[1]
 23791  		x := v.Args[0]
 23792  		v_1 := v.Args[1]
 23793  		if v_1.Op != OpOr64 {
 23794  			break
 23795  		}
 23796  		_ = v_1.Args[1]
 23797  		z := v_1.Args[0]
 23798  		i := v_1.Args[1]
 23799  		if i.Op != OpConst64 {
 23800  			break
 23801  		}
 23802  		t := i.Type
 23803  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 23804  			break
 23805  		}
 23806  		v.reset(OpOr64)
 23807  		v.AddArg(i)
 23808  		v0 := b.NewValue0(v.Pos, OpOr64, t)
 23809  		v0.AddArg(z)
 23810  		v0.AddArg(x)
 23811  		v.AddArg(v0)
 23812  		return true
 23813  	}
 23814  	// match: (Or64 (Const64 <t> [c]) (Or64 (Const64 <t> [d]) x))
 23815  	// cond:
 23816  	// result: (Or64 (Const64 <t> [c|d]) x)
 23817  	for {
 23818  		_ = v.Args[1]
 23819  		v_0 := v.Args[0]
 23820  		if v_0.Op != OpConst64 {
 23821  			break
 23822  		}
 23823  		t := v_0.Type
 23824  		c := v_0.AuxInt
 23825  		v_1 := v.Args[1]
 23826  		if v_1.Op != OpOr64 {
 23827  			break
 23828  		}
 23829  		_ = v_1.Args[1]
 23830  		v_1_0 := v_1.Args[0]
 23831  		if v_1_0.Op != OpConst64 {
 23832  			break
 23833  		}
 23834  		if v_1_0.Type != t {
 23835  			break
 23836  		}
 23837  		d := v_1_0.AuxInt
 23838  		x := v_1.Args[1]
 23839  		v.reset(OpOr64)
 23840  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23841  		v0.AuxInt = c | d
 23842  		v.AddArg(v0)
 23843  		v.AddArg(x)
 23844  		return true
 23845  	}
 23846  	return false
 23847  }
 23848  func rewriteValuegeneric_OpOr64_20(v *Value) bool {
 23849  	b := v.Block
 23850  	_ = b
 23851  	// match: (Or64 (Const64 <t> [c]) (Or64 x (Const64 <t> [d])))
 23852  	// cond:
 23853  	// result: (Or64 (Const64 <t> [c|d]) x)
 23854  	for {
 23855  		_ = v.Args[1]
 23856  		v_0 := v.Args[0]
 23857  		if v_0.Op != OpConst64 {
 23858  			break
 23859  		}
 23860  		t := v_0.Type
 23861  		c := v_0.AuxInt
 23862  		v_1 := v.Args[1]
 23863  		if v_1.Op != OpOr64 {
 23864  			break
 23865  		}
 23866  		_ = v_1.Args[1]
 23867  		x := v_1.Args[0]
 23868  		v_1_1 := v_1.Args[1]
 23869  		if v_1_1.Op != OpConst64 {
 23870  			break
 23871  		}
 23872  		if v_1_1.Type != t {
 23873  			break
 23874  		}
 23875  		d := v_1_1.AuxInt
 23876  		v.reset(OpOr64)
 23877  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23878  		v0.AuxInt = c | d
 23879  		v.AddArg(v0)
 23880  		v.AddArg(x)
 23881  		return true
 23882  	}
 23883  	// match: (Or64 (Or64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 23884  	// cond:
 23885  	// result: (Or64 (Const64 <t> [c|d]) x)
 23886  	for {
 23887  		_ = v.Args[1]
 23888  		v_0 := v.Args[0]
 23889  		if v_0.Op != OpOr64 {
 23890  			break
 23891  		}
 23892  		_ = v_0.Args[1]
 23893  		v_0_0 := v_0.Args[0]
 23894  		if v_0_0.Op != OpConst64 {
 23895  			break
 23896  		}
 23897  		t := v_0_0.Type
 23898  		d := v_0_0.AuxInt
 23899  		x := v_0.Args[1]
 23900  		v_1 := v.Args[1]
 23901  		if v_1.Op != OpConst64 {
 23902  			break
 23903  		}
 23904  		if v_1.Type != t {
 23905  			break
 23906  		}
 23907  		c := v_1.AuxInt
 23908  		v.reset(OpOr64)
 23909  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23910  		v0.AuxInt = c | d
 23911  		v.AddArg(v0)
 23912  		v.AddArg(x)
 23913  		return true
 23914  	}
 23915  	// match: (Or64 (Or64 x (Const64 <t> [d])) (Const64 <t> [c]))
 23916  	// cond:
 23917  	// result: (Or64 (Const64 <t> [c|d]) x)
 23918  	for {
 23919  		_ = v.Args[1]
 23920  		v_0 := v.Args[0]
 23921  		if v_0.Op != OpOr64 {
 23922  			break
 23923  		}
 23924  		_ = v_0.Args[1]
 23925  		x := v_0.Args[0]
 23926  		v_0_1 := v_0.Args[1]
 23927  		if v_0_1.Op != OpConst64 {
 23928  			break
 23929  		}
 23930  		t := v_0_1.Type
 23931  		d := v_0_1.AuxInt
 23932  		v_1 := v.Args[1]
 23933  		if v_1.Op != OpConst64 {
 23934  			break
 23935  		}
 23936  		if v_1.Type != t {
 23937  			break
 23938  		}
 23939  		c := v_1.AuxInt
 23940  		v.reset(OpOr64)
 23941  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 23942  		v0.AuxInt = c | d
 23943  		v.AddArg(v0)
 23944  		v.AddArg(x)
 23945  		return true
 23946  	}
 23947  	return false
 23948  }
 23949  func rewriteValuegeneric_OpOr8_0(v *Value) bool {
 23950  	// match: (Or8 (Const8 [c]) (Const8 [d]))
 23951  	// cond:
 23952  	// result: (Const8 [int64(int8(c|d))])
 23953  	for {
 23954  		_ = v.Args[1]
 23955  		v_0 := v.Args[0]
 23956  		if v_0.Op != OpConst8 {
 23957  			break
 23958  		}
 23959  		c := v_0.AuxInt
 23960  		v_1 := v.Args[1]
 23961  		if v_1.Op != OpConst8 {
 23962  			break
 23963  		}
 23964  		d := v_1.AuxInt
 23965  		v.reset(OpConst8)
 23966  		v.AuxInt = int64(int8(c | d))
 23967  		return true
 23968  	}
 23969  	// match: (Or8 (Const8 [d]) (Const8 [c]))
 23970  	// cond:
 23971  	// result: (Const8 [int64(int8(c|d))])
 23972  	for {
 23973  		_ = v.Args[1]
 23974  		v_0 := v.Args[0]
 23975  		if v_0.Op != OpConst8 {
 23976  			break
 23977  		}
 23978  		d := v_0.AuxInt
 23979  		v_1 := v.Args[1]
 23980  		if v_1.Op != OpConst8 {
 23981  			break
 23982  		}
 23983  		c := v_1.AuxInt
 23984  		v.reset(OpConst8)
 23985  		v.AuxInt = int64(int8(c | d))
 23986  		return true
 23987  	}
 23988  	// match: (Or8 x x)
 23989  	// cond:
 23990  	// result: x
 23991  	for {
 23992  		_ = v.Args[1]
 23993  		x := v.Args[0]
 23994  		if x != v.Args[1] {
 23995  			break
 23996  		}
 23997  		v.reset(OpCopy)
 23998  		v.Type = x.Type
 23999  		v.AddArg(x)
 24000  		return true
 24001  	}
 24002  	// match: (Or8 (Const8 [0]) x)
 24003  	// cond:
 24004  	// result: x
 24005  	for {
 24006  		_ = v.Args[1]
 24007  		v_0 := v.Args[0]
 24008  		if v_0.Op != OpConst8 {
 24009  			break
 24010  		}
 24011  		if v_0.AuxInt != 0 {
 24012  			break
 24013  		}
 24014  		x := v.Args[1]
 24015  		v.reset(OpCopy)
 24016  		v.Type = x.Type
 24017  		v.AddArg(x)
 24018  		return true
 24019  	}
 24020  	// match: (Or8 x (Const8 [0]))
 24021  	// cond:
 24022  	// result: x
 24023  	for {
 24024  		_ = v.Args[1]
 24025  		x := v.Args[0]
 24026  		v_1 := v.Args[1]
 24027  		if v_1.Op != OpConst8 {
 24028  			break
 24029  		}
 24030  		if v_1.AuxInt != 0 {
 24031  			break
 24032  		}
 24033  		v.reset(OpCopy)
 24034  		v.Type = x.Type
 24035  		v.AddArg(x)
 24036  		return true
 24037  	}
 24038  	// match: (Or8 (Const8 [-1]) _)
 24039  	// cond:
 24040  	// result: (Const8 [-1])
 24041  	for {
 24042  		_ = v.Args[1]
 24043  		v_0 := v.Args[0]
 24044  		if v_0.Op != OpConst8 {
 24045  			break
 24046  		}
 24047  		if v_0.AuxInt != -1 {
 24048  			break
 24049  		}
 24050  		v.reset(OpConst8)
 24051  		v.AuxInt = -1
 24052  		return true
 24053  	}
 24054  	// match: (Or8 _ (Const8 [-1]))
 24055  	// cond:
 24056  	// result: (Const8 [-1])
 24057  	for {
 24058  		_ = v.Args[1]
 24059  		v_1 := v.Args[1]
 24060  		if v_1.Op != OpConst8 {
 24061  			break
 24062  		}
 24063  		if v_1.AuxInt != -1 {
 24064  			break
 24065  		}
 24066  		v.reset(OpConst8)
 24067  		v.AuxInt = -1
 24068  		return true
 24069  	}
 24070  	// match: (Or8 x (Or8 x y))
 24071  	// cond:
 24072  	// result: (Or8 x y)
 24073  	for {
 24074  		_ = v.Args[1]
 24075  		x := v.Args[0]
 24076  		v_1 := v.Args[1]
 24077  		if v_1.Op != OpOr8 {
 24078  			break
 24079  		}
 24080  		_ = v_1.Args[1]
 24081  		if x != v_1.Args[0] {
 24082  			break
 24083  		}
 24084  		y := v_1.Args[1]
 24085  		v.reset(OpOr8)
 24086  		v.AddArg(x)
 24087  		v.AddArg(y)
 24088  		return true
 24089  	}
 24090  	// match: (Or8 x (Or8 y x))
 24091  	// cond:
 24092  	// result: (Or8 x y)
 24093  	for {
 24094  		_ = v.Args[1]
 24095  		x := v.Args[0]
 24096  		v_1 := v.Args[1]
 24097  		if v_1.Op != OpOr8 {
 24098  			break
 24099  		}
 24100  		_ = v_1.Args[1]
 24101  		y := v_1.Args[0]
 24102  		if x != v_1.Args[1] {
 24103  			break
 24104  		}
 24105  		v.reset(OpOr8)
 24106  		v.AddArg(x)
 24107  		v.AddArg(y)
 24108  		return true
 24109  	}
 24110  	// match: (Or8 (Or8 x y) x)
 24111  	// cond:
 24112  	// result: (Or8 x y)
 24113  	for {
 24114  		_ = v.Args[1]
 24115  		v_0 := v.Args[0]
 24116  		if v_0.Op != OpOr8 {
 24117  			break
 24118  		}
 24119  		_ = v_0.Args[1]
 24120  		x := v_0.Args[0]
 24121  		y := v_0.Args[1]
 24122  		if x != v.Args[1] {
 24123  			break
 24124  		}
 24125  		v.reset(OpOr8)
 24126  		v.AddArg(x)
 24127  		v.AddArg(y)
 24128  		return true
 24129  	}
 24130  	return false
 24131  }
 24132  func rewriteValuegeneric_OpOr8_10(v *Value) bool {
 24133  	b := v.Block
 24134  	_ = b
 24135  	// match: (Or8 (Or8 y x) x)
 24136  	// cond:
 24137  	// result: (Or8 x y)
 24138  	for {
 24139  		_ = v.Args[1]
 24140  		v_0 := v.Args[0]
 24141  		if v_0.Op != OpOr8 {
 24142  			break
 24143  		}
 24144  		_ = v_0.Args[1]
 24145  		y := v_0.Args[0]
 24146  		x := v_0.Args[1]
 24147  		if x != v.Args[1] {
 24148  			break
 24149  		}
 24150  		v.reset(OpOr8)
 24151  		v.AddArg(x)
 24152  		v.AddArg(y)
 24153  		return true
 24154  	}
 24155  	// match: (Or8 (And8 x (Const8 [c2])) (Const8 <t> [c1]))
 24156  	// cond: ^(c1 | c2) == 0
 24157  	// result: (Or8 (Const8 <t> [c1]) x)
 24158  	for {
 24159  		_ = v.Args[1]
 24160  		v_0 := v.Args[0]
 24161  		if v_0.Op != OpAnd8 {
 24162  			break
 24163  		}
 24164  		_ = v_0.Args[1]
 24165  		x := v_0.Args[0]
 24166  		v_0_1 := v_0.Args[1]
 24167  		if v_0_1.Op != OpConst8 {
 24168  			break
 24169  		}
 24170  		c2 := v_0_1.AuxInt
 24171  		v_1 := v.Args[1]
 24172  		if v_1.Op != OpConst8 {
 24173  			break
 24174  		}
 24175  		t := v_1.Type
 24176  		c1 := v_1.AuxInt
 24177  		if !(^(c1 | c2) == 0) {
 24178  			break
 24179  		}
 24180  		v.reset(OpOr8)
 24181  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24182  		v0.AuxInt = c1
 24183  		v.AddArg(v0)
 24184  		v.AddArg(x)
 24185  		return true
 24186  	}
 24187  	// match: (Or8 (And8 (Const8 [c2]) x) (Const8 <t> [c1]))
 24188  	// cond: ^(c1 | c2) == 0
 24189  	// result: (Or8 (Const8 <t> [c1]) x)
 24190  	for {
 24191  		_ = v.Args[1]
 24192  		v_0 := v.Args[0]
 24193  		if v_0.Op != OpAnd8 {
 24194  			break
 24195  		}
 24196  		_ = v_0.Args[1]
 24197  		v_0_0 := v_0.Args[0]
 24198  		if v_0_0.Op != OpConst8 {
 24199  			break
 24200  		}
 24201  		c2 := v_0_0.AuxInt
 24202  		x := v_0.Args[1]
 24203  		v_1 := v.Args[1]
 24204  		if v_1.Op != OpConst8 {
 24205  			break
 24206  		}
 24207  		t := v_1.Type
 24208  		c1 := v_1.AuxInt
 24209  		if !(^(c1 | c2) == 0) {
 24210  			break
 24211  		}
 24212  		v.reset(OpOr8)
 24213  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24214  		v0.AuxInt = c1
 24215  		v.AddArg(v0)
 24216  		v.AddArg(x)
 24217  		return true
 24218  	}
 24219  	// match: (Or8 (Const8 <t> [c1]) (And8 x (Const8 [c2])))
 24220  	// cond: ^(c1 | c2) == 0
 24221  	// result: (Or8 (Const8 <t> [c1]) x)
 24222  	for {
 24223  		_ = v.Args[1]
 24224  		v_0 := v.Args[0]
 24225  		if v_0.Op != OpConst8 {
 24226  			break
 24227  		}
 24228  		t := v_0.Type
 24229  		c1 := v_0.AuxInt
 24230  		v_1 := v.Args[1]
 24231  		if v_1.Op != OpAnd8 {
 24232  			break
 24233  		}
 24234  		_ = v_1.Args[1]
 24235  		x := v_1.Args[0]
 24236  		v_1_1 := v_1.Args[1]
 24237  		if v_1_1.Op != OpConst8 {
 24238  			break
 24239  		}
 24240  		c2 := v_1_1.AuxInt
 24241  		if !(^(c1 | c2) == 0) {
 24242  			break
 24243  		}
 24244  		v.reset(OpOr8)
 24245  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24246  		v0.AuxInt = c1
 24247  		v.AddArg(v0)
 24248  		v.AddArg(x)
 24249  		return true
 24250  	}
 24251  	// match: (Or8 (Const8 <t> [c1]) (And8 (Const8 [c2]) x))
 24252  	// cond: ^(c1 | c2) == 0
 24253  	// result: (Or8 (Const8 <t> [c1]) x)
 24254  	for {
 24255  		_ = v.Args[1]
 24256  		v_0 := v.Args[0]
 24257  		if v_0.Op != OpConst8 {
 24258  			break
 24259  		}
 24260  		t := v_0.Type
 24261  		c1 := v_0.AuxInt
 24262  		v_1 := v.Args[1]
 24263  		if v_1.Op != OpAnd8 {
 24264  			break
 24265  		}
 24266  		_ = v_1.Args[1]
 24267  		v_1_0 := v_1.Args[0]
 24268  		if v_1_0.Op != OpConst8 {
 24269  			break
 24270  		}
 24271  		c2 := v_1_0.AuxInt
 24272  		x := v_1.Args[1]
 24273  		if !(^(c1 | c2) == 0) {
 24274  			break
 24275  		}
 24276  		v.reset(OpOr8)
 24277  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24278  		v0.AuxInt = c1
 24279  		v.AddArg(v0)
 24280  		v.AddArg(x)
 24281  		return true
 24282  	}
 24283  	// match: (Or8 (Or8 i:(Const8 <t>) z) x)
 24284  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 24285  	// result: (Or8 i (Or8 <t> z x))
 24286  	for {
 24287  		_ = v.Args[1]
 24288  		v_0 := v.Args[0]
 24289  		if v_0.Op != OpOr8 {
 24290  			break
 24291  		}
 24292  		_ = v_0.Args[1]
 24293  		i := v_0.Args[0]
 24294  		if i.Op != OpConst8 {
 24295  			break
 24296  		}
 24297  		t := i.Type
 24298  		z := v_0.Args[1]
 24299  		x := v.Args[1]
 24300  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 24301  			break
 24302  		}
 24303  		v.reset(OpOr8)
 24304  		v.AddArg(i)
 24305  		v0 := b.NewValue0(v.Pos, OpOr8, t)
 24306  		v0.AddArg(z)
 24307  		v0.AddArg(x)
 24308  		v.AddArg(v0)
 24309  		return true
 24310  	}
 24311  	// match: (Or8 (Or8 z i:(Const8 <t>)) x)
 24312  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 24313  	// result: (Or8 i (Or8 <t> z x))
 24314  	for {
 24315  		_ = v.Args[1]
 24316  		v_0 := v.Args[0]
 24317  		if v_0.Op != OpOr8 {
 24318  			break
 24319  		}
 24320  		_ = v_0.Args[1]
 24321  		z := v_0.Args[0]
 24322  		i := v_0.Args[1]
 24323  		if i.Op != OpConst8 {
 24324  			break
 24325  		}
 24326  		t := i.Type
 24327  		x := v.Args[1]
 24328  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 24329  			break
 24330  		}
 24331  		v.reset(OpOr8)
 24332  		v.AddArg(i)
 24333  		v0 := b.NewValue0(v.Pos, OpOr8, t)
 24334  		v0.AddArg(z)
 24335  		v0.AddArg(x)
 24336  		v.AddArg(v0)
 24337  		return true
 24338  	}
 24339  	// match: (Or8 x (Or8 i:(Const8 <t>) z))
 24340  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 24341  	// result: (Or8 i (Or8 <t> z x))
 24342  	for {
 24343  		_ = v.Args[1]
 24344  		x := v.Args[0]
 24345  		v_1 := v.Args[1]
 24346  		if v_1.Op != OpOr8 {
 24347  			break
 24348  		}
 24349  		_ = v_1.Args[1]
 24350  		i := v_1.Args[0]
 24351  		if i.Op != OpConst8 {
 24352  			break
 24353  		}
 24354  		t := i.Type
 24355  		z := v_1.Args[1]
 24356  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 24357  			break
 24358  		}
 24359  		v.reset(OpOr8)
 24360  		v.AddArg(i)
 24361  		v0 := b.NewValue0(v.Pos, OpOr8, t)
 24362  		v0.AddArg(z)
 24363  		v0.AddArg(x)
 24364  		v.AddArg(v0)
 24365  		return true
 24366  	}
 24367  	// match: (Or8 x (Or8 z i:(Const8 <t>)))
 24368  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 24369  	// result: (Or8 i (Or8 <t> z x))
 24370  	for {
 24371  		_ = v.Args[1]
 24372  		x := v.Args[0]
 24373  		v_1 := v.Args[1]
 24374  		if v_1.Op != OpOr8 {
 24375  			break
 24376  		}
 24377  		_ = v_1.Args[1]
 24378  		z := v_1.Args[0]
 24379  		i := v_1.Args[1]
 24380  		if i.Op != OpConst8 {
 24381  			break
 24382  		}
 24383  		t := i.Type
 24384  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 24385  			break
 24386  		}
 24387  		v.reset(OpOr8)
 24388  		v.AddArg(i)
 24389  		v0 := b.NewValue0(v.Pos, OpOr8, t)
 24390  		v0.AddArg(z)
 24391  		v0.AddArg(x)
 24392  		v.AddArg(v0)
 24393  		return true
 24394  	}
 24395  	// match: (Or8 (Const8 <t> [c]) (Or8 (Const8 <t> [d]) x))
 24396  	// cond:
 24397  	// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 24398  	for {
 24399  		_ = v.Args[1]
 24400  		v_0 := v.Args[0]
 24401  		if v_0.Op != OpConst8 {
 24402  			break
 24403  		}
 24404  		t := v_0.Type
 24405  		c := v_0.AuxInt
 24406  		v_1 := v.Args[1]
 24407  		if v_1.Op != OpOr8 {
 24408  			break
 24409  		}
 24410  		_ = v_1.Args[1]
 24411  		v_1_0 := v_1.Args[0]
 24412  		if v_1_0.Op != OpConst8 {
 24413  			break
 24414  		}
 24415  		if v_1_0.Type != t {
 24416  			break
 24417  		}
 24418  		d := v_1_0.AuxInt
 24419  		x := v_1.Args[1]
 24420  		v.reset(OpOr8)
 24421  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24422  		v0.AuxInt = int64(int8(c | d))
 24423  		v.AddArg(v0)
 24424  		v.AddArg(x)
 24425  		return true
 24426  	}
 24427  	return false
 24428  }
 24429  func rewriteValuegeneric_OpOr8_20(v *Value) bool {
 24430  	b := v.Block
 24431  	_ = b
 24432  	// match: (Or8 (Const8 <t> [c]) (Or8 x (Const8 <t> [d])))
 24433  	// cond:
 24434  	// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 24435  	for {
 24436  		_ = v.Args[1]
 24437  		v_0 := v.Args[0]
 24438  		if v_0.Op != OpConst8 {
 24439  			break
 24440  		}
 24441  		t := v_0.Type
 24442  		c := v_0.AuxInt
 24443  		v_1 := v.Args[1]
 24444  		if v_1.Op != OpOr8 {
 24445  			break
 24446  		}
 24447  		_ = v_1.Args[1]
 24448  		x := v_1.Args[0]
 24449  		v_1_1 := v_1.Args[1]
 24450  		if v_1_1.Op != OpConst8 {
 24451  			break
 24452  		}
 24453  		if v_1_1.Type != t {
 24454  			break
 24455  		}
 24456  		d := v_1_1.AuxInt
 24457  		v.reset(OpOr8)
 24458  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24459  		v0.AuxInt = int64(int8(c | d))
 24460  		v.AddArg(v0)
 24461  		v.AddArg(x)
 24462  		return true
 24463  	}
 24464  	// match: (Or8 (Or8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 24465  	// cond:
 24466  	// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 24467  	for {
 24468  		_ = v.Args[1]
 24469  		v_0 := v.Args[0]
 24470  		if v_0.Op != OpOr8 {
 24471  			break
 24472  		}
 24473  		_ = v_0.Args[1]
 24474  		v_0_0 := v_0.Args[0]
 24475  		if v_0_0.Op != OpConst8 {
 24476  			break
 24477  		}
 24478  		t := v_0_0.Type
 24479  		d := v_0_0.AuxInt
 24480  		x := v_0.Args[1]
 24481  		v_1 := v.Args[1]
 24482  		if v_1.Op != OpConst8 {
 24483  			break
 24484  		}
 24485  		if v_1.Type != t {
 24486  			break
 24487  		}
 24488  		c := v_1.AuxInt
 24489  		v.reset(OpOr8)
 24490  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24491  		v0.AuxInt = int64(int8(c | d))
 24492  		v.AddArg(v0)
 24493  		v.AddArg(x)
 24494  		return true
 24495  	}
 24496  	// match: (Or8 (Or8 x (Const8 <t> [d])) (Const8 <t> [c]))
 24497  	// cond:
 24498  	// result: (Or8 (Const8 <t> [int64(int8(c|d))]) x)
 24499  	for {
 24500  		_ = v.Args[1]
 24501  		v_0 := v.Args[0]
 24502  		if v_0.Op != OpOr8 {
 24503  			break
 24504  		}
 24505  		_ = v_0.Args[1]
 24506  		x := v_0.Args[0]
 24507  		v_0_1 := v_0.Args[1]
 24508  		if v_0_1.Op != OpConst8 {
 24509  			break
 24510  		}
 24511  		t := v_0_1.Type
 24512  		d := v_0_1.AuxInt
 24513  		v_1 := v.Args[1]
 24514  		if v_1.Op != OpConst8 {
 24515  			break
 24516  		}
 24517  		if v_1.Type != t {
 24518  			break
 24519  		}
 24520  		c := v_1.AuxInt
 24521  		v.reset(OpOr8)
 24522  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 24523  		v0.AuxInt = int64(int8(c | d))
 24524  		v.AddArg(v0)
 24525  		v.AddArg(x)
 24526  		return true
 24527  	}
 24528  	return false
 24529  }
 24530  func rewriteValuegeneric_OpPhi_0(v *Value) bool {
 24531  	// match: (Phi (Const8 [c]) (Const8 [c]))
 24532  	// cond:
 24533  	// result: (Const8 [c])
 24534  	for {
 24535  		_ = v.Args[1]
 24536  		v_0 := v.Args[0]
 24537  		if v_0.Op != OpConst8 {
 24538  			break
 24539  		}
 24540  		c := v_0.AuxInt
 24541  		v_1 := v.Args[1]
 24542  		if v_1.Op != OpConst8 {
 24543  			break
 24544  		}
 24545  		if v_1.AuxInt != c {
 24546  			break
 24547  		}
 24548  		if len(v.Args) != 2 {
 24549  			break
 24550  		}
 24551  		v.reset(OpConst8)
 24552  		v.AuxInt = c
 24553  		return true
 24554  	}
 24555  	// match: (Phi (Const16 [c]) (Const16 [c]))
 24556  	// cond:
 24557  	// result: (Const16 [c])
 24558  	for {
 24559  		_ = v.Args[1]
 24560  		v_0 := v.Args[0]
 24561  		if v_0.Op != OpConst16 {
 24562  			break
 24563  		}
 24564  		c := v_0.AuxInt
 24565  		v_1 := v.Args[1]
 24566  		if v_1.Op != OpConst16 {
 24567  			break
 24568  		}
 24569  		if v_1.AuxInt != c {
 24570  			break
 24571  		}
 24572  		if len(v.Args) != 2 {
 24573  			break
 24574  		}
 24575  		v.reset(OpConst16)
 24576  		v.AuxInt = c
 24577  		return true
 24578  	}
 24579  	// match: (Phi (Const32 [c]) (Const32 [c]))
 24580  	// cond:
 24581  	// result: (Const32 [c])
 24582  	for {
 24583  		_ = v.Args[1]
 24584  		v_0 := v.Args[0]
 24585  		if v_0.Op != OpConst32 {
 24586  			break
 24587  		}
 24588  		c := v_0.AuxInt
 24589  		v_1 := v.Args[1]
 24590  		if v_1.Op != OpConst32 {
 24591  			break
 24592  		}
 24593  		if v_1.AuxInt != c {
 24594  			break
 24595  		}
 24596  		if len(v.Args) != 2 {
 24597  			break
 24598  		}
 24599  		v.reset(OpConst32)
 24600  		v.AuxInt = c
 24601  		return true
 24602  	}
 24603  	// match: (Phi (Const64 [c]) (Const64 [c]))
 24604  	// cond:
 24605  	// result: (Const64 [c])
 24606  	for {
 24607  		_ = v.Args[1]
 24608  		v_0 := v.Args[0]
 24609  		if v_0.Op != OpConst64 {
 24610  			break
 24611  		}
 24612  		c := v_0.AuxInt
 24613  		v_1 := v.Args[1]
 24614  		if v_1.Op != OpConst64 {
 24615  			break
 24616  		}
 24617  		if v_1.AuxInt != c {
 24618  			break
 24619  		}
 24620  		if len(v.Args) != 2 {
 24621  			break
 24622  		}
 24623  		v.reset(OpConst64)
 24624  		v.AuxInt = c
 24625  		return true
 24626  	}
 24627  	return false
 24628  }
 24629  func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool {
 24630  	b := v.Block
 24631  	_ = b
 24632  	config := b.Func.Config
 24633  	_ = config
 24634  	typ := &b.Func.Config.Types
 24635  	_ = typ
 24636  	// match: (PtrIndex <t> ptr idx)
 24637  	// cond: config.PtrSize == 4
 24638  	// result: (AddPtr ptr (Mul32 <typ.Int> idx (Const32 <typ.Int> [t.Elem().Size()])))
 24639  	for {
 24640  		t := v.Type
 24641  		_ = v.Args[1]
 24642  		ptr := v.Args[0]
 24643  		idx := v.Args[1]
 24644  		if !(config.PtrSize == 4) {
 24645  			break
 24646  		}
 24647  		v.reset(OpAddPtr)
 24648  		v.AddArg(ptr)
 24649  		v0 := b.NewValue0(v.Pos, OpMul32, typ.Int)
 24650  		v0.AddArg(idx)
 24651  		v1 := b.NewValue0(v.Pos, OpConst32, typ.Int)
 24652  		v1.AuxInt = t.Elem().Size()
 24653  		v0.AddArg(v1)
 24654  		v.AddArg(v0)
 24655  		return true
 24656  	}
 24657  	// match: (PtrIndex <t> ptr idx)
 24658  	// cond: config.PtrSize == 8
 24659  	// result: (AddPtr ptr (Mul64 <typ.Int> idx (Const64 <typ.Int> [t.Elem().Size()])))
 24660  	for {
 24661  		t := v.Type
 24662  		_ = v.Args[1]
 24663  		ptr := v.Args[0]
 24664  		idx := v.Args[1]
 24665  		if !(config.PtrSize == 8) {
 24666  			break
 24667  		}
 24668  		v.reset(OpAddPtr)
 24669  		v.AddArg(ptr)
 24670  		v0 := b.NewValue0(v.Pos, OpMul64, typ.Int)
 24671  		v0.AddArg(idx)
 24672  		v1 := b.NewValue0(v.Pos, OpConst64, typ.Int)
 24673  		v1.AuxInt = t.Elem().Size()
 24674  		v0.AddArg(v1)
 24675  		v.AddArg(v0)
 24676  		return true
 24677  	}
 24678  	return false
 24679  }
 24680  func rewriteValuegeneric_OpRound32F_0(v *Value) bool {
 24681  	// match: (Round32F x:(Const32F))
 24682  	// cond:
 24683  	// result: x
 24684  	for {
 24685  		x := v.Args[0]
 24686  		if x.Op != OpConst32F {
 24687  			break
 24688  		}
 24689  		v.reset(OpCopy)
 24690  		v.Type = x.Type
 24691  		v.AddArg(x)
 24692  		return true
 24693  	}
 24694  	return false
 24695  }
 24696  func rewriteValuegeneric_OpRound64F_0(v *Value) bool {
 24697  	// match: (Round64F x:(Const64F))
 24698  	// cond:
 24699  	// result: x
 24700  	for {
 24701  		x := v.Args[0]
 24702  		if x.Op != OpConst64F {
 24703  			break
 24704  		}
 24705  		v.reset(OpCopy)
 24706  		v.Type = x.Type
 24707  		v.AddArg(x)
 24708  		return true
 24709  	}
 24710  	return false
 24711  }
 24712  func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool {
 24713  	b := v.Block
 24714  	_ = b
 24715  	// match: (Rsh16Ux16 <t> x (Const16 [c]))
 24716  	// cond:
 24717  	// result: (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))]))
 24718  	for {
 24719  		t := v.Type
 24720  		_ = v.Args[1]
 24721  		x := v.Args[0]
 24722  		v_1 := v.Args[1]
 24723  		if v_1.Op != OpConst16 {
 24724  			break
 24725  		}
 24726  		c := v_1.AuxInt
 24727  		v.reset(OpRsh16Ux64)
 24728  		v.AddArg(x)
 24729  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 24730  		v0.AuxInt = int64(uint16(c))
 24731  		v.AddArg(v0)
 24732  		return true
 24733  	}
 24734  	// match: (Rsh16Ux16 (Const16 [0]) _)
 24735  	// cond:
 24736  	// result: (Const16 [0])
 24737  	for {
 24738  		_ = v.Args[1]
 24739  		v_0 := v.Args[0]
 24740  		if v_0.Op != OpConst16 {
 24741  			break
 24742  		}
 24743  		if v_0.AuxInt != 0 {
 24744  			break
 24745  		}
 24746  		v.reset(OpConst16)
 24747  		v.AuxInt = 0
 24748  		return true
 24749  	}
 24750  	return false
 24751  }
 24752  func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool {
 24753  	b := v.Block
 24754  	_ = b
 24755  	// match: (Rsh16Ux32 <t> x (Const32 [c]))
 24756  	// cond:
 24757  	// result: (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))]))
 24758  	for {
 24759  		t := v.Type
 24760  		_ = v.Args[1]
 24761  		x := v.Args[0]
 24762  		v_1 := v.Args[1]
 24763  		if v_1.Op != OpConst32 {
 24764  			break
 24765  		}
 24766  		c := v_1.AuxInt
 24767  		v.reset(OpRsh16Ux64)
 24768  		v.AddArg(x)
 24769  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 24770  		v0.AuxInt = int64(uint32(c))
 24771  		v.AddArg(v0)
 24772  		return true
 24773  	}
 24774  	// match: (Rsh16Ux32 (Const16 [0]) _)
 24775  	// cond:
 24776  	// result: (Const16 [0])
 24777  	for {
 24778  		_ = v.Args[1]
 24779  		v_0 := v.Args[0]
 24780  		if v_0.Op != OpConst16 {
 24781  			break
 24782  		}
 24783  		if v_0.AuxInt != 0 {
 24784  			break
 24785  		}
 24786  		v.reset(OpConst16)
 24787  		v.AuxInt = 0
 24788  		return true
 24789  	}
 24790  	return false
 24791  }
 24792  func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool {
 24793  	b := v.Block
 24794  	_ = b
 24795  	typ := &b.Func.Config.Types
 24796  	_ = typ
 24797  	// match: (Rsh16Ux64 (Const16 [c]) (Const64 [d]))
 24798  	// cond:
 24799  	// result: (Const16 [int64(int16(uint16(c) >> uint64(d)))])
 24800  	for {
 24801  		_ = v.Args[1]
 24802  		v_0 := v.Args[0]
 24803  		if v_0.Op != OpConst16 {
 24804  			break
 24805  		}
 24806  		c := v_0.AuxInt
 24807  		v_1 := v.Args[1]
 24808  		if v_1.Op != OpConst64 {
 24809  			break
 24810  		}
 24811  		d := v_1.AuxInt
 24812  		v.reset(OpConst16)
 24813  		v.AuxInt = int64(int16(uint16(c) >> uint64(d)))
 24814  		return true
 24815  	}
 24816  	// match: (Rsh16Ux64 x (Const64 [0]))
 24817  	// cond:
 24818  	// result: x
 24819  	for {
 24820  		_ = v.Args[1]
 24821  		x := v.Args[0]
 24822  		v_1 := v.Args[1]
 24823  		if v_1.Op != OpConst64 {
 24824  			break
 24825  		}
 24826  		if v_1.AuxInt != 0 {
 24827  			break
 24828  		}
 24829  		v.reset(OpCopy)
 24830  		v.Type = x.Type
 24831  		v.AddArg(x)
 24832  		return true
 24833  	}
 24834  	// match: (Rsh16Ux64 (Const16 [0]) _)
 24835  	// cond:
 24836  	// result: (Const16 [0])
 24837  	for {
 24838  		_ = v.Args[1]
 24839  		v_0 := v.Args[0]
 24840  		if v_0.Op != OpConst16 {
 24841  			break
 24842  		}
 24843  		if v_0.AuxInt != 0 {
 24844  			break
 24845  		}
 24846  		v.reset(OpConst16)
 24847  		v.AuxInt = 0
 24848  		return true
 24849  	}
 24850  	// match: (Rsh16Ux64 _ (Const64 [c]))
 24851  	// cond: uint64(c) >= 16
 24852  	// result: (Const16 [0])
 24853  	for {
 24854  		_ = v.Args[1]
 24855  		v_1 := v.Args[1]
 24856  		if v_1.Op != OpConst64 {
 24857  			break
 24858  		}
 24859  		c := v_1.AuxInt
 24860  		if !(uint64(c) >= 16) {
 24861  			break
 24862  		}
 24863  		v.reset(OpConst16)
 24864  		v.AuxInt = 0
 24865  		return true
 24866  	}
 24867  	// match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d]))
 24868  	// cond: !uaddOvf(c,d)
 24869  	// result: (Rsh16Ux64 x (Const64 <t> [c+d]))
 24870  	for {
 24871  		t := v.Type
 24872  		_ = v.Args[1]
 24873  		v_0 := v.Args[0]
 24874  		if v_0.Op != OpRsh16Ux64 {
 24875  			break
 24876  		}
 24877  		_ = v_0.Args[1]
 24878  		x := v_0.Args[0]
 24879  		v_0_1 := v_0.Args[1]
 24880  		if v_0_1.Op != OpConst64 {
 24881  			break
 24882  		}
 24883  		c := v_0_1.AuxInt
 24884  		v_1 := v.Args[1]
 24885  		if v_1.Op != OpConst64 {
 24886  			break
 24887  		}
 24888  		d := v_1.AuxInt
 24889  		if !(!uaddOvf(c, d)) {
 24890  			break
 24891  		}
 24892  		v.reset(OpRsh16Ux64)
 24893  		v.AddArg(x)
 24894  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 24895  		v0.AuxInt = c + d
 24896  		v.AddArg(v0)
 24897  		return true
 24898  	}
 24899  	// match: (Rsh16Ux64 (Rsh16x64 x _) (Const64 <t> [15]))
 24900  	// cond:
 24901  	// result: (Rsh16Ux64 x (Const64 <t> [15]))
 24902  	for {
 24903  		_ = v.Args[1]
 24904  		v_0 := v.Args[0]
 24905  		if v_0.Op != OpRsh16x64 {
 24906  			break
 24907  		}
 24908  		_ = v_0.Args[1]
 24909  		x := v_0.Args[0]
 24910  		v_1 := v.Args[1]
 24911  		if v_1.Op != OpConst64 {
 24912  			break
 24913  		}
 24914  		t := v_1.Type
 24915  		if v_1.AuxInt != 15 {
 24916  			break
 24917  		}
 24918  		v.reset(OpRsh16Ux64)
 24919  		v.AddArg(x)
 24920  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 24921  		v0.AuxInt = 15
 24922  		v.AddArg(v0)
 24923  		return true
 24924  	}
 24925  	// match: (Rsh16Ux64 (Lsh16x64 (Rsh16Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 24926  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 24927  	// result: (Rsh16Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 24928  	for {
 24929  		_ = v.Args[1]
 24930  		v_0 := v.Args[0]
 24931  		if v_0.Op != OpLsh16x64 {
 24932  			break
 24933  		}
 24934  		_ = v_0.Args[1]
 24935  		v_0_0 := v_0.Args[0]
 24936  		if v_0_0.Op != OpRsh16Ux64 {
 24937  			break
 24938  		}
 24939  		_ = v_0_0.Args[1]
 24940  		x := v_0_0.Args[0]
 24941  		v_0_0_1 := v_0_0.Args[1]
 24942  		if v_0_0_1.Op != OpConst64 {
 24943  			break
 24944  		}
 24945  		c1 := v_0_0_1.AuxInt
 24946  		v_0_1 := v_0.Args[1]
 24947  		if v_0_1.Op != OpConst64 {
 24948  			break
 24949  		}
 24950  		c2 := v_0_1.AuxInt
 24951  		v_1 := v.Args[1]
 24952  		if v_1.Op != OpConst64 {
 24953  			break
 24954  		}
 24955  		c3 := v_1.AuxInt
 24956  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 24957  			break
 24958  		}
 24959  		v.reset(OpRsh16Ux64)
 24960  		v.AddArg(x)
 24961  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 24962  		v0.AuxInt = c1 - c2 + c3
 24963  		v.AddArg(v0)
 24964  		return true
 24965  	}
 24966  	// match: (Rsh16Ux64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
 24967  	// cond:
 24968  	// result: (ZeroExt8to16 (Trunc16to8 <typ.UInt8> x))
 24969  	for {
 24970  		_ = v.Args[1]
 24971  		v_0 := v.Args[0]
 24972  		if v_0.Op != OpLsh16x64 {
 24973  			break
 24974  		}
 24975  		_ = v_0.Args[1]
 24976  		x := v_0.Args[0]
 24977  		v_0_1 := v_0.Args[1]
 24978  		if v_0_1.Op != OpConst64 {
 24979  			break
 24980  		}
 24981  		if v_0_1.AuxInt != 8 {
 24982  			break
 24983  		}
 24984  		v_1 := v.Args[1]
 24985  		if v_1.Op != OpConst64 {
 24986  			break
 24987  		}
 24988  		if v_1.AuxInt != 8 {
 24989  			break
 24990  		}
 24991  		v.reset(OpZeroExt8to16)
 24992  		v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.UInt8)
 24993  		v0.AddArg(x)
 24994  		v.AddArg(v0)
 24995  		return true
 24996  	}
 24997  	return false
 24998  }
 24999  func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool {
 25000  	b := v.Block
 25001  	_ = b
 25002  	// match: (Rsh16Ux8 <t> x (Const8 [c]))
 25003  	// cond:
 25004  	// result: (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))]))
 25005  	for {
 25006  		t := v.Type
 25007  		_ = v.Args[1]
 25008  		x := v.Args[0]
 25009  		v_1 := v.Args[1]
 25010  		if v_1.Op != OpConst8 {
 25011  			break
 25012  		}
 25013  		c := v_1.AuxInt
 25014  		v.reset(OpRsh16Ux64)
 25015  		v.AddArg(x)
 25016  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25017  		v0.AuxInt = int64(uint8(c))
 25018  		v.AddArg(v0)
 25019  		return true
 25020  	}
 25021  	// match: (Rsh16Ux8 (Const16 [0]) _)
 25022  	// cond:
 25023  	// result: (Const16 [0])
 25024  	for {
 25025  		_ = v.Args[1]
 25026  		v_0 := v.Args[0]
 25027  		if v_0.Op != OpConst16 {
 25028  			break
 25029  		}
 25030  		if v_0.AuxInt != 0 {
 25031  			break
 25032  		}
 25033  		v.reset(OpConst16)
 25034  		v.AuxInt = 0
 25035  		return true
 25036  	}
 25037  	return false
 25038  }
 25039  func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool {
 25040  	b := v.Block
 25041  	_ = b
 25042  	// match: (Rsh16x16 <t> x (Const16 [c]))
 25043  	// cond:
 25044  	// result: (Rsh16x64 x (Const64 <t> [int64(uint16(c))]))
 25045  	for {
 25046  		t := v.Type
 25047  		_ = v.Args[1]
 25048  		x := v.Args[0]
 25049  		v_1 := v.Args[1]
 25050  		if v_1.Op != OpConst16 {
 25051  			break
 25052  		}
 25053  		c := v_1.AuxInt
 25054  		v.reset(OpRsh16x64)
 25055  		v.AddArg(x)
 25056  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25057  		v0.AuxInt = int64(uint16(c))
 25058  		v.AddArg(v0)
 25059  		return true
 25060  	}
 25061  	// match: (Rsh16x16 (Const16 [0]) _)
 25062  	// cond:
 25063  	// result: (Const16 [0])
 25064  	for {
 25065  		_ = v.Args[1]
 25066  		v_0 := v.Args[0]
 25067  		if v_0.Op != OpConst16 {
 25068  			break
 25069  		}
 25070  		if v_0.AuxInt != 0 {
 25071  			break
 25072  		}
 25073  		v.reset(OpConst16)
 25074  		v.AuxInt = 0
 25075  		return true
 25076  	}
 25077  	return false
 25078  }
 25079  func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool {
 25080  	b := v.Block
 25081  	_ = b
 25082  	// match: (Rsh16x32 <t> x (Const32 [c]))
 25083  	// cond:
 25084  	// result: (Rsh16x64 x (Const64 <t> [int64(uint32(c))]))
 25085  	for {
 25086  		t := v.Type
 25087  		_ = v.Args[1]
 25088  		x := v.Args[0]
 25089  		v_1 := v.Args[1]
 25090  		if v_1.Op != OpConst32 {
 25091  			break
 25092  		}
 25093  		c := v_1.AuxInt
 25094  		v.reset(OpRsh16x64)
 25095  		v.AddArg(x)
 25096  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25097  		v0.AuxInt = int64(uint32(c))
 25098  		v.AddArg(v0)
 25099  		return true
 25100  	}
 25101  	// match: (Rsh16x32 (Const16 [0]) _)
 25102  	// cond:
 25103  	// result: (Const16 [0])
 25104  	for {
 25105  		_ = v.Args[1]
 25106  		v_0 := v.Args[0]
 25107  		if v_0.Op != OpConst16 {
 25108  			break
 25109  		}
 25110  		if v_0.AuxInt != 0 {
 25111  			break
 25112  		}
 25113  		v.reset(OpConst16)
 25114  		v.AuxInt = 0
 25115  		return true
 25116  	}
 25117  	return false
 25118  }
 25119  func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool {
 25120  	b := v.Block
 25121  	_ = b
 25122  	typ := &b.Func.Config.Types
 25123  	_ = typ
 25124  	// match: (Rsh16x64 (Const16 [c]) (Const64 [d]))
 25125  	// cond:
 25126  	// result: (Const16 [int64(int16(c) >> uint64(d))])
 25127  	for {
 25128  		_ = v.Args[1]
 25129  		v_0 := v.Args[0]
 25130  		if v_0.Op != OpConst16 {
 25131  			break
 25132  		}
 25133  		c := v_0.AuxInt
 25134  		v_1 := v.Args[1]
 25135  		if v_1.Op != OpConst64 {
 25136  			break
 25137  		}
 25138  		d := v_1.AuxInt
 25139  		v.reset(OpConst16)
 25140  		v.AuxInt = int64(int16(c) >> uint64(d))
 25141  		return true
 25142  	}
 25143  	// match: (Rsh16x64 x (Const64 [0]))
 25144  	// cond:
 25145  	// result: x
 25146  	for {
 25147  		_ = v.Args[1]
 25148  		x := v.Args[0]
 25149  		v_1 := v.Args[1]
 25150  		if v_1.Op != OpConst64 {
 25151  			break
 25152  		}
 25153  		if v_1.AuxInt != 0 {
 25154  			break
 25155  		}
 25156  		v.reset(OpCopy)
 25157  		v.Type = x.Type
 25158  		v.AddArg(x)
 25159  		return true
 25160  	}
 25161  	// match: (Rsh16x64 (Const16 [0]) _)
 25162  	// cond:
 25163  	// result: (Const16 [0])
 25164  	for {
 25165  		_ = v.Args[1]
 25166  		v_0 := v.Args[0]
 25167  		if v_0.Op != OpConst16 {
 25168  			break
 25169  		}
 25170  		if v_0.AuxInt != 0 {
 25171  			break
 25172  		}
 25173  		v.reset(OpConst16)
 25174  		v.AuxInt = 0
 25175  		return true
 25176  	}
 25177  	// match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d]))
 25178  	// cond: !uaddOvf(c,d)
 25179  	// result: (Rsh16x64 x (Const64 <t> [c+d]))
 25180  	for {
 25181  		t := v.Type
 25182  		_ = v.Args[1]
 25183  		v_0 := v.Args[0]
 25184  		if v_0.Op != OpRsh16x64 {
 25185  			break
 25186  		}
 25187  		_ = v_0.Args[1]
 25188  		x := v_0.Args[0]
 25189  		v_0_1 := v_0.Args[1]
 25190  		if v_0_1.Op != OpConst64 {
 25191  			break
 25192  		}
 25193  		c := v_0_1.AuxInt
 25194  		v_1 := v.Args[1]
 25195  		if v_1.Op != OpConst64 {
 25196  			break
 25197  		}
 25198  		d := v_1.AuxInt
 25199  		if !(!uaddOvf(c, d)) {
 25200  			break
 25201  		}
 25202  		v.reset(OpRsh16x64)
 25203  		v.AddArg(x)
 25204  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25205  		v0.AuxInt = c + d
 25206  		v.AddArg(v0)
 25207  		return true
 25208  	}
 25209  	// match: (Rsh16x64 (Lsh16x64 x (Const64 [8])) (Const64 [8]))
 25210  	// cond:
 25211  	// result: (SignExt8to16 (Trunc16to8 <typ.Int8> x))
 25212  	for {
 25213  		_ = v.Args[1]
 25214  		v_0 := v.Args[0]
 25215  		if v_0.Op != OpLsh16x64 {
 25216  			break
 25217  		}
 25218  		_ = v_0.Args[1]
 25219  		x := v_0.Args[0]
 25220  		v_0_1 := v_0.Args[1]
 25221  		if v_0_1.Op != OpConst64 {
 25222  			break
 25223  		}
 25224  		if v_0_1.AuxInt != 8 {
 25225  			break
 25226  		}
 25227  		v_1 := v.Args[1]
 25228  		if v_1.Op != OpConst64 {
 25229  			break
 25230  		}
 25231  		if v_1.AuxInt != 8 {
 25232  			break
 25233  		}
 25234  		v.reset(OpSignExt8to16)
 25235  		v0 := b.NewValue0(v.Pos, OpTrunc16to8, typ.Int8)
 25236  		v0.AddArg(x)
 25237  		v.AddArg(v0)
 25238  		return true
 25239  	}
 25240  	return false
 25241  }
 25242  func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool {
 25243  	b := v.Block
 25244  	_ = b
 25245  	// match: (Rsh16x8 <t> x (Const8 [c]))
 25246  	// cond:
 25247  	// result: (Rsh16x64 x (Const64 <t> [int64(uint8(c))]))
 25248  	for {
 25249  		t := v.Type
 25250  		_ = v.Args[1]
 25251  		x := v.Args[0]
 25252  		v_1 := v.Args[1]
 25253  		if v_1.Op != OpConst8 {
 25254  			break
 25255  		}
 25256  		c := v_1.AuxInt
 25257  		v.reset(OpRsh16x64)
 25258  		v.AddArg(x)
 25259  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25260  		v0.AuxInt = int64(uint8(c))
 25261  		v.AddArg(v0)
 25262  		return true
 25263  	}
 25264  	// match: (Rsh16x8 (Const16 [0]) _)
 25265  	// cond:
 25266  	// result: (Const16 [0])
 25267  	for {
 25268  		_ = v.Args[1]
 25269  		v_0 := v.Args[0]
 25270  		if v_0.Op != OpConst16 {
 25271  			break
 25272  		}
 25273  		if v_0.AuxInt != 0 {
 25274  			break
 25275  		}
 25276  		v.reset(OpConst16)
 25277  		v.AuxInt = 0
 25278  		return true
 25279  	}
 25280  	return false
 25281  }
 25282  func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool {
 25283  	b := v.Block
 25284  	_ = b
 25285  	// match: (Rsh32Ux16 <t> x (Const16 [c]))
 25286  	// cond:
 25287  	// result: (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))]))
 25288  	for {
 25289  		t := v.Type
 25290  		_ = v.Args[1]
 25291  		x := v.Args[0]
 25292  		v_1 := v.Args[1]
 25293  		if v_1.Op != OpConst16 {
 25294  			break
 25295  		}
 25296  		c := v_1.AuxInt
 25297  		v.reset(OpRsh32Ux64)
 25298  		v.AddArg(x)
 25299  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25300  		v0.AuxInt = int64(uint16(c))
 25301  		v.AddArg(v0)
 25302  		return true
 25303  	}
 25304  	// match: (Rsh32Ux16 (Const32 [0]) _)
 25305  	// cond:
 25306  	// result: (Const32 [0])
 25307  	for {
 25308  		_ = v.Args[1]
 25309  		v_0 := v.Args[0]
 25310  		if v_0.Op != OpConst32 {
 25311  			break
 25312  		}
 25313  		if v_0.AuxInt != 0 {
 25314  			break
 25315  		}
 25316  		v.reset(OpConst32)
 25317  		v.AuxInt = 0
 25318  		return true
 25319  	}
 25320  	return false
 25321  }
 25322  func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool {
 25323  	b := v.Block
 25324  	_ = b
 25325  	// match: (Rsh32Ux32 <t> x (Const32 [c]))
 25326  	// cond:
 25327  	// result: (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))]))
 25328  	for {
 25329  		t := v.Type
 25330  		_ = v.Args[1]
 25331  		x := v.Args[0]
 25332  		v_1 := v.Args[1]
 25333  		if v_1.Op != OpConst32 {
 25334  			break
 25335  		}
 25336  		c := v_1.AuxInt
 25337  		v.reset(OpRsh32Ux64)
 25338  		v.AddArg(x)
 25339  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25340  		v0.AuxInt = int64(uint32(c))
 25341  		v.AddArg(v0)
 25342  		return true
 25343  	}
 25344  	// match: (Rsh32Ux32 (Const32 [0]) _)
 25345  	// cond:
 25346  	// result: (Const32 [0])
 25347  	for {
 25348  		_ = v.Args[1]
 25349  		v_0 := v.Args[0]
 25350  		if v_0.Op != OpConst32 {
 25351  			break
 25352  		}
 25353  		if v_0.AuxInt != 0 {
 25354  			break
 25355  		}
 25356  		v.reset(OpConst32)
 25357  		v.AuxInt = 0
 25358  		return true
 25359  	}
 25360  	return false
 25361  }
 25362  func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool {
 25363  	b := v.Block
 25364  	_ = b
 25365  	typ := &b.Func.Config.Types
 25366  	_ = typ
 25367  	// match: (Rsh32Ux64 (Const32 [c]) (Const64 [d]))
 25368  	// cond:
 25369  	// result: (Const32 [int64(int32(uint32(c) >> uint64(d)))])
 25370  	for {
 25371  		_ = v.Args[1]
 25372  		v_0 := v.Args[0]
 25373  		if v_0.Op != OpConst32 {
 25374  			break
 25375  		}
 25376  		c := v_0.AuxInt
 25377  		v_1 := v.Args[1]
 25378  		if v_1.Op != OpConst64 {
 25379  			break
 25380  		}
 25381  		d := v_1.AuxInt
 25382  		v.reset(OpConst32)
 25383  		v.AuxInt = int64(int32(uint32(c) >> uint64(d)))
 25384  		return true
 25385  	}
 25386  	// match: (Rsh32Ux64 x (Const64 [0]))
 25387  	// cond:
 25388  	// result: x
 25389  	for {
 25390  		_ = v.Args[1]
 25391  		x := v.Args[0]
 25392  		v_1 := v.Args[1]
 25393  		if v_1.Op != OpConst64 {
 25394  			break
 25395  		}
 25396  		if v_1.AuxInt != 0 {
 25397  			break
 25398  		}
 25399  		v.reset(OpCopy)
 25400  		v.Type = x.Type
 25401  		v.AddArg(x)
 25402  		return true
 25403  	}
 25404  	// match: (Rsh32Ux64 (Const32 [0]) _)
 25405  	// cond:
 25406  	// result: (Const32 [0])
 25407  	for {
 25408  		_ = v.Args[1]
 25409  		v_0 := v.Args[0]
 25410  		if v_0.Op != OpConst32 {
 25411  			break
 25412  		}
 25413  		if v_0.AuxInt != 0 {
 25414  			break
 25415  		}
 25416  		v.reset(OpConst32)
 25417  		v.AuxInt = 0
 25418  		return true
 25419  	}
 25420  	// match: (Rsh32Ux64 _ (Const64 [c]))
 25421  	// cond: uint64(c) >= 32
 25422  	// result: (Const32 [0])
 25423  	for {
 25424  		_ = v.Args[1]
 25425  		v_1 := v.Args[1]
 25426  		if v_1.Op != OpConst64 {
 25427  			break
 25428  		}
 25429  		c := v_1.AuxInt
 25430  		if !(uint64(c) >= 32) {
 25431  			break
 25432  		}
 25433  		v.reset(OpConst32)
 25434  		v.AuxInt = 0
 25435  		return true
 25436  	}
 25437  	// match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d]))
 25438  	// cond: !uaddOvf(c,d)
 25439  	// result: (Rsh32Ux64 x (Const64 <t> [c+d]))
 25440  	for {
 25441  		t := v.Type
 25442  		_ = v.Args[1]
 25443  		v_0 := v.Args[0]
 25444  		if v_0.Op != OpRsh32Ux64 {
 25445  			break
 25446  		}
 25447  		_ = v_0.Args[1]
 25448  		x := v_0.Args[0]
 25449  		v_0_1 := v_0.Args[1]
 25450  		if v_0_1.Op != OpConst64 {
 25451  			break
 25452  		}
 25453  		c := v_0_1.AuxInt
 25454  		v_1 := v.Args[1]
 25455  		if v_1.Op != OpConst64 {
 25456  			break
 25457  		}
 25458  		d := v_1.AuxInt
 25459  		if !(!uaddOvf(c, d)) {
 25460  			break
 25461  		}
 25462  		v.reset(OpRsh32Ux64)
 25463  		v.AddArg(x)
 25464  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25465  		v0.AuxInt = c + d
 25466  		v.AddArg(v0)
 25467  		return true
 25468  	}
 25469  	// match: (Rsh32Ux64 (Rsh32x64 x _) (Const64 <t> [31]))
 25470  	// cond:
 25471  	// result: (Rsh32Ux64 x (Const64 <t> [31]))
 25472  	for {
 25473  		_ = v.Args[1]
 25474  		v_0 := v.Args[0]
 25475  		if v_0.Op != OpRsh32x64 {
 25476  			break
 25477  		}
 25478  		_ = v_0.Args[1]
 25479  		x := v_0.Args[0]
 25480  		v_1 := v.Args[1]
 25481  		if v_1.Op != OpConst64 {
 25482  			break
 25483  		}
 25484  		t := v_1.Type
 25485  		if v_1.AuxInt != 31 {
 25486  			break
 25487  		}
 25488  		v.reset(OpRsh32Ux64)
 25489  		v.AddArg(x)
 25490  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25491  		v0.AuxInt = 31
 25492  		v.AddArg(v0)
 25493  		return true
 25494  	}
 25495  	// match: (Rsh32Ux64 (Lsh32x64 (Rsh32Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 25496  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 25497  	// result: (Rsh32Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 25498  	for {
 25499  		_ = v.Args[1]
 25500  		v_0 := v.Args[0]
 25501  		if v_0.Op != OpLsh32x64 {
 25502  			break
 25503  		}
 25504  		_ = v_0.Args[1]
 25505  		v_0_0 := v_0.Args[0]
 25506  		if v_0_0.Op != OpRsh32Ux64 {
 25507  			break
 25508  		}
 25509  		_ = v_0_0.Args[1]
 25510  		x := v_0_0.Args[0]
 25511  		v_0_0_1 := v_0_0.Args[1]
 25512  		if v_0_0_1.Op != OpConst64 {
 25513  			break
 25514  		}
 25515  		c1 := v_0_0_1.AuxInt
 25516  		v_0_1 := v_0.Args[1]
 25517  		if v_0_1.Op != OpConst64 {
 25518  			break
 25519  		}
 25520  		c2 := v_0_1.AuxInt
 25521  		v_1 := v.Args[1]
 25522  		if v_1.Op != OpConst64 {
 25523  			break
 25524  		}
 25525  		c3 := v_1.AuxInt
 25526  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 25527  			break
 25528  		}
 25529  		v.reset(OpRsh32Ux64)
 25530  		v.AddArg(x)
 25531  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 25532  		v0.AuxInt = c1 - c2 + c3
 25533  		v.AddArg(v0)
 25534  		return true
 25535  	}
 25536  	// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
 25537  	// cond:
 25538  	// result: (ZeroExt8to32 (Trunc32to8 <typ.UInt8> x))
 25539  	for {
 25540  		_ = v.Args[1]
 25541  		v_0 := v.Args[0]
 25542  		if v_0.Op != OpLsh32x64 {
 25543  			break
 25544  		}
 25545  		_ = v_0.Args[1]
 25546  		x := v_0.Args[0]
 25547  		v_0_1 := v_0.Args[1]
 25548  		if v_0_1.Op != OpConst64 {
 25549  			break
 25550  		}
 25551  		if v_0_1.AuxInt != 24 {
 25552  			break
 25553  		}
 25554  		v_1 := v.Args[1]
 25555  		if v_1.Op != OpConst64 {
 25556  			break
 25557  		}
 25558  		if v_1.AuxInt != 24 {
 25559  			break
 25560  		}
 25561  		v.reset(OpZeroExt8to32)
 25562  		v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.UInt8)
 25563  		v0.AddArg(x)
 25564  		v.AddArg(v0)
 25565  		return true
 25566  	}
 25567  	// match: (Rsh32Ux64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
 25568  	// cond:
 25569  	// result: (ZeroExt16to32 (Trunc32to16 <typ.UInt16> x))
 25570  	for {
 25571  		_ = v.Args[1]
 25572  		v_0 := v.Args[0]
 25573  		if v_0.Op != OpLsh32x64 {
 25574  			break
 25575  		}
 25576  		_ = v_0.Args[1]
 25577  		x := v_0.Args[0]
 25578  		v_0_1 := v_0.Args[1]
 25579  		if v_0_1.Op != OpConst64 {
 25580  			break
 25581  		}
 25582  		if v_0_1.AuxInt != 16 {
 25583  			break
 25584  		}
 25585  		v_1 := v.Args[1]
 25586  		if v_1.Op != OpConst64 {
 25587  			break
 25588  		}
 25589  		if v_1.AuxInt != 16 {
 25590  			break
 25591  		}
 25592  		v.reset(OpZeroExt16to32)
 25593  		v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.UInt16)
 25594  		v0.AddArg(x)
 25595  		v.AddArg(v0)
 25596  		return true
 25597  	}
 25598  	return false
 25599  }
 25600  func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool {
 25601  	b := v.Block
 25602  	_ = b
 25603  	// match: (Rsh32Ux8 <t> x (Const8 [c]))
 25604  	// cond:
 25605  	// result: (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))]))
 25606  	for {
 25607  		t := v.Type
 25608  		_ = v.Args[1]
 25609  		x := v.Args[0]
 25610  		v_1 := v.Args[1]
 25611  		if v_1.Op != OpConst8 {
 25612  			break
 25613  		}
 25614  		c := v_1.AuxInt
 25615  		v.reset(OpRsh32Ux64)
 25616  		v.AddArg(x)
 25617  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25618  		v0.AuxInt = int64(uint8(c))
 25619  		v.AddArg(v0)
 25620  		return true
 25621  	}
 25622  	// match: (Rsh32Ux8 (Const32 [0]) _)
 25623  	// cond:
 25624  	// result: (Const32 [0])
 25625  	for {
 25626  		_ = v.Args[1]
 25627  		v_0 := v.Args[0]
 25628  		if v_0.Op != OpConst32 {
 25629  			break
 25630  		}
 25631  		if v_0.AuxInt != 0 {
 25632  			break
 25633  		}
 25634  		v.reset(OpConst32)
 25635  		v.AuxInt = 0
 25636  		return true
 25637  	}
 25638  	return false
 25639  }
 25640  func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool {
 25641  	b := v.Block
 25642  	_ = b
 25643  	// match: (Rsh32x16 <t> x (Const16 [c]))
 25644  	// cond:
 25645  	// result: (Rsh32x64 x (Const64 <t> [int64(uint16(c))]))
 25646  	for {
 25647  		t := v.Type
 25648  		_ = v.Args[1]
 25649  		x := v.Args[0]
 25650  		v_1 := v.Args[1]
 25651  		if v_1.Op != OpConst16 {
 25652  			break
 25653  		}
 25654  		c := v_1.AuxInt
 25655  		v.reset(OpRsh32x64)
 25656  		v.AddArg(x)
 25657  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25658  		v0.AuxInt = int64(uint16(c))
 25659  		v.AddArg(v0)
 25660  		return true
 25661  	}
 25662  	// match: (Rsh32x16 (Const32 [0]) _)
 25663  	// cond:
 25664  	// result: (Const32 [0])
 25665  	for {
 25666  		_ = v.Args[1]
 25667  		v_0 := v.Args[0]
 25668  		if v_0.Op != OpConst32 {
 25669  			break
 25670  		}
 25671  		if v_0.AuxInt != 0 {
 25672  			break
 25673  		}
 25674  		v.reset(OpConst32)
 25675  		v.AuxInt = 0
 25676  		return true
 25677  	}
 25678  	return false
 25679  }
 25680  func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool {
 25681  	b := v.Block
 25682  	_ = b
 25683  	// match: (Rsh32x32 <t> x (Const32 [c]))
 25684  	// cond:
 25685  	// result: (Rsh32x64 x (Const64 <t> [int64(uint32(c))]))
 25686  	for {
 25687  		t := v.Type
 25688  		_ = v.Args[1]
 25689  		x := v.Args[0]
 25690  		v_1 := v.Args[1]
 25691  		if v_1.Op != OpConst32 {
 25692  			break
 25693  		}
 25694  		c := v_1.AuxInt
 25695  		v.reset(OpRsh32x64)
 25696  		v.AddArg(x)
 25697  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25698  		v0.AuxInt = int64(uint32(c))
 25699  		v.AddArg(v0)
 25700  		return true
 25701  	}
 25702  	// match: (Rsh32x32 (Const32 [0]) _)
 25703  	// cond:
 25704  	// result: (Const32 [0])
 25705  	for {
 25706  		_ = v.Args[1]
 25707  		v_0 := v.Args[0]
 25708  		if v_0.Op != OpConst32 {
 25709  			break
 25710  		}
 25711  		if v_0.AuxInt != 0 {
 25712  			break
 25713  		}
 25714  		v.reset(OpConst32)
 25715  		v.AuxInt = 0
 25716  		return true
 25717  	}
 25718  	return false
 25719  }
 25720  func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool {
 25721  	b := v.Block
 25722  	_ = b
 25723  	typ := &b.Func.Config.Types
 25724  	_ = typ
 25725  	// match: (Rsh32x64 (Const32 [c]) (Const64 [d]))
 25726  	// cond:
 25727  	// result: (Const32 [int64(int32(c) >> uint64(d))])
 25728  	for {
 25729  		_ = v.Args[1]
 25730  		v_0 := v.Args[0]
 25731  		if v_0.Op != OpConst32 {
 25732  			break
 25733  		}
 25734  		c := v_0.AuxInt
 25735  		v_1 := v.Args[1]
 25736  		if v_1.Op != OpConst64 {
 25737  			break
 25738  		}
 25739  		d := v_1.AuxInt
 25740  		v.reset(OpConst32)
 25741  		v.AuxInt = int64(int32(c) >> uint64(d))
 25742  		return true
 25743  	}
 25744  	// match: (Rsh32x64 x (Const64 [0]))
 25745  	// cond:
 25746  	// result: x
 25747  	for {
 25748  		_ = v.Args[1]
 25749  		x := v.Args[0]
 25750  		v_1 := v.Args[1]
 25751  		if v_1.Op != OpConst64 {
 25752  			break
 25753  		}
 25754  		if v_1.AuxInt != 0 {
 25755  			break
 25756  		}
 25757  		v.reset(OpCopy)
 25758  		v.Type = x.Type
 25759  		v.AddArg(x)
 25760  		return true
 25761  	}
 25762  	// match: (Rsh32x64 (Const32 [0]) _)
 25763  	// cond:
 25764  	// result: (Const32 [0])
 25765  	for {
 25766  		_ = v.Args[1]
 25767  		v_0 := v.Args[0]
 25768  		if v_0.Op != OpConst32 {
 25769  			break
 25770  		}
 25771  		if v_0.AuxInt != 0 {
 25772  			break
 25773  		}
 25774  		v.reset(OpConst32)
 25775  		v.AuxInt = 0
 25776  		return true
 25777  	}
 25778  	// match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d]))
 25779  	// cond: !uaddOvf(c,d)
 25780  	// result: (Rsh32x64 x (Const64 <t> [c+d]))
 25781  	for {
 25782  		t := v.Type
 25783  		_ = v.Args[1]
 25784  		v_0 := v.Args[0]
 25785  		if v_0.Op != OpRsh32x64 {
 25786  			break
 25787  		}
 25788  		_ = v_0.Args[1]
 25789  		x := v_0.Args[0]
 25790  		v_0_1 := v_0.Args[1]
 25791  		if v_0_1.Op != OpConst64 {
 25792  			break
 25793  		}
 25794  		c := v_0_1.AuxInt
 25795  		v_1 := v.Args[1]
 25796  		if v_1.Op != OpConst64 {
 25797  			break
 25798  		}
 25799  		d := v_1.AuxInt
 25800  		if !(!uaddOvf(c, d)) {
 25801  			break
 25802  		}
 25803  		v.reset(OpRsh32x64)
 25804  		v.AddArg(x)
 25805  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25806  		v0.AuxInt = c + d
 25807  		v.AddArg(v0)
 25808  		return true
 25809  	}
 25810  	// match: (Rsh32x64 (Lsh32x64 x (Const64 [24])) (Const64 [24]))
 25811  	// cond:
 25812  	// result: (SignExt8to32 (Trunc32to8 <typ.Int8> x))
 25813  	for {
 25814  		_ = v.Args[1]
 25815  		v_0 := v.Args[0]
 25816  		if v_0.Op != OpLsh32x64 {
 25817  			break
 25818  		}
 25819  		_ = v_0.Args[1]
 25820  		x := v_0.Args[0]
 25821  		v_0_1 := v_0.Args[1]
 25822  		if v_0_1.Op != OpConst64 {
 25823  			break
 25824  		}
 25825  		if v_0_1.AuxInt != 24 {
 25826  			break
 25827  		}
 25828  		v_1 := v.Args[1]
 25829  		if v_1.Op != OpConst64 {
 25830  			break
 25831  		}
 25832  		if v_1.AuxInt != 24 {
 25833  			break
 25834  		}
 25835  		v.reset(OpSignExt8to32)
 25836  		v0 := b.NewValue0(v.Pos, OpTrunc32to8, typ.Int8)
 25837  		v0.AddArg(x)
 25838  		v.AddArg(v0)
 25839  		return true
 25840  	}
 25841  	// match: (Rsh32x64 (Lsh32x64 x (Const64 [16])) (Const64 [16]))
 25842  	// cond:
 25843  	// result: (SignExt16to32 (Trunc32to16 <typ.Int16> x))
 25844  	for {
 25845  		_ = v.Args[1]
 25846  		v_0 := v.Args[0]
 25847  		if v_0.Op != OpLsh32x64 {
 25848  			break
 25849  		}
 25850  		_ = v_0.Args[1]
 25851  		x := v_0.Args[0]
 25852  		v_0_1 := v_0.Args[1]
 25853  		if v_0_1.Op != OpConst64 {
 25854  			break
 25855  		}
 25856  		if v_0_1.AuxInt != 16 {
 25857  			break
 25858  		}
 25859  		v_1 := v.Args[1]
 25860  		if v_1.Op != OpConst64 {
 25861  			break
 25862  		}
 25863  		if v_1.AuxInt != 16 {
 25864  			break
 25865  		}
 25866  		v.reset(OpSignExt16to32)
 25867  		v0 := b.NewValue0(v.Pos, OpTrunc32to16, typ.Int16)
 25868  		v0.AddArg(x)
 25869  		v.AddArg(v0)
 25870  		return true
 25871  	}
 25872  	return false
 25873  }
 25874  func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool {
 25875  	b := v.Block
 25876  	_ = b
 25877  	// match: (Rsh32x8 <t> x (Const8 [c]))
 25878  	// cond:
 25879  	// result: (Rsh32x64 x (Const64 <t> [int64(uint8(c))]))
 25880  	for {
 25881  		t := v.Type
 25882  		_ = v.Args[1]
 25883  		x := v.Args[0]
 25884  		v_1 := v.Args[1]
 25885  		if v_1.Op != OpConst8 {
 25886  			break
 25887  		}
 25888  		c := v_1.AuxInt
 25889  		v.reset(OpRsh32x64)
 25890  		v.AddArg(x)
 25891  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25892  		v0.AuxInt = int64(uint8(c))
 25893  		v.AddArg(v0)
 25894  		return true
 25895  	}
 25896  	// match: (Rsh32x8 (Const32 [0]) _)
 25897  	// cond:
 25898  	// result: (Const32 [0])
 25899  	for {
 25900  		_ = v.Args[1]
 25901  		v_0 := v.Args[0]
 25902  		if v_0.Op != OpConst32 {
 25903  			break
 25904  		}
 25905  		if v_0.AuxInt != 0 {
 25906  			break
 25907  		}
 25908  		v.reset(OpConst32)
 25909  		v.AuxInt = 0
 25910  		return true
 25911  	}
 25912  	return false
 25913  }
 25914  func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool {
 25915  	b := v.Block
 25916  	_ = b
 25917  	// match: (Rsh64Ux16 <t> x (Const16 [c]))
 25918  	// cond:
 25919  	// result: (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))]))
 25920  	for {
 25921  		t := v.Type
 25922  		_ = v.Args[1]
 25923  		x := v.Args[0]
 25924  		v_1 := v.Args[1]
 25925  		if v_1.Op != OpConst16 {
 25926  			break
 25927  		}
 25928  		c := v_1.AuxInt
 25929  		v.reset(OpRsh64Ux64)
 25930  		v.AddArg(x)
 25931  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25932  		v0.AuxInt = int64(uint16(c))
 25933  		v.AddArg(v0)
 25934  		return true
 25935  	}
 25936  	// match: (Rsh64Ux16 (Const64 [0]) _)
 25937  	// cond:
 25938  	// result: (Const64 [0])
 25939  	for {
 25940  		_ = v.Args[1]
 25941  		v_0 := v.Args[0]
 25942  		if v_0.Op != OpConst64 {
 25943  			break
 25944  		}
 25945  		if v_0.AuxInt != 0 {
 25946  			break
 25947  		}
 25948  		v.reset(OpConst64)
 25949  		v.AuxInt = 0
 25950  		return true
 25951  	}
 25952  	return false
 25953  }
 25954  func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool {
 25955  	b := v.Block
 25956  	_ = b
 25957  	// match: (Rsh64Ux32 <t> x (Const32 [c]))
 25958  	// cond:
 25959  	// result: (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))]))
 25960  	for {
 25961  		t := v.Type
 25962  		_ = v.Args[1]
 25963  		x := v.Args[0]
 25964  		v_1 := v.Args[1]
 25965  		if v_1.Op != OpConst32 {
 25966  			break
 25967  		}
 25968  		c := v_1.AuxInt
 25969  		v.reset(OpRsh64Ux64)
 25970  		v.AddArg(x)
 25971  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 25972  		v0.AuxInt = int64(uint32(c))
 25973  		v.AddArg(v0)
 25974  		return true
 25975  	}
 25976  	// match: (Rsh64Ux32 (Const64 [0]) _)
 25977  	// cond:
 25978  	// result: (Const64 [0])
 25979  	for {
 25980  		_ = v.Args[1]
 25981  		v_0 := v.Args[0]
 25982  		if v_0.Op != OpConst64 {
 25983  			break
 25984  		}
 25985  		if v_0.AuxInt != 0 {
 25986  			break
 25987  		}
 25988  		v.reset(OpConst64)
 25989  		v.AuxInt = 0
 25990  		return true
 25991  	}
 25992  	return false
 25993  }
 25994  func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool {
 25995  	b := v.Block
 25996  	_ = b
 25997  	typ := &b.Func.Config.Types
 25998  	_ = typ
 25999  	// match: (Rsh64Ux64 (Const64 [c]) (Const64 [d]))
 26000  	// cond:
 26001  	// result: (Const64 [int64(uint64(c) >> uint64(d))])
 26002  	for {
 26003  		_ = v.Args[1]
 26004  		v_0 := v.Args[0]
 26005  		if v_0.Op != OpConst64 {
 26006  			break
 26007  		}
 26008  		c := v_0.AuxInt
 26009  		v_1 := v.Args[1]
 26010  		if v_1.Op != OpConst64 {
 26011  			break
 26012  		}
 26013  		d := v_1.AuxInt
 26014  		v.reset(OpConst64)
 26015  		v.AuxInt = int64(uint64(c) >> uint64(d))
 26016  		return true
 26017  	}
 26018  	// match: (Rsh64Ux64 x (Const64 [0]))
 26019  	// cond:
 26020  	// result: x
 26021  	for {
 26022  		_ = v.Args[1]
 26023  		x := v.Args[0]
 26024  		v_1 := v.Args[1]
 26025  		if v_1.Op != OpConst64 {
 26026  			break
 26027  		}
 26028  		if v_1.AuxInt != 0 {
 26029  			break
 26030  		}
 26031  		v.reset(OpCopy)
 26032  		v.Type = x.Type
 26033  		v.AddArg(x)
 26034  		return true
 26035  	}
 26036  	// match: (Rsh64Ux64 (Const64 [0]) _)
 26037  	// cond:
 26038  	// result: (Const64 [0])
 26039  	for {
 26040  		_ = v.Args[1]
 26041  		v_0 := v.Args[0]
 26042  		if v_0.Op != OpConst64 {
 26043  			break
 26044  		}
 26045  		if v_0.AuxInt != 0 {
 26046  			break
 26047  		}
 26048  		v.reset(OpConst64)
 26049  		v.AuxInt = 0
 26050  		return true
 26051  	}
 26052  	// match: (Rsh64Ux64 _ (Const64 [c]))
 26053  	// cond: uint64(c) >= 64
 26054  	// result: (Const64 [0])
 26055  	for {
 26056  		_ = v.Args[1]
 26057  		v_1 := v.Args[1]
 26058  		if v_1.Op != OpConst64 {
 26059  			break
 26060  		}
 26061  		c := v_1.AuxInt
 26062  		if !(uint64(c) >= 64) {
 26063  			break
 26064  		}
 26065  		v.reset(OpConst64)
 26066  		v.AuxInt = 0
 26067  		return true
 26068  	}
 26069  	// match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d]))
 26070  	// cond: !uaddOvf(c,d)
 26071  	// result: (Rsh64Ux64 x (Const64 <t> [c+d]))
 26072  	for {
 26073  		t := v.Type
 26074  		_ = v.Args[1]
 26075  		v_0 := v.Args[0]
 26076  		if v_0.Op != OpRsh64Ux64 {
 26077  			break
 26078  		}
 26079  		_ = v_0.Args[1]
 26080  		x := v_0.Args[0]
 26081  		v_0_1 := v_0.Args[1]
 26082  		if v_0_1.Op != OpConst64 {
 26083  			break
 26084  		}
 26085  		c := v_0_1.AuxInt
 26086  		v_1 := v.Args[1]
 26087  		if v_1.Op != OpConst64 {
 26088  			break
 26089  		}
 26090  		d := v_1.AuxInt
 26091  		if !(!uaddOvf(c, d)) {
 26092  			break
 26093  		}
 26094  		v.reset(OpRsh64Ux64)
 26095  		v.AddArg(x)
 26096  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26097  		v0.AuxInt = c + d
 26098  		v.AddArg(v0)
 26099  		return true
 26100  	}
 26101  	// match: (Rsh64Ux64 (Rsh64x64 x _) (Const64 <t> [63]))
 26102  	// cond:
 26103  	// result: (Rsh64Ux64 x (Const64 <t> [63]))
 26104  	for {
 26105  		_ = v.Args[1]
 26106  		v_0 := v.Args[0]
 26107  		if v_0.Op != OpRsh64x64 {
 26108  			break
 26109  		}
 26110  		_ = v_0.Args[1]
 26111  		x := v_0.Args[0]
 26112  		v_1 := v.Args[1]
 26113  		if v_1.Op != OpConst64 {
 26114  			break
 26115  		}
 26116  		t := v_1.Type
 26117  		if v_1.AuxInt != 63 {
 26118  			break
 26119  		}
 26120  		v.reset(OpRsh64Ux64)
 26121  		v.AddArg(x)
 26122  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26123  		v0.AuxInt = 63
 26124  		v.AddArg(v0)
 26125  		return true
 26126  	}
 26127  	// match: (Rsh64Ux64 (Lsh64x64 (Rsh64Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 26128  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 26129  	// result: (Rsh64Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 26130  	for {
 26131  		_ = v.Args[1]
 26132  		v_0 := v.Args[0]
 26133  		if v_0.Op != OpLsh64x64 {
 26134  			break
 26135  		}
 26136  		_ = v_0.Args[1]
 26137  		v_0_0 := v_0.Args[0]
 26138  		if v_0_0.Op != OpRsh64Ux64 {
 26139  			break
 26140  		}
 26141  		_ = v_0_0.Args[1]
 26142  		x := v_0_0.Args[0]
 26143  		v_0_0_1 := v_0_0.Args[1]
 26144  		if v_0_0_1.Op != OpConst64 {
 26145  			break
 26146  		}
 26147  		c1 := v_0_0_1.AuxInt
 26148  		v_0_1 := v_0.Args[1]
 26149  		if v_0_1.Op != OpConst64 {
 26150  			break
 26151  		}
 26152  		c2 := v_0_1.AuxInt
 26153  		v_1 := v.Args[1]
 26154  		if v_1.Op != OpConst64 {
 26155  			break
 26156  		}
 26157  		c3 := v_1.AuxInt
 26158  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 26159  			break
 26160  		}
 26161  		v.reset(OpRsh64Ux64)
 26162  		v.AddArg(x)
 26163  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 26164  		v0.AuxInt = c1 - c2 + c3
 26165  		v.AddArg(v0)
 26166  		return true
 26167  	}
 26168  	// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
 26169  	// cond:
 26170  	// result: (ZeroExt8to64 (Trunc64to8 <typ.UInt8> x))
 26171  	for {
 26172  		_ = v.Args[1]
 26173  		v_0 := v.Args[0]
 26174  		if v_0.Op != OpLsh64x64 {
 26175  			break
 26176  		}
 26177  		_ = v_0.Args[1]
 26178  		x := v_0.Args[0]
 26179  		v_0_1 := v_0.Args[1]
 26180  		if v_0_1.Op != OpConst64 {
 26181  			break
 26182  		}
 26183  		if v_0_1.AuxInt != 56 {
 26184  			break
 26185  		}
 26186  		v_1 := v.Args[1]
 26187  		if v_1.Op != OpConst64 {
 26188  			break
 26189  		}
 26190  		if v_1.AuxInt != 56 {
 26191  			break
 26192  		}
 26193  		v.reset(OpZeroExt8to64)
 26194  		v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.UInt8)
 26195  		v0.AddArg(x)
 26196  		v.AddArg(v0)
 26197  		return true
 26198  	}
 26199  	// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
 26200  	// cond:
 26201  	// result: (ZeroExt16to64 (Trunc64to16 <typ.UInt16> x))
 26202  	for {
 26203  		_ = v.Args[1]
 26204  		v_0 := v.Args[0]
 26205  		if v_0.Op != OpLsh64x64 {
 26206  			break
 26207  		}
 26208  		_ = v_0.Args[1]
 26209  		x := v_0.Args[0]
 26210  		v_0_1 := v_0.Args[1]
 26211  		if v_0_1.Op != OpConst64 {
 26212  			break
 26213  		}
 26214  		if v_0_1.AuxInt != 48 {
 26215  			break
 26216  		}
 26217  		v_1 := v.Args[1]
 26218  		if v_1.Op != OpConst64 {
 26219  			break
 26220  		}
 26221  		if v_1.AuxInt != 48 {
 26222  			break
 26223  		}
 26224  		v.reset(OpZeroExt16to64)
 26225  		v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.UInt16)
 26226  		v0.AddArg(x)
 26227  		v.AddArg(v0)
 26228  		return true
 26229  	}
 26230  	// match: (Rsh64Ux64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
 26231  	// cond:
 26232  	// result: (ZeroExt32to64 (Trunc64to32 <typ.UInt32> x))
 26233  	for {
 26234  		_ = v.Args[1]
 26235  		v_0 := v.Args[0]
 26236  		if v_0.Op != OpLsh64x64 {
 26237  			break
 26238  		}
 26239  		_ = v_0.Args[1]
 26240  		x := v_0.Args[0]
 26241  		v_0_1 := v_0.Args[1]
 26242  		if v_0_1.Op != OpConst64 {
 26243  			break
 26244  		}
 26245  		if v_0_1.AuxInt != 32 {
 26246  			break
 26247  		}
 26248  		v_1 := v.Args[1]
 26249  		if v_1.Op != OpConst64 {
 26250  			break
 26251  		}
 26252  		if v_1.AuxInt != 32 {
 26253  			break
 26254  		}
 26255  		v.reset(OpZeroExt32to64)
 26256  		v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.UInt32)
 26257  		v0.AddArg(x)
 26258  		v.AddArg(v0)
 26259  		return true
 26260  	}
 26261  	return false
 26262  }
 26263  func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool {
 26264  	b := v.Block
 26265  	_ = b
 26266  	// match: (Rsh64Ux8 <t> x (Const8 [c]))
 26267  	// cond:
 26268  	// result: (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))]))
 26269  	for {
 26270  		t := v.Type
 26271  		_ = v.Args[1]
 26272  		x := v.Args[0]
 26273  		v_1 := v.Args[1]
 26274  		if v_1.Op != OpConst8 {
 26275  			break
 26276  		}
 26277  		c := v_1.AuxInt
 26278  		v.reset(OpRsh64Ux64)
 26279  		v.AddArg(x)
 26280  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26281  		v0.AuxInt = int64(uint8(c))
 26282  		v.AddArg(v0)
 26283  		return true
 26284  	}
 26285  	// match: (Rsh64Ux8 (Const64 [0]) _)
 26286  	// cond:
 26287  	// result: (Const64 [0])
 26288  	for {
 26289  		_ = v.Args[1]
 26290  		v_0 := v.Args[0]
 26291  		if v_0.Op != OpConst64 {
 26292  			break
 26293  		}
 26294  		if v_0.AuxInt != 0 {
 26295  			break
 26296  		}
 26297  		v.reset(OpConst64)
 26298  		v.AuxInt = 0
 26299  		return true
 26300  	}
 26301  	return false
 26302  }
 26303  func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool {
 26304  	b := v.Block
 26305  	_ = b
 26306  	// match: (Rsh64x16 <t> x (Const16 [c]))
 26307  	// cond:
 26308  	// result: (Rsh64x64 x (Const64 <t> [int64(uint16(c))]))
 26309  	for {
 26310  		t := v.Type
 26311  		_ = v.Args[1]
 26312  		x := v.Args[0]
 26313  		v_1 := v.Args[1]
 26314  		if v_1.Op != OpConst16 {
 26315  			break
 26316  		}
 26317  		c := v_1.AuxInt
 26318  		v.reset(OpRsh64x64)
 26319  		v.AddArg(x)
 26320  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26321  		v0.AuxInt = int64(uint16(c))
 26322  		v.AddArg(v0)
 26323  		return true
 26324  	}
 26325  	// match: (Rsh64x16 (Const64 [0]) _)
 26326  	// cond:
 26327  	// result: (Const64 [0])
 26328  	for {
 26329  		_ = v.Args[1]
 26330  		v_0 := v.Args[0]
 26331  		if v_0.Op != OpConst64 {
 26332  			break
 26333  		}
 26334  		if v_0.AuxInt != 0 {
 26335  			break
 26336  		}
 26337  		v.reset(OpConst64)
 26338  		v.AuxInt = 0
 26339  		return true
 26340  	}
 26341  	return false
 26342  }
 26343  func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool {
 26344  	b := v.Block
 26345  	_ = b
 26346  	// match: (Rsh64x32 <t> x (Const32 [c]))
 26347  	// cond:
 26348  	// result: (Rsh64x64 x (Const64 <t> [int64(uint32(c))]))
 26349  	for {
 26350  		t := v.Type
 26351  		_ = v.Args[1]
 26352  		x := v.Args[0]
 26353  		v_1 := v.Args[1]
 26354  		if v_1.Op != OpConst32 {
 26355  			break
 26356  		}
 26357  		c := v_1.AuxInt
 26358  		v.reset(OpRsh64x64)
 26359  		v.AddArg(x)
 26360  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26361  		v0.AuxInt = int64(uint32(c))
 26362  		v.AddArg(v0)
 26363  		return true
 26364  	}
 26365  	// match: (Rsh64x32 (Const64 [0]) _)
 26366  	// cond:
 26367  	// result: (Const64 [0])
 26368  	for {
 26369  		_ = v.Args[1]
 26370  		v_0 := v.Args[0]
 26371  		if v_0.Op != OpConst64 {
 26372  			break
 26373  		}
 26374  		if v_0.AuxInt != 0 {
 26375  			break
 26376  		}
 26377  		v.reset(OpConst64)
 26378  		v.AuxInt = 0
 26379  		return true
 26380  	}
 26381  	return false
 26382  }
 26383  func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool {
 26384  	b := v.Block
 26385  	_ = b
 26386  	typ := &b.Func.Config.Types
 26387  	_ = typ
 26388  	// match: (Rsh64x64 (Const64 [c]) (Const64 [d]))
 26389  	// cond:
 26390  	// result: (Const64 [c >> uint64(d)])
 26391  	for {
 26392  		_ = v.Args[1]
 26393  		v_0 := v.Args[0]
 26394  		if v_0.Op != OpConst64 {
 26395  			break
 26396  		}
 26397  		c := v_0.AuxInt
 26398  		v_1 := v.Args[1]
 26399  		if v_1.Op != OpConst64 {
 26400  			break
 26401  		}
 26402  		d := v_1.AuxInt
 26403  		v.reset(OpConst64)
 26404  		v.AuxInt = c >> uint64(d)
 26405  		return true
 26406  	}
 26407  	// match: (Rsh64x64 x (Const64 [0]))
 26408  	// cond:
 26409  	// result: x
 26410  	for {
 26411  		_ = v.Args[1]
 26412  		x := v.Args[0]
 26413  		v_1 := v.Args[1]
 26414  		if v_1.Op != OpConst64 {
 26415  			break
 26416  		}
 26417  		if v_1.AuxInt != 0 {
 26418  			break
 26419  		}
 26420  		v.reset(OpCopy)
 26421  		v.Type = x.Type
 26422  		v.AddArg(x)
 26423  		return true
 26424  	}
 26425  	// match: (Rsh64x64 (Const64 [0]) _)
 26426  	// cond:
 26427  	// result: (Const64 [0])
 26428  	for {
 26429  		_ = v.Args[1]
 26430  		v_0 := v.Args[0]
 26431  		if v_0.Op != OpConst64 {
 26432  			break
 26433  		}
 26434  		if v_0.AuxInt != 0 {
 26435  			break
 26436  		}
 26437  		v.reset(OpConst64)
 26438  		v.AuxInt = 0
 26439  		return true
 26440  	}
 26441  	// match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d]))
 26442  	// cond: !uaddOvf(c,d)
 26443  	// result: (Rsh64x64 x (Const64 <t> [c+d]))
 26444  	for {
 26445  		t := v.Type
 26446  		_ = v.Args[1]
 26447  		v_0 := v.Args[0]
 26448  		if v_0.Op != OpRsh64x64 {
 26449  			break
 26450  		}
 26451  		_ = v_0.Args[1]
 26452  		x := v_0.Args[0]
 26453  		v_0_1 := v_0.Args[1]
 26454  		if v_0_1.Op != OpConst64 {
 26455  			break
 26456  		}
 26457  		c := v_0_1.AuxInt
 26458  		v_1 := v.Args[1]
 26459  		if v_1.Op != OpConst64 {
 26460  			break
 26461  		}
 26462  		d := v_1.AuxInt
 26463  		if !(!uaddOvf(c, d)) {
 26464  			break
 26465  		}
 26466  		v.reset(OpRsh64x64)
 26467  		v.AddArg(x)
 26468  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26469  		v0.AuxInt = c + d
 26470  		v.AddArg(v0)
 26471  		return true
 26472  	}
 26473  	// match: (Rsh64x64 (Lsh64x64 x (Const64 [56])) (Const64 [56]))
 26474  	// cond:
 26475  	// result: (SignExt8to64 (Trunc64to8 <typ.Int8> x))
 26476  	for {
 26477  		_ = v.Args[1]
 26478  		v_0 := v.Args[0]
 26479  		if v_0.Op != OpLsh64x64 {
 26480  			break
 26481  		}
 26482  		_ = v_0.Args[1]
 26483  		x := v_0.Args[0]
 26484  		v_0_1 := v_0.Args[1]
 26485  		if v_0_1.Op != OpConst64 {
 26486  			break
 26487  		}
 26488  		if v_0_1.AuxInt != 56 {
 26489  			break
 26490  		}
 26491  		v_1 := v.Args[1]
 26492  		if v_1.Op != OpConst64 {
 26493  			break
 26494  		}
 26495  		if v_1.AuxInt != 56 {
 26496  			break
 26497  		}
 26498  		v.reset(OpSignExt8to64)
 26499  		v0 := b.NewValue0(v.Pos, OpTrunc64to8, typ.Int8)
 26500  		v0.AddArg(x)
 26501  		v.AddArg(v0)
 26502  		return true
 26503  	}
 26504  	// match: (Rsh64x64 (Lsh64x64 x (Const64 [48])) (Const64 [48]))
 26505  	// cond:
 26506  	// result: (SignExt16to64 (Trunc64to16 <typ.Int16> x))
 26507  	for {
 26508  		_ = v.Args[1]
 26509  		v_0 := v.Args[0]
 26510  		if v_0.Op != OpLsh64x64 {
 26511  			break
 26512  		}
 26513  		_ = v_0.Args[1]
 26514  		x := v_0.Args[0]
 26515  		v_0_1 := v_0.Args[1]
 26516  		if v_0_1.Op != OpConst64 {
 26517  			break
 26518  		}
 26519  		if v_0_1.AuxInt != 48 {
 26520  			break
 26521  		}
 26522  		v_1 := v.Args[1]
 26523  		if v_1.Op != OpConst64 {
 26524  			break
 26525  		}
 26526  		if v_1.AuxInt != 48 {
 26527  			break
 26528  		}
 26529  		v.reset(OpSignExt16to64)
 26530  		v0 := b.NewValue0(v.Pos, OpTrunc64to16, typ.Int16)
 26531  		v0.AddArg(x)
 26532  		v.AddArg(v0)
 26533  		return true
 26534  	}
 26535  	// match: (Rsh64x64 (Lsh64x64 x (Const64 [32])) (Const64 [32]))
 26536  	// cond:
 26537  	// result: (SignExt32to64 (Trunc64to32 <typ.Int32> x))
 26538  	for {
 26539  		_ = v.Args[1]
 26540  		v_0 := v.Args[0]
 26541  		if v_0.Op != OpLsh64x64 {
 26542  			break
 26543  		}
 26544  		_ = v_0.Args[1]
 26545  		x := v_0.Args[0]
 26546  		v_0_1 := v_0.Args[1]
 26547  		if v_0_1.Op != OpConst64 {
 26548  			break
 26549  		}
 26550  		if v_0_1.AuxInt != 32 {
 26551  			break
 26552  		}
 26553  		v_1 := v.Args[1]
 26554  		if v_1.Op != OpConst64 {
 26555  			break
 26556  		}
 26557  		if v_1.AuxInt != 32 {
 26558  			break
 26559  		}
 26560  		v.reset(OpSignExt32to64)
 26561  		v0 := b.NewValue0(v.Pos, OpTrunc64to32, typ.Int32)
 26562  		v0.AddArg(x)
 26563  		v.AddArg(v0)
 26564  		return true
 26565  	}
 26566  	return false
 26567  }
 26568  func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool {
 26569  	b := v.Block
 26570  	_ = b
 26571  	// match: (Rsh64x8 <t> x (Const8 [c]))
 26572  	// cond:
 26573  	// result: (Rsh64x64 x (Const64 <t> [int64(uint8(c))]))
 26574  	for {
 26575  		t := v.Type
 26576  		_ = v.Args[1]
 26577  		x := v.Args[0]
 26578  		v_1 := v.Args[1]
 26579  		if v_1.Op != OpConst8 {
 26580  			break
 26581  		}
 26582  		c := v_1.AuxInt
 26583  		v.reset(OpRsh64x64)
 26584  		v.AddArg(x)
 26585  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26586  		v0.AuxInt = int64(uint8(c))
 26587  		v.AddArg(v0)
 26588  		return true
 26589  	}
 26590  	// match: (Rsh64x8 (Const64 [0]) _)
 26591  	// cond:
 26592  	// result: (Const64 [0])
 26593  	for {
 26594  		_ = v.Args[1]
 26595  		v_0 := v.Args[0]
 26596  		if v_0.Op != OpConst64 {
 26597  			break
 26598  		}
 26599  		if v_0.AuxInt != 0 {
 26600  			break
 26601  		}
 26602  		v.reset(OpConst64)
 26603  		v.AuxInt = 0
 26604  		return true
 26605  	}
 26606  	return false
 26607  }
 26608  func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool {
 26609  	b := v.Block
 26610  	_ = b
 26611  	// match: (Rsh8Ux16 <t> x (Const16 [c]))
 26612  	// cond:
 26613  	// result: (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))]))
 26614  	for {
 26615  		t := v.Type
 26616  		_ = v.Args[1]
 26617  		x := v.Args[0]
 26618  		v_1 := v.Args[1]
 26619  		if v_1.Op != OpConst16 {
 26620  			break
 26621  		}
 26622  		c := v_1.AuxInt
 26623  		v.reset(OpRsh8Ux64)
 26624  		v.AddArg(x)
 26625  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26626  		v0.AuxInt = int64(uint16(c))
 26627  		v.AddArg(v0)
 26628  		return true
 26629  	}
 26630  	// match: (Rsh8Ux16 (Const8 [0]) _)
 26631  	// cond:
 26632  	// result: (Const8 [0])
 26633  	for {
 26634  		_ = v.Args[1]
 26635  		v_0 := v.Args[0]
 26636  		if v_0.Op != OpConst8 {
 26637  			break
 26638  		}
 26639  		if v_0.AuxInt != 0 {
 26640  			break
 26641  		}
 26642  		v.reset(OpConst8)
 26643  		v.AuxInt = 0
 26644  		return true
 26645  	}
 26646  	return false
 26647  }
 26648  func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool {
 26649  	b := v.Block
 26650  	_ = b
 26651  	// match: (Rsh8Ux32 <t> x (Const32 [c]))
 26652  	// cond:
 26653  	// result: (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))]))
 26654  	for {
 26655  		t := v.Type
 26656  		_ = v.Args[1]
 26657  		x := v.Args[0]
 26658  		v_1 := v.Args[1]
 26659  		if v_1.Op != OpConst32 {
 26660  			break
 26661  		}
 26662  		c := v_1.AuxInt
 26663  		v.reset(OpRsh8Ux64)
 26664  		v.AddArg(x)
 26665  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26666  		v0.AuxInt = int64(uint32(c))
 26667  		v.AddArg(v0)
 26668  		return true
 26669  	}
 26670  	// match: (Rsh8Ux32 (Const8 [0]) _)
 26671  	// cond:
 26672  	// result: (Const8 [0])
 26673  	for {
 26674  		_ = v.Args[1]
 26675  		v_0 := v.Args[0]
 26676  		if v_0.Op != OpConst8 {
 26677  			break
 26678  		}
 26679  		if v_0.AuxInt != 0 {
 26680  			break
 26681  		}
 26682  		v.reset(OpConst8)
 26683  		v.AuxInt = 0
 26684  		return true
 26685  	}
 26686  	return false
 26687  }
 26688  func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool {
 26689  	b := v.Block
 26690  	_ = b
 26691  	typ := &b.Func.Config.Types
 26692  	_ = typ
 26693  	// match: (Rsh8Ux64 (Const8 [c]) (Const64 [d]))
 26694  	// cond:
 26695  	// result: (Const8 [int64(int8(uint8(c) >> uint64(d)))])
 26696  	for {
 26697  		_ = v.Args[1]
 26698  		v_0 := v.Args[0]
 26699  		if v_0.Op != OpConst8 {
 26700  			break
 26701  		}
 26702  		c := v_0.AuxInt
 26703  		v_1 := v.Args[1]
 26704  		if v_1.Op != OpConst64 {
 26705  			break
 26706  		}
 26707  		d := v_1.AuxInt
 26708  		v.reset(OpConst8)
 26709  		v.AuxInt = int64(int8(uint8(c) >> uint64(d)))
 26710  		return true
 26711  	}
 26712  	// match: (Rsh8Ux64 x (Const64 [0]))
 26713  	// cond:
 26714  	// result: x
 26715  	for {
 26716  		_ = v.Args[1]
 26717  		x := v.Args[0]
 26718  		v_1 := v.Args[1]
 26719  		if v_1.Op != OpConst64 {
 26720  			break
 26721  		}
 26722  		if v_1.AuxInt != 0 {
 26723  			break
 26724  		}
 26725  		v.reset(OpCopy)
 26726  		v.Type = x.Type
 26727  		v.AddArg(x)
 26728  		return true
 26729  	}
 26730  	// match: (Rsh8Ux64 (Const8 [0]) _)
 26731  	// cond:
 26732  	// result: (Const8 [0])
 26733  	for {
 26734  		_ = v.Args[1]
 26735  		v_0 := v.Args[0]
 26736  		if v_0.Op != OpConst8 {
 26737  			break
 26738  		}
 26739  		if v_0.AuxInt != 0 {
 26740  			break
 26741  		}
 26742  		v.reset(OpConst8)
 26743  		v.AuxInt = 0
 26744  		return true
 26745  	}
 26746  	// match: (Rsh8Ux64 _ (Const64 [c]))
 26747  	// cond: uint64(c) >= 8
 26748  	// result: (Const8 [0])
 26749  	for {
 26750  		_ = v.Args[1]
 26751  		v_1 := v.Args[1]
 26752  		if v_1.Op != OpConst64 {
 26753  			break
 26754  		}
 26755  		c := v_1.AuxInt
 26756  		if !(uint64(c) >= 8) {
 26757  			break
 26758  		}
 26759  		v.reset(OpConst8)
 26760  		v.AuxInt = 0
 26761  		return true
 26762  	}
 26763  	// match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d]))
 26764  	// cond: !uaddOvf(c,d)
 26765  	// result: (Rsh8Ux64 x (Const64 <t> [c+d]))
 26766  	for {
 26767  		t := v.Type
 26768  		_ = v.Args[1]
 26769  		v_0 := v.Args[0]
 26770  		if v_0.Op != OpRsh8Ux64 {
 26771  			break
 26772  		}
 26773  		_ = v_0.Args[1]
 26774  		x := v_0.Args[0]
 26775  		v_0_1 := v_0.Args[1]
 26776  		if v_0_1.Op != OpConst64 {
 26777  			break
 26778  		}
 26779  		c := v_0_1.AuxInt
 26780  		v_1 := v.Args[1]
 26781  		if v_1.Op != OpConst64 {
 26782  			break
 26783  		}
 26784  		d := v_1.AuxInt
 26785  		if !(!uaddOvf(c, d)) {
 26786  			break
 26787  		}
 26788  		v.reset(OpRsh8Ux64)
 26789  		v.AddArg(x)
 26790  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26791  		v0.AuxInt = c + d
 26792  		v.AddArg(v0)
 26793  		return true
 26794  	}
 26795  	// match: (Rsh8Ux64 (Rsh8x64 x _) (Const64 <t> [7]))
 26796  	// cond:
 26797  	// result: (Rsh8Ux64 x (Const64 <t> [7] ))
 26798  	for {
 26799  		_ = v.Args[1]
 26800  		v_0 := v.Args[0]
 26801  		if v_0.Op != OpRsh8x64 {
 26802  			break
 26803  		}
 26804  		_ = v_0.Args[1]
 26805  		x := v_0.Args[0]
 26806  		v_1 := v.Args[1]
 26807  		if v_1.Op != OpConst64 {
 26808  			break
 26809  		}
 26810  		t := v_1.Type
 26811  		if v_1.AuxInt != 7 {
 26812  			break
 26813  		}
 26814  		v.reset(OpRsh8Ux64)
 26815  		v.AddArg(x)
 26816  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26817  		v0.AuxInt = 7
 26818  		v.AddArg(v0)
 26819  		return true
 26820  	}
 26821  	// match: (Rsh8Ux64 (Lsh8x64 (Rsh8Ux64 x (Const64 [c1])) (Const64 [c2])) (Const64 [c3]))
 26822  	// cond: uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)
 26823  	// result: (Rsh8Ux64 x (Const64 <typ.UInt64> [c1-c2+c3]))
 26824  	for {
 26825  		_ = v.Args[1]
 26826  		v_0 := v.Args[0]
 26827  		if v_0.Op != OpLsh8x64 {
 26828  			break
 26829  		}
 26830  		_ = v_0.Args[1]
 26831  		v_0_0 := v_0.Args[0]
 26832  		if v_0_0.Op != OpRsh8Ux64 {
 26833  			break
 26834  		}
 26835  		_ = v_0_0.Args[1]
 26836  		x := v_0_0.Args[0]
 26837  		v_0_0_1 := v_0_0.Args[1]
 26838  		if v_0_0_1.Op != OpConst64 {
 26839  			break
 26840  		}
 26841  		c1 := v_0_0_1.AuxInt
 26842  		v_0_1 := v_0.Args[1]
 26843  		if v_0_1.Op != OpConst64 {
 26844  			break
 26845  		}
 26846  		c2 := v_0_1.AuxInt
 26847  		v_1 := v.Args[1]
 26848  		if v_1.Op != OpConst64 {
 26849  			break
 26850  		}
 26851  		c3 := v_1.AuxInt
 26852  		if !(uint64(c1) >= uint64(c2) && uint64(c3) >= uint64(c2) && !uaddOvf(c1-c2, c3)) {
 26853  			break
 26854  		}
 26855  		v.reset(OpRsh8Ux64)
 26856  		v.AddArg(x)
 26857  		v0 := b.NewValue0(v.Pos, OpConst64, typ.UInt64)
 26858  		v0.AuxInt = c1 - c2 + c3
 26859  		v.AddArg(v0)
 26860  		return true
 26861  	}
 26862  	return false
 26863  }
 26864  func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool {
 26865  	b := v.Block
 26866  	_ = b
 26867  	// match: (Rsh8Ux8 <t> x (Const8 [c]))
 26868  	// cond:
 26869  	// result: (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))]))
 26870  	for {
 26871  		t := v.Type
 26872  		_ = v.Args[1]
 26873  		x := v.Args[0]
 26874  		v_1 := v.Args[1]
 26875  		if v_1.Op != OpConst8 {
 26876  			break
 26877  		}
 26878  		c := v_1.AuxInt
 26879  		v.reset(OpRsh8Ux64)
 26880  		v.AddArg(x)
 26881  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26882  		v0.AuxInt = int64(uint8(c))
 26883  		v.AddArg(v0)
 26884  		return true
 26885  	}
 26886  	// match: (Rsh8Ux8 (Const8 [0]) _)
 26887  	// cond:
 26888  	// result: (Const8 [0])
 26889  	for {
 26890  		_ = v.Args[1]
 26891  		v_0 := v.Args[0]
 26892  		if v_0.Op != OpConst8 {
 26893  			break
 26894  		}
 26895  		if v_0.AuxInt != 0 {
 26896  			break
 26897  		}
 26898  		v.reset(OpConst8)
 26899  		v.AuxInt = 0
 26900  		return true
 26901  	}
 26902  	return false
 26903  }
 26904  func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool {
 26905  	b := v.Block
 26906  	_ = b
 26907  	// match: (Rsh8x16 <t> x (Const16 [c]))
 26908  	// cond:
 26909  	// result: (Rsh8x64 x (Const64 <t> [int64(uint16(c))]))
 26910  	for {
 26911  		t := v.Type
 26912  		_ = v.Args[1]
 26913  		x := v.Args[0]
 26914  		v_1 := v.Args[1]
 26915  		if v_1.Op != OpConst16 {
 26916  			break
 26917  		}
 26918  		c := v_1.AuxInt
 26919  		v.reset(OpRsh8x64)
 26920  		v.AddArg(x)
 26921  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26922  		v0.AuxInt = int64(uint16(c))
 26923  		v.AddArg(v0)
 26924  		return true
 26925  	}
 26926  	// match: (Rsh8x16 (Const8 [0]) _)
 26927  	// cond:
 26928  	// result: (Const8 [0])
 26929  	for {
 26930  		_ = v.Args[1]
 26931  		v_0 := v.Args[0]
 26932  		if v_0.Op != OpConst8 {
 26933  			break
 26934  		}
 26935  		if v_0.AuxInt != 0 {
 26936  			break
 26937  		}
 26938  		v.reset(OpConst8)
 26939  		v.AuxInt = 0
 26940  		return true
 26941  	}
 26942  	return false
 26943  }
 26944  func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool {
 26945  	b := v.Block
 26946  	_ = b
 26947  	// match: (Rsh8x32 <t> x (Const32 [c]))
 26948  	// cond:
 26949  	// result: (Rsh8x64 x (Const64 <t> [int64(uint32(c))]))
 26950  	for {
 26951  		t := v.Type
 26952  		_ = v.Args[1]
 26953  		x := v.Args[0]
 26954  		v_1 := v.Args[1]
 26955  		if v_1.Op != OpConst32 {
 26956  			break
 26957  		}
 26958  		c := v_1.AuxInt
 26959  		v.reset(OpRsh8x64)
 26960  		v.AddArg(x)
 26961  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 26962  		v0.AuxInt = int64(uint32(c))
 26963  		v.AddArg(v0)
 26964  		return true
 26965  	}
 26966  	// match: (Rsh8x32 (Const8 [0]) _)
 26967  	// cond:
 26968  	// result: (Const8 [0])
 26969  	for {
 26970  		_ = v.Args[1]
 26971  		v_0 := v.Args[0]
 26972  		if v_0.Op != OpConst8 {
 26973  			break
 26974  		}
 26975  		if v_0.AuxInt != 0 {
 26976  			break
 26977  		}
 26978  		v.reset(OpConst8)
 26979  		v.AuxInt = 0
 26980  		return true
 26981  	}
 26982  	return false
 26983  }
 26984  func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool {
 26985  	b := v.Block
 26986  	_ = b
 26987  	// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
 26988  	// cond:
 26989  	// result: (Const8 [int64(int8(c) >> uint64(d))])
 26990  	for {
 26991  		_ = v.Args[1]
 26992  		v_0 := v.Args[0]
 26993  		if v_0.Op != OpConst8 {
 26994  			break
 26995  		}
 26996  		c := v_0.AuxInt
 26997  		v_1 := v.Args[1]
 26998  		if v_1.Op != OpConst64 {
 26999  			break
 27000  		}
 27001  		d := v_1.AuxInt
 27002  		v.reset(OpConst8)
 27003  		v.AuxInt = int64(int8(c) >> uint64(d))
 27004  		return true
 27005  	}
 27006  	// match: (Rsh8x64 x (Const64 [0]))
 27007  	// cond:
 27008  	// result: x
 27009  	for {
 27010  		_ = v.Args[1]
 27011  		x := v.Args[0]
 27012  		v_1 := v.Args[1]
 27013  		if v_1.Op != OpConst64 {
 27014  			break
 27015  		}
 27016  		if v_1.AuxInt != 0 {
 27017  			break
 27018  		}
 27019  		v.reset(OpCopy)
 27020  		v.Type = x.Type
 27021  		v.AddArg(x)
 27022  		return true
 27023  	}
 27024  	// match: (Rsh8x64 (Const8 [0]) _)
 27025  	// cond:
 27026  	// result: (Const8 [0])
 27027  	for {
 27028  		_ = v.Args[1]
 27029  		v_0 := v.Args[0]
 27030  		if v_0.Op != OpConst8 {
 27031  			break
 27032  		}
 27033  		if v_0.AuxInt != 0 {
 27034  			break
 27035  		}
 27036  		v.reset(OpConst8)
 27037  		v.AuxInt = 0
 27038  		return true
 27039  	}
 27040  	// match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d]))
 27041  	// cond: !uaddOvf(c,d)
 27042  	// result: (Rsh8x64 x (Const64 <t> [c+d]))
 27043  	for {
 27044  		t := v.Type
 27045  		_ = v.Args[1]
 27046  		v_0 := v.Args[0]
 27047  		if v_0.Op != OpRsh8x64 {
 27048  			break
 27049  		}
 27050  		_ = v_0.Args[1]
 27051  		x := v_0.Args[0]
 27052  		v_0_1 := v_0.Args[1]
 27053  		if v_0_1.Op != OpConst64 {
 27054  			break
 27055  		}
 27056  		c := v_0_1.AuxInt
 27057  		v_1 := v.Args[1]
 27058  		if v_1.Op != OpConst64 {
 27059  			break
 27060  		}
 27061  		d := v_1.AuxInt
 27062  		if !(!uaddOvf(c, d)) {
 27063  			break
 27064  		}
 27065  		v.reset(OpRsh8x64)
 27066  		v.AddArg(x)
 27067  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 27068  		v0.AuxInt = c + d
 27069  		v.AddArg(v0)
 27070  		return true
 27071  	}
 27072  	return false
 27073  }
 27074  func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool {
 27075  	b := v.Block
 27076  	_ = b
 27077  	// match: (Rsh8x8 <t> x (Const8 [c]))
 27078  	// cond:
 27079  	// result: (Rsh8x64 x (Const64 <t> [int64(uint8(c))]))
 27080  	for {
 27081  		t := v.Type
 27082  		_ = v.Args[1]
 27083  		x := v.Args[0]
 27084  		v_1 := v.Args[1]
 27085  		if v_1.Op != OpConst8 {
 27086  			break
 27087  		}
 27088  		c := v_1.AuxInt
 27089  		v.reset(OpRsh8x64)
 27090  		v.AddArg(x)
 27091  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 27092  		v0.AuxInt = int64(uint8(c))
 27093  		v.AddArg(v0)
 27094  		return true
 27095  	}
 27096  	// match: (Rsh8x8 (Const8 [0]) _)
 27097  	// cond:
 27098  	// result: (Const8 [0])
 27099  	for {
 27100  		_ = v.Args[1]
 27101  		v_0 := v.Args[0]
 27102  		if v_0.Op != OpConst8 {
 27103  			break
 27104  		}
 27105  		if v_0.AuxInt != 0 {
 27106  			break
 27107  		}
 27108  		v.reset(OpConst8)
 27109  		v.AuxInt = 0
 27110  		return true
 27111  	}
 27112  	return false
 27113  }
 27114  func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool {
 27115  	// match: (SignExt16to32 (Const16 [c]))
 27116  	// cond:
 27117  	// result: (Const32 [int64( int16(c))])
 27118  	for {
 27119  		v_0 := v.Args[0]
 27120  		if v_0.Op != OpConst16 {
 27121  			break
 27122  		}
 27123  		c := v_0.AuxInt
 27124  		v.reset(OpConst32)
 27125  		v.AuxInt = int64(int16(c))
 27126  		return true
 27127  	}
 27128  	// match: (SignExt16to32 (Trunc32to16 x:(Rsh32x64 _ (Const64 [s]))))
 27129  	// cond: s >= 16
 27130  	// result: x
 27131  	for {
 27132  		v_0 := v.Args[0]
 27133  		if v_0.Op != OpTrunc32to16 {
 27134  			break
 27135  		}
 27136  		x := v_0.Args[0]
 27137  		if x.Op != OpRsh32x64 {
 27138  			break
 27139  		}
 27140  		_ = x.Args[1]
 27141  		x_1 := x.Args[1]
 27142  		if x_1.Op != OpConst64 {
 27143  			break
 27144  		}
 27145  		s := x_1.AuxInt
 27146  		if !(s >= 16) {
 27147  			break
 27148  		}
 27149  		v.reset(OpCopy)
 27150  		v.Type = x.Type
 27151  		v.AddArg(x)
 27152  		return true
 27153  	}
 27154  	return false
 27155  }
 27156  func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool {
 27157  	// match: (SignExt16to64 (Const16 [c]))
 27158  	// cond:
 27159  	// result: (Const64 [int64( int16(c))])
 27160  	for {
 27161  		v_0 := v.Args[0]
 27162  		if v_0.Op != OpConst16 {
 27163  			break
 27164  		}
 27165  		c := v_0.AuxInt
 27166  		v.reset(OpConst64)
 27167  		v.AuxInt = int64(int16(c))
 27168  		return true
 27169  	}
 27170  	// match: (SignExt16to64 (Trunc64to16 x:(Rsh64x64 _ (Const64 [s]))))
 27171  	// cond: s >= 48
 27172  	// result: x
 27173  	for {
 27174  		v_0 := v.Args[0]
 27175  		if v_0.Op != OpTrunc64to16 {
 27176  			break
 27177  		}
 27178  		x := v_0.Args[0]
 27179  		if x.Op != OpRsh64x64 {
 27180  			break
 27181  		}
 27182  		_ = x.Args[1]
 27183  		x_1 := x.Args[1]
 27184  		if x_1.Op != OpConst64 {
 27185  			break
 27186  		}
 27187  		s := x_1.AuxInt
 27188  		if !(s >= 48) {
 27189  			break
 27190  		}
 27191  		v.reset(OpCopy)
 27192  		v.Type = x.Type
 27193  		v.AddArg(x)
 27194  		return true
 27195  	}
 27196  	return false
 27197  }
 27198  func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool {
 27199  	// match: (SignExt32to64 (Const32 [c]))
 27200  	// cond:
 27201  	// result: (Const64 [int64( int32(c))])
 27202  	for {
 27203  		v_0 := v.Args[0]
 27204  		if v_0.Op != OpConst32 {
 27205  			break
 27206  		}
 27207  		c := v_0.AuxInt
 27208  		v.reset(OpConst64)
 27209  		v.AuxInt = int64(int32(c))
 27210  		return true
 27211  	}
 27212  	// match: (SignExt32to64 (Trunc64to32 x:(Rsh64x64 _ (Const64 [s]))))
 27213  	// cond: s >= 32
 27214  	// result: x
 27215  	for {
 27216  		v_0 := v.Args[0]
 27217  		if v_0.Op != OpTrunc64to32 {
 27218  			break
 27219  		}
 27220  		x := v_0.Args[0]
 27221  		if x.Op != OpRsh64x64 {
 27222  			break
 27223  		}
 27224  		_ = x.Args[1]
 27225  		x_1 := x.Args[1]
 27226  		if x_1.Op != OpConst64 {
 27227  			break
 27228  		}
 27229  		s := x_1.AuxInt
 27230  		if !(s >= 32) {
 27231  			break
 27232  		}
 27233  		v.reset(OpCopy)
 27234  		v.Type = x.Type
 27235  		v.AddArg(x)
 27236  		return true
 27237  	}
 27238  	return false
 27239  }
 27240  func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool {
 27241  	// match: (SignExt8to16 (Const8 [c]))
 27242  	// cond:
 27243  	// result: (Const16 [int64( int8(c))])
 27244  	for {
 27245  		v_0 := v.Args[0]
 27246  		if v_0.Op != OpConst8 {
 27247  			break
 27248  		}
 27249  		c := v_0.AuxInt
 27250  		v.reset(OpConst16)
 27251  		v.AuxInt = int64(int8(c))
 27252  		return true
 27253  	}
 27254  	// match: (SignExt8to16 (Trunc16to8 x:(Rsh16x64 _ (Const64 [s]))))
 27255  	// cond: s >= 8
 27256  	// result: x
 27257  	for {
 27258  		v_0 := v.Args[0]
 27259  		if v_0.Op != OpTrunc16to8 {
 27260  			break
 27261  		}
 27262  		x := v_0.Args[0]
 27263  		if x.Op != OpRsh16x64 {
 27264  			break
 27265  		}
 27266  		_ = x.Args[1]
 27267  		x_1 := x.Args[1]
 27268  		if x_1.Op != OpConst64 {
 27269  			break
 27270  		}
 27271  		s := x_1.AuxInt
 27272  		if !(s >= 8) {
 27273  			break
 27274  		}
 27275  		v.reset(OpCopy)
 27276  		v.Type = x.Type
 27277  		v.AddArg(x)
 27278  		return true
 27279  	}
 27280  	return false
 27281  }
 27282  func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool {
 27283  	// match: (SignExt8to32 (Const8 [c]))
 27284  	// cond:
 27285  	// result: (Const32 [int64( int8(c))])
 27286  	for {
 27287  		v_0 := v.Args[0]
 27288  		if v_0.Op != OpConst8 {
 27289  			break
 27290  		}
 27291  		c := v_0.AuxInt
 27292  		v.reset(OpConst32)
 27293  		v.AuxInt = int64(int8(c))
 27294  		return true
 27295  	}
 27296  	// match: (SignExt8to32 (Trunc32to8 x:(Rsh32x64 _ (Const64 [s]))))
 27297  	// cond: s >= 24
 27298  	// result: x
 27299  	for {
 27300  		v_0 := v.Args[0]
 27301  		if v_0.Op != OpTrunc32to8 {
 27302  			break
 27303  		}
 27304  		x := v_0.Args[0]
 27305  		if x.Op != OpRsh32x64 {
 27306  			break
 27307  		}
 27308  		_ = x.Args[1]
 27309  		x_1 := x.Args[1]
 27310  		if x_1.Op != OpConst64 {
 27311  			break
 27312  		}
 27313  		s := x_1.AuxInt
 27314  		if !(s >= 24) {
 27315  			break
 27316  		}
 27317  		v.reset(OpCopy)
 27318  		v.Type = x.Type
 27319  		v.AddArg(x)
 27320  		return true
 27321  	}
 27322  	return false
 27323  }
 27324  func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool {
 27325  	// match: (SignExt8to64 (Const8 [c]))
 27326  	// cond:
 27327  	// result: (Const64 [int64( int8(c))])
 27328  	for {
 27329  		v_0 := v.Args[0]
 27330  		if v_0.Op != OpConst8 {
 27331  			break
 27332  		}
 27333  		c := v_0.AuxInt
 27334  		v.reset(OpConst64)
 27335  		v.AuxInt = int64(int8(c))
 27336  		return true
 27337  	}
 27338  	// match: (SignExt8to64 (Trunc64to8 x:(Rsh64x64 _ (Const64 [s]))))
 27339  	// cond: s >= 56
 27340  	// result: x
 27341  	for {
 27342  		v_0 := v.Args[0]
 27343  		if v_0.Op != OpTrunc64to8 {
 27344  			break
 27345  		}
 27346  		x := v_0.Args[0]
 27347  		if x.Op != OpRsh64x64 {
 27348  			break
 27349  		}
 27350  		_ = x.Args[1]
 27351  		x_1 := x.Args[1]
 27352  		if x_1.Op != OpConst64 {
 27353  			break
 27354  		}
 27355  		s := x_1.AuxInt
 27356  		if !(s >= 56) {
 27357  			break
 27358  		}
 27359  		v.reset(OpCopy)
 27360  		v.Type = x.Type
 27361  		v.AddArg(x)
 27362  		return true
 27363  	}
 27364  	return false
 27365  }
 27366  func rewriteValuegeneric_OpSliceCap_0(v *Value) bool {
 27367  	// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
 27368  	// cond:
 27369  	// result: (Const64 <t> [c])
 27370  	for {
 27371  		v_0 := v.Args[0]
 27372  		if v_0.Op != OpSliceMake {
 27373  			break
 27374  		}
 27375  		_ = v_0.Args[2]
 27376  		v_0_2 := v_0.Args[2]
 27377  		if v_0_2.Op != OpConst64 {
 27378  			break
 27379  		}
 27380  		t := v_0_2.Type
 27381  		c := v_0_2.AuxInt
 27382  		v.reset(OpConst64)
 27383  		v.Type = t
 27384  		v.AuxInt = c
 27385  		return true
 27386  	}
 27387  	// match: (SliceCap (SliceMake _ _ (Const32 <t> [c])))
 27388  	// cond:
 27389  	// result: (Const32 <t> [c])
 27390  	for {
 27391  		v_0 := v.Args[0]
 27392  		if v_0.Op != OpSliceMake {
 27393  			break
 27394  		}
 27395  		_ = v_0.Args[2]
 27396  		v_0_2 := v_0.Args[2]
 27397  		if v_0_2.Op != OpConst32 {
 27398  			break
 27399  		}
 27400  		t := v_0_2.Type
 27401  		c := v_0_2.AuxInt
 27402  		v.reset(OpConst32)
 27403  		v.Type = t
 27404  		v.AuxInt = c
 27405  		return true
 27406  	}
 27407  	// match: (SliceCap (SliceMake _ _ (SliceCap x)))
 27408  	// cond:
 27409  	// result: (SliceCap x)
 27410  	for {
 27411  		v_0 := v.Args[0]
 27412  		if v_0.Op != OpSliceMake {
 27413  			break
 27414  		}
 27415  		_ = v_0.Args[2]
 27416  		v_0_2 := v_0.Args[2]
 27417  		if v_0_2.Op != OpSliceCap {
 27418  			break
 27419  		}
 27420  		x := v_0_2.Args[0]
 27421  		v.reset(OpSliceCap)
 27422  		v.AddArg(x)
 27423  		return true
 27424  	}
 27425  	// match: (SliceCap (SliceMake _ _ (SliceLen x)))
 27426  	// cond:
 27427  	// result: (SliceLen x)
 27428  	for {
 27429  		v_0 := v.Args[0]
 27430  		if v_0.Op != OpSliceMake {
 27431  			break
 27432  		}
 27433  		_ = v_0.Args[2]
 27434  		v_0_2 := v_0.Args[2]
 27435  		if v_0_2.Op != OpSliceLen {
 27436  			break
 27437  		}
 27438  		x := v_0_2.Args[0]
 27439  		v.reset(OpSliceLen)
 27440  		v.AddArg(x)
 27441  		return true
 27442  	}
 27443  	return false
 27444  }
 27445  func rewriteValuegeneric_OpSliceLen_0(v *Value) bool {
 27446  	// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
 27447  	// cond:
 27448  	// result: (Const64 <t> [c])
 27449  	for {
 27450  		v_0 := v.Args[0]
 27451  		if v_0.Op != OpSliceMake {
 27452  			break
 27453  		}
 27454  		_ = v_0.Args[2]
 27455  		v_0_1 := v_0.Args[1]
 27456  		if v_0_1.Op != OpConst64 {
 27457  			break
 27458  		}
 27459  		t := v_0_1.Type
 27460  		c := v_0_1.AuxInt
 27461  		v.reset(OpConst64)
 27462  		v.Type = t
 27463  		v.AuxInt = c
 27464  		return true
 27465  	}
 27466  	// match: (SliceLen (SliceMake _ (Const32 <t> [c]) _))
 27467  	// cond:
 27468  	// result: (Const32 <t> [c])
 27469  	for {
 27470  		v_0 := v.Args[0]
 27471  		if v_0.Op != OpSliceMake {
 27472  			break
 27473  		}
 27474  		_ = v_0.Args[2]
 27475  		v_0_1 := v_0.Args[1]
 27476  		if v_0_1.Op != OpConst32 {
 27477  			break
 27478  		}
 27479  		t := v_0_1.Type
 27480  		c := v_0_1.AuxInt
 27481  		v.reset(OpConst32)
 27482  		v.Type = t
 27483  		v.AuxInt = c
 27484  		return true
 27485  	}
 27486  	// match: (SliceLen (SliceMake _ (SliceLen x) _))
 27487  	// cond:
 27488  	// result: (SliceLen x)
 27489  	for {
 27490  		v_0 := v.Args[0]
 27491  		if v_0.Op != OpSliceMake {
 27492  			break
 27493  		}
 27494  		_ = v_0.Args[2]
 27495  		v_0_1 := v_0.Args[1]
 27496  		if v_0_1.Op != OpSliceLen {
 27497  			break
 27498  		}
 27499  		x := v_0_1.Args[0]
 27500  		v.reset(OpSliceLen)
 27501  		v.AddArg(x)
 27502  		return true
 27503  	}
 27504  	return false
 27505  }
 27506  func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool {
 27507  	// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
 27508  	// cond:
 27509  	// result: (SlicePtr x)
 27510  	for {
 27511  		v_0 := v.Args[0]
 27512  		if v_0.Op != OpSliceMake {
 27513  			break
 27514  		}
 27515  		_ = v_0.Args[2]
 27516  		v_0_0 := v_0.Args[0]
 27517  		if v_0_0.Op != OpSlicePtr {
 27518  			break
 27519  		}
 27520  		x := v_0_0.Args[0]
 27521  		v.reset(OpSlicePtr)
 27522  		v.AddArg(x)
 27523  		return true
 27524  	}
 27525  	return false
 27526  }
 27527  func rewriteValuegeneric_OpSlicemask_0(v *Value) bool {
 27528  	// match: (Slicemask (Const32 [x]))
 27529  	// cond: x > 0
 27530  	// result: (Const32 [-1])
 27531  	for {
 27532  		v_0 := v.Args[0]
 27533  		if v_0.Op != OpConst32 {
 27534  			break
 27535  		}
 27536  		x := v_0.AuxInt
 27537  		if !(x > 0) {
 27538  			break
 27539  		}
 27540  		v.reset(OpConst32)
 27541  		v.AuxInt = -1
 27542  		return true
 27543  	}
 27544  	// match: (Slicemask (Const32 [0]))
 27545  	// cond:
 27546  	// result: (Const32 [0])
 27547  	for {
 27548  		v_0 := v.Args[0]
 27549  		if v_0.Op != OpConst32 {
 27550  			break
 27551  		}
 27552  		if v_0.AuxInt != 0 {
 27553  			break
 27554  		}
 27555  		v.reset(OpConst32)
 27556  		v.AuxInt = 0
 27557  		return true
 27558  	}
 27559  	// match: (Slicemask (Const64 [x]))
 27560  	// cond: x > 0
 27561  	// result: (Const64 [-1])
 27562  	for {
 27563  		v_0 := v.Args[0]
 27564  		if v_0.Op != OpConst64 {
 27565  			break
 27566  		}
 27567  		x := v_0.AuxInt
 27568  		if !(x > 0) {
 27569  			break
 27570  		}
 27571  		v.reset(OpConst64)
 27572  		v.AuxInt = -1
 27573  		return true
 27574  	}
 27575  	// match: (Slicemask (Const64 [0]))
 27576  	// cond:
 27577  	// result: (Const64 [0])
 27578  	for {
 27579  		v_0 := v.Args[0]
 27580  		if v_0.Op != OpConst64 {
 27581  			break
 27582  		}
 27583  		if v_0.AuxInt != 0 {
 27584  			break
 27585  		}
 27586  		v.reset(OpConst64)
 27587  		v.AuxInt = 0
 27588  		return true
 27589  	}
 27590  	return false
 27591  }
 27592  func rewriteValuegeneric_OpSqrt_0(v *Value) bool {
 27593  	// match: (Sqrt (Const64F [c]))
 27594  	// cond:
 27595  	// result: (Const64F [auxFrom64F(math.Sqrt(auxTo64F(c)))])
 27596  	for {
 27597  		v_0 := v.Args[0]
 27598  		if v_0.Op != OpConst64F {
 27599  			break
 27600  		}
 27601  		c := v_0.AuxInt
 27602  		v.reset(OpConst64F)
 27603  		v.AuxInt = auxFrom64F(math.Sqrt(auxTo64F(c)))
 27604  		return true
 27605  	}
 27606  	return false
 27607  }
 27608  func rewriteValuegeneric_OpStaticCall_0(v *Value) bool {
 27609  	b := v.Block
 27610  	_ = b
 27611  	config := b.Func.Config
 27612  	_ = config
 27613  	// match: (StaticCall {sym} s1:(Store _ (Const64 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))
 27614  	// cond: isSameSym(sym,"runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst,src,sz,config) && clobber(s1) && clobber(s2) && clobber(s3)
 27615  	// result: (Move {t.(*types.Type).Elem()} [sz] dst src mem)
 27616  	for {
 27617  		sym := v.Aux
 27618  		s1 := v.Args[0]
 27619  		if s1.Op != OpStore {
 27620  			break
 27621  		}
 27622  		_ = s1.Args[2]
 27623  		s1_1 := s1.Args[1]
 27624  		if s1_1.Op != OpConst64 {
 27625  			break
 27626  		}
 27627  		sz := s1_1.AuxInt
 27628  		s2 := s1.Args[2]
 27629  		if s2.Op != OpStore {
 27630  			break
 27631  		}
 27632  		_ = s2.Args[2]
 27633  		src := s2.Args[1]
 27634  		s3 := s2.Args[2]
 27635  		if s3.Op != OpStore {
 27636  			break
 27637  		}
 27638  		t := s3.Aux
 27639  		_ = s3.Args[2]
 27640  		dst := s3.Args[1]
 27641  		mem := s3.Args[2]
 27642  		if !(isSameSym(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1) && clobber(s2) && clobber(s3)) {
 27643  			break
 27644  		}
 27645  		v.reset(OpMove)
 27646  		v.AuxInt = sz
 27647  		v.Aux = t.(*types.Type).Elem()
 27648  		v.AddArg(dst)
 27649  		v.AddArg(src)
 27650  		v.AddArg(mem)
 27651  		return true
 27652  	}
 27653  	// match: (StaticCall {sym} s1:(Store _ (Const32 [sz]) s2:(Store _ src s3:(Store {t} _ dst mem))))
 27654  	// cond: isSameSym(sym,"runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst,src,sz,config) && clobber(s1) && clobber(s2) && clobber(s3)
 27655  	// result: (Move {t.(*types.Type).Elem()} [sz] dst src mem)
 27656  	for {
 27657  		sym := v.Aux
 27658  		s1 := v.Args[0]
 27659  		if s1.Op != OpStore {
 27660  			break
 27661  		}
 27662  		_ = s1.Args[2]
 27663  		s1_1 := s1.Args[1]
 27664  		if s1_1.Op != OpConst32 {
 27665  			break
 27666  		}
 27667  		sz := s1_1.AuxInt
 27668  		s2 := s1.Args[2]
 27669  		if s2.Op != OpStore {
 27670  			break
 27671  		}
 27672  		_ = s2.Args[2]
 27673  		src := s2.Args[1]
 27674  		s3 := s2.Args[2]
 27675  		if s3.Op != OpStore {
 27676  			break
 27677  		}
 27678  		t := s3.Aux
 27679  		_ = s3.Args[2]
 27680  		dst := s3.Args[1]
 27681  		mem := s3.Args[2]
 27682  		if !(isSameSym(sym, "runtime.memmove") && s1.Uses == 1 && s2.Uses == 1 && s3.Uses == 1 && isInlinableMemmove(dst, src, sz, config) && clobber(s1) && clobber(s2) && clobber(s3)) {
 27683  			break
 27684  		}
 27685  		v.reset(OpMove)
 27686  		v.AuxInt = sz
 27687  		v.Aux = t.(*types.Type).Elem()
 27688  		v.AddArg(dst)
 27689  		v.AddArg(src)
 27690  		v.AddArg(mem)
 27691  		return true
 27692  	}
 27693  	// match: (StaticCall {sym} x)
 27694  	// cond: needRaceCleanup(sym,v)
 27695  	// result: x
 27696  	for {
 27697  		sym := v.Aux
 27698  		x := v.Args[0]
 27699  		if !(needRaceCleanup(sym, v)) {
 27700  			break
 27701  		}
 27702  		v.reset(OpCopy)
 27703  		v.Type = x.Type
 27704  		v.AddArg(x)
 27705  		return true
 27706  	}
 27707  	return false
 27708  }
 27709  func rewriteValuegeneric_OpStore_0(v *Value) bool {
 27710  	b := v.Block
 27711  	_ = b
 27712  	// match: (Store {t1} p1 (Load <t2> p2 mem) mem)
 27713  	// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1)
 27714  	// result: mem
 27715  	for {
 27716  		t1 := v.Aux
 27717  		_ = v.Args[2]
 27718  		p1 := v.Args[0]
 27719  		v_1 := v.Args[1]
 27720  		if v_1.Op != OpLoad {
 27721  			break
 27722  		}
 27723  		t2 := v_1.Type
 27724  		_ = v_1.Args[1]
 27725  		p2 := v_1.Args[0]
 27726  		mem := v_1.Args[1]
 27727  		if mem != v.Args[2] {
 27728  			break
 27729  		}
 27730  		if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1)) {
 27731  			break
 27732  		}
 27733  		v.reset(OpCopy)
 27734  		v.Type = mem.Type
 27735  		v.AddArg(mem)
 27736  		return true
 27737  	}
 27738  	// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ oldmem))
 27739  	// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3))
 27740  	// result: mem
 27741  	for {
 27742  		t1 := v.Aux
 27743  		_ = v.Args[2]
 27744  		p1 := v.Args[0]
 27745  		v_1 := v.Args[1]
 27746  		if v_1.Op != OpLoad {
 27747  			break
 27748  		}
 27749  		t2 := v_1.Type
 27750  		_ = v_1.Args[1]
 27751  		p2 := v_1.Args[0]
 27752  		oldmem := v_1.Args[1]
 27753  		mem := v.Args[2]
 27754  		if mem.Op != OpStore {
 27755  			break
 27756  		}
 27757  		t3 := mem.Aux
 27758  		_ = mem.Args[2]
 27759  		p3 := mem.Args[0]
 27760  		if oldmem != mem.Args[2] {
 27761  			break
 27762  		}
 27763  		if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3))) {
 27764  			break
 27765  		}
 27766  		v.reset(OpCopy)
 27767  		v.Type = mem.Type
 27768  		v.AddArg(mem)
 27769  		return true
 27770  	}
 27771  	// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ oldmem)))
 27772  	// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4))
 27773  	// result: mem
 27774  	for {
 27775  		t1 := v.Aux
 27776  		_ = v.Args[2]
 27777  		p1 := v.Args[0]
 27778  		v_1 := v.Args[1]
 27779  		if v_1.Op != OpLoad {
 27780  			break
 27781  		}
 27782  		t2 := v_1.Type
 27783  		_ = v_1.Args[1]
 27784  		p2 := v_1.Args[0]
 27785  		oldmem := v_1.Args[1]
 27786  		mem := v.Args[2]
 27787  		if mem.Op != OpStore {
 27788  			break
 27789  		}
 27790  		t3 := mem.Aux
 27791  		_ = mem.Args[2]
 27792  		p3 := mem.Args[0]
 27793  		mem_2 := mem.Args[2]
 27794  		if mem_2.Op != OpStore {
 27795  			break
 27796  		}
 27797  		t4 := mem_2.Aux
 27798  		_ = mem_2.Args[2]
 27799  		p4 := mem_2.Args[0]
 27800  		if oldmem != mem_2.Args[2] {
 27801  			break
 27802  		}
 27803  		if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4))) {
 27804  			break
 27805  		}
 27806  		v.reset(OpCopy)
 27807  		v.Type = mem.Type
 27808  		v.AddArg(mem)
 27809  		return true
 27810  	}
 27811  	// match: (Store {t1} p1 (Load <t2> p2 oldmem) mem:(Store {t3} p3 _ (Store {t4} p4 _ (Store {t5} p5 _ oldmem))))
 27812  	// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5))
 27813  	// result: mem
 27814  	for {
 27815  		t1 := v.Aux
 27816  		_ = v.Args[2]
 27817  		p1 := v.Args[0]
 27818  		v_1 := v.Args[1]
 27819  		if v_1.Op != OpLoad {
 27820  			break
 27821  		}
 27822  		t2 := v_1.Type
 27823  		_ = v_1.Args[1]
 27824  		p2 := v_1.Args[0]
 27825  		oldmem := v_1.Args[1]
 27826  		mem := v.Args[2]
 27827  		if mem.Op != OpStore {
 27828  			break
 27829  		}
 27830  		t3 := mem.Aux
 27831  		_ = mem.Args[2]
 27832  		p3 := mem.Args[0]
 27833  		mem_2 := mem.Args[2]
 27834  		if mem_2.Op != OpStore {
 27835  			break
 27836  		}
 27837  		t4 := mem_2.Aux
 27838  		_ = mem_2.Args[2]
 27839  		p4 := mem_2.Args[0]
 27840  		mem_2_2 := mem_2.Args[2]
 27841  		if mem_2_2.Op != OpStore {
 27842  			break
 27843  		}
 27844  		t5 := mem_2_2.Aux
 27845  		_ = mem_2_2.Args[2]
 27846  		p5 := mem_2_2.Args[0]
 27847  		if oldmem != mem_2_2.Args[2] {
 27848  			break
 27849  		}
 27850  		if !(isSamePtr(p1, p2) && t2.Size() == sizeof(t1) && disjoint(p1, sizeof(t1), p3, sizeof(t3)) && disjoint(p1, sizeof(t1), p4, sizeof(t4)) && disjoint(p1, sizeof(t1), p5, sizeof(t5))) {
 27851  			break
 27852  		}
 27853  		v.reset(OpCopy)
 27854  		v.Type = mem.Type
 27855  		v.AddArg(mem)
 27856  		return true
 27857  	}
 27858  	// match: (Store {t} (OffPtr [o] p1) x mem:(Zero [n] p2 _))
 27859  	// cond: isConstZero(x) && o >= 0 && sizeof(t) + o <= n && isSamePtr(p1, p2)
 27860  	// result: mem
 27861  	for {
 27862  		t := v.Aux
 27863  		_ = v.Args[2]
 27864  		v_0 := v.Args[0]
 27865  		if v_0.Op != OpOffPtr {
 27866  			break
 27867  		}
 27868  		o := v_0.AuxInt
 27869  		p1 := v_0.Args[0]
 27870  		x := v.Args[1]
 27871  		mem := v.Args[2]
 27872  		if mem.Op != OpZero {
 27873  			break
 27874  		}
 27875  		n := mem.AuxInt
 27876  		_ = mem.Args[1]
 27877  		p2 := mem.Args[0]
 27878  		if !(isConstZero(x) && o >= 0 && sizeof(t)+o <= n && isSamePtr(p1, p2)) {
 27879  			break
 27880  		}
 27881  		v.reset(OpCopy)
 27882  		v.Type = mem.Type
 27883  		v.AddArg(mem)
 27884  		return true
 27885  	}
 27886  	// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Zero [n] p3 _)))
 27887  	// cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2))
 27888  	// result: mem
 27889  	for {
 27890  		t1 := v.Aux
 27891  		_ = v.Args[2]
 27892  		op := v.Args[0]
 27893  		if op.Op != OpOffPtr {
 27894  			break
 27895  		}
 27896  		o1 := op.AuxInt
 27897  		p1 := op.Args[0]
 27898  		x := v.Args[1]
 27899  		mem := v.Args[2]
 27900  		if mem.Op != OpStore {
 27901  			break
 27902  		}
 27903  		t2 := mem.Aux
 27904  		_ = mem.Args[2]
 27905  		p2 := mem.Args[0]
 27906  		mem_2 := mem.Args[2]
 27907  		if mem_2.Op != OpZero {
 27908  			break
 27909  		}
 27910  		n := mem_2.AuxInt
 27911  		_ = mem_2.Args[1]
 27912  		p3 := mem_2.Args[0]
 27913  		if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p3) && disjoint(op, sizeof(t1), p2, sizeof(t2))) {
 27914  			break
 27915  		}
 27916  		v.reset(OpCopy)
 27917  		v.Type = mem.Type
 27918  		v.AddArg(mem)
 27919  		return true
 27920  	}
 27921  	// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Zero [n] p4 _))))
 27922  	// cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3))
 27923  	// result: mem
 27924  	for {
 27925  		t1 := v.Aux
 27926  		_ = v.Args[2]
 27927  		op := v.Args[0]
 27928  		if op.Op != OpOffPtr {
 27929  			break
 27930  		}
 27931  		o1 := op.AuxInt
 27932  		p1 := op.Args[0]
 27933  		x := v.Args[1]
 27934  		mem := v.Args[2]
 27935  		if mem.Op != OpStore {
 27936  			break
 27937  		}
 27938  		t2 := mem.Aux
 27939  		_ = mem.Args[2]
 27940  		p2 := mem.Args[0]
 27941  		mem_2 := mem.Args[2]
 27942  		if mem_2.Op != OpStore {
 27943  			break
 27944  		}
 27945  		t3 := mem_2.Aux
 27946  		_ = mem_2.Args[2]
 27947  		p3 := mem_2.Args[0]
 27948  		mem_2_2 := mem_2.Args[2]
 27949  		if mem_2_2.Op != OpZero {
 27950  			break
 27951  		}
 27952  		n := mem_2_2.AuxInt
 27953  		_ = mem_2_2.Args[1]
 27954  		p4 := mem_2_2.Args[0]
 27955  		if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p4) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3))) {
 27956  			break
 27957  		}
 27958  		v.reset(OpCopy)
 27959  		v.Type = mem.Type
 27960  		v.AddArg(mem)
 27961  		return true
 27962  	}
 27963  	// match: (Store {t1} op:(OffPtr [o1] p1) x mem:(Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ (Zero [n] p5 _)))))
 27964  	// cond: isConstZero(x) && o1 >= 0 && sizeof(t1) + o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4))
 27965  	// result: mem
 27966  	for {
 27967  		t1 := v.Aux
 27968  		_ = v.Args[2]
 27969  		op := v.Args[0]
 27970  		if op.Op != OpOffPtr {
 27971  			break
 27972  		}
 27973  		o1 := op.AuxInt
 27974  		p1 := op.Args[0]
 27975  		x := v.Args[1]
 27976  		mem := v.Args[2]
 27977  		if mem.Op != OpStore {
 27978  			break
 27979  		}
 27980  		t2 := mem.Aux
 27981  		_ = mem.Args[2]
 27982  		p2 := mem.Args[0]
 27983  		mem_2 := mem.Args[2]
 27984  		if mem_2.Op != OpStore {
 27985  			break
 27986  		}
 27987  		t3 := mem_2.Aux
 27988  		_ = mem_2.Args[2]
 27989  		p3 := mem_2.Args[0]
 27990  		mem_2_2 := mem_2.Args[2]
 27991  		if mem_2_2.Op != OpStore {
 27992  			break
 27993  		}
 27994  		t4 := mem_2_2.Aux
 27995  		_ = mem_2_2.Args[2]
 27996  		p4 := mem_2_2.Args[0]
 27997  		mem_2_2_2 := mem_2_2.Args[2]
 27998  		if mem_2_2_2.Op != OpZero {
 27999  			break
 28000  		}
 28001  		n := mem_2_2_2.AuxInt
 28002  		_ = mem_2_2_2.Args[1]
 28003  		p5 := mem_2_2_2.Args[0]
 28004  		if !(isConstZero(x) && o1 >= 0 && sizeof(t1)+o1 <= n && isSamePtr(p1, p5) && disjoint(op, sizeof(t1), p2, sizeof(t2)) && disjoint(op, sizeof(t1), p3, sizeof(t3)) && disjoint(op, sizeof(t1), p4, sizeof(t4))) {
 28005  			break
 28006  		}
 28007  		v.reset(OpCopy)
 28008  		v.Type = mem.Type
 28009  		v.AddArg(mem)
 28010  		return true
 28011  	}
 28012  	// match: (Store _ (StructMake0) mem)
 28013  	// cond:
 28014  	// result: mem
 28015  	for {
 28016  		_ = v.Args[2]
 28017  		v_1 := v.Args[1]
 28018  		if v_1.Op != OpStructMake0 {
 28019  			break
 28020  		}
 28021  		mem := v.Args[2]
 28022  		v.reset(OpCopy)
 28023  		v.Type = mem.Type
 28024  		v.AddArg(mem)
 28025  		return true
 28026  	}
 28027  	// match: (Store dst (StructMake1 <t> f0) mem)
 28028  	// cond:
 28029  	// result: (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)
 28030  	for {
 28031  		_ = v.Args[2]
 28032  		dst := v.Args[0]
 28033  		v_1 := v.Args[1]
 28034  		if v_1.Op != OpStructMake1 {
 28035  			break
 28036  		}
 28037  		t := v_1.Type
 28038  		f0 := v_1.Args[0]
 28039  		mem := v.Args[2]
 28040  		v.reset(OpStore)
 28041  		v.Aux = t.FieldType(0)
 28042  		v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 28043  		v0.AuxInt = 0
 28044  		v0.AddArg(dst)
 28045  		v.AddArg(v0)
 28046  		v.AddArg(f0)
 28047  		v.AddArg(mem)
 28048  		return true
 28049  	}
 28050  	return false
 28051  }
 28052  func rewriteValuegeneric_OpStore_10(v *Value) bool {
 28053  	b := v.Block
 28054  	_ = b
 28055  	config := b.Func.Config
 28056  	_ = config
 28057  	fe := b.Func.fe
 28058  	_ = fe
 28059  	// match: (Store dst (StructMake2 <t> f0 f1) mem)
 28060  	// cond:
 28061  	// result: (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))
 28062  	for {
 28063  		_ = v.Args[2]
 28064  		dst := v.Args[0]
 28065  		v_1 := v.Args[1]
 28066  		if v_1.Op != OpStructMake2 {
 28067  			break
 28068  		}
 28069  		t := v_1.Type
 28070  		_ = v_1.Args[1]
 28071  		f0 := v_1.Args[0]
 28072  		f1 := v_1.Args[1]
 28073  		mem := v.Args[2]
 28074  		v.reset(OpStore)
 28075  		v.Aux = t.FieldType(1)
 28076  		v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 28077  		v0.AuxInt = t.FieldOff(1)
 28078  		v0.AddArg(dst)
 28079  		v.AddArg(v0)
 28080  		v.AddArg(f1)
 28081  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28082  		v1.Aux = t.FieldType(0)
 28083  		v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 28084  		v2.AuxInt = 0
 28085  		v2.AddArg(dst)
 28086  		v1.AddArg(v2)
 28087  		v1.AddArg(f0)
 28088  		v1.AddArg(mem)
 28089  		v.AddArg(v1)
 28090  		return true
 28091  	}
 28092  	// match: (Store dst (StructMake3 <t> f0 f1 f2) mem)
 28093  	// cond:
 28094  	// result: (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem)))
 28095  	for {
 28096  		_ = v.Args[2]
 28097  		dst := v.Args[0]
 28098  		v_1 := v.Args[1]
 28099  		if v_1.Op != OpStructMake3 {
 28100  			break
 28101  		}
 28102  		t := v_1.Type
 28103  		_ = v_1.Args[2]
 28104  		f0 := v_1.Args[0]
 28105  		f1 := v_1.Args[1]
 28106  		f2 := v_1.Args[2]
 28107  		mem := v.Args[2]
 28108  		v.reset(OpStore)
 28109  		v.Aux = t.FieldType(2)
 28110  		v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 28111  		v0.AuxInt = t.FieldOff(2)
 28112  		v0.AddArg(dst)
 28113  		v.AddArg(v0)
 28114  		v.AddArg(f2)
 28115  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28116  		v1.Aux = t.FieldType(1)
 28117  		v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 28118  		v2.AuxInt = t.FieldOff(1)
 28119  		v2.AddArg(dst)
 28120  		v1.AddArg(v2)
 28121  		v1.AddArg(f1)
 28122  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28123  		v3.Aux = t.FieldType(0)
 28124  		v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 28125  		v4.AuxInt = 0
 28126  		v4.AddArg(dst)
 28127  		v3.AddArg(v4)
 28128  		v3.AddArg(f0)
 28129  		v3.AddArg(mem)
 28130  		v1.AddArg(v3)
 28131  		v.AddArg(v1)
 28132  		return true
 28133  	}
 28134  	// match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem)
 28135  	// cond:
 28136  	// result: (Store {t.FieldType(3)} (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store {t.FieldType(2)} (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))))
 28137  	for {
 28138  		_ = v.Args[2]
 28139  		dst := v.Args[0]
 28140  		v_1 := v.Args[1]
 28141  		if v_1.Op != OpStructMake4 {
 28142  			break
 28143  		}
 28144  		t := v_1.Type
 28145  		_ = v_1.Args[3]
 28146  		f0 := v_1.Args[0]
 28147  		f1 := v_1.Args[1]
 28148  		f2 := v_1.Args[2]
 28149  		f3 := v_1.Args[3]
 28150  		mem := v.Args[2]
 28151  		v.reset(OpStore)
 28152  		v.Aux = t.FieldType(3)
 28153  		v0 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(3).PtrTo())
 28154  		v0.AuxInt = t.FieldOff(3)
 28155  		v0.AddArg(dst)
 28156  		v.AddArg(v0)
 28157  		v.AddArg(f3)
 28158  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28159  		v1.Aux = t.FieldType(2)
 28160  		v2 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(2).PtrTo())
 28161  		v2.AuxInt = t.FieldOff(2)
 28162  		v2.AddArg(dst)
 28163  		v1.AddArg(v2)
 28164  		v1.AddArg(f2)
 28165  		v3 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28166  		v3.Aux = t.FieldType(1)
 28167  		v4 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(1).PtrTo())
 28168  		v4.AuxInt = t.FieldOff(1)
 28169  		v4.AddArg(dst)
 28170  		v3.AddArg(v4)
 28171  		v3.AddArg(f1)
 28172  		v5 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28173  		v5.Aux = t.FieldType(0)
 28174  		v6 := b.NewValue0(v.Pos, OpOffPtr, t.FieldType(0).PtrTo())
 28175  		v6.AuxInt = 0
 28176  		v6.AddArg(dst)
 28177  		v5.AddArg(v6)
 28178  		v5.AddArg(f0)
 28179  		v5.AddArg(mem)
 28180  		v3.AddArg(v5)
 28181  		v1.AddArg(v3)
 28182  		v.AddArg(v1)
 28183  		return true
 28184  	}
 28185  	// match: (Store {t} dst (Load src mem) mem)
 28186  	// cond: !fe.CanSSA(t.(*types.Type))
 28187  	// result: (Move {t} [sizeof(t)] dst src mem)
 28188  	for {
 28189  		t := v.Aux
 28190  		_ = v.Args[2]
 28191  		dst := v.Args[0]
 28192  		v_1 := v.Args[1]
 28193  		if v_1.Op != OpLoad {
 28194  			break
 28195  		}
 28196  		_ = v_1.Args[1]
 28197  		src := v_1.Args[0]
 28198  		mem := v_1.Args[1]
 28199  		if mem != v.Args[2] {
 28200  			break
 28201  		}
 28202  		if !(!fe.CanSSA(t.(*types.Type))) {
 28203  			break
 28204  		}
 28205  		v.reset(OpMove)
 28206  		v.AuxInt = sizeof(t)
 28207  		v.Aux = t
 28208  		v.AddArg(dst)
 28209  		v.AddArg(src)
 28210  		v.AddArg(mem)
 28211  		return true
 28212  	}
 28213  	// match: (Store {t} dst (Load src mem) (VarDef {x} mem))
 28214  	// cond: !fe.CanSSA(t.(*types.Type))
 28215  	// result: (Move {t} [sizeof(t)] dst src (VarDef {x} mem))
 28216  	for {
 28217  		t := v.Aux
 28218  		_ = v.Args[2]
 28219  		dst := v.Args[0]
 28220  		v_1 := v.Args[1]
 28221  		if v_1.Op != OpLoad {
 28222  			break
 28223  		}
 28224  		_ = v_1.Args[1]
 28225  		src := v_1.Args[0]
 28226  		mem := v_1.Args[1]
 28227  		v_2 := v.Args[2]
 28228  		if v_2.Op != OpVarDef {
 28229  			break
 28230  		}
 28231  		x := v_2.Aux
 28232  		if mem != v_2.Args[0] {
 28233  			break
 28234  		}
 28235  		if !(!fe.CanSSA(t.(*types.Type))) {
 28236  			break
 28237  		}
 28238  		v.reset(OpMove)
 28239  		v.AuxInt = sizeof(t)
 28240  		v.Aux = t
 28241  		v.AddArg(dst)
 28242  		v.AddArg(src)
 28243  		v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 28244  		v0.Aux = x
 28245  		v0.AddArg(mem)
 28246  		v.AddArg(v0)
 28247  		return true
 28248  	}
 28249  	// match: (Store _ (ArrayMake0) mem)
 28250  	// cond:
 28251  	// result: mem
 28252  	for {
 28253  		_ = v.Args[2]
 28254  		v_1 := v.Args[1]
 28255  		if v_1.Op != OpArrayMake0 {
 28256  			break
 28257  		}
 28258  		mem := v.Args[2]
 28259  		v.reset(OpCopy)
 28260  		v.Type = mem.Type
 28261  		v.AddArg(mem)
 28262  		return true
 28263  	}
 28264  	// match: (Store dst (ArrayMake1 e) mem)
 28265  	// cond:
 28266  	// result: (Store {e.Type} dst e mem)
 28267  	for {
 28268  		_ = v.Args[2]
 28269  		dst := v.Args[0]
 28270  		v_1 := v.Args[1]
 28271  		if v_1.Op != OpArrayMake1 {
 28272  			break
 28273  		}
 28274  		e := v_1.Args[0]
 28275  		mem := v.Args[2]
 28276  		v.reset(OpStore)
 28277  		v.Aux = e.Type
 28278  		v.AddArg(dst)
 28279  		v.AddArg(e)
 28280  		v.AddArg(mem)
 28281  		return true
 28282  	}
 28283  	// match: (Store (Load (OffPtr [c] (SP)) mem) x mem)
 28284  	// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
 28285  	// result: mem
 28286  	for {
 28287  		_ = v.Args[2]
 28288  		v_0 := v.Args[0]
 28289  		if v_0.Op != OpLoad {
 28290  			break
 28291  		}
 28292  		_ = v_0.Args[1]
 28293  		v_0_0 := v_0.Args[0]
 28294  		if v_0_0.Op != OpOffPtr {
 28295  			break
 28296  		}
 28297  		c := v_0_0.AuxInt
 28298  		v_0_0_0 := v_0_0.Args[0]
 28299  		if v_0_0_0.Op != OpSP {
 28300  			break
 28301  		}
 28302  		mem := v_0.Args[1]
 28303  		x := v.Args[1]
 28304  		if mem != v.Args[2] {
 28305  			break
 28306  		}
 28307  		if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
 28308  			break
 28309  		}
 28310  		v.reset(OpCopy)
 28311  		v.Type = mem.Type
 28312  		v.AddArg(mem)
 28313  		return true
 28314  	}
 28315  	// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
 28316  	// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
 28317  	// result: mem
 28318  	for {
 28319  		_ = v.Args[2]
 28320  		v_0 := v.Args[0]
 28321  		if v_0.Op != OpOffPtr {
 28322  			break
 28323  		}
 28324  		v_0_0 := v_0.Args[0]
 28325  		if v_0_0.Op != OpLoad {
 28326  			break
 28327  		}
 28328  		_ = v_0_0.Args[1]
 28329  		v_0_0_0 := v_0_0.Args[0]
 28330  		if v_0_0_0.Op != OpOffPtr {
 28331  			break
 28332  		}
 28333  		c := v_0_0_0.AuxInt
 28334  		v_0_0_0_0 := v_0_0_0.Args[0]
 28335  		if v_0_0_0_0.Op != OpSP {
 28336  			break
 28337  		}
 28338  		mem := v_0_0.Args[1]
 28339  		x := v.Args[1]
 28340  		if mem != v.Args[2] {
 28341  			break
 28342  		}
 28343  		if !(isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
 28344  			break
 28345  		}
 28346  		v.reset(OpCopy)
 28347  		v.Type = mem.Type
 28348  		v.AddArg(mem)
 28349  		return true
 28350  	}
 28351  	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Move [n] p3 _ mem)))
 28352  	// cond: m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)
 28353  	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem))
 28354  	for {
 28355  		t1 := v.Aux
 28356  		_ = v.Args[2]
 28357  		op1 := v.Args[0]
 28358  		if op1.Op != OpOffPtr {
 28359  			break
 28360  		}
 28361  		o1 := op1.AuxInt
 28362  		p1 := op1.Args[0]
 28363  		d1 := v.Args[1]
 28364  		m2 := v.Args[2]
 28365  		if m2.Op != OpStore {
 28366  			break
 28367  		}
 28368  		t2 := m2.Aux
 28369  		_ = m2.Args[2]
 28370  		op2 := m2.Args[0]
 28371  		if op2.Op != OpOffPtr {
 28372  			break
 28373  		}
 28374  		if op2.AuxInt != 0 {
 28375  			break
 28376  		}
 28377  		p2 := op2.Args[0]
 28378  		d2 := m2.Args[1]
 28379  		m3 := m2.Args[2]
 28380  		if m3.Op != OpMove {
 28381  			break
 28382  		}
 28383  		n := m3.AuxInt
 28384  		_ = m3.Args[2]
 28385  		p3 := m3.Args[0]
 28386  		mem := m3.Args[2]
 28387  		if !(m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)) {
 28388  			break
 28389  		}
 28390  		v.reset(OpStore)
 28391  		v.Aux = t1
 28392  		v.AddArg(op1)
 28393  		v.AddArg(d1)
 28394  		v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28395  		v0.Aux = t2
 28396  		v0.AddArg(op2)
 28397  		v0.AddArg(d2)
 28398  		v0.AddArg(mem)
 28399  		v.AddArg(v0)
 28400  		return true
 28401  	}
 28402  	return false
 28403  }
 28404  func rewriteValuegeneric_OpStore_20(v *Value) bool {
 28405  	b := v.Block
 28406  	_ = b
 28407  	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Move [n] p4 _ mem))))
 28408  	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)
 28409  	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
 28410  	for {
 28411  		t1 := v.Aux
 28412  		_ = v.Args[2]
 28413  		op1 := v.Args[0]
 28414  		if op1.Op != OpOffPtr {
 28415  			break
 28416  		}
 28417  		o1 := op1.AuxInt
 28418  		p1 := op1.Args[0]
 28419  		d1 := v.Args[1]
 28420  		m2 := v.Args[2]
 28421  		if m2.Op != OpStore {
 28422  			break
 28423  		}
 28424  		t2 := m2.Aux
 28425  		_ = m2.Args[2]
 28426  		op2 := m2.Args[0]
 28427  		if op2.Op != OpOffPtr {
 28428  			break
 28429  		}
 28430  		o2 := op2.AuxInt
 28431  		p2 := op2.Args[0]
 28432  		d2 := m2.Args[1]
 28433  		m3 := m2.Args[2]
 28434  		if m3.Op != OpStore {
 28435  			break
 28436  		}
 28437  		t3 := m3.Aux
 28438  		_ = m3.Args[2]
 28439  		op3 := m3.Args[0]
 28440  		if op3.Op != OpOffPtr {
 28441  			break
 28442  		}
 28443  		if op3.AuxInt != 0 {
 28444  			break
 28445  		}
 28446  		p3 := op3.Args[0]
 28447  		d3 := m3.Args[1]
 28448  		m4 := m3.Args[2]
 28449  		if m4.Op != OpMove {
 28450  			break
 28451  		}
 28452  		n := m4.AuxInt
 28453  		_ = m4.Args[2]
 28454  		p4 := m4.Args[0]
 28455  		mem := m4.Args[2]
 28456  		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)) {
 28457  			break
 28458  		}
 28459  		v.reset(OpStore)
 28460  		v.Aux = t1
 28461  		v.AddArg(op1)
 28462  		v.AddArg(d1)
 28463  		v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28464  		v0.Aux = t2
 28465  		v0.AddArg(op2)
 28466  		v0.AddArg(d2)
 28467  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28468  		v1.Aux = t3
 28469  		v1.AddArg(op3)
 28470  		v1.AddArg(d3)
 28471  		v1.AddArg(mem)
 28472  		v0.AddArg(v1)
 28473  		v.AddArg(v0)
 28474  		return true
 28475  	}
 28476  	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Move [n] p5 _ mem)))))
 28477  	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4) + sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)
 28478  	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem))))
 28479  	for {
 28480  		t1 := v.Aux
 28481  		_ = v.Args[2]
 28482  		op1 := v.Args[0]
 28483  		if op1.Op != OpOffPtr {
 28484  			break
 28485  		}
 28486  		o1 := op1.AuxInt
 28487  		p1 := op1.Args[0]
 28488  		d1 := v.Args[1]
 28489  		m2 := v.Args[2]
 28490  		if m2.Op != OpStore {
 28491  			break
 28492  		}
 28493  		t2 := m2.Aux
 28494  		_ = m2.Args[2]
 28495  		op2 := m2.Args[0]
 28496  		if op2.Op != OpOffPtr {
 28497  			break
 28498  		}
 28499  		o2 := op2.AuxInt
 28500  		p2 := op2.Args[0]
 28501  		d2 := m2.Args[1]
 28502  		m3 := m2.Args[2]
 28503  		if m3.Op != OpStore {
 28504  			break
 28505  		}
 28506  		t3 := m3.Aux
 28507  		_ = m3.Args[2]
 28508  		op3 := m3.Args[0]
 28509  		if op3.Op != OpOffPtr {
 28510  			break
 28511  		}
 28512  		o3 := op3.AuxInt
 28513  		p3 := op3.Args[0]
 28514  		d3 := m3.Args[1]
 28515  		m4 := m3.Args[2]
 28516  		if m4.Op != OpStore {
 28517  			break
 28518  		}
 28519  		t4 := m4.Aux
 28520  		_ = m4.Args[2]
 28521  		op4 := m4.Args[0]
 28522  		if op4.Op != OpOffPtr {
 28523  			break
 28524  		}
 28525  		if op4.AuxInt != 0 {
 28526  			break
 28527  		}
 28528  		p4 := op4.Args[0]
 28529  		d4 := m4.Args[1]
 28530  		m5 := m4.Args[2]
 28531  		if m5.Op != OpMove {
 28532  			break
 28533  		}
 28534  		n := m5.AuxInt
 28535  		_ = m5.Args[2]
 28536  		p5 := m5.Args[0]
 28537  		mem := m5.Args[2]
 28538  		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4)+sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)) {
 28539  			break
 28540  		}
 28541  		v.reset(OpStore)
 28542  		v.Aux = t1
 28543  		v.AddArg(op1)
 28544  		v.AddArg(d1)
 28545  		v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28546  		v0.Aux = t2
 28547  		v0.AddArg(op2)
 28548  		v0.AddArg(d2)
 28549  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28550  		v1.Aux = t3
 28551  		v1.AddArg(op3)
 28552  		v1.AddArg(d3)
 28553  		v2 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28554  		v2.Aux = t4
 28555  		v2.AddArg(op4)
 28556  		v2.AddArg(d4)
 28557  		v2.AddArg(mem)
 28558  		v1.AddArg(v2)
 28559  		v0.AddArg(v1)
 28560  		v.AddArg(v0)
 28561  		return true
 28562  	}
 28563  	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [0] p2) d2 m3:(Zero [n] p3 mem)))
 28564  	// cond: m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)
 28565  	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 mem))
 28566  	for {
 28567  		t1 := v.Aux
 28568  		_ = v.Args[2]
 28569  		op1 := v.Args[0]
 28570  		if op1.Op != OpOffPtr {
 28571  			break
 28572  		}
 28573  		o1 := op1.AuxInt
 28574  		p1 := op1.Args[0]
 28575  		d1 := v.Args[1]
 28576  		m2 := v.Args[2]
 28577  		if m2.Op != OpStore {
 28578  			break
 28579  		}
 28580  		t2 := m2.Aux
 28581  		_ = m2.Args[2]
 28582  		op2 := m2.Args[0]
 28583  		if op2.Op != OpOffPtr {
 28584  			break
 28585  		}
 28586  		if op2.AuxInt != 0 {
 28587  			break
 28588  		}
 28589  		p2 := op2.Args[0]
 28590  		d2 := m2.Args[1]
 28591  		m3 := m2.Args[2]
 28592  		if m3.Op != OpZero {
 28593  			break
 28594  		}
 28595  		n := m3.AuxInt
 28596  		_ = m3.Args[1]
 28597  		p3 := m3.Args[0]
 28598  		mem := m3.Args[1]
 28599  		if !(m2.Uses == 1 && m3.Uses == 1 && o1 == sizeof(t2) && n == sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && clobber(m2) && clobber(m3)) {
 28600  			break
 28601  		}
 28602  		v.reset(OpStore)
 28603  		v.Aux = t1
 28604  		v.AddArg(op1)
 28605  		v.AddArg(d1)
 28606  		v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28607  		v0.Aux = t2
 28608  		v0.AddArg(op2)
 28609  		v0.AddArg(d2)
 28610  		v0.AddArg(mem)
 28611  		v.AddArg(v0)
 28612  		return true
 28613  	}
 28614  	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Zero [n] p4 mem))))
 28615  	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)
 28616  	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
 28617  	for {
 28618  		t1 := v.Aux
 28619  		_ = v.Args[2]
 28620  		op1 := v.Args[0]
 28621  		if op1.Op != OpOffPtr {
 28622  			break
 28623  		}
 28624  		o1 := op1.AuxInt
 28625  		p1 := op1.Args[0]
 28626  		d1 := v.Args[1]
 28627  		m2 := v.Args[2]
 28628  		if m2.Op != OpStore {
 28629  			break
 28630  		}
 28631  		t2 := m2.Aux
 28632  		_ = m2.Args[2]
 28633  		op2 := m2.Args[0]
 28634  		if op2.Op != OpOffPtr {
 28635  			break
 28636  		}
 28637  		o2 := op2.AuxInt
 28638  		p2 := op2.Args[0]
 28639  		d2 := m2.Args[1]
 28640  		m3 := m2.Args[2]
 28641  		if m3.Op != OpStore {
 28642  			break
 28643  		}
 28644  		t3 := m3.Aux
 28645  		_ = m3.Args[2]
 28646  		op3 := m3.Args[0]
 28647  		if op3.Op != OpOffPtr {
 28648  			break
 28649  		}
 28650  		if op3.AuxInt != 0 {
 28651  			break
 28652  		}
 28653  		p3 := op3.Args[0]
 28654  		d3 := m3.Args[1]
 28655  		m4 := m3.Args[2]
 28656  		if m4.Op != OpZero {
 28657  			break
 28658  		}
 28659  		n := m4.AuxInt
 28660  		_ = m4.Args[1]
 28661  		p4 := m4.Args[0]
 28662  		mem := m4.Args[1]
 28663  		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)) {
 28664  			break
 28665  		}
 28666  		v.reset(OpStore)
 28667  		v.Aux = t1
 28668  		v.AddArg(op1)
 28669  		v.AddArg(d1)
 28670  		v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28671  		v0.Aux = t2
 28672  		v0.AddArg(op2)
 28673  		v0.AddArg(d2)
 28674  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28675  		v1.Aux = t3
 28676  		v1.AddArg(op3)
 28677  		v1.AddArg(d3)
 28678  		v1.AddArg(mem)
 28679  		v0.AddArg(v1)
 28680  		v.AddArg(v0)
 28681  		return true
 28682  	}
 28683  	// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [o3] p3) d3 m4:(Store {t4} op4:(OffPtr [0] p4) d4 m5:(Zero [n] p5 mem)))))
 28684  	// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4) + sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)
 28685  	// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 (Store {t4} op4 d4 mem))))
 28686  	for {
 28687  		t1 := v.Aux
 28688  		_ = v.Args[2]
 28689  		op1 := v.Args[0]
 28690  		if op1.Op != OpOffPtr {
 28691  			break
 28692  		}
 28693  		o1 := op1.AuxInt
 28694  		p1 := op1.Args[0]
 28695  		d1 := v.Args[1]
 28696  		m2 := v.Args[2]
 28697  		if m2.Op != OpStore {
 28698  			break
 28699  		}
 28700  		t2 := m2.Aux
 28701  		_ = m2.Args[2]
 28702  		op2 := m2.Args[0]
 28703  		if op2.Op != OpOffPtr {
 28704  			break
 28705  		}
 28706  		o2 := op2.AuxInt
 28707  		p2 := op2.Args[0]
 28708  		d2 := m2.Args[1]
 28709  		m3 := m2.Args[2]
 28710  		if m3.Op != OpStore {
 28711  			break
 28712  		}
 28713  		t3 := m3.Aux
 28714  		_ = m3.Args[2]
 28715  		op3 := m3.Args[0]
 28716  		if op3.Op != OpOffPtr {
 28717  			break
 28718  		}
 28719  		o3 := op3.AuxInt
 28720  		p3 := op3.Args[0]
 28721  		d3 := m3.Args[1]
 28722  		m4 := m3.Args[2]
 28723  		if m4.Op != OpStore {
 28724  			break
 28725  		}
 28726  		t4 := m4.Aux
 28727  		_ = m4.Args[2]
 28728  		op4 := m4.Args[0]
 28729  		if op4.Op != OpOffPtr {
 28730  			break
 28731  		}
 28732  		if op4.AuxInt != 0 {
 28733  			break
 28734  		}
 28735  		p4 := op4.Args[0]
 28736  		d4 := m4.Args[1]
 28737  		m5 := m4.Args[2]
 28738  		if m5.Op != OpZero {
 28739  			break
 28740  		}
 28741  		n := m5.AuxInt
 28742  		_ = m5.Args[1]
 28743  		p5 := m5.Args[0]
 28744  		mem := m5.Args[1]
 28745  		if !(m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && m5.Uses == 1 && o3 == sizeof(t4) && o2-o3 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t4)+sizeof(t3)+sizeof(t2)+sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && clobber(m2) && clobber(m3) && clobber(m4) && clobber(m5)) {
 28746  			break
 28747  		}
 28748  		v.reset(OpStore)
 28749  		v.Aux = t1
 28750  		v.AddArg(op1)
 28751  		v.AddArg(d1)
 28752  		v0 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28753  		v0.Aux = t2
 28754  		v0.AddArg(op2)
 28755  		v0.AddArg(d2)
 28756  		v1 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28757  		v1.Aux = t3
 28758  		v1.AddArg(op3)
 28759  		v1.AddArg(d3)
 28760  		v2 := b.NewValue0(v.Pos, OpStore, types.TypeMem)
 28761  		v2.Aux = t4
 28762  		v2.AddArg(op4)
 28763  		v2.AddArg(d4)
 28764  		v2.AddArg(mem)
 28765  		v1.AddArg(v2)
 28766  		v0.AddArg(v1)
 28767  		v.AddArg(v0)
 28768  		return true
 28769  	}
 28770  	return false
 28771  }
 28772  func rewriteValuegeneric_OpStringLen_0(v *Value) bool {
 28773  	// match: (StringLen (StringMake _ (Const64 <t> [c])))
 28774  	// cond:
 28775  	// result: (Const64 <t> [c])
 28776  	for {
 28777  		v_0 := v.Args[0]
 28778  		if v_0.Op != OpStringMake {
 28779  			break
 28780  		}
 28781  		_ = v_0.Args[1]
 28782  		v_0_1 := v_0.Args[1]
 28783  		if v_0_1.Op != OpConst64 {
 28784  			break
 28785  		}
 28786  		t := v_0_1.Type
 28787  		c := v_0_1.AuxInt
 28788  		v.reset(OpConst64)
 28789  		v.Type = t
 28790  		v.AuxInt = c
 28791  		return true
 28792  	}
 28793  	return false
 28794  }
 28795  func rewriteValuegeneric_OpStringPtr_0(v *Value) bool {
 28796  	// match: (StringPtr (StringMake (Addr <t> {s} base) _))
 28797  	// cond:
 28798  	// result: (Addr <t> {s} base)
 28799  	for {
 28800  		v_0 := v.Args[0]
 28801  		if v_0.Op != OpStringMake {
 28802  			break
 28803  		}
 28804  		_ = v_0.Args[1]
 28805  		v_0_0 := v_0.Args[0]
 28806  		if v_0_0.Op != OpAddr {
 28807  			break
 28808  		}
 28809  		t := v_0_0.Type
 28810  		s := v_0_0.Aux
 28811  		base := v_0_0.Args[0]
 28812  		v.reset(OpAddr)
 28813  		v.Type = t
 28814  		v.Aux = s
 28815  		v.AddArg(base)
 28816  		return true
 28817  	}
 28818  	return false
 28819  }
 28820  func rewriteValuegeneric_OpStructSelect_0(v *Value) bool {
 28821  	// match: (StructSelect (StructMake1 x))
 28822  	// cond:
 28823  	// result: x
 28824  	for {
 28825  		v_0 := v.Args[0]
 28826  		if v_0.Op != OpStructMake1 {
 28827  			break
 28828  		}
 28829  		x := v_0.Args[0]
 28830  		v.reset(OpCopy)
 28831  		v.Type = x.Type
 28832  		v.AddArg(x)
 28833  		return true
 28834  	}
 28835  	// match: (StructSelect [0] (StructMake2 x _))
 28836  	// cond:
 28837  	// result: x
 28838  	for {
 28839  		if v.AuxInt != 0 {
 28840  			break
 28841  		}
 28842  		v_0 := v.Args[0]
 28843  		if v_0.Op != OpStructMake2 {
 28844  			break
 28845  		}
 28846  		_ = v_0.Args[1]
 28847  		x := v_0.Args[0]
 28848  		v.reset(OpCopy)
 28849  		v.Type = x.Type
 28850  		v.AddArg(x)
 28851  		return true
 28852  	}
 28853  	// match: (StructSelect [1] (StructMake2 _ x))
 28854  	// cond:
 28855  	// result: x
 28856  	for {
 28857  		if v.AuxInt != 1 {
 28858  			break
 28859  		}
 28860  		v_0 := v.Args[0]
 28861  		if v_0.Op != OpStructMake2 {
 28862  			break
 28863  		}
 28864  		_ = v_0.Args[1]
 28865  		x := v_0.Args[1]
 28866  		v.reset(OpCopy)
 28867  		v.Type = x.Type
 28868  		v.AddArg(x)
 28869  		return true
 28870  	}
 28871  	// match: (StructSelect [0] (StructMake3 x _ _))
 28872  	// cond:
 28873  	// result: x
 28874  	for {
 28875  		if v.AuxInt != 0 {
 28876  			break
 28877  		}
 28878  		v_0 := v.Args[0]
 28879  		if v_0.Op != OpStructMake3 {
 28880  			break
 28881  		}
 28882  		_ = v_0.Args[2]
 28883  		x := v_0.Args[0]
 28884  		v.reset(OpCopy)
 28885  		v.Type = x.Type
 28886  		v.AddArg(x)
 28887  		return true
 28888  	}
 28889  	// match: (StructSelect [1] (StructMake3 _ x _))
 28890  	// cond:
 28891  	// result: x
 28892  	for {
 28893  		if v.AuxInt != 1 {
 28894  			break
 28895  		}
 28896  		v_0 := v.Args[0]
 28897  		if v_0.Op != OpStructMake3 {
 28898  			break
 28899  		}
 28900  		_ = v_0.Args[2]
 28901  		x := v_0.Args[1]
 28902  		v.reset(OpCopy)
 28903  		v.Type = x.Type
 28904  		v.AddArg(x)
 28905  		return true
 28906  	}
 28907  	// match: (StructSelect [2] (StructMake3 _ _ x))
 28908  	// cond:
 28909  	// result: x
 28910  	for {
 28911  		if v.AuxInt != 2 {
 28912  			break
 28913  		}
 28914  		v_0 := v.Args[0]
 28915  		if v_0.Op != OpStructMake3 {
 28916  			break
 28917  		}
 28918  		_ = v_0.Args[2]
 28919  		x := v_0.Args[2]
 28920  		v.reset(OpCopy)
 28921  		v.Type = x.Type
 28922  		v.AddArg(x)
 28923  		return true
 28924  	}
 28925  	// match: (StructSelect [0] (StructMake4 x _ _ _))
 28926  	// cond:
 28927  	// result: x
 28928  	for {
 28929  		if v.AuxInt != 0 {
 28930  			break
 28931  		}
 28932  		v_0 := v.Args[0]
 28933  		if v_0.Op != OpStructMake4 {
 28934  			break
 28935  		}
 28936  		_ = v_0.Args[3]
 28937  		x := v_0.Args[0]
 28938  		v.reset(OpCopy)
 28939  		v.Type = x.Type
 28940  		v.AddArg(x)
 28941  		return true
 28942  	}
 28943  	// match: (StructSelect [1] (StructMake4 _ x _ _))
 28944  	// cond:
 28945  	// result: x
 28946  	for {
 28947  		if v.AuxInt != 1 {
 28948  			break
 28949  		}
 28950  		v_0 := v.Args[0]
 28951  		if v_0.Op != OpStructMake4 {
 28952  			break
 28953  		}
 28954  		_ = v_0.Args[3]
 28955  		x := v_0.Args[1]
 28956  		v.reset(OpCopy)
 28957  		v.Type = x.Type
 28958  		v.AddArg(x)
 28959  		return true
 28960  	}
 28961  	// match: (StructSelect [2] (StructMake4 _ _ x _))
 28962  	// cond:
 28963  	// result: x
 28964  	for {
 28965  		if v.AuxInt != 2 {
 28966  			break
 28967  		}
 28968  		v_0 := v.Args[0]
 28969  		if v_0.Op != OpStructMake4 {
 28970  			break
 28971  		}
 28972  		_ = v_0.Args[3]
 28973  		x := v_0.Args[2]
 28974  		v.reset(OpCopy)
 28975  		v.Type = x.Type
 28976  		v.AddArg(x)
 28977  		return true
 28978  	}
 28979  	// match: (StructSelect [3] (StructMake4 _ _ _ x))
 28980  	// cond:
 28981  	// result: x
 28982  	for {
 28983  		if v.AuxInt != 3 {
 28984  			break
 28985  		}
 28986  		v_0 := v.Args[0]
 28987  		if v_0.Op != OpStructMake4 {
 28988  			break
 28989  		}
 28990  		_ = v_0.Args[3]
 28991  		x := v_0.Args[3]
 28992  		v.reset(OpCopy)
 28993  		v.Type = x.Type
 28994  		v.AddArg(x)
 28995  		return true
 28996  	}
 28997  	return false
 28998  }
 28999  func rewriteValuegeneric_OpStructSelect_10(v *Value) bool {
 29000  	b := v.Block
 29001  	_ = b
 29002  	fe := b.Func.fe
 29003  	_ = fe
 29004  	// match: (StructSelect [i] x:(Load <t> ptr mem))
 29005  	// cond: !fe.CanSSA(t)
 29006  	// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
 29007  	for {
 29008  		i := v.AuxInt
 29009  		x := v.Args[0]
 29010  		if x.Op != OpLoad {
 29011  			break
 29012  		}
 29013  		t := x.Type
 29014  		_ = x.Args[1]
 29015  		ptr := x.Args[0]
 29016  		mem := x.Args[1]
 29017  		if !(!fe.CanSSA(t)) {
 29018  			break
 29019  		}
 29020  		b = x.Block
 29021  		v0 := b.NewValue0(v.Pos, OpLoad, v.Type)
 29022  		v.reset(OpCopy)
 29023  		v.AddArg(v0)
 29024  		v1 := b.NewValue0(v.Pos, OpOffPtr, v.Type.PtrTo())
 29025  		v1.AuxInt = t.FieldOff(int(i))
 29026  		v1.AddArg(ptr)
 29027  		v0.AddArg(v1)
 29028  		v0.AddArg(mem)
 29029  		return true
 29030  	}
 29031  	// match: (StructSelect [0] x:(IData _))
 29032  	// cond:
 29033  	// result: x
 29034  	for {
 29035  		if v.AuxInt != 0 {
 29036  			break
 29037  		}
 29038  		x := v.Args[0]
 29039  		if x.Op != OpIData {
 29040  			break
 29041  		}
 29042  		v.reset(OpCopy)
 29043  		v.Type = x.Type
 29044  		v.AddArg(x)
 29045  		return true
 29046  	}
 29047  	return false
 29048  }
 29049  func rewriteValuegeneric_OpSub16_0(v *Value) bool {
 29050  	b := v.Block
 29051  	_ = b
 29052  	// match: (Sub16 (Const16 [c]) (Const16 [d]))
 29053  	// cond:
 29054  	// result: (Const16 [int64(int16(c-d))])
 29055  	for {
 29056  		_ = v.Args[1]
 29057  		v_0 := v.Args[0]
 29058  		if v_0.Op != OpConst16 {
 29059  			break
 29060  		}
 29061  		c := v_0.AuxInt
 29062  		v_1 := v.Args[1]
 29063  		if v_1.Op != OpConst16 {
 29064  			break
 29065  		}
 29066  		d := v_1.AuxInt
 29067  		v.reset(OpConst16)
 29068  		v.AuxInt = int64(int16(c - d))
 29069  		return true
 29070  	}
 29071  	// match: (Sub16 x (Const16 <t> [c]))
 29072  	// cond: x.Op != OpConst16
 29073  	// result: (Add16 (Const16 <t> [int64(int16(-c))]) x)
 29074  	for {
 29075  		_ = v.Args[1]
 29076  		x := v.Args[0]
 29077  		v_1 := v.Args[1]
 29078  		if v_1.Op != OpConst16 {
 29079  			break
 29080  		}
 29081  		t := v_1.Type
 29082  		c := v_1.AuxInt
 29083  		if !(x.Op != OpConst16) {
 29084  			break
 29085  		}
 29086  		v.reset(OpAdd16)
 29087  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 29088  		v0.AuxInt = int64(int16(-c))
 29089  		v.AddArg(v0)
 29090  		v.AddArg(x)
 29091  		return true
 29092  	}
 29093  	// match: (Sub16 <t> (Mul16 x y) (Mul16 x z))
 29094  	// cond:
 29095  	// result: (Mul16 x (Sub16 <t> y z))
 29096  	for {
 29097  		t := v.Type
 29098  		_ = v.Args[1]
 29099  		v_0 := v.Args[0]
 29100  		if v_0.Op != OpMul16 {
 29101  			break
 29102  		}
 29103  		_ = v_0.Args[1]
 29104  		x := v_0.Args[0]
 29105  		y := v_0.Args[1]
 29106  		v_1 := v.Args[1]
 29107  		if v_1.Op != OpMul16 {
 29108  			break
 29109  		}
 29110  		_ = v_1.Args[1]
 29111  		if x != v_1.Args[0] {
 29112  			break
 29113  		}
 29114  		z := v_1.Args[1]
 29115  		v.reset(OpMul16)
 29116  		v.AddArg(x)
 29117  		v0 := b.NewValue0(v.Pos, OpSub16, t)
 29118  		v0.AddArg(y)
 29119  		v0.AddArg(z)
 29120  		v.AddArg(v0)
 29121  		return true
 29122  	}
 29123  	// match: (Sub16 <t> (Mul16 y x) (Mul16 x z))
 29124  	// cond:
 29125  	// result: (Mul16 x (Sub16 <t> y z))
 29126  	for {
 29127  		t := v.Type
 29128  		_ = v.Args[1]
 29129  		v_0 := v.Args[0]
 29130  		if v_0.Op != OpMul16 {
 29131  			break
 29132  		}
 29133  		_ = v_0.Args[1]
 29134  		y := v_0.Args[0]
 29135  		x := v_0.Args[1]
 29136  		v_1 := v.Args[1]
 29137  		if v_1.Op != OpMul16 {
 29138  			break
 29139  		}
 29140  		_ = v_1.Args[1]
 29141  		if x != v_1.Args[0] {
 29142  			break
 29143  		}
 29144  		z := v_1.Args[1]
 29145  		v.reset(OpMul16)
 29146  		v.AddArg(x)
 29147  		v0 := b.NewValue0(v.Pos, OpSub16, t)
 29148  		v0.AddArg(y)
 29149  		v0.AddArg(z)
 29150  		v.AddArg(v0)
 29151  		return true
 29152  	}
 29153  	// match: (Sub16 <t> (Mul16 x y) (Mul16 z x))
 29154  	// cond:
 29155  	// result: (Mul16 x (Sub16 <t> y z))
 29156  	for {
 29157  		t := v.Type
 29158  		_ = v.Args[1]
 29159  		v_0 := v.Args[0]
 29160  		if v_0.Op != OpMul16 {
 29161  			break
 29162  		}
 29163  		_ = v_0.Args[1]
 29164  		x := v_0.Args[0]
 29165  		y := v_0.Args[1]
 29166  		v_1 := v.Args[1]
 29167  		if v_1.Op != OpMul16 {
 29168  			break
 29169  		}
 29170  		_ = v_1.Args[1]
 29171  		z := v_1.Args[0]
 29172  		if x != v_1.Args[1] {
 29173  			break
 29174  		}
 29175  		v.reset(OpMul16)
 29176  		v.AddArg(x)
 29177  		v0 := b.NewValue0(v.Pos, OpSub16, t)
 29178  		v0.AddArg(y)
 29179  		v0.AddArg(z)
 29180  		v.AddArg(v0)
 29181  		return true
 29182  	}
 29183  	// match: (Sub16 <t> (Mul16 y x) (Mul16 z x))
 29184  	// cond:
 29185  	// result: (Mul16 x (Sub16 <t> y z))
 29186  	for {
 29187  		t := v.Type
 29188  		_ = v.Args[1]
 29189  		v_0 := v.Args[0]
 29190  		if v_0.Op != OpMul16 {
 29191  			break
 29192  		}
 29193  		_ = v_0.Args[1]
 29194  		y := v_0.Args[0]
 29195  		x := v_0.Args[1]
 29196  		v_1 := v.Args[1]
 29197  		if v_1.Op != OpMul16 {
 29198  			break
 29199  		}
 29200  		_ = v_1.Args[1]
 29201  		z := v_1.Args[0]
 29202  		if x != v_1.Args[1] {
 29203  			break
 29204  		}
 29205  		v.reset(OpMul16)
 29206  		v.AddArg(x)
 29207  		v0 := b.NewValue0(v.Pos, OpSub16, t)
 29208  		v0.AddArg(y)
 29209  		v0.AddArg(z)
 29210  		v.AddArg(v0)
 29211  		return true
 29212  	}
 29213  	// match: (Sub16 x x)
 29214  	// cond:
 29215  	// result: (Const16 [0])
 29216  	for {
 29217  		_ = v.Args[1]
 29218  		x := v.Args[0]
 29219  		if x != v.Args[1] {
 29220  			break
 29221  		}
 29222  		v.reset(OpConst16)
 29223  		v.AuxInt = 0
 29224  		return true
 29225  	}
 29226  	// match: (Sub16 (Add16 x y) x)
 29227  	// cond:
 29228  	// result: y
 29229  	for {
 29230  		_ = v.Args[1]
 29231  		v_0 := v.Args[0]
 29232  		if v_0.Op != OpAdd16 {
 29233  			break
 29234  		}
 29235  		_ = v_0.Args[1]
 29236  		x := v_0.Args[0]
 29237  		y := v_0.Args[1]
 29238  		if x != v.Args[1] {
 29239  			break
 29240  		}
 29241  		v.reset(OpCopy)
 29242  		v.Type = y.Type
 29243  		v.AddArg(y)
 29244  		return true
 29245  	}
 29246  	// match: (Sub16 (Add16 y x) x)
 29247  	// cond:
 29248  	// result: y
 29249  	for {
 29250  		_ = v.Args[1]
 29251  		v_0 := v.Args[0]
 29252  		if v_0.Op != OpAdd16 {
 29253  			break
 29254  		}
 29255  		_ = v_0.Args[1]
 29256  		y := v_0.Args[0]
 29257  		x := v_0.Args[1]
 29258  		if x != v.Args[1] {
 29259  			break
 29260  		}
 29261  		v.reset(OpCopy)
 29262  		v.Type = y.Type
 29263  		v.AddArg(y)
 29264  		return true
 29265  	}
 29266  	// match: (Sub16 (Add16 x y) y)
 29267  	// cond:
 29268  	// result: x
 29269  	for {
 29270  		_ = v.Args[1]
 29271  		v_0 := v.Args[0]
 29272  		if v_0.Op != OpAdd16 {
 29273  			break
 29274  		}
 29275  		_ = v_0.Args[1]
 29276  		x := v_0.Args[0]
 29277  		y := v_0.Args[1]
 29278  		if y != v.Args[1] {
 29279  			break
 29280  		}
 29281  		v.reset(OpCopy)
 29282  		v.Type = x.Type
 29283  		v.AddArg(x)
 29284  		return true
 29285  	}
 29286  	return false
 29287  }
 29288  func rewriteValuegeneric_OpSub16_10(v *Value) bool {
 29289  	b := v.Block
 29290  	_ = b
 29291  	// match: (Sub16 (Add16 y x) y)
 29292  	// cond:
 29293  	// result: x
 29294  	for {
 29295  		_ = v.Args[1]
 29296  		v_0 := v.Args[0]
 29297  		if v_0.Op != OpAdd16 {
 29298  			break
 29299  		}
 29300  		_ = v_0.Args[1]
 29301  		y := v_0.Args[0]
 29302  		x := v_0.Args[1]
 29303  		if y != v.Args[1] {
 29304  			break
 29305  		}
 29306  		v.reset(OpCopy)
 29307  		v.Type = x.Type
 29308  		v.AddArg(x)
 29309  		return true
 29310  	}
 29311  	// match: (Sub16 x (Sub16 i:(Const16 <t>) z))
 29312  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 29313  	// result: (Sub16 (Add16 <t> x z) i)
 29314  	for {
 29315  		_ = v.Args[1]
 29316  		x := v.Args[0]
 29317  		v_1 := v.Args[1]
 29318  		if v_1.Op != OpSub16 {
 29319  			break
 29320  		}
 29321  		_ = v_1.Args[1]
 29322  		i := v_1.Args[0]
 29323  		if i.Op != OpConst16 {
 29324  			break
 29325  		}
 29326  		t := i.Type
 29327  		z := v_1.Args[1]
 29328  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 29329  			break
 29330  		}
 29331  		v.reset(OpSub16)
 29332  		v0 := b.NewValue0(v.Pos, OpAdd16, t)
 29333  		v0.AddArg(x)
 29334  		v0.AddArg(z)
 29335  		v.AddArg(v0)
 29336  		v.AddArg(i)
 29337  		return true
 29338  	}
 29339  	// match: (Sub16 x (Sub16 z i:(Const16 <t>)))
 29340  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 29341  	// result: (Add16 i (Sub16 <t> x z))
 29342  	for {
 29343  		_ = v.Args[1]
 29344  		x := v.Args[0]
 29345  		v_1 := v.Args[1]
 29346  		if v_1.Op != OpSub16 {
 29347  			break
 29348  		}
 29349  		_ = v_1.Args[1]
 29350  		z := v_1.Args[0]
 29351  		i := v_1.Args[1]
 29352  		if i.Op != OpConst16 {
 29353  			break
 29354  		}
 29355  		t := i.Type
 29356  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 29357  			break
 29358  		}
 29359  		v.reset(OpAdd16)
 29360  		v.AddArg(i)
 29361  		v0 := b.NewValue0(v.Pos, OpSub16, t)
 29362  		v0.AddArg(x)
 29363  		v0.AddArg(z)
 29364  		v.AddArg(v0)
 29365  		return true
 29366  	}
 29367  	// match: (Sub16 (Const16 <t> [c]) (Sub16 x (Const16 <t> [d])))
 29368  	// cond:
 29369  	// result: (Sub16 (Const16 <t> [int64(int16(c+d))]) x)
 29370  	for {
 29371  		_ = v.Args[1]
 29372  		v_0 := v.Args[0]
 29373  		if v_0.Op != OpConst16 {
 29374  			break
 29375  		}
 29376  		t := v_0.Type
 29377  		c := v_0.AuxInt
 29378  		v_1 := v.Args[1]
 29379  		if v_1.Op != OpSub16 {
 29380  			break
 29381  		}
 29382  		_ = v_1.Args[1]
 29383  		x := v_1.Args[0]
 29384  		v_1_1 := v_1.Args[1]
 29385  		if v_1_1.Op != OpConst16 {
 29386  			break
 29387  		}
 29388  		if v_1_1.Type != t {
 29389  			break
 29390  		}
 29391  		d := v_1_1.AuxInt
 29392  		v.reset(OpSub16)
 29393  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 29394  		v0.AuxInt = int64(int16(c + d))
 29395  		v.AddArg(v0)
 29396  		v.AddArg(x)
 29397  		return true
 29398  	}
 29399  	// match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
 29400  	// cond:
 29401  	// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
 29402  	for {
 29403  		_ = v.Args[1]
 29404  		v_0 := v.Args[0]
 29405  		if v_0.Op != OpConst16 {
 29406  			break
 29407  		}
 29408  		t := v_0.Type
 29409  		c := v_0.AuxInt
 29410  		v_1 := v.Args[1]
 29411  		if v_1.Op != OpSub16 {
 29412  			break
 29413  		}
 29414  		_ = v_1.Args[1]
 29415  		v_1_0 := v_1.Args[0]
 29416  		if v_1_0.Op != OpConst16 {
 29417  			break
 29418  		}
 29419  		if v_1_0.Type != t {
 29420  			break
 29421  		}
 29422  		d := v_1_0.AuxInt
 29423  		x := v_1.Args[1]
 29424  		v.reset(OpAdd16)
 29425  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 29426  		v0.AuxInt = int64(int16(c - d))
 29427  		v.AddArg(v0)
 29428  		v.AddArg(x)
 29429  		return true
 29430  	}
 29431  	return false
 29432  }
 29433  func rewriteValuegeneric_OpSub32_0(v *Value) bool {
 29434  	b := v.Block
 29435  	_ = b
 29436  	// match: (Sub32 (Const32 [c]) (Const32 [d]))
 29437  	// cond:
 29438  	// result: (Const32 [int64(int32(c-d))])
 29439  	for {
 29440  		_ = v.Args[1]
 29441  		v_0 := v.Args[0]
 29442  		if v_0.Op != OpConst32 {
 29443  			break
 29444  		}
 29445  		c := v_0.AuxInt
 29446  		v_1 := v.Args[1]
 29447  		if v_1.Op != OpConst32 {
 29448  			break
 29449  		}
 29450  		d := v_1.AuxInt
 29451  		v.reset(OpConst32)
 29452  		v.AuxInt = int64(int32(c - d))
 29453  		return true
 29454  	}
 29455  	// match: (Sub32 x (Const32 <t> [c]))
 29456  	// cond: x.Op != OpConst32
 29457  	// result: (Add32 (Const32 <t> [int64(int32(-c))]) x)
 29458  	for {
 29459  		_ = v.Args[1]
 29460  		x := v.Args[0]
 29461  		v_1 := v.Args[1]
 29462  		if v_1.Op != OpConst32 {
 29463  			break
 29464  		}
 29465  		t := v_1.Type
 29466  		c := v_1.AuxInt
 29467  		if !(x.Op != OpConst32) {
 29468  			break
 29469  		}
 29470  		v.reset(OpAdd32)
 29471  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 29472  		v0.AuxInt = int64(int32(-c))
 29473  		v.AddArg(v0)
 29474  		v.AddArg(x)
 29475  		return true
 29476  	}
 29477  	// match: (Sub32 <t> (Mul32 x y) (Mul32 x z))
 29478  	// cond:
 29479  	// result: (Mul32 x (Sub32 <t> y z))
 29480  	for {
 29481  		t := v.Type
 29482  		_ = v.Args[1]
 29483  		v_0 := v.Args[0]
 29484  		if v_0.Op != OpMul32 {
 29485  			break
 29486  		}
 29487  		_ = v_0.Args[1]
 29488  		x := v_0.Args[0]
 29489  		y := v_0.Args[1]
 29490  		v_1 := v.Args[1]
 29491  		if v_1.Op != OpMul32 {
 29492  			break
 29493  		}
 29494  		_ = v_1.Args[1]
 29495  		if x != v_1.Args[0] {
 29496  			break
 29497  		}
 29498  		z := v_1.Args[1]
 29499  		v.reset(OpMul32)
 29500  		v.AddArg(x)
 29501  		v0 := b.NewValue0(v.Pos, OpSub32, t)
 29502  		v0.AddArg(y)
 29503  		v0.AddArg(z)
 29504  		v.AddArg(v0)
 29505  		return true
 29506  	}
 29507  	// match: (Sub32 <t> (Mul32 y x) (Mul32 x z))
 29508  	// cond:
 29509  	// result: (Mul32 x (Sub32 <t> y z))
 29510  	for {
 29511  		t := v.Type
 29512  		_ = v.Args[1]
 29513  		v_0 := v.Args[0]
 29514  		if v_0.Op != OpMul32 {
 29515  			break
 29516  		}
 29517  		_ = v_0.Args[1]
 29518  		y := v_0.Args[0]
 29519  		x := v_0.Args[1]
 29520  		v_1 := v.Args[1]
 29521  		if v_1.Op != OpMul32 {
 29522  			break
 29523  		}
 29524  		_ = v_1.Args[1]
 29525  		if x != v_1.Args[0] {
 29526  			break
 29527  		}
 29528  		z := v_1.Args[1]
 29529  		v.reset(OpMul32)
 29530  		v.AddArg(x)
 29531  		v0 := b.NewValue0(v.Pos, OpSub32, t)
 29532  		v0.AddArg(y)
 29533  		v0.AddArg(z)
 29534  		v.AddArg(v0)
 29535  		return true
 29536  	}
 29537  	// match: (Sub32 <t> (Mul32 x y) (Mul32 z x))
 29538  	// cond:
 29539  	// result: (Mul32 x (Sub32 <t> y z))
 29540  	for {
 29541  		t := v.Type
 29542  		_ = v.Args[1]
 29543  		v_0 := v.Args[0]
 29544  		if v_0.Op != OpMul32 {
 29545  			break
 29546  		}
 29547  		_ = v_0.Args[1]
 29548  		x := v_0.Args[0]
 29549  		y := v_0.Args[1]
 29550  		v_1 := v.Args[1]
 29551  		if v_1.Op != OpMul32 {
 29552  			break
 29553  		}
 29554  		_ = v_1.Args[1]
 29555  		z := v_1.Args[0]
 29556  		if x != v_1.Args[1] {
 29557  			break
 29558  		}
 29559  		v.reset(OpMul32)
 29560  		v.AddArg(x)
 29561  		v0 := b.NewValue0(v.Pos, OpSub32, t)
 29562  		v0.AddArg(y)
 29563  		v0.AddArg(z)
 29564  		v.AddArg(v0)
 29565  		return true
 29566  	}
 29567  	// match: (Sub32 <t> (Mul32 y x) (Mul32 z x))
 29568  	// cond:
 29569  	// result: (Mul32 x (Sub32 <t> y z))
 29570  	for {
 29571  		t := v.Type
 29572  		_ = v.Args[1]
 29573  		v_0 := v.Args[0]
 29574  		if v_0.Op != OpMul32 {
 29575  			break
 29576  		}
 29577  		_ = v_0.Args[1]
 29578  		y := v_0.Args[0]
 29579  		x := v_0.Args[1]
 29580  		v_1 := v.Args[1]
 29581  		if v_1.Op != OpMul32 {
 29582  			break
 29583  		}
 29584  		_ = v_1.Args[1]
 29585  		z := v_1.Args[0]
 29586  		if x != v_1.Args[1] {
 29587  			break
 29588  		}
 29589  		v.reset(OpMul32)
 29590  		v.AddArg(x)
 29591  		v0 := b.NewValue0(v.Pos, OpSub32, t)
 29592  		v0.AddArg(y)
 29593  		v0.AddArg(z)
 29594  		v.AddArg(v0)
 29595  		return true
 29596  	}
 29597  	// match: (Sub32 x x)
 29598  	// cond:
 29599  	// result: (Const32 [0])
 29600  	for {
 29601  		_ = v.Args[1]
 29602  		x := v.Args[0]
 29603  		if x != v.Args[1] {
 29604  			break
 29605  		}
 29606  		v.reset(OpConst32)
 29607  		v.AuxInt = 0
 29608  		return true
 29609  	}
 29610  	// match: (Sub32 (Add32 x y) x)
 29611  	// cond:
 29612  	// result: y
 29613  	for {
 29614  		_ = v.Args[1]
 29615  		v_0 := v.Args[0]
 29616  		if v_0.Op != OpAdd32 {
 29617  			break
 29618  		}
 29619  		_ = v_0.Args[1]
 29620  		x := v_0.Args[0]
 29621  		y := v_0.Args[1]
 29622  		if x != v.Args[1] {
 29623  			break
 29624  		}
 29625  		v.reset(OpCopy)
 29626  		v.Type = y.Type
 29627  		v.AddArg(y)
 29628  		return true
 29629  	}
 29630  	// match: (Sub32 (Add32 y x) x)
 29631  	// cond:
 29632  	// result: y
 29633  	for {
 29634  		_ = v.Args[1]
 29635  		v_0 := v.Args[0]
 29636  		if v_0.Op != OpAdd32 {
 29637  			break
 29638  		}
 29639  		_ = v_0.Args[1]
 29640  		y := v_0.Args[0]
 29641  		x := v_0.Args[1]
 29642  		if x != v.Args[1] {
 29643  			break
 29644  		}
 29645  		v.reset(OpCopy)
 29646  		v.Type = y.Type
 29647  		v.AddArg(y)
 29648  		return true
 29649  	}
 29650  	// match: (Sub32 (Add32 x y) y)
 29651  	// cond:
 29652  	// result: x
 29653  	for {
 29654  		_ = v.Args[1]
 29655  		v_0 := v.Args[0]
 29656  		if v_0.Op != OpAdd32 {
 29657  			break
 29658  		}
 29659  		_ = v_0.Args[1]
 29660  		x := v_0.Args[0]
 29661  		y := v_0.Args[1]
 29662  		if y != v.Args[1] {
 29663  			break
 29664  		}
 29665  		v.reset(OpCopy)
 29666  		v.Type = x.Type
 29667  		v.AddArg(x)
 29668  		return true
 29669  	}
 29670  	return false
 29671  }
 29672  func rewriteValuegeneric_OpSub32_10(v *Value) bool {
 29673  	b := v.Block
 29674  	_ = b
 29675  	// match: (Sub32 (Add32 y x) y)
 29676  	// cond:
 29677  	// result: x
 29678  	for {
 29679  		_ = v.Args[1]
 29680  		v_0 := v.Args[0]
 29681  		if v_0.Op != OpAdd32 {
 29682  			break
 29683  		}
 29684  		_ = v_0.Args[1]
 29685  		y := v_0.Args[0]
 29686  		x := v_0.Args[1]
 29687  		if y != v.Args[1] {
 29688  			break
 29689  		}
 29690  		v.reset(OpCopy)
 29691  		v.Type = x.Type
 29692  		v.AddArg(x)
 29693  		return true
 29694  	}
 29695  	// match: (Sub32 x (Sub32 i:(Const32 <t>) z))
 29696  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 29697  	// result: (Sub32 (Add32 <t> x z) i)
 29698  	for {
 29699  		_ = v.Args[1]
 29700  		x := v.Args[0]
 29701  		v_1 := v.Args[1]
 29702  		if v_1.Op != OpSub32 {
 29703  			break
 29704  		}
 29705  		_ = v_1.Args[1]
 29706  		i := v_1.Args[0]
 29707  		if i.Op != OpConst32 {
 29708  			break
 29709  		}
 29710  		t := i.Type
 29711  		z := v_1.Args[1]
 29712  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 29713  			break
 29714  		}
 29715  		v.reset(OpSub32)
 29716  		v0 := b.NewValue0(v.Pos, OpAdd32, t)
 29717  		v0.AddArg(x)
 29718  		v0.AddArg(z)
 29719  		v.AddArg(v0)
 29720  		v.AddArg(i)
 29721  		return true
 29722  	}
 29723  	// match: (Sub32 x (Sub32 z i:(Const32 <t>)))
 29724  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 29725  	// result: (Add32 i (Sub32 <t> x z))
 29726  	for {
 29727  		_ = v.Args[1]
 29728  		x := v.Args[0]
 29729  		v_1 := v.Args[1]
 29730  		if v_1.Op != OpSub32 {
 29731  			break
 29732  		}
 29733  		_ = v_1.Args[1]
 29734  		z := v_1.Args[0]
 29735  		i := v_1.Args[1]
 29736  		if i.Op != OpConst32 {
 29737  			break
 29738  		}
 29739  		t := i.Type
 29740  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 29741  			break
 29742  		}
 29743  		v.reset(OpAdd32)
 29744  		v.AddArg(i)
 29745  		v0 := b.NewValue0(v.Pos, OpSub32, t)
 29746  		v0.AddArg(x)
 29747  		v0.AddArg(z)
 29748  		v.AddArg(v0)
 29749  		return true
 29750  	}
 29751  	// match: (Sub32 (Const32 <t> [c]) (Sub32 x (Const32 <t> [d])))
 29752  	// cond:
 29753  	// result: (Sub32 (Const32 <t> [int64(int32(c+d))]) x)
 29754  	for {
 29755  		_ = v.Args[1]
 29756  		v_0 := v.Args[0]
 29757  		if v_0.Op != OpConst32 {
 29758  			break
 29759  		}
 29760  		t := v_0.Type
 29761  		c := v_0.AuxInt
 29762  		v_1 := v.Args[1]
 29763  		if v_1.Op != OpSub32 {
 29764  			break
 29765  		}
 29766  		_ = v_1.Args[1]
 29767  		x := v_1.Args[0]
 29768  		v_1_1 := v_1.Args[1]
 29769  		if v_1_1.Op != OpConst32 {
 29770  			break
 29771  		}
 29772  		if v_1_1.Type != t {
 29773  			break
 29774  		}
 29775  		d := v_1_1.AuxInt
 29776  		v.reset(OpSub32)
 29777  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 29778  		v0.AuxInt = int64(int32(c + d))
 29779  		v.AddArg(v0)
 29780  		v.AddArg(x)
 29781  		return true
 29782  	}
 29783  	// match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
 29784  	// cond:
 29785  	// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
 29786  	for {
 29787  		_ = v.Args[1]
 29788  		v_0 := v.Args[0]
 29789  		if v_0.Op != OpConst32 {
 29790  			break
 29791  		}
 29792  		t := v_0.Type
 29793  		c := v_0.AuxInt
 29794  		v_1 := v.Args[1]
 29795  		if v_1.Op != OpSub32 {
 29796  			break
 29797  		}
 29798  		_ = v_1.Args[1]
 29799  		v_1_0 := v_1.Args[0]
 29800  		if v_1_0.Op != OpConst32 {
 29801  			break
 29802  		}
 29803  		if v_1_0.Type != t {
 29804  			break
 29805  		}
 29806  		d := v_1_0.AuxInt
 29807  		x := v_1.Args[1]
 29808  		v.reset(OpAdd32)
 29809  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 29810  		v0.AuxInt = int64(int32(c - d))
 29811  		v.AddArg(v0)
 29812  		v.AddArg(x)
 29813  		return true
 29814  	}
 29815  	return false
 29816  }
 29817  func rewriteValuegeneric_OpSub32F_0(v *Value) bool {
 29818  	// match: (Sub32F (Const32F [c]) (Const32F [d]))
 29819  	// cond:
 29820  	// result: (Const32F [auxFrom32F(auxTo32F(c) - auxTo32F(d))])
 29821  	for {
 29822  		_ = v.Args[1]
 29823  		v_0 := v.Args[0]
 29824  		if v_0.Op != OpConst32F {
 29825  			break
 29826  		}
 29827  		c := v_0.AuxInt
 29828  		v_1 := v.Args[1]
 29829  		if v_1.Op != OpConst32F {
 29830  			break
 29831  		}
 29832  		d := v_1.AuxInt
 29833  		v.reset(OpConst32F)
 29834  		v.AuxInt = auxFrom32F(auxTo32F(c) - auxTo32F(d))
 29835  		return true
 29836  	}
 29837  	return false
 29838  }
 29839  func rewriteValuegeneric_OpSub64_0(v *Value) bool {
 29840  	b := v.Block
 29841  	_ = b
 29842  	// match: (Sub64 (Const64 [c]) (Const64 [d]))
 29843  	// cond:
 29844  	// result: (Const64 [c-d])
 29845  	for {
 29846  		_ = v.Args[1]
 29847  		v_0 := v.Args[0]
 29848  		if v_0.Op != OpConst64 {
 29849  			break
 29850  		}
 29851  		c := v_0.AuxInt
 29852  		v_1 := v.Args[1]
 29853  		if v_1.Op != OpConst64 {
 29854  			break
 29855  		}
 29856  		d := v_1.AuxInt
 29857  		v.reset(OpConst64)
 29858  		v.AuxInt = c - d
 29859  		return true
 29860  	}
 29861  	// match: (Sub64 x (Const64 <t> [c]))
 29862  	// cond: x.Op != OpConst64
 29863  	// result: (Add64 (Const64 <t> [-c]) x)
 29864  	for {
 29865  		_ = v.Args[1]
 29866  		x := v.Args[0]
 29867  		v_1 := v.Args[1]
 29868  		if v_1.Op != OpConst64 {
 29869  			break
 29870  		}
 29871  		t := v_1.Type
 29872  		c := v_1.AuxInt
 29873  		if !(x.Op != OpConst64) {
 29874  			break
 29875  		}
 29876  		v.reset(OpAdd64)
 29877  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 29878  		v0.AuxInt = -c
 29879  		v.AddArg(v0)
 29880  		v.AddArg(x)
 29881  		return true
 29882  	}
 29883  	// match: (Sub64 <t> (Mul64 x y) (Mul64 x z))
 29884  	// cond:
 29885  	// result: (Mul64 x (Sub64 <t> y z))
 29886  	for {
 29887  		t := v.Type
 29888  		_ = v.Args[1]
 29889  		v_0 := v.Args[0]
 29890  		if v_0.Op != OpMul64 {
 29891  			break
 29892  		}
 29893  		_ = v_0.Args[1]
 29894  		x := v_0.Args[0]
 29895  		y := v_0.Args[1]
 29896  		v_1 := v.Args[1]
 29897  		if v_1.Op != OpMul64 {
 29898  			break
 29899  		}
 29900  		_ = v_1.Args[1]
 29901  		if x != v_1.Args[0] {
 29902  			break
 29903  		}
 29904  		z := v_1.Args[1]
 29905  		v.reset(OpMul64)
 29906  		v.AddArg(x)
 29907  		v0 := b.NewValue0(v.Pos, OpSub64, t)
 29908  		v0.AddArg(y)
 29909  		v0.AddArg(z)
 29910  		v.AddArg(v0)
 29911  		return true
 29912  	}
 29913  	// match: (Sub64 <t> (Mul64 y x) (Mul64 x z))
 29914  	// cond:
 29915  	// result: (Mul64 x (Sub64 <t> y z))
 29916  	for {
 29917  		t := v.Type
 29918  		_ = v.Args[1]
 29919  		v_0 := v.Args[0]
 29920  		if v_0.Op != OpMul64 {
 29921  			break
 29922  		}
 29923  		_ = v_0.Args[1]
 29924  		y := v_0.Args[0]
 29925  		x := v_0.Args[1]
 29926  		v_1 := v.Args[1]
 29927  		if v_1.Op != OpMul64 {
 29928  			break
 29929  		}
 29930  		_ = v_1.Args[1]
 29931  		if x != v_1.Args[0] {
 29932  			break
 29933  		}
 29934  		z := v_1.Args[1]
 29935  		v.reset(OpMul64)
 29936  		v.AddArg(x)
 29937  		v0 := b.NewValue0(v.Pos, OpSub64, t)
 29938  		v0.AddArg(y)
 29939  		v0.AddArg(z)
 29940  		v.AddArg(v0)
 29941  		return true
 29942  	}
 29943  	// match: (Sub64 <t> (Mul64 x y) (Mul64 z x))
 29944  	// cond:
 29945  	// result: (Mul64 x (Sub64 <t> y z))
 29946  	for {
 29947  		t := v.Type
 29948  		_ = v.Args[1]
 29949  		v_0 := v.Args[0]
 29950  		if v_0.Op != OpMul64 {
 29951  			break
 29952  		}
 29953  		_ = v_0.Args[1]
 29954  		x := v_0.Args[0]
 29955  		y := v_0.Args[1]
 29956  		v_1 := v.Args[1]
 29957  		if v_1.Op != OpMul64 {
 29958  			break
 29959  		}
 29960  		_ = v_1.Args[1]
 29961  		z := v_1.Args[0]
 29962  		if x != v_1.Args[1] {
 29963  			break
 29964  		}
 29965  		v.reset(OpMul64)
 29966  		v.AddArg(x)
 29967  		v0 := b.NewValue0(v.Pos, OpSub64, t)
 29968  		v0.AddArg(y)
 29969  		v0.AddArg(z)
 29970  		v.AddArg(v0)
 29971  		return true
 29972  	}
 29973  	// match: (Sub64 <t> (Mul64 y x) (Mul64 z x))
 29974  	// cond:
 29975  	// result: (Mul64 x (Sub64 <t> y z))
 29976  	for {
 29977  		t := v.Type
 29978  		_ = v.Args[1]
 29979  		v_0 := v.Args[0]
 29980  		if v_0.Op != OpMul64 {
 29981  			break
 29982  		}
 29983  		_ = v_0.Args[1]
 29984  		y := v_0.Args[0]
 29985  		x := v_0.Args[1]
 29986  		v_1 := v.Args[1]
 29987  		if v_1.Op != OpMul64 {
 29988  			break
 29989  		}
 29990  		_ = v_1.Args[1]
 29991  		z := v_1.Args[0]
 29992  		if x != v_1.Args[1] {
 29993  			break
 29994  		}
 29995  		v.reset(OpMul64)
 29996  		v.AddArg(x)
 29997  		v0 := b.NewValue0(v.Pos, OpSub64, t)
 29998  		v0.AddArg(y)
 29999  		v0.AddArg(z)
 30000  		v.AddArg(v0)
 30001  		return true
 30002  	}
 30003  	// match: (Sub64 x x)
 30004  	// cond:
 30005  	// result: (Const64 [0])
 30006  	for {
 30007  		_ = v.Args[1]
 30008  		x := v.Args[0]
 30009  		if x != v.Args[1] {
 30010  			break
 30011  		}
 30012  		v.reset(OpConst64)
 30013  		v.AuxInt = 0
 30014  		return true
 30015  	}
 30016  	// match: (Sub64 (Add64 x y) x)
 30017  	// cond:
 30018  	// result: y
 30019  	for {
 30020  		_ = v.Args[1]
 30021  		v_0 := v.Args[0]
 30022  		if v_0.Op != OpAdd64 {
 30023  			break
 30024  		}
 30025  		_ = v_0.Args[1]
 30026  		x := v_0.Args[0]
 30027  		y := v_0.Args[1]
 30028  		if x != v.Args[1] {
 30029  			break
 30030  		}
 30031  		v.reset(OpCopy)
 30032  		v.Type = y.Type
 30033  		v.AddArg(y)
 30034  		return true
 30035  	}
 30036  	// match: (Sub64 (Add64 y x) x)
 30037  	// cond:
 30038  	// result: y
 30039  	for {
 30040  		_ = v.Args[1]
 30041  		v_0 := v.Args[0]
 30042  		if v_0.Op != OpAdd64 {
 30043  			break
 30044  		}
 30045  		_ = v_0.Args[1]
 30046  		y := v_0.Args[0]
 30047  		x := v_0.Args[1]
 30048  		if x != v.Args[1] {
 30049  			break
 30050  		}
 30051  		v.reset(OpCopy)
 30052  		v.Type = y.Type
 30053  		v.AddArg(y)
 30054  		return true
 30055  	}
 30056  	// match: (Sub64 (Add64 x y) y)
 30057  	// cond:
 30058  	// result: x
 30059  	for {
 30060  		_ = v.Args[1]
 30061  		v_0 := v.Args[0]
 30062  		if v_0.Op != OpAdd64 {
 30063  			break
 30064  		}
 30065  		_ = v_0.Args[1]
 30066  		x := v_0.Args[0]
 30067  		y := v_0.Args[1]
 30068  		if y != v.Args[1] {
 30069  			break
 30070  		}
 30071  		v.reset(OpCopy)
 30072  		v.Type = x.Type
 30073  		v.AddArg(x)
 30074  		return true
 30075  	}
 30076  	return false
 30077  }
 30078  func rewriteValuegeneric_OpSub64_10(v *Value) bool {
 30079  	b := v.Block
 30080  	_ = b
 30081  	// match: (Sub64 (Add64 y x) y)
 30082  	// cond:
 30083  	// result: x
 30084  	for {
 30085  		_ = v.Args[1]
 30086  		v_0 := v.Args[0]
 30087  		if v_0.Op != OpAdd64 {
 30088  			break
 30089  		}
 30090  		_ = v_0.Args[1]
 30091  		y := v_0.Args[0]
 30092  		x := v_0.Args[1]
 30093  		if y != v.Args[1] {
 30094  			break
 30095  		}
 30096  		v.reset(OpCopy)
 30097  		v.Type = x.Type
 30098  		v.AddArg(x)
 30099  		return true
 30100  	}
 30101  	// match: (Sub64 x (Sub64 i:(Const64 <t>) z))
 30102  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 30103  	// result: (Sub64 (Add64 <t> x z) i)
 30104  	for {
 30105  		_ = v.Args[1]
 30106  		x := v.Args[0]
 30107  		v_1 := v.Args[1]
 30108  		if v_1.Op != OpSub64 {
 30109  			break
 30110  		}
 30111  		_ = v_1.Args[1]
 30112  		i := v_1.Args[0]
 30113  		if i.Op != OpConst64 {
 30114  			break
 30115  		}
 30116  		t := i.Type
 30117  		z := v_1.Args[1]
 30118  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 30119  			break
 30120  		}
 30121  		v.reset(OpSub64)
 30122  		v0 := b.NewValue0(v.Pos, OpAdd64, t)
 30123  		v0.AddArg(x)
 30124  		v0.AddArg(z)
 30125  		v.AddArg(v0)
 30126  		v.AddArg(i)
 30127  		return true
 30128  	}
 30129  	// match: (Sub64 x (Sub64 z i:(Const64 <t>)))
 30130  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 30131  	// result: (Add64 i (Sub64 <t> x z))
 30132  	for {
 30133  		_ = v.Args[1]
 30134  		x := v.Args[0]
 30135  		v_1 := v.Args[1]
 30136  		if v_1.Op != OpSub64 {
 30137  			break
 30138  		}
 30139  		_ = v_1.Args[1]
 30140  		z := v_1.Args[0]
 30141  		i := v_1.Args[1]
 30142  		if i.Op != OpConst64 {
 30143  			break
 30144  		}
 30145  		t := i.Type
 30146  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 30147  			break
 30148  		}
 30149  		v.reset(OpAdd64)
 30150  		v.AddArg(i)
 30151  		v0 := b.NewValue0(v.Pos, OpSub64, t)
 30152  		v0.AddArg(x)
 30153  		v0.AddArg(z)
 30154  		v.AddArg(v0)
 30155  		return true
 30156  	}
 30157  	// match: (Sub64 (Const64 <t> [c]) (Sub64 x (Const64 <t> [d])))
 30158  	// cond:
 30159  	// result: (Sub64 (Const64 <t> [c+d]) x)
 30160  	for {
 30161  		_ = v.Args[1]
 30162  		v_0 := v.Args[0]
 30163  		if v_0.Op != OpConst64 {
 30164  			break
 30165  		}
 30166  		t := v_0.Type
 30167  		c := v_0.AuxInt
 30168  		v_1 := v.Args[1]
 30169  		if v_1.Op != OpSub64 {
 30170  			break
 30171  		}
 30172  		_ = v_1.Args[1]
 30173  		x := v_1.Args[0]
 30174  		v_1_1 := v_1.Args[1]
 30175  		if v_1_1.Op != OpConst64 {
 30176  			break
 30177  		}
 30178  		if v_1_1.Type != t {
 30179  			break
 30180  		}
 30181  		d := v_1_1.AuxInt
 30182  		v.reset(OpSub64)
 30183  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 30184  		v0.AuxInt = c + d
 30185  		v.AddArg(v0)
 30186  		v.AddArg(x)
 30187  		return true
 30188  	}
 30189  	// match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
 30190  	// cond:
 30191  	// result: (Add64 (Const64 <t> [c-d]) x)
 30192  	for {
 30193  		_ = v.Args[1]
 30194  		v_0 := v.Args[0]
 30195  		if v_0.Op != OpConst64 {
 30196  			break
 30197  		}
 30198  		t := v_0.Type
 30199  		c := v_0.AuxInt
 30200  		v_1 := v.Args[1]
 30201  		if v_1.Op != OpSub64 {
 30202  			break
 30203  		}
 30204  		_ = v_1.Args[1]
 30205  		v_1_0 := v_1.Args[0]
 30206  		if v_1_0.Op != OpConst64 {
 30207  			break
 30208  		}
 30209  		if v_1_0.Type != t {
 30210  			break
 30211  		}
 30212  		d := v_1_0.AuxInt
 30213  		x := v_1.Args[1]
 30214  		v.reset(OpAdd64)
 30215  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 30216  		v0.AuxInt = c - d
 30217  		v.AddArg(v0)
 30218  		v.AddArg(x)
 30219  		return true
 30220  	}
 30221  	return false
 30222  }
 30223  func rewriteValuegeneric_OpSub64F_0(v *Value) bool {
 30224  	// match: (Sub64F (Const64F [c]) (Const64F [d]))
 30225  	// cond:
 30226  	// result: (Const64F [auxFrom64F(auxTo64F(c) - auxTo64F(d))])
 30227  	for {
 30228  		_ = v.Args[1]
 30229  		v_0 := v.Args[0]
 30230  		if v_0.Op != OpConst64F {
 30231  			break
 30232  		}
 30233  		c := v_0.AuxInt
 30234  		v_1 := v.Args[1]
 30235  		if v_1.Op != OpConst64F {
 30236  			break
 30237  		}
 30238  		d := v_1.AuxInt
 30239  		v.reset(OpConst64F)
 30240  		v.AuxInt = auxFrom64F(auxTo64F(c) - auxTo64F(d))
 30241  		return true
 30242  	}
 30243  	return false
 30244  }
 30245  func rewriteValuegeneric_OpSub8_0(v *Value) bool {
 30246  	b := v.Block
 30247  	_ = b
 30248  	// match: (Sub8 (Const8 [c]) (Const8 [d]))
 30249  	// cond:
 30250  	// result: (Const8 [int64(int8(c-d))])
 30251  	for {
 30252  		_ = v.Args[1]
 30253  		v_0 := v.Args[0]
 30254  		if v_0.Op != OpConst8 {
 30255  			break
 30256  		}
 30257  		c := v_0.AuxInt
 30258  		v_1 := v.Args[1]
 30259  		if v_1.Op != OpConst8 {
 30260  			break
 30261  		}
 30262  		d := v_1.AuxInt
 30263  		v.reset(OpConst8)
 30264  		v.AuxInt = int64(int8(c - d))
 30265  		return true
 30266  	}
 30267  	// match: (Sub8 x (Const8 <t> [c]))
 30268  	// cond: x.Op != OpConst8
 30269  	// result: (Add8 (Const8 <t> [int64(int8(-c))]) x)
 30270  	for {
 30271  		_ = v.Args[1]
 30272  		x := v.Args[0]
 30273  		v_1 := v.Args[1]
 30274  		if v_1.Op != OpConst8 {
 30275  			break
 30276  		}
 30277  		t := v_1.Type
 30278  		c := v_1.AuxInt
 30279  		if !(x.Op != OpConst8) {
 30280  			break
 30281  		}
 30282  		v.reset(OpAdd8)
 30283  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 30284  		v0.AuxInt = int64(int8(-c))
 30285  		v.AddArg(v0)
 30286  		v.AddArg(x)
 30287  		return true
 30288  	}
 30289  	// match: (Sub8 <t> (Mul8 x y) (Mul8 x z))
 30290  	// cond:
 30291  	// result: (Mul8 x (Sub8 <t> y z))
 30292  	for {
 30293  		t := v.Type
 30294  		_ = v.Args[1]
 30295  		v_0 := v.Args[0]
 30296  		if v_0.Op != OpMul8 {
 30297  			break
 30298  		}
 30299  		_ = v_0.Args[1]
 30300  		x := v_0.Args[0]
 30301  		y := v_0.Args[1]
 30302  		v_1 := v.Args[1]
 30303  		if v_1.Op != OpMul8 {
 30304  			break
 30305  		}
 30306  		_ = v_1.Args[1]
 30307  		if x != v_1.Args[0] {
 30308  			break
 30309  		}
 30310  		z := v_1.Args[1]
 30311  		v.reset(OpMul8)
 30312  		v.AddArg(x)
 30313  		v0 := b.NewValue0(v.Pos, OpSub8, t)
 30314  		v0.AddArg(y)
 30315  		v0.AddArg(z)
 30316  		v.AddArg(v0)
 30317  		return true
 30318  	}
 30319  	// match: (Sub8 <t> (Mul8 y x) (Mul8 x z))
 30320  	// cond:
 30321  	// result: (Mul8 x (Sub8 <t> y z))
 30322  	for {
 30323  		t := v.Type
 30324  		_ = v.Args[1]
 30325  		v_0 := v.Args[0]
 30326  		if v_0.Op != OpMul8 {
 30327  			break
 30328  		}
 30329  		_ = v_0.Args[1]
 30330  		y := v_0.Args[0]
 30331  		x := v_0.Args[1]
 30332  		v_1 := v.Args[1]
 30333  		if v_1.Op != OpMul8 {
 30334  			break
 30335  		}
 30336  		_ = v_1.Args[1]
 30337  		if x != v_1.Args[0] {
 30338  			break
 30339  		}
 30340  		z := v_1.Args[1]
 30341  		v.reset(OpMul8)
 30342  		v.AddArg(x)
 30343  		v0 := b.NewValue0(v.Pos, OpSub8, t)
 30344  		v0.AddArg(y)
 30345  		v0.AddArg(z)
 30346  		v.AddArg(v0)
 30347  		return true
 30348  	}
 30349  	// match: (Sub8 <t> (Mul8 x y) (Mul8 z x))
 30350  	// cond:
 30351  	// result: (Mul8 x (Sub8 <t> y z))
 30352  	for {
 30353  		t := v.Type
 30354  		_ = v.Args[1]
 30355  		v_0 := v.Args[0]
 30356  		if v_0.Op != OpMul8 {
 30357  			break
 30358  		}
 30359  		_ = v_0.Args[1]
 30360  		x := v_0.Args[0]
 30361  		y := v_0.Args[1]
 30362  		v_1 := v.Args[1]
 30363  		if v_1.Op != OpMul8 {
 30364  			break
 30365  		}
 30366  		_ = v_1.Args[1]
 30367  		z := v_1.Args[0]
 30368  		if x != v_1.Args[1] {
 30369  			break
 30370  		}
 30371  		v.reset(OpMul8)
 30372  		v.AddArg(x)
 30373  		v0 := b.NewValue0(v.Pos, OpSub8, t)
 30374  		v0.AddArg(y)
 30375  		v0.AddArg(z)
 30376  		v.AddArg(v0)
 30377  		return true
 30378  	}
 30379  	// match: (Sub8 <t> (Mul8 y x) (Mul8 z x))
 30380  	// cond:
 30381  	// result: (Mul8 x (Sub8 <t> y z))
 30382  	for {
 30383  		t := v.Type
 30384  		_ = v.Args[1]
 30385  		v_0 := v.Args[0]
 30386  		if v_0.Op != OpMul8 {
 30387  			break
 30388  		}
 30389  		_ = v_0.Args[1]
 30390  		y := v_0.Args[0]
 30391  		x := v_0.Args[1]
 30392  		v_1 := v.Args[1]
 30393  		if v_1.Op != OpMul8 {
 30394  			break
 30395  		}
 30396  		_ = v_1.Args[1]
 30397  		z := v_1.Args[0]
 30398  		if x != v_1.Args[1] {
 30399  			break
 30400  		}
 30401  		v.reset(OpMul8)
 30402  		v.AddArg(x)
 30403  		v0 := b.NewValue0(v.Pos, OpSub8, t)
 30404  		v0.AddArg(y)
 30405  		v0.AddArg(z)
 30406  		v.AddArg(v0)
 30407  		return true
 30408  	}
 30409  	// match: (Sub8 x x)
 30410  	// cond:
 30411  	// result: (Const8 [0])
 30412  	for {
 30413  		_ = v.Args[1]
 30414  		x := v.Args[0]
 30415  		if x != v.Args[1] {
 30416  			break
 30417  		}
 30418  		v.reset(OpConst8)
 30419  		v.AuxInt = 0
 30420  		return true
 30421  	}
 30422  	// match: (Sub8 (Add8 x y) x)
 30423  	// cond:
 30424  	// result: y
 30425  	for {
 30426  		_ = v.Args[1]
 30427  		v_0 := v.Args[0]
 30428  		if v_0.Op != OpAdd8 {
 30429  			break
 30430  		}
 30431  		_ = v_0.Args[1]
 30432  		x := v_0.Args[0]
 30433  		y := v_0.Args[1]
 30434  		if x != v.Args[1] {
 30435  			break
 30436  		}
 30437  		v.reset(OpCopy)
 30438  		v.Type = y.Type
 30439  		v.AddArg(y)
 30440  		return true
 30441  	}
 30442  	// match: (Sub8 (Add8 y x) x)
 30443  	// cond:
 30444  	// result: y
 30445  	for {
 30446  		_ = v.Args[1]
 30447  		v_0 := v.Args[0]
 30448  		if v_0.Op != OpAdd8 {
 30449  			break
 30450  		}
 30451  		_ = v_0.Args[1]
 30452  		y := v_0.Args[0]
 30453  		x := v_0.Args[1]
 30454  		if x != v.Args[1] {
 30455  			break
 30456  		}
 30457  		v.reset(OpCopy)
 30458  		v.Type = y.Type
 30459  		v.AddArg(y)
 30460  		return true
 30461  	}
 30462  	// match: (Sub8 (Add8 x y) y)
 30463  	// cond:
 30464  	// result: x
 30465  	for {
 30466  		_ = v.Args[1]
 30467  		v_0 := v.Args[0]
 30468  		if v_0.Op != OpAdd8 {
 30469  			break
 30470  		}
 30471  		_ = v_0.Args[1]
 30472  		x := v_0.Args[0]
 30473  		y := v_0.Args[1]
 30474  		if y != v.Args[1] {
 30475  			break
 30476  		}
 30477  		v.reset(OpCopy)
 30478  		v.Type = x.Type
 30479  		v.AddArg(x)
 30480  		return true
 30481  	}
 30482  	return false
 30483  }
 30484  func rewriteValuegeneric_OpSub8_10(v *Value) bool {
 30485  	b := v.Block
 30486  	_ = b
 30487  	// match: (Sub8 (Add8 y x) y)
 30488  	// cond:
 30489  	// result: x
 30490  	for {
 30491  		_ = v.Args[1]
 30492  		v_0 := v.Args[0]
 30493  		if v_0.Op != OpAdd8 {
 30494  			break
 30495  		}
 30496  		_ = v_0.Args[1]
 30497  		y := v_0.Args[0]
 30498  		x := v_0.Args[1]
 30499  		if y != v.Args[1] {
 30500  			break
 30501  		}
 30502  		v.reset(OpCopy)
 30503  		v.Type = x.Type
 30504  		v.AddArg(x)
 30505  		return true
 30506  	}
 30507  	// match: (Sub8 x (Sub8 i:(Const8 <t>) z))
 30508  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 30509  	// result: (Sub8 (Add8 <t> x z) i)
 30510  	for {
 30511  		_ = v.Args[1]
 30512  		x := v.Args[0]
 30513  		v_1 := v.Args[1]
 30514  		if v_1.Op != OpSub8 {
 30515  			break
 30516  		}
 30517  		_ = v_1.Args[1]
 30518  		i := v_1.Args[0]
 30519  		if i.Op != OpConst8 {
 30520  			break
 30521  		}
 30522  		t := i.Type
 30523  		z := v_1.Args[1]
 30524  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 30525  			break
 30526  		}
 30527  		v.reset(OpSub8)
 30528  		v0 := b.NewValue0(v.Pos, OpAdd8, t)
 30529  		v0.AddArg(x)
 30530  		v0.AddArg(z)
 30531  		v.AddArg(v0)
 30532  		v.AddArg(i)
 30533  		return true
 30534  	}
 30535  	// match: (Sub8 x (Sub8 z i:(Const8 <t>)))
 30536  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 30537  	// result: (Add8 i (Sub8 <t> x z))
 30538  	for {
 30539  		_ = v.Args[1]
 30540  		x := v.Args[0]
 30541  		v_1 := v.Args[1]
 30542  		if v_1.Op != OpSub8 {
 30543  			break
 30544  		}
 30545  		_ = v_1.Args[1]
 30546  		z := v_1.Args[0]
 30547  		i := v_1.Args[1]
 30548  		if i.Op != OpConst8 {
 30549  			break
 30550  		}
 30551  		t := i.Type
 30552  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 30553  			break
 30554  		}
 30555  		v.reset(OpAdd8)
 30556  		v.AddArg(i)
 30557  		v0 := b.NewValue0(v.Pos, OpSub8, t)
 30558  		v0.AddArg(x)
 30559  		v0.AddArg(z)
 30560  		v.AddArg(v0)
 30561  		return true
 30562  	}
 30563  	// match: (Sub8 (Const8 <t> [c]) (Sub8 x (Const8 <t> [d])))
 30564  	// cond:
 30565  	// result: (Sub8 (Const8 <t> [int64(int8(c+d))]) x)
 30566  	for {
 30567  		_ = v.Args[1]
 30568  		v_0 := v.Args[0]
 30569  		if v_0.Op != OpConst8 {
 30570  			break
 30571  		}
 30572  		t := v_0.Type
 30573  		c := v_0.AuxInt
 30574  		v_1 := v.Args[1]
 30575  		if v_1.Op != OpSub8 {
 30576  			break
 30577  		}
 30578  		_ = v_1.Args[1]
 30579  		x := v_1.Args[0]
 30580  		v_1_1 := v_1.Args[1]
 30581  		if v_1_1.Op != OpConst8 {
 30582  			break
 30583  		}
 30584  		if v_1_1.Type != t {
 30585  			break
 30586  		}
 30587  		d := v_1_1.AuxInt
 30588  		v.reset(OpSub8)
 30589  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 30590  		v0.AuxInt = int64(int8(c + d))
 30591  		v.AddArg(v0)
 30592  		v.AddArg(x)
 30593  		return true
 30594  	}
 30595  	// match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
 30596  	// cond:
 30597  	// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
 30598  	for {
 30599  		_ = v.Args[1]
 30600  		v_0 := v.Args[0]
 30601  		if v_0.Op != OpConst8 {
 30602  			break
 30603  		}
 30604  		t := v_0.Type
 30605  		c := v_0.AuxInt
 30606  		v_1 := v.Args[1]
 30607  		if v_1.Op != OpSub8 {
 30608  			break
 30609  		}
 30610  		_ = v_1.Args[1]
 30611  		v_1_0 := v_1.Args[0]
 30612  		if v_1_0.Op != OpConst8 {
 30613  			break
 30614  		}
 30615  		if v_1_0.Type != t {
 30616  			break
 30617  		}
 30618  		d := v_1_0.AuxInt
 30619  		x := v_1.Args[1]
 30620  		v.reset(OpAdd8)
 30621  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 30622  		v0.AuxInt = int64(int8(c - d))
 30623  		v.AddArg(v0)
 30624  		v.AddArg(x)
 30625  		return true
 30626  	}
 30627  	return false
 30628  }
 30629  func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool {
 30630  	// match: (Trunc16to8 (Const16 [c]))
 30631  	// cond:
 30632  	// result: (Const8 [int64(int8(c))])
 30633  	for {
 30634  		v_0 := v.Args[0]
 30635  		if v_0.Op != OpConst16 {
 30636  			break
 30637  		}
 30638  		c := v_0.AuxInt
 30639  		v.reset(OpConst8)
 30640  		v.AuxInt = int64(int8(c))
 30641  		return true
 30642  	}
 30643  	// match: (Trunc16to8 (ZeroExt8to16 x))
 30644  	// cond:
 30645  	// result: x
 30646  	for {
 30647  		v_0 := v.Args[0]
 30648  		if v_0.Op != OpZeroExt8to16 {
 30649  			break
 30650  		}
 30651  		x := v_0.Args[0]
 30652  		v.reset(OpCopy)
 30653  		v.Type = x.Type
 30654  		v.AddArg(x)
 30655  		return true
 30656  	}
 30657  	// match: (Trunc16to8 (SignExt8to16 x))
 30658  	// cond:
 30659  	// result: x
 30660  	for {
 30661  		v_0 := v.Args[0]
 30662  		if v_0.Op != OpSignExt8to16 {
 30663  			break
 30664  		}
 30665  		x := v_0.Args[0]
 30666  		v.reset(OpCopy)
 30667  		v.Type = x.Type
 30668  		v.AddArg(x)
 30669  		return true
 30670  	}
 30671  	// match: (Trunc16to8 (And16 (Const16 [y]) x))
 30672  	// cond: y&0xFF == 0xFF
 30673  	// result: (Trunc16to8 x)
 30674  	for {
 30675  		v_0 := v.Args[0]
 30676  		if v_0.Op != OpAnd16 {
 30677  			break
 30678  		}
 30679  		_ = v_0.Args[1]
 30680  		v_0_0 := v_0.Args[0]
 30681  		if v_0_0.Op != OpConst16 {
 30682  			break
 30683  		}
 30684  		y := v_0_0.AuxInt
 30685  		x := v_0.Args[1]
 30686  		if !(y&0xFF == 0xFF) {
 30687  			break
 30688  		}
 30689  		v.reset(OpTrunc16to8)
 30690  		v.AddArg(x)
 30691  		return true
 30692  	}
 30693  	// match: (Trunc16to8 (And16 x (Const16 [y])))
 30694  	// cond: y&0xFF == 0xFF
 30695  	// result: (Trunc16to8 x)
 30696  	for {
 30697  		v_0 := v.Args[0]
 30698  		if v_0.Op != OpAnd16 {
 30699  			break
 30700  		}
 30701  		_ = v_0.Args[1]
 30702  		x := v_0.Args[0]
 30703  		v_0_1 := v_0.Args[1]
 30704  		if v_0_1.Op != OpConst16 {
 30705  			break
 30706  		}
 30707  		y := v_0_1.AuxInt
 30708  		if !(y&0xFF == 0xFF) {
 30709  			break
 30710  		}
 30711  		v.reset(OpTrunc16to8)
 30712  		v.AddArg(x)
 30713  		return true
 30714  	}
 30715  	return false
 30716  }
 30717  func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool {
 30718  	// match: (Trunc32to16 (Const32 [c]))
 30719  	// cond:
 30720  	// result: (Const16 [int64(int16(c))])
 30721  	for {
 30722  		v_0 := v.Args[0]
 30723  		if v_0.Op != OpConst32 {
 30724  			break
 30725  		}
 30726  		c := v_0.AuxInt
 30727  		v.reset(OpConst16)
 30728  		v.AuxInt = int64(int16(c))
 30729  		return true
 30730  	}
 30731  	// match: (Trunc32to16 (ZeroExt8to32 x))
 30732  	// cond:
 30733  	// result: (ZeroExt8to16 x)
 30734  	for {
 30735  		v_0 := v.Args[0]
 30736  		if v_0.Op != OpZeroExt8to32 {
 30737  			break
 30738  		}
 30739  		x := v_0.Args[0]
 30740  		v.reset(OpZeroExt8to16)
 30741  		v.AddArg(x)
 30742  		return true
 30743  	}
 30744  	// match: (Trunc32to16 (ZeroExt16to32 x))
 30745  	// cond:
 30746  	// result: x
 30747  	for {
 30748  		v_0 := v.Args[0]
 30749  		if v_0.Op != OpZeroExt16to32 {
 30750  			break
 30751  		}
 30752  		x := v_0.Args[0]
 30753  		v.reset(OpCopy)
 30754  		v.Type = x.Type
 30755  		v.AddArg(x)
 30756  		return true
 30757  	}
 30758  	// match: (Trunc32to16 (SignExt8to32 x))
 30759  	// cond:
 30760  	// result: (SignExt8to16 x)
 30761  	for {
 30762  		v_0 := v.Args[0]
 30763  		if v_0.Op != OpSignExt8to32 {
 30764  			break
 30765  		}
 30766  		x := v_0.Args[0]
 30767  		v.reset(OpSignExt8to16)
 30768  		v.AddArg(x)
 30769  		return true
 30770  	}
 30771  	// match: (Trunc32to16 (SignExt16to32 x))
 30772  	// cond:
 30773  	// result: x
 30774  	for {
 30775  		v_0 := v.Args[0]
 30776  		if v_0.Op != OpSignExt16to32 {
 30777  			break
 30778  		}
 30779  		x := v_0.Args[0]
 30780  		v.reset(OpCopy)
 30781  		v.Type = x.Type
 30782  		v.AddArg(x)
 30783  		return true
 30784  	}
 30785  	// match: (Trunc32to16 (And32 (Const32 [y]) x))
 30786  	// cond: y&0xFFFF == 0xFFFF
 30787  	// result: (Trunc32to16 x)
 30788  	for {
 30789  		v_0 := v.Args[0]
 30790  		if v_0.Op != OpAnd32 {
 30791  			break
 30792  		}
 30793  		_ = v_0.Args[1]
 30794  		v_0_0 := v_0.Args[0]
 30795  		if v_0_0.Op != OpConst32 {
 30796  			break
 30797  		}
 30798  		y := v_0_0.AuxInt
 30799  		x := v_0.Args[1]
 30800  		if !(y&0xFFFF == 0xFFFF) {
 30801  			break
 30802  		}
 30803  		v.reset(OpTrunc32to16)
 30804  		v.AddArg(x)
 30805  		return true
 30806  	}
 30807  	// match: (Trunc32to16 (And32 x (Const32 [y])))
 30808  	// cond: y&0xFFFF == 0xFFFF
 30809  	// result: (Trunc32to16 x)
 30810  	for {
 30811  		v_0 := v.Args[0]
 30812  		if v_0.Op != OpAnd32 {
 30813  			break
 30814  		}
 30815  		_ = v_0.Args[1]
 30816  		x := v_0.Args[0]
 30817  		v_0_1 := v_0.Args[1]
 30818  		if v_0_1.Op != OpConst32 {
 30819  			break
 30820  		}
 30821  		y := v_0_1.AuxInt
 30822  		if !(y&0xFFFF == 0xFFFF) {
 30823  			break
 30824  		}
 30825  		v.reset(OpTrunc32to16)
 30826  		v.AddArg(x)
 30827  		return true
 30828  	}
 30829  	return false
 30830  }
 30831  func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool {
 30832  	// match: (Trunc32to8 (Const32 [c]))
 30833  	// cond:
 30834  	// result: (Const8 [int64(int8(c))])
 30835  	for {
 30836  		v_0 := v.Args[0]
 30837  		if v_0.Op != OpConst32 {
 30838  			break
 30839  		}
 30840  		c := v_0.AuxInt
 30841  		v.reset(OpConst8)
 30842  		v.AuxInt = int64(int8(c))
 30843  		return true
 30844  	}
 30845  	// match: (Trunc32to8 (ZeroExt8to32 x))
 30846  	// cond:
 30847  	// result: x
 30848  	for {
 30849  		v_0 := v.Args[0]
 30850  		if v_0.Op != OpZeroExt8to32 {
 30851  			break
 30852  		}
 30853  		x := v_0.Args[0]
 30854  		v.reset(OpCopy)
 30855  		v.Type = x.Type
 30856  		v.AddArg(x)
 30857  		return true
 30858  	}
 30859  	// match: (Trunc32to8 (SignExt8to32 x))
 30860  	// cond:
 30861  	// result: x
 30862  	for {
 30863  		v_0 := v.Args[0]
 30864  		if v_0.Op != OpSignExt8to32 {
 30865  			break
 30866  		}
 30867  		x := v_0.Args[0]
 30868  		v.reset(OpCopy)
 30869  		v.Type = x.Type
 30870  		v.AddArg(x)
 30871  		return true
 30872  	}
 30873  	// match: (Trunc32to8 (And32 (Const32 [y]) x))
 30874  	// cond: y&0xFF == 0xFF
 30875  	// result: (Trunc32to8 x)
 30876  	for {
 30877  		v_0 := v.Args[0]
 30878  		if v_0.Op != OpAnd32 {
 30879  			break
 30880  		}
 30881  		_ = v_0.Args[1]
 30882  		v_0_0 := v_0.Args[0]
 30883  		if v_0_0.Op != OpConst32 {
 30884  			break
 30885  		}
 30886  		y := v_0_0.AuxInt
 30887  		x := v_0.Args[1]
 30888  		if !(y&0xFF == 0xFF) {
 30889  			break
 30890  		}
 30891  		v.reset(OpTrunc32to8)
 30892  		v.AddArg(x)
 30893  		return true
 30894  	}
 30895  	// match: (Trunc32to8 (And32 x (Const32 [y])))
 30896  	// cond: y&0xFF == 0xFF
 30897  	// result: (Trunc32to8 x)
 30898  	for {
 30899  		v_0 := v.Args[0]
 30900  		if v_0.Op != OpAnd32 {
 30901  			break
 30902  		}
 30903  		_ = v_0.Args[1]
 30904  		x := v_0.Args[0]
 30905  		v_0_1 := v_0.Args[1]
 30906  		if v_0_1.Op != OpConst32 {
 30907  			break
 30908  		}
 30909  		y := v_0_1.AuxInt
 30910  		if !(y&0xFF == 0xFF) {
 30911  			break
 30912  		}
 30913  		v.reset(OpTrunc32to8)
 30914  		v.AddArg(x)
 30915  		return true
 30916  	}
 30917  	return false
 30918  }
 30919  func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool {
 30920  	// match: (Trunc64to16 (Const64 [c]))
 30921  	// cond:
 30922  	// result: (Const16 [int64(int16(c))])
 30923  	for {
 30924  		v_0 := v.Args[0]
 30925  		if v_0.Op != OpConst64 {
 30926  			break
 30927  		}
 30928  		c := v_0.AuxInt
 30929  		v.reset(OpConst16)
 30930  		v.AuxInt = int64(int16(c))
 30931  		return true
 30932  	}
 30933  	// match: (Trunc64to16 (ZeroExt8to64 x))
 30934  	// cond:
 30935  	// result: (ZeroExt8to16 x)
 30936  	for {
 30937  		v_0 := v.Args[0]
 30938  		if v_0.Op != OpZeroExt8to64 {
 30939  			break
 30940  		}
 30941  		x := v_0.Args[0]
 30942  		v.reset(OpZeroExt8to16)
 30943  		v.AddArg(x)
 30944  		return true
 30945  	}
 30946  	// match: (Trunc64to16 (ZeroExt16to64 x))
 30947  	// cond:
 30948  	// result: x
 30949  	for {
 30950  		v_0 := v.Args[0]
 30951  		if v_0.Op != OpZeroExt16to64 {
 30952  			break
 30953  		}
 30954  		x := v_0.Args[0]
 30955  		v.reset(OpCopy)
 30956  		v.Type = x.Type
 30957  		v.AddArg(x)
 30958  		return true
 30959  	}
 30960  	// match: (Trunc64to16 (SignExt8to64 x))
 30961  	// cond:
 30962  	// result: (SignExt8to16 x)
 30963  	for {
 30964  		v_0 := v.Args[0]
 30965  		if v_0.Op != OpSignExt8to64 {
 30966  			break
 30967  		}
 30968  		x := v_0.Args[0]
 30969  		v.reset(OpSignExt8to16)
 30970  		v.AddArg(x)
 30971  		return true
 30972  	}
 30973  	// match: (Trunc64to16 (SignExt16to64 x))
 30974  	// cond:
 30975  	// result: x
 30976  	for {
 30977  		v_0 := v.Args[0]
 30978  		if v_0.Op != OpSignExt16to64 {
 30979  			break
 30980  		}
 30981  		x := v_0.Args[0]
 30982  		v.reset(OpCopy)
 30983  		v.Type = x.Type
 30984  		v.AddArg(x)
 30985  		return true
 30986  	}
 30987  	// match: (Trunc64to16 (And64 (Const64 [y]) x))
 30988  	// cond: y&0xFFFF == 0xFFFF
 30989  	// result: (Trunc64to16 x)
 30990  	for {
 30991  		v_0 := v.Args[0]
 30992  		if v_0.Op != OpAnd64 {
 30993  			break
 30994  		}
 30995  		_ = v_0.Args[1]
 30996  		v_0_0 := v_0.Args[0]
 30997  		if v_0_0.Op != OpConst64 {
 30998  			break
 30999  		}
 31000  		y := v_0_0.AuxInt
 31001  		x := v_0.Args[1]
 31002  		if !(y&0xFFFF == 0xFFFF) {
 31003  			break
 31004  		}
 31005  		v.reset(OpTrunc64to16)
 31006  		v.AddArg(x)
 31007  		return true
 31008  	}
 31009  	// match: (Trunc64to16 (And64 x (Const64 [y])))
 31010  	// cond: y&0xFFFF == 0xFFFF
 31011  	// result: (Trunc64to16 x)
 31012  	for {
 31013  		v_0 := v.Args[0]
 31014  		if v_0.Op != OpAnd64 {
 31015  			break
 31016  		}
 31017  		_ = v_0.Args[1]
 31018  		x := v_0.Args[0]
 31019  		v_0_1 := v_0.Args[1]
 31020  		if v_0_1.Op != OpConst64 {
 31021  			break
 31022  		}
 31023  		y := v_0_1.AuxInt
 31024  		if !(y&0xFFFF == 0xFFFF) {
 31025  			break
 31026  		}
 31027  		v.reset(OpTrunc64to16)
 31028  		v.AddArg(x)
 31029  		return true
 31030  	}
 31031  	return false
 31032  }
 31033  func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool {
 31034  	// match: (Trunc64to32 (Const64 [c]))
 31035  	// cond:
 31036  	// result: (Const32 [int64(int32(c))])
 31037  	for {
 31038  		v_0 := v.Args[0]
 31039  		if v_0.Op != OpConst64 {
 31040  			break
 31041  		}
 31042  		c := v_0.AuxInt
 31043  		v.reset(OpConst32)
 31044  		v.AuxInt = int64(int32(c))
 31045  		return true
 31046  	}
 31047  	// match: (Trunc64to32 (ZeroExt8to64 x))
 31048  	// cond:
 31049  	// result: (ZeroExt8to32 x)
 31050  	for {
 31051  		v_0 := v.Args[0]
 31052  		if v_0.Op != OpZeroExt8to64 {
 31053  			break
 31054  		}
 31055  		x := v_0.Args[0]
 31056  		v.reset(OpZeroExt8to32)
 31057  		v.AddArg(x)
 31058  		return true
 31059  	}
 31060  	// match: (Trunc64to32 (ZeroExt16to64 x))
 31061  	// cond:
 31062  	// result: (ZeroExt16to32 x)
 31063  	for {
 31064  		v_0 := v.Args[0]
 31065  		if v_0.Op != OpZeroExt16to64 {
 31066  			break
 31067  		}
 31068  		x := v_0.Args[0]
 31069  		v.reset(OpZeroExt16to32)
 31070  		v.AddArg(x)
 31071  		return true
 31072  	}
 31073  	// match: (Trunc64to32 (ZeroExt32to64 x))
 31074  	// cond:
 31075  	// result: x
 31076  	for {
 31077  		v_0 := v.Args[0]
 31078  		if v_0.Op != OpZeroExt32to64 {
 31079  			break
 31080  		}
 31081  		x := v_0.Args[0]
 31082  		v.reset(OpCopy)
 31083  		v.Type = x.Type
 31084  		v.AddArg(x)
 31085  		return true
 31086  	}
 31087  	// match: (Trunc64to32 (SignExt8to64 x))
 31088  	// cond:
 31089  	// result: (SignExt8to32 x)
 31090  	for {
 31091  		v_0 := v.Args[0]
 31092  		if v_0.Op != OpSignExt8to64 {
 31093  			break
 31094  		}
 31095  		x := v_0.Args[0]
 31096  		v.reset(OpSignExt8to32)
 31097  		v.AddArg(x)
 31098  		return true
 31099  	}
 31100  	// match: (Trunc64to32 (SignExt16to64 x))
 31101  	// cond:
 31102  	// result: (SignExt16to32 x)
 31103  	for {
 31104  		v_0 := v.Args[0]
 31105  		if v_0.Op != OpSignExt16to64 {
 31106  			break
 31107  		}
 31108  		x := v_0.Args[0]
 31109  		v.reset(OpSignExt16to32)
 31110  		v.AddArg(x)
 31111  		return true
 31112  	}
 31113  	// match: (Trunc64to32 (SignExt32to64 x))
 31114  	// cond:
 31115  	// result: x
 31116  	for {
 31117  		v_0 := v.Args[0]
 31118  		if v_0.Op != OpSignExt32to64 {
 31119  			break
 31120  		}
 31121  		x := v_0.Args[0]
 31122  		v.reset(OpCopy)
 31123  		v.Type = x.Type
 31124  		v.AddArg(x)
 31125  		return true
 31126  	}
 31127  	// match: (Trunc64to32 (And64 (Const64 [y]) x))
 31128  	// cond: y&0xFFFFFFFF == 0xFFFFFFFF
 31129  	// result: (Trunc64to32 x)
 31130  	for {
 31131  		v_0 := v.Args[0]
 31132  		if v_0.Op != OpAnd64 {
 31133  			break
 31134  		}
 31135  		_ = v_0.Args[1]
 31136  		v_0_0 := v_0.Args[0]
 31137  		if v_0_0.Op != OpConst64 {
 31138  			break
 31139  		}
 31140  		y := v_0_0.AuxInt
 31141  		x := v_0.Args[1]
 31142  		if !(y&0xFFFFFFFF == 0xFFFFFFFF) {
 31143  			break
 31144  		}
 31145  		v.reset(OpTrunc64to32)
 31146  		v.AddArg(x)
 31147  		return true
 31148  	}
 31149  	// match: (Trunc64to32 (And64 x (Const64 [y])))
 31150  	// cond: y&0xFFFFFFFF == 0xFFFFFFFF
 31151  	// result: (Trunc64to32 x)
 31152  	for {
 31153  		v_0 := v.Args[0]
 31154  		if v_0.Op != OpAnd64 {
 31155  			break
 31156  		}
 31157  		_ = v_0.Args[1]
 31158  		x := v_0.Args[0]
 31159  		v_0_1 := v_0.Args[1]
 31160  		if v_0_1.Op != OpConst64 {
 31161  			break
 31162  		}
 31163  		y := v_0_1.AuxInt
 31164  		if !(y&0xFFFFFFFF == 0xFFFFFFFF) {
 31165  			break
 31166  		}
 31167  		v.reset(OpTrunc64to32)
 31168  		v.AddArg(x)
 31169  		return true
 31170  	}
 31171  	return false
 31172  }
 31173  func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool {
 31174  	// match: (Trunc64to8 (Const64 [c]))
 31175  	// cond:
 31176  	// result: (Const8 [int64(int8(c))])
 31177  	for {
 31178  		v_0 := v.Args[0]
 31179  		if v_0.Op != OpConst64 {
 31180  			break
 31181  		}
 31182  		c := v_0.AuxInt
 31183  		v.reset(OpConst8)
 31184  		v.AuxInt = int64(int8(c))
 31185  		return true
 31186  	}
 31187  	// match: (Trunc64to8 (ZeroExt8to64 x))
 31188  	// cond:
 31189  	// result: x
 31190  	for {
 31191  		v_0 := v.Args[0]
 31192  		if v_0.Op != OpZeroExt8to64 {
 31193  			break
 31194  		}
 31195  		x := v_0.Args[0]
 31196  		v.reset(OpCopy)
 31197  		v.Type = x.Type
 31198  		v.AddArg(x)
 31199  		return true
 31200  	}
 31201  	// match: (Trunc64to8 (SignExt8to64 x))
 31202  	// cond:
 31203  	// result: x
 31204  	for {
 31205  		v_0 := v.Args[0]
 31206  		if v_0.Op != OpSignExt8to64 {
 31207  			break
 31208  		}
 31209  		x := v_0.Args[0]
 31210  		v.reset(OpCopy)
 31211  		v.Type = x.Type
 31212  		v.AddArg(x)
 31213  		return true
 31214  	}
 31215  	// match: (Trunc64to8 (And64 (Const64 [y]) x))
 31216  	// cond: y&0xFF == 0xFF
 31217  	// result: (Trunc64to8 x)
 31218  	for {
 31219  		v_0 := v.Args[0]
 31220  		if v_0.Op != OpAnd64 {
 31221  			break
 31222  		}
 31223  		_ = v_0.Args[1]
 31224  		v_0_0 := v_0.Args[0]
 31225  		if v_0_0.Op != OpConst64 {
 31226  			break
 31227  		}
 31228  		y := v_0_0.AuxInt
 31229  		x := v_0.Args[1]
 31230  		if !(y&0xFF == 0xFF) {
 31231  			break
 31232  		}
 31233  		v.reset(OpTrunc64to8)
 31234  		v.AddArg(x)
 31235  		return true
 31236  	}
 31237  	// match: (Trunc64to8 (And64 x (Const64 [y])))
 31238  	// cond: y&0xFF == 0xFF
 31239  	// result: (Trunc64to8 x)
 31240  	for {
 31241  		v_0 := v.Args[0]
 31242  		if v_0.Op != OpAnd64 {
 31243  			break
 31244  		}
 31245  		_ = v_0.Args[1]
 31246  		x := v_0.Args[0]
 31247  		v_0_1 := v_0.Args[1]
 31248  		if v_0_1.Op != OpConst64 {
 31249  			break
 31250  		}
 31251  		y := v_0_1.AuxInt
 31252  		if !(y&0xFF == 0xFF) {
 31253  			break
 31254  		}
 31255  		v.reset(OpTrunc64to8)
 31256  		v.AddArg(x)
 31257  		return true
 31258  	}
 31259  	return false
 31260  }
 31261  func rewriteValuegeneric_OpXor16_0(v *Value) bool {
 31262  	b := v.Block
 31263  	_ = b
 31264  	// match: (Xor16 (Const16 [c]) (Const16 [d]))
 31265  	// cond:
 31266  	// result: (Const16 [int64(int16(c^d))])
 31267  	for {
 31268  		_ = v.Args[1]
 31269  		v_0 := v.Args[0]
 31270  		if v_0.Op != OpConst16 {
 31271  			break
 31272  		}
 31273  		c := v_0.AuxInt
 31274  		v_1 := v.Args[1]
 31275  		if v_1.Op != OpConst16 {
 31276  			break
 31277  		}
 31278  		d := v_1.AuxInt
 31279  		v.reset(OpConst16)
 31280  		v.AuxInt = int64(int16(c ^ d))
 31281  		return true
 31282  	}
 31283  	// match: (Xor16 (Const16 [d]) (Const16 [c]))
 31284  	// cond:
 31285  	// result: (Const16 [int64(int16(c^d))])
 31286  	for {
 31287  		_ = v.Args[1]
 31288  		v_0 := v.Args[0]
 31289  		if v_0.Op != OpConst16 {
 31290  			break
 31291  		}
 31292  		d := v_0.AuxInt
 31293  		v_1 := v.Args[1]
 31294  		if v_1.Op != OpConst16 {
 31295  			break
 31296  		}
 31297  		c := v_1.AuxInt
 31298  		v.reset(OpConst16)
 31299  		v.AuxInt = int64(int16(c ^ d))
 31300  		return true
 31301  	}
 31302  	// match: (Xor16 x x)
 31303  	// cond:
 31304  	// result: (Const16 [0])
 31305  	for {
 31306  		_ = v.Args[1]
 31307  		x := v.Args[0]
 31308  		if x != v.Args[1] {
 31309  			break
 31310  		}
 31311  		v.reset(OpConst16)
 31312  		v.AuxInt = 0
 31313  		return true
 31314  	}
 31315  	// match: (Xor16 (Const16 [0]) x)
 31316  	// cond:
 31317  	// result: x
 31318  	for {
 31319  		_ = v.Args[1]
 31320  		v_0 := v.Args[0]
 31321  		if v_0.Op != OpConst16 {
 31322  			break
 31323  		}
 31324  		if v_0.AuxInt != 0 {
 31325  			break
 31326  		}
 31327  		x := v.Args[1]
 31328  		v.reset(OpCopy)
 31329  		v.Type = x.Type
 31330  		v.AddArg(x)
 31331  		return true
 31332  	}
 31333  	// match: (Xor16 x (Const16 [0]))
 31334  	// cond:
 31335  	// result: x
 31336  	for {
 31337  		_ = v.Args[1]
 31338  		x := v.Args[0]
 31339  		v_1 := v.Args[1]
 31340  		if v_1.Op != OpConst16 {
 31341  			break
 31342  		}
 31343  		if v_1.AuxInt != 0 {
 31344  			break
 31345  		}
 31346  		v.reset(OpCopy)
 31347  		v.Type = x.Type
 31348  		v.AddArg(x)
 31349  		return true
 31350  	}
 31351  	// match: (Xor16 x (Xor16 x y))
 31352  	// cond:
 31353  	// result: y
 31354  	for {
 31355  		_ = v.Args[1]
 31356  		x := v.Args[0]
 31357  		v_1 := v.Args[1]
 31358  		if v_1.Op != OpXor16 {
 31359  			break
 31360  		}
 31361  		_ = v_1.Args[1]
 31362  		if x != v_1.Args[0] {
 31363  			break
 31364  		}
 31365  		y := v_1.Args[1]
 31366  		v.reset(OpCopy)
 31367  		v.Type = y.Type
 31368  		v.AddArg(y)
 31369  		return true
 31370  	}
 31371  	// match: (Xor16 x (Xor16 y x))
 31372  	// cond:
 31373  	// result: y
 31374  	for {
 31375  		_ = v.Args[1]
 31376  		x := v.Args[0]
 31377  		v_1 := v.Args[1]
 31378  		if v_1.Op != OpXor16 {
 31379  			break
 31380  		}
 31381  		_ = v_1.Args[1]
 31382  		y := v_1.Args[0]
 31383  		if x != v_1.Args[1] {
 31384  			break
 31385  		}
 31386  		v.reset(OpCopy)
 31387  		v.Type = y.Type
 31388  		v.AddArg(y)
 31389  		return true
 31390  	}
 31391  	// match: (Xor16 (Xor16 x y) x)
 31392  	// cond:
 31393  	// result: y
 31394  	for {
 31395  		_ = v.Args[1]
 31396  		v_0 := v.Args[0]
 31397  		if v_0.Op != OpXor16 {
 31398  			break
 31399  		}
 31400  		_ = v_0.Args[1]
 31401  		x := v_0.Args[0]
 31402  		y := v_0.Args[1]
 31403  		if x != v.Args[1] {
 31404  			break
 31405  		}
 31406  		v.reset(OpCopy)
 31407  		v.Type = y.Type
 31408  		v.AddArg(y)
 31409  		return true
 31410  	}
 31411  	// match: (Xor16 (Xor16 y x) x)
 31412  	// cond:
 31413  	// result: y
 31414  	for {
 31415  		_ = v.Args[1]
 31416  		v_0 := v.Args[0]
 31417  		if v_0.Op != OpXor16 {
 31418  			break
 31419  		}
 31420  		_ = v_0.Args[1]
 31421  		y := v_0.Args[0]
 31422  		x := v_0.Args[1]
 31423  		if x != v.Args[1] {
 31424  			break
 31425  		}
 31426  		v.reset(OpCopy)
 31427  		v.Type = y.Type
 31428  		v.AddArg(y)
 31429  		return true
 31430  	}
 31431  	// match: (Xor16 (Xor16 i:(Const16 <t>) z) x)
 31432  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 31433  	// result: (Xor16 i (Xor16 <t> z x))
 31434  	for {
 31435  		_ = v.Args[1]
 31436  		v_0 := v.Args[0]
 31437  		if v_0.Op != OpXor16 {
 31438  			break
 31439  		}
 31440  		_ = v_0.Args[1]
 31441  		i := v_0.Args[0]
 31442  		if i.Op != OpConst16 {
 31443  			break
 31444  		}
 31445  		t := i.Type
 31446  		z := v_0.Args[1]
 31447  		x := v.Args[1]
 31448  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 31449  			break
 31450  		}
 31451  		v.reset(OpXor16)
 31452  		v.AddArg(i)
 31453  		v0 := b.NewValue0(v.Pos, OpXor16, t)
 31454  		v0.AddArg(z)
 31455  		v0.AddArg(x)
 31456  		v.AddArg(v0)
 31457  		return true
 31458  	}
 31459  	return false
 31460  }
 31461  func rewriteValuegeneric_OpXor16_10(v *Value) bool {
 31462  	b := v.Block
 31463  	_ = b
 31464  	// match: (Xor16 (Xor16 z i:(Const16 <t>)) x)
 31465  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 31466  	// result: (Xor16 i (Xor16 <t> z x))
 31467  	for {
 31468  		_ = v.Args[1]
 31469  		v_0 := v.Args[0]
 31470  		if v_0.Op != OpXor16 {
 31471  			break
 31472  		}
 31473  		_ = v_0.Args[1]
 31474  		z := v_0.Args[0]
 31475  		i := v_0.Args[1]
 31476  		if i.Op != OpConst16 {
 31477  			break
 31478  		}
 31479  		t := i.Type
 31480  		x := v.Args[1]
 31481  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 31482  			break
 31483  		}
 31484  		v.reset(OpXor16)
 31485  		v.AddArg(i)
 31486  		v0 := b.NewValue0(v.Pos, OpXor16, t)
 31487  		v0.AddArg(z)
 31488  		v0.AddArg(x)
 31489  		v.AddArg(v0)
 31490  		return true
 31491  	}
 31492  	// match: (Xor16 x (Xor16 i:(Const16 <t>) z))
 31493  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 31494  	// result: (Xor16 i (Xor16 <t> z x))
 31495  	for {
 31496  		_ = v.Args[1]
 31497  		x := v.Args[0]
 31498  		v_1 := v.Args[1]
 31499  		if v_1.Op != OpXor16 {
 31500  			break
 31501  		}
 31502  		_ = v_1.Args[1]
 31503  		i := v_1.Args[0]
 31504  		if i.Op != OpConst16 {
 31505  			break
 31506  		}
 31507  		t := i.Type
 31508  		z := v_1.Args[1]
 31509  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 31510  			break
 31511  		}
 31512  		v.reset(OpXor16)
 31513  		v.AddArg(i)
 31514  		v0 := b.NewValue0(v.Pos, OpXor16, t)
 31515  		v0.AddArg(z)
 31516  		v0.AddArg(x)
 31517  		v.AddArg(v0)
 31518  		return true
 31519  	}
 31520  	// match: (Xor16 x (Xor16 z i:(Const16 <t>)))
 31521  	// cond: (z.Op != OpConst16 && x.Op != OpConst16)
 31522  	// result: (Xor16 i (Xor16 <t> z x))
 31523  	for {
 31524  		_ = v.Args[1]
 31525  		x := v.Args[0]
 31526  		v_1 := v.Args[1]
 31527  		if v_1.Op != OpXor16 {
 31528  			break
 31529  		}
 31530  		_ = v_1.Args[1]
 31531  		z := v_1.Args[0]
 31532  		i := v_1.Args[1]
 31533  		if i.Op != OpConst16 {
 31534  			break
 31535  		}
 31536  		t := i.Type
 31537  		if !(z.Op != OpConst16 && x.Op != OpConst16) {
 31538  			break
 31539  		}
 31540  		v.reset(OpXor16)
 31541  		v.AddArg(i)
 31542  		v0 := b.NewValue0(v.Pos, OpXor16, t)
 31543  		v0.AddArg(z)
 31544  		v0.AddArg(x)
 31545  		v.AddArg(v0)
 31546  		return true
 31547  	}
 31548  	// match: (Xor16 (Const16 <t> [c]) (Xor16 (Const16 <t> [d]) x))
 31549  	// cond:
 31550  	// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 31551  	for {
 31552  		_ = v.Args[1]
 31553  		v_0 := v.Args[0]
 31554  		if v_0.Op != OpConst16 {
 31555  			break
 31556  		}
 31557  		t := v_0.Type
 31558  		c := v_0.AuxInt
 31559  		v_1 := v.Args[1]
 31560  		if v_1.Op != OpXor16 {
 31561  			break
 31562  		}
 31563  		_ = v_1.Args[1]
 31564  		v_1_0 := v_1.Args[0]
 31565  		if v_1_0.Op != OpConst16 {
 31566  			break
 31567  		}
 31568  		if v_1_0.Type != t {
 31569  			break
 31570  		}
 31571  		d := v_1_0.AuxInt
 31572  		x := v_1.Args[1]
 31573  		v.reset(OpXor16)
 31574  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 31575  		v0.AuxInt = int64(int16(c ^ d))
 31576  		v.AddArg(v0)
 31577  		v.AddArg(x)
 31578  		return true
 31579  	}
 31580  	// match: (Xor16 (Const16 <t> [c]) (Xor16 x (Const16 <t> [d])))
 31581  	// cond:
 31582  	// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 31583  	for {
 31584  		_ = v.Args[1]
 31585  		v_0 := v.Args[0]
 31586  		if v_0.Op != OpConst16 {
 31587  			break
 31588  		}
 31589  		t := v_0.Type
 31590  		c := v_0.AuxInt
 31591  		v_1 := v.Args[1]
 31592  		if v_1.Op != OpXor16 {
 31593  			break
 31594  		}
 31595  		_ = v_1.Args[1]
 31596  		x := v_1.Args[0]
 31597  		v_1_1 := v_1.Args[1]
 31598  		if v_1_1.Op != OpConst16 {
 31599  			break
 31600  		}
 31601  		if v_1_1.Type != t {
 31602  			break
 31603  		}
 31604  		d := v_1_1.AuxInt
 31605  		v.reset(OpXor16)
 31606  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 31607  		v0.AuxInt = int64(int16(c ^ d))
 31608  		v.AddArg(v0)
 31609  		v.AddArg(x)
 31610  		return true
 31611  	}
 31612  	// match: (Xor16 (Xor16 (Const16 <t> [d]) x) (Const16 <t> [c]))
 31613  	// cond:
 31614  	// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 31615  	for {
 31616  		_ = v.Args[1]
 31617  		v_0 := v.Args[0]
 31618  		if v_0.Op != OpXor16 {
 31619  			break
 31620  		}
 31621  		_ = v_0.Args[1]
 31622  		v_0_0 := v_0.Args[0]
 31623  		if v_0_0.Op != OpConst16 {
 31624  			break
 31625  		}
 31626  		t := v_0_0.Type
 31627  		d := v_0_0.AuxInt
 31628  		x := v_0.Args[1]
 31629  		v_1 := v.Args[1]
 31630  		if v_1.Op != OpConst16 {
 31631  			break
 31632  		}
 31633  		if v_1.Type != t {
 31634  			break
 31635  		}
 31636  		c := v_1.AuxInt
 31637  		v.reset(OpXor16)
 31638  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 31639  		v0.AuxInt = int64(int16(c ^ d))
 31640  		v.AddArg(v0)
 31641  		v.AddArg(x)
 31642  		return true
 31643  	}
 31644  	// match: (Xor16 (Xor16 x (Const16 <t> [d])) (Const16 <t> [c]))
 31645  	// cond:
 31646  	// result: (Xor16 (Const16 <t> [int64(int16(c^d))]) x)
 31647  	for {
 31648  		_ = v.Args[1]
 31649  		v_0 := v.Args[0]
 31650  		if v_0.Op != OpXor16 {
 31651  			break
 31652  		}
 31653  		_ = v_0.Args[1]
 31654  		x := v_0.Args[0]
 31655  		v_0_1 := v_0.Args[1]
 31656  		if v_0_1.Op != OpConst16 {
 31657  			break
 31658  		}
 31659  		t := v_0_1.Type
 31660  		d := v_0_1.AuxInt
 31661  		v_1 := v.Args[1]
 31662  		if v_1.Op != OpConst16 {
 31663  			break
 31664  		}
 31665  		if v_1.Type != t {
 31666  			break
 31667  		}
 31668  		c := v_1.AuxInt
 31669  		v.reset(OpXor16)
 31670  		v0 := b.NewValue0(v.Pos, OpConst16, t)
 31671  		v0.AuxInt = int64(int16(c ^ d))
 31672  		v.AddArg(v0)
 31673  		v.AddArg(x)
 31674  		return true
 31675  	}
 31676  	return false
 31677  }
 31678  func rewriteValuegeneric_OpXor32_0(v *Value) bool {
 31679  	b := v.Block
 31680  	_ = b
 31681  	// match: (Xor32 (Const32 [c]) (Const32 [d]))
 31682  	// cond:
 31683  	// result: (Const32 [int64(int32(c^d))])
 31684  	for {
 31685  		_ = v.Args[1]
 31686  		v_0 := v.Args[0]
 31687  		if v_0.Op != OpConst32 {
 31688  			break
 31689  		}
 31690  		c := v_0.AuxInt
 31691  		v_1 := v.Args[1]
 31692  		if v_1.Op != OpConst32 {
 31693  			break
 31694  		}
 31695  		d := v_1.AuxInt
 31696  		v.reset(OpConst32)
 31697  		v.AuxInt = int64(int32(c ^ d))
 31698  		return true
 31699  	}
 31700  	// match: (Xor32 (Const32 [d]) (Const32 [c]))
 31701  	// cond:
 31702  	// result: (Const32 [int64(int32(c^d))])
 31703  	for {
 31704  		_ = v.Args[1]
 31705  		v_0 := v.Args[0]
 31706  		if v_0.Op != OpConst32 {
 31707  			break
 31708  		}
 31709  		d := v_0.AuxInt
 31710  		v_1 := v.Args[1]
 31711  		if v_1.Op != OpConst32 {
 31712  			break
 31713  		}
 31714  		c := v_1.AuxInt
 31715  		v.reset(OpConst32)
 31716  		v.AuxInt = int64(int32(c ^ d))
 31717  		return true
 31718  	}
 31719  	// match: (Xor32 x x)
 31720  	// cond:
 31721  	// result: (Const32 [0])
 31722  	for {
 31723  		_ = v.Args[1]
 31724  		x := v.Args[0]
 31725  		if x != v.Args[1] {
 31726  			break
 31727  		}
 31728  		v.reset(OpConst32)
 31729  		v.AuxInt = 0
 31730  		return true
 31731  	}
 31732  	// match: (Xor32 (Const32 [0]) x)
 31733  	// cond:
 31734  	// result: x
 31735  	for {
 31736  		_ = v.Args[1]
 31737  		v_0 := v.Args[0]
 31738  		if v_0.Op != OpConst32 {
 31739  			break
 31740  		}
 31741  		if v_0.AuxInt != 0 {
 31742  			break
 31743  		}
 31744  		x := v.Args[1]
 31745  		v.reset(OpCopy)
 31746  		v.Type = x.Type
 31747  		v.AddArg(x)
 31748  		return true
 31749  	}
 31750  	// match: (Xor32 x (Const32 [0]))
 31751  	// cond:
 31752  	// result: x
 31753  	for {
 31754  		_ = v.Args[1]
 31755  		x := v.Args[0]
 31756  		v_1 := v.Args[1]
 31757  		if v_1.Op != OpConst32 {
 31758  			break
 31759  		}
 31760  		if v_1.AuxInt != 0 {
 31761  			break
 31762  		}
 31763  		v.reset(OpCopy)
 31764  		v.Type = x.Type
 31765  		v.AddArg(x)
 31766  		return true
 31767  	}
 31768  	// match: (Xor32 x (Xor32 x y))
 31769  	// cond:
 31770  	// result: y
 31771  	for {
 31772  		_ = v.Args[1]
 31773  		x := v.Args[0]
 31774  		v_1 := v.Args[1]
 31775  		if v_1.Op != OpXor32 {
 31776  			break
 31777  		}
 31778  		_ = v_1.Args[1]
 31779  		if x != v_1.Args[0] {
 31780  			break
 31781  		}
 31782  		y := v_1.Args[1]
 31783  		v.reset(OpCopy)
 31784  		v.Type = y.Type
 31785  		v.AddArg(y)
 31786  		return true
 31787  	}
 31788  	// match: (Xor32 x (Xor32 y x))
 31789  	// cond:
 31790  	// result: y
 31791  	for {
 31792  		_ = v.Args[1]
 31793  		x := v.Args[0]
 31794  		v_1 := v.Args[1]
 31795  		if v_1.Op != OpXor32 {
 31796  			break
 31797  		}
 31798  		_ = v_1.Args[1]
 31799  		y := v_1.Args[0]
 31800  		if x != v_1.Args[1] {
 31801  			break
 31802  		}
 31803  		v.reset(OpCopy)
 31804  		v.Type = y.Type
 31805  		v.AddArg(y)
 31806  		return true
 31807  	}
 31808  	// match: (Xor32 (Xor32 x y) x)
 31809  	// cond:
 31810  	// result: y
 31811  	for {
 31812  		_ = v.Args[1]
 31813  		v_0 := v.Args[0]
 31814  		if v_0.Op != OpXor32 {
 31815  			break
 31816  		}
 31817  		_ = v_0.Args[1]
 31818  		x := v_0.Args[0]
 31819  		y := v_0.Args[1]
 31820  		if x != v.Args[1] {
 31821  			break
 31822  		}
 31823  		v.reset(OpCopy)
 31824  		v.Type = y.Type
 31825  		v.AddArg(y)
 31826  		return true
 31827  	}
 31828  	// match: (Xor32 (Xor32 y x) x)
 31829  	// cond:
 31830  	// result: y
 31831  	for {
 31832  		_ = v.Args[1]
 31833  		v_0 := v.Args[0]
 31834  		if v_0.Op != OpXor32 {
 31835  			break
 31836  		}
 31837  		_ = v_0.Args[1]
 31838  		y := v_0.Args[0]
 31839  		x := v_0.Args[1]
 31840  		if x != v.Args[1] {
 31841  			break
 31842  		}
 31843  		v.reset(OpCopy)
 31844  		v.Type = y.Type
 31845  		v.AddArg(y)
 31846  		return true
 31847  	}
 31848  	// match: (Xor32 (Xor32 i:(Const32 <t>) z) x)
 31849  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 31850  	// result: (Xor32 i (Xor32 <t> z x))
 31851  	for {
 31852  		_ = v.Args[1]
 31853  		v_0 := v.Args[0]
 31854  		if v_0.Op != OpXor32 {
 31855  			break
 31856  		}
 31857  		_ = v_0.Args[1]
 31858  		i := v_0.Args[0]
 31859  		if i.Op != OpConst32 {
 31860  			break
 31861  		}
 31862  		t := i.Type
 31863  		z := v_0.Args[1]
 31864  		x := v.Args[1]
 31865  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 31866  			break
 31867  		}
 31868  		v.reset(OpXor32)
 31869  		v.AddArg(i)
 31870  		v0 := b.NewValue0(v.Pos, OpXor32, t)
 31871  		v0.AddArg(z)
 31872  		v0.AddArg(x)
 31873  		v.AddArg(v0)
 31874  		return true
 31875  	}
 31876  	return false
 31877  }
 31878  func rewriteValuegeneric_OpXor32_10(v *Value) bool {
 31879  	b := v.Block
 31880  	_ = b
 31881  	// match: (Xor32 (Xor32 z i:(Const32 <t>)) x)
 31882  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 31883  	// result: (Xor32 i (Xor32 <t> z x))
 31884  	for {
 31885  		_ = v.Args[1]
 31886  		v_0 := v.Args[0]
 31887  		if v_0.Op != OpXor32 {
 31888  			break
 31889  		}
 31890  		_ = v_0.Args[1]
 31891  		z := v_0.Args[0]
 31892  		i := v_0.Args[1]
 31893  		if i.Op != OpConst32 {
 31894  			break
 31895  		}
 31896  		t := i.Type
 31897  		x := v.Args[1]
 31898  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 31899  			break
 31900  		}
 31901  		v.reset(OpXor32)
 31902  		v.AddArg(i)
 31903  		v0 := b.NewValue0(v.Pos, OpXor32, t)
 31904  		v0.AddArg(z)
 31905  		v0.AddArg(x)
 31906  		v.AddArg(v0)
 31907  		return true
 31908  	}
 31909  	// match: (Xor32 x (Xor32 i:(Const32 <t>) z))
 31910  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 31911  	// result: (Xor32 i (Xor32 <t> z x))
 31912  	for {
 31913  		_ = v.Args[1]
 31914  		x := v.Args[0]
 31915  		v_1 := v.Args[1]
 31916  		if v_1.Op != OpXor32 {
 31917  			break
 31918  		}
 31919  		_ = v_1.Args[1]
 31920  		i := v_1.Args[0]
 31921  		if i.Op != OpConst32 {
 31922  			break
 31923  		}
 31924  		t := i.Type
 31925  		z := v_1.Args[1]
 31926  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 31927  			break
 31928  		}
 31929  		v.reset(OpXor32)
 31930  		v.AddArg(i)
 31931  		v0 := b.NewValue0(v.Pos, OpXor32, t)
 31932  		v0.AddArg(z)
 31933  		v0.AddArg(x)
 31934  		v.AddArg(v0)
 31935  		return true
 31936  	}
 31937  	// match: (Xor32 x (Xor32 z i:(Const32 <t>)))
 31938  	// cond: (z.Op != OpConst32 && x.Op != OpConst32)
 31939  	// result: (Xor32 i (Xor32 <t> z x))
 31940  	for {
 31941  		_ = v.Args[1]
 31942  		x := v.Args[0]
 31943  		v_1 := v.Args[1]
 31944  		if v_1.Op != OpXor32 {
 31945  			break
 31946  		}
 31947  		_ = v_1.Args[1]
 31948  		z := v_1.Args[0]
 31949  		i := v_1.Args[1]
 31950  		if i.Op != OpConst32 {
 31951  			break
 31952  		}
 31953  		t := i.Type
 31954  		if !(z.Op != OpConst32 && x.Op != OpConst32) {
 31955  			break
 31956  		}
 31957  		v.reset(OpXor32)
 31958  		v.AddArg(i)
 31959  		v0 := b.NewValue0(v.Pos, OpXor32, t)
 31960  		v0.AddArg(z)
 31961  		v0.AddArg(x)
 31962  		v.AddArg(v0)
 31963  		return true
 31964  	}
 31965  	// match: (Xor32 (Const32 <t> [c]) (Xor32 (Const32 <t> [d]) x))
 31966  	// cond:
 31967  	// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 31968  	for {
 31969  		_ = v.Args[1]
 31970  		v_0 := v.Args[0]
 31971  		if v_0.Op != OpConst32 {
 31972  			break
 31973  		}
 31974  		t := v_0.Type
 31975  		c := v_0.AuxInt
 31976  		v_1 := v.Args[1]
 31977  		if v_1.Op != OpXor32 {
 31978  			break
 31979  		}
 31980  		_ = v_1.Args[1]
 31981  		v_1_0 := v_1.Args[0]
 31982  		if v_1_0.Op != OpConst32 {
 31983  			break
 31984  		}
 31985  		if v_1_0.Type != t {
 31986  			break
 31987  		}
 31988  		d := v_1_0.AuxInt
 31989  		x := v_1.Args[1]
 31990  		v.reset(OpXor32)
 31991  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 31992  		v0.AuxInt = int64(int32(c ^ d))
 31993  		v.AddArg(v0)
 31994  		v.AddArg(x)
 31995  		return true
 31996  	}
 31997  	// match: (Xor32 (Const32 <t> [c]) (Xor32 x (Const32 <t> [d])))
 31998  	// cond:
 31999  	// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 32000  	for {
 32001  		_ = v.Args[1]
 32002  		v_0 := v.Args[0]
 32003  		if v_0.Op != OpConst32 {
 32004  			break
 32005  		}
 32006  		t := v_0.Type
 32007  		c := v_0.AuxInt
 32008  		v_1 := v.Args[1]
 32009  		if v_1.Op != OpXor32 {
 32010  			break
 32011  		}
 32012  		_ = v_1.Args[1]
 32013  		x := v_1.Args[0]
 32014  		v_1_1 := v_1.Args[1]
 32015  		if v_1_1.Op != OpConst32 {
 32016  			break
 32017  		}
 32018  		if v_1_1.Type != t {
 32019  			break
 32020  		}
 32021  		d := v_1_1.AuxInt
 32022  		v.reset(OpXor32)
 32023  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 32024  		v0.AuxInt = int64(int32(c ^ d))
 32025  		v.AddArg(v0)
 32026  		v.AddArg(x)
 32027  		return true
 32028  	}
 32029  	// match: (Xor32 (Xor32 (Const32 <t> [d]) x) (Const32 <t> [c]))
 32030  	// cond:
 32031  	// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 32032  	for {
 32033  		_ = v.Args[1]
 32034  		v_0 := v.Args[0]
 32035  		if v_0.Op != OpXor32 {
 32036  			break
 32037  		}
 32038  		_ = v_0.Args[1]
 32039  		v_0_0 := v_0.Args[0]
 32040  		if v_0_0.Op != OpConst32 {
 32041  			break
 32042  		}
 32043  		t := v_0_0.Type
 32044  		d := v_0_0.AuxInt
 32045  		x := v_0.Args[1]
 32046  		v_1 := v.Args[1]
 32047  		if v_1.Op != OpConst32 {
 32048  			break
 32049  		}
 32050  		if v_1.Type != t {
 32051  			break
 32052  		}
 32053  		c := v_1.AuxInt
 32054  		v.reset(OpXor32)
 32055  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 32056  		v0.AuxInt = int64(int32(c ^ d))
 32057  		v.AddArg(v0)
 32058  		v.AddArg(x)
 32059  		return true
 32060  	}
 32061  	// match: (Xor32 (Xor32 x (Const32 <t> [d])) (Const32 <t> [c]))
 32062  	// cond:
 32063  	// result: (Xor32 (Const32 <t> [int64(int32(c^d))]) x)
 32064  	for {
 32065  		_ = v.Args[1]
 32066  		v_0 := v.Args[0]
 32067  		if v_0.Op != OpXor32 {
 32068  			break
 32069  		}
 32070  		_ = v_0.Args[1]
 32071  		x := v_0.Args[0]
 32072  		v_0_1 := v_0.Args[1]
 32073  		if v_0_1.Op != OpConst32 {
 32074  			break
 32075  		}
 32076  		t := v_0_1.Type
 32077  		d := v_0_1.AuxInt
 32078  		v_1 := v.Args[1]
 32079  		if v_1.Op != OpConst32 {
 32080  			break
 32081  		}
 32082  		if v_1.Type != t {
 32083  			break
 32084  		}
 32085  		c := v_1.AuxInt
 32086  		v.reset(OpXor32)
 32087  		v0 := b.NewValue0(v.Pos, OpConst32, t)
 32088  		v0.AuxInt = int64(int32(c ^ d))
 32089  		v.AddArg(v0)
 32090  		v.AddArg(x)
 32091  		return true
 32092  	}
 32093  	return false
 32094  }
 32095  func rewriteValuegeneric_OpXor64_0(v *Value) bool {
 32096  	b := v.Block
 32097  	_ = b
 32098  	// match: (Xor64 (Const64 [c]) (Const64 [d]))
 32099  	// cond:
 32100  	// result: (Const64 [c^d])
 32101  	for {
 32102  		_ = v.Args[1]
 32103  		v_0 := v.Args[0]
 32104  		if v_0.Op != OpConst64 {
 32105  			break
 32106  		}
 32107  		c := v_0.AuxInt
 32108  		v_1 := v.Args[1]
 32109  		if v_1.Op != OpConst64 {
 32110  			break
 32111  		}
 32112  		d := v_1.AuxInt
 32113  		v.reset(OpConst64)
 32114  		v.AuxInt = c ^ d
 32115  		return true
 32116  	}
 32117  	// match: (Xor64 (Const64 [d]) (Const64 [c]))
 32118  	// cond:
 32119  	// result: (Const64 [c^d])
 32120  	for {
 32121  		_ = v.Args[1]
 32122  		v_0 := v.Args[0]
 32123  		if v_0.Op != OpConst64 {
 32124  			break
 32125  		}
 32126  		d := v_0.AuxInt
 32127  		v_1 := v.Args[1]
 32128  		if v_1.Op != OpConst64 {
 32129  			break
 32130  		}
 32131  		c := v_1.AuxInt
 32132  		v.reset(OpConst64)
 32133  		v.AuxInt = c ^ d
 32134  		return true
 32135  	}
 32136  	// match: (Xor64 x x)
 32137  	// cond:
 32138  	// result: (Const64 [0])
 32139  	for {
 32140  		_ = v.Args[1]
 32141  		x := v.Args[0]
 32142  		if x != v.Args[1] {
 32143  			break
 32144  		}
 32145  		v.reset(OpConst64)
 32146  		v.AuxInt = 0
 32147  		return true
 32148  	}
 32149  	// match: (Xor64 (Const64 [0]) x)
 32150  	// cond:
 32151  	// result: x
 32152  	for {
 32153  		_ = v.Args[1]
 32154  		v_0 := v.Args[0]
 32155  		if v_0.Op != OpConst64 {
 32156  			break
 32157  		}
 32158  		if v_0.AuxInt != 0 {
 32159  			break
 32160  		}
 32161  		x := v.Args[1]
 32162  		v.reset(OpCopy)
 32163  		v.Type = x.Type
 32164  		v.AddArg(x)
 32165  		return true
 32166  	}
 32167  	// match: (Xor64 x (Const64 [0]))
 32168  	// cond:
 32169  	// result: x
 32170  	for {
 32171  		_ = v.Args[1]
 32172  		x := v.Args[0]
 32173  		v_1 := v.Args[1]
 32174  		if v_1.Op != OpConst64 {
 32175  			break
 32176  		}
 32177  		if v_1.AuxInt != 0 {
 32178  			break
 32179  		}
 32180  		v.reset(OpCopy)
 32181  		v.Type = x.Type
 32182  		v.AddArg(x)
 32183  		return true
 32184  	}
 32185  	// match: (Xor64 x (Xor64 x y))
 32186  	// cond:
 32187  	// result: y
 32188  	for {
 32189  		_ = v.Args[1]
 32190  		x := v.Args[0]
 32191  		v_1 := v.Args[1]
 32192  		if v_1.Op != OpXor64 {
 32193  			break
 32194  		}
 32195  		_ = v_1.Args[1]
 32196  		if x != v_1.Args[0] {
 32197  			break
 32198  		}
 32199  		y := v_1.Args[1]
 32200  		v.reset(OpCopy)
 32201  		v.Type = y.Type
 32202  		v.AddArg(y)
 32203  		return true
 32204  	}
 32205  	// match: (Xor64 x (Xor64 y x))
 32206  	// cond:
 32207  	// result: y
 32208  	for {
 32209  		_ = v.Args[1]
 32210  		x := v.Args[0]
 32211  		v_1 := v.Args[1]
 32212  		if v_1.Op != OpXor64 {
 32213  			break
 32214  		}
 32215  		_ = v_1.Args[1]
 32216  		y := v_1.Args[0]
 32217  		if x != v_1.Args[1] {
 32218  			break
 32219  		}
 32220  		v.reset(OpCopy)
 32221  		v.Type = y.Type
 32222  		v.AddArg(y)
 32223  		return true
 32224  	}
 32225  	// match: (Xor64 (Xor64 x y) x)
 32226  	// cond:
 32227  	// result: y
 32228  	for {
 32229  		_ = v.Args[1]
 32230  		v_0 := v.Args[0]
 32231  		if v_0.Op != OpXor64 {
 32232  			break
 32233  		}
 32234  		_ = v_0.Args[1]
 32235  		x := v_0.Args[0]
 32236  		y := v_0.Args[1]
 32237  		if x != v.Args[1] {
 32238  			break
 32239  		}
 32240  		v.reset(OpCopy)
 32241  		v.Type = y.Type
 32242  		v.AddArg(y)
 32243  		return true
 32244  	}
 32245  	// match: (Xor64 (Xor64 y x) x)
 32246  	// cond:
 32247  	// result: y
 32248  	for {
 32249  		_ = v.Args[1]
 32250  		v_0 := v.Args[0]
 32251  		if v_0.Op != OpXor64 {
 32252  			break
 32253  		}
 32254  		_ = v_0.Args[1]
 32255  		y := v_0.Args[0]
 32256  		x := v_0.Args[1]
 32257  		if x != v.Args[1] {
 32258  			break
 32259  		}
 32260  		v.reset(OpCopy)
 32261  		v.Type = y.Type
 32262  		v.AddArg(y)
 32263  		return true
 32264  	}
 32265  	// match: (Xor64 (Xor64 i:(Const64 <t>) z) x)
 32266  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 32267  	// result: (Xor64 i (Xor64 <t> z x))
 32268  	for {
 32269  		_ = v.Args[1]
 32270  		v_0 := v.Args[0]
 32271  		if v_0.Op != OpXor64 {
 32272  			break
 32273  		}
 32274  		_ = v_0.Args[1]
 32275  		i := v_0.Args[0]
 32276  		if i.Op != OpConst64 {
 32277  			break
 32278  		}
 32279  		t := i.Type
 32280  		z := v_0.Args[1]
 32281  		x := v.Args[1]
 32282  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 32283  			break
 32284  		}
 32285  		v.reset(OpXor64)
 32286  		v.AddArg(i)
 32287  		v0 := b.NewValue0(v.Pos, OpXor64, t)
 32288  		v0.AddArg(z)
 32289  		v0.AddArg(x)
 32290  		v.AddArg(v0)
 32291  		return true
 32292  	}
 32293  	return false
 32294  }
 32295  func rewriteValuegeneric_OpXor64_10(v *Value) bool {
 32296  	b := v.Block
 32297  	_ = b
 32298  	// match: (Xor64 (Xor64 z i:(Const64 <t>)) x)
 32299  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 32300  	// result: (Xor64 i (Xor64 <t> z x))
 32301  	for {
 32302  		_ = v.Args[1]
 32303  		v_0 := v.Args[0]
 32304  		if v_0.Op != OpXor64 {
 32305  			break
 32306  		}
 32307  		_ = v_0.Args[1]
 32308  		z := v_0.Args[0]
 32309  		i := v_0.Args[1]
 32310  		if i.Op != OpConst64 {
 32311  			break
 32312  		}
 32313  		t := i.Type
 32314  		x := v.Args[1]
 32315  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 32316  			break
 32317  		}
 32318  		v.reset(OpXor64)
 32319  		v.AddArg(i)
 32320  		v0 := b.NewValue0(v.Pos, OpXor64, t)
 32321  		v0.AddArg(z)
 32322  		v0.AddArg(x)
 32323  		v.AddArg(v0)
 32324  		return true
 32325  	}
 32326  	// match: (Xor64 x (Xor64 i:(Const64 <t>) z))
 32327  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 32328  	// result: (Xor64 i (Xor64 <t> z x))
 32329  	for {
 32330  		_ = v.Args[1]
 32331  		x := v.Args[0]
 32332  		v_1 := v.Args[1]
 32333  		if v_1.Op != OpXor64 {
 32334  			break
 32335  		}
 32336  		_ = v_1.Args[1]
 32337  		i := v_1.Args[0]
 32338  		if i.Op != OpConst64 {
 32339  			break
 32340  		}
 32341  		t := i.Type
 32342  		z := v_1.Args[1]
 32343  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 32344  			break
 32345  		}
 32346  		v.reset(OpXor64)
 32347  		v.AddArg(i)
 32348  		v0 := b.NewValue0(v.Pos, OpXor64, t)
 32349  		v0.AddArg(z)
 32350  		v0.AddArg(x)
 32351  		v.AddArg(v0)
 32352  		return true
 32353  	}
 32354  	// match: (Xor64 x (Xor64 z i:(Const64 <t>)))
 32355  	// cond: (z.Op != OpConst64 && x.Op != OpConst64)
 32356  	// result: (Xor64 i (Xor64 <t> z x))
 32357  	for {
 32358  		_ = v.Args[1]
 32359  		x := v.Args[0]
 32360  		v_1 := v.Args[1]
 32361  		if v_1.Op != OpXor64 {
 32362  			break
 32363  		}
 32364  		_ = v_1.Args[1]
 32365  		z := v_1.Args[0]
 32366  		i := v_1.Args[1]
 32367  		if i.Op != OpConst64 {
 32368  			break
 32369  		}
 32370  		t := i.Type
 32371  		if !(z.Op != OpConst64 && x.Op != OpConst64) {
 32372  			break
 32373  		}
 32374  		v.reset(OpXor64)
 32375  		v.AddArg(i)
 32376  		v0 := b.NewValue0(v.Pos, OpXor64, t)
 32377  		v0.AddArg(z)
 32378  		v0.AddArg(x)
 32379  		v.AddArg(v0)
 32380  		return true
 32381  	}
 32382  	// match: (Xor64 (Const64 <t> [c]) (Xor64 (Const64 <t> [d]) x))
 32383  	// cond:
 32384  	// result: (Xor64 (Const64 <t> [c^d]) x)
 32385  	for {
 32386  		_ = v.Args[1]
 32387  		v_0 := v.Args[0]
 32388  		if v_0.Op != OpConst64 {
 32389  			break
 32390  		}
 32391  		t := v_0.Type
 32392  		c := v_0.AuxInt
 32393  		v_1 := v.Args[1]
 32394  		if v_1.Op != OpXor64 {
 32395  			break
 32396  		}
 32397  		_ = v_1.Args[1]
 32398  		v_1_0 := v_1.Args[0]
 32399  		if v_1_0.Op != OpConst64 {
 32400  			break
 32401  		}
 32402  		if v_1_0.Type != t {
 32403  			break
 32404  		}
 32405  		d := v_1_0.AuxInt
 32406  		x := v_1.Args[1]
 32407  		v.reset(OpXor64)
 32408  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 32409  		v0.AuxInt = c ^ d
 32410  		v.AddArg(v0)
 32411  		v.AddArg(x)
 32412  		return true
 32413  	}
 32414  	// match: (Xor64 (Const64 <t> [c]) (Xor64 x (Const64 <t> [d])))
 32415  	// cond:
 32416  	// result: (Xor64 (Const64 <t> [c^d]) x)
 32417  	for {
 32418  		_ = v.Args[1]
 32419  		v_0 := v.Args[0]
 32420  		if v_0.Op != OpConst64 {
 32421  			break
 32422  		}
 32423  		t := v_0.Type
 32424  		c := v_0.AuxInt
 32425  		v_1 := v.Args[1]
 32426  		if v_1.Op != OpXor64 {
 32427  			break
 32428  		}
 32429  		_ = v_1.Args[1]
 32430  		x := v_1.Args[0]
 32431  		v_1_1 := v_1.Args[1]
 32432  		if v_1_1.Op != OpConst64 {
 32433  			break
 32434  		}
 32435  		if v_1_1.Type != t {
 32436  			break
 32437  		}
 32438  		d := v_1_1.AuxInt
 32439  		v.reset(OpXor64)
 32440  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 32441  		v0.AuxInt = c ^ d
 32442  		v.AddArg(v0)
 32443  		v.AddArg(x)
 32444  		return true
 32445  	}
 32446  	// match: (Xor64 (Xor64 (Const64 <t> [d]) x) (Const64 <t> [c]))
 32447  	// cond:
 32448  	// result: (Xor64 (Const64 <t> [c^d]) x)
 32449  	for {
 32450  		_ = v.Args[1]
 32451  		v_0 := v.Args[0]
 32452  		if v_0.Op != OpXor64 {
 32453  			break
 32454  		}
 32455  		_ = v_0.Args[1]
 32456  		v_0_0 := v_0.Args[0]
 32457  		if v_0_0.Op != OpConst64 {
 32458  			break
 32459  		}
 32460  		t := v_0_0.Type
 32461  		d := v_0_0.AuxInt
 32462  		x := v_0.Args[1]
 32463  		v_1 := v.Args[1]
 32464  		if v_1.Op != OpConst64 {
 32465  			break
 32466  		}
 32467  		if v_1.Type != t {
 32468  			break
 32469  		}
 32470  		c := v_1.AuxInt
 32471  		v.reset(OpXor64)
 32472  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 32473  		v0.AuxInt = c ^ d
 32474  		v.AddArg(v0)
 32475  		v.AddArg(x)
 32476  		return true
 32477  	}
 32478  	// match: (Xor64 (Xor64 x (Const64 <t> [d])) (Const64 <t> [c]))
 32479  	// cond:
 32480  	// result: (Xor64 (Const64 <t> [c^d]) x)
 32481  	for {
 32482  		_ = v.Args[1]
 32483  		v_0 := v.Args[0]
 32484  		if v_0.Op != OpXor64 {
 32485  			break
 32486  		}
 32487  		_ = v_0.Args[1]
 32488  		x := v_0.Args[0]
 32489  		v_0_1 := v_0.Args[1]
 32490  		if v_0_1.Op != OpConst64 {
 32491  			break
 32492  		}
 32493  		t := v_0_1.Type
 32494  		d := v_0_1.AuxInt
 32495  		v_1 := v.Args[1]
 32496  		if v_1.Op != OpConst64 {
 32497  			break
 32498  		}
 32499  		if v_1.Type != t {
 32500  			break
 32501  		}
 32502  		c := v_1.AuxInt
 32503  		v.reset(OpXor64)
 32504  		v0 := b.NewValue0(v.Pos, OpConst64, t)
 32505  		v0.AuxInt = c ^ d
 32506  		v.AddArg(v0)
 32507  		v.AddArg(x)
 32508  		return true
 32509  	}
 32510  	return false
 32511  }
 32512  func rewriteValuegeneric_OpXor8_0(v *Value) bool {
 32513  	b := v.Block
 32514  	_ = b
 32515  	// match: (Xor8 (Const8 [c]) (Const8 [d]))
 32516  	// cond:
 32517  	// result: (Const8 [int64(int8(c^d))])
 32518  	for {
 32519  		_ = v.Args[1]
 32520  		v_0 := v.Args[0]
 32521  		if v_0.Op != OpConst8 {
 32522  			break
 32523  		}
 32524  		c := v_0.AuxInt
 32525  		v_1 := v.Args[1]
 32526  		if v_1.Op != OpConst8 {
 32527  			break
 32528  		}
 32529  		d := v_1.AuxInt
 32530  		v.reset(OpConst8)
 32531  		v.AuxInt = int64(int8(c ^ d))
 32532  		return true
 32533  	}
 32534  	// match: (Xor8 (Const8 [d]) (Const8 [c]))
 32535  	// cond:
 32536  	// result: (Const8 [int64(int8(c^d))])
 32537  	for {
 32538  		_ = v.Args[1]
 32539  		v_0 := v.Args[0]
 32540  		if v_0.Op != OpConst8 {
 32541  			break
 32542  		}
 32543  		d := v_0.AuxInt
 32544  		v_1 := v.Args[1]
 32545  		if v_1.Op != OpConst8 {
 32546  			break
 32547  		}
 32548  		c := v_1.AuxInt
 32549  		v.reset(OpConst8)
 32550  		v.AuxInt = int64(int8(c ^ d))
 32551  		return true
 32552  	}
 32553  	// match: (Xor8 x x)
 32554  	// cond:
 32555  	// result: (Const8 [0])
 32556  	for {
 32557  		_ = v.Args[1]
 32558  		x := v.Args[0]
 32559  		if x != v.Args[1] {
 32560  			break
 32561  		}
 32562  		v.reset(OpConst8)
 32563  		v.AuxInt = 0
 32564  		return true
 32565  	}
 32566  	// match: (Xor8 (Const8 [0]) x)
 32567  	// cond:
 32568  	// result: x
 32569  	for {
 32570  		_ = v.Args[1]
 32571  		v_0 := v.Args[0]
 32572  		if v_0.Op != OpConst8 {
 32573  			break
 32574  		}
 32575  		if v_0.AuxInt != 0 {
 32576  			break
 32577  		}
 32578  		x := v.Args[1]
 32579  		v.reset(OpCopy)
 32580  		v.Type = x.Type
 32581  		v.AddArg(x)
 32582  		return true
 32583  	}
 32584  	// match: (Xor8 x (Const8 [0]))
 32585  	// cond:
 32586  	// result: x
 32587  	for {
 32588  		_ = v.Args[1]
 32589  		x := v.Args[0]
 32590  		v_1 := v.Args[1]
 32591  		if v_1.Op != OpConst8 {
 32592  			break
 32593  		}
 32594  		if v_1.AuxInt != 0 {
 32595  			break
 32596  		}
 32597  		v.reset(OpCopy)
 32598  		v.Type = x.Type
 32599  		v.AddArg(x)
 32600  		return true
 32601  	}
 32602  	// match: (Xor8 x (Xor8 x y))
 32603  	// cond:
 32604  	// result: y
 32605  	for {
 32606  		_ = v.Args[1]
 32607  		x := v.Args[0]
 32608  		v_1 := v.Args[1]
 32609  		if v_1.Op != OpXor8 {
 32610  			break
 32611  		}
 32612  		_ = v_1.Args[1]
 32613  		if x != v_1.Args[0] {
 32614  			break
 32615  		}
 32616  		y := v_1.Args[1]
 32617  		v.reset(OpCopy)
 32618  		v.Type = y.Type
 32619  		v.AddArg(y)
 32620  		return true
 32621  	}
 32622  	// match: (Xor8 x (Xor8 y x))
 32623  	// cond:
 32624  	// result: y
 32625  	for {
 32626  		_ = v.Args[1]
 32627  		x := v.Args[0]
 32628  		v_1 := v.Args[1]
 32629  		if v_1.Op != OpXor8 {
 32630  			break
 32631  		}
 32632  		_ = v_1.Args[1]
 32633  		y := v_1.Args[0]
 32634  		if x != v_1.Args[1] {
 32635  			break
 32636  		}
 32637  		v.reset(OpCopy)
 32638  		v.Type = y.Type
 32639  		v.AddArg(y)
 32640  		return true
 32641  	}
 32642  	// match: (Xor8 (Xor8 x y) x)
 32643  	// cond:
 32644  	// result: y
 32645  	for {
 32646  		_ = v.Args[1]
 32647  		v_0 := v.Args[0]
 32648  		if v_0.Op != OpXor8 {
 32649  			break
 32650  		}
 32651  		_ = v_0.Args[1]
 32652  		x := v_0.Args[0]
 32653  		y := v_0.Args[1]
 32654  		if x != v.Args[1] {
 32655  			break
 32656  		}
 32657  		v.reset(OpCopy)
 32658  		v.Type = y.Type
 32659  		v.AddArg(y)
 32660  		return true
 32661  	}
 32662  	// match: (Xor8 (Xor8 y x) x)
 32663  	// cond:
 32664  	// result: y
 32665  	for {
 32666  		_ = v.Args[1]
 32667  		v_0 := v.Args[0]
 32668  		if v_0.Op != OpXor8 {
 32669  			break
 32670  		}
 32671  		_ = v_0.Args[1]
 32672  		y := v_0.Args[0]
 32673  		x := v_0.Args[1]
 32674  		if x != v.Args[1] {
 32675  			break
 32676  		}
 32677  		v.reset(OpCopy)
 32678  		v.Type = y.Type
 32679  		v.AddArg(y)
 32680  		return true
 32681  	}
 32682  	// match: (Xor8 (Xor8 i:(Const8 <t>) z) x)
 32683  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 32684  	// result: (Xor8 i (Xor8 <t> z x))
 32685  	for {
 32686  		_ = v.Args[1]
 32687  		v_0 := v.Args[0]
 32688  		if v_0.Op != OpXor8 {
 32689  			break
 32690  		}
 32691  		_ = v_0.Args[1]
 32692  		i := v_0.Args[0]
 32693  		if i.Op != OpConst8 {
 32694  			break
 32695  		}
 32696  		t := i.Type
 32697  		z := v_0.Args[1]
 32698  		x := v.Args[1]
 32699  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 32700  			break
 32701  		}
 32702  		v.reset(OpXor8)
 32703  		v.AddArg(i)
 32704  		v0 := b.NewValue0(v.Pos, OpXor8, t)
 32705  		v0.AddArg(z)
 32706  		v0.AddArg(x)
 32707  		v.AddArg(v0)
 32708  		return true
 32709  	}
 32710  	return false
 32711  }
 32712  func rewriteValuegeneric_OpXor8_10(v *Value) bool {
 32713  	b := v.Block
 32714  	_ = b
 32715  	// match: (Xor8 (Xor8 z i:(Const8 <t>)) x)
 32716  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 32717  	// result: (Xor8 i (Xor8 <t> z x))
 32718  	for {
 32719  		_ = v.Args[1]
 32720  		v_0 := v.Args[0]
 32721  		if v_0.Op != OpXor8 {
 32722  			break
 32723  		}
 32724  		_ = v_0.Args[1]
 32725  		z := v_0.Args[0]
 32726  		i := v_0.Args[1]
 32727  		if i.Op != OpConst8 {
 32728  			break
 32729  		}
 32730  		t := i.Type
 32731  		x := v.Args[1]
 32732  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 32733  			break
 32734  		}
 32735  		v.reset(OpXor8)
 32736  		v.AddArg(i)
 32737  		v0 := b.NewValue0(v.Pos, OpXor8, t)
 32738  		v0.AddArg(z)
 32739  		v0.AddArg(x)
 32740  		v.AddArg(v0)
 32741  		return true
 32742  	}
 32743  	// match: (Xor8 x (Xor8 i:(Const8 <t>) z))
 32744  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 32745  	// result: (Xor8 i (Xor8 <t> z x))
 32746  	for {
 32747  		_ = v.Args[1]
 32748  		x := v.Args[0]
 32749  		v_1 := v.Args[1]
 32750  		if v_1.Op != OpXor8 {
 32751  			break
 32752  		}
 32753  		_ = v_1.Args[1]
 32754  		i := v_1.Args[0]
 32755  		if i.Op != OpConst8 {
 32756  			break
 32757  		}
 32758  		t := i.Type
 32759  		z := v_1.Args[1]
 32760  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 32761  			break
 32762  		}
 32763  		v.reset(OpXor8)
 32764  		v.AddArg(i)
 32765  		v0 := b.NewValue0(v.Pos, OpXor8, t)
 32766  		v0.AddArg(z)
 32767  		v0.AddArg(x)
 32768  		v.AddArg(v0)
 32769  		return true
 32770  	}
 32771  	// match: (Xor8 x (Xor8 z i:(Const8 <t>)))
 32772  	// cond: (z.Op != OpConst8 && x.Op != OpConst8)
 32773  	// result: (Xor8 i (Xor8 <t> z x))
 32774  	for {
 32775  		_ = v.Args[1]
 32776  		x := v.Args[0]
 32777  		v_1 := v.Args[1]
 32778  		if v_1.Op != OpXor8 {
 32779  			break
 32780  		}
 32781  		_ = v_1.Args[1]
 32782  		z := v_1.Args[0]
 32783  		i := v_1.Args[1]
 32784  		if i.Op != OpConst8 {
 32785  			break
 32786  		}
 32787  		t := i.Type
 32788  		if !(z.Op != OpConst8 && x.Op != OpConst8) {
 32789  			break
 32790  		}
 32791  		v.reset(OpXor8)
 32792  		v.AddArg(i)
 32793  		v0 := b.NewValue0(v.Pos, OpXor8, t)
 32794  		v0.AddArg(z)
 32795  		v0.AddArg(x)
 32796  		v.AddArg(v0)
 32797  		return true
 32798  	}
 32799  	// match: (Xor8 (Const8 <t> [c]) (Xor8 (Const8 <t> [d]) x))
 32800  	// cond:
 32801  	// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 32802  	for {
 32803  		_ = v.Args[1]
 32804  		v_0 := v.Args[0]
 32805  		if v_0.Op != OpConst8 {
 32806  			break
 32807  		}
 32808  		t := v_0.Type
 32809  		c := v_0.AuxInt
 32810  		v_1 := v.Args[1]
 32811  		if v_1.Op != OpXor8 {
 32812  			break
 32813  		}
 32814  		_ = v_1.Args[1]
 32815  		v_1_0 := v_1.Args[0]
 32816  		if v_1_0.Op != OpConst8 {
 32817  			break
 32818  		}
 32819  		if v_1_0.Type != t {
 32820  			break
 32821  		}
 32822  		d := v_1_0.AuxInt
 32823  		x := v_1.Args[1]
 32824  		v.reset(OpXor8)
 32825  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 32826  		v0.AuxInt = int64(int8(c ^ d))
 32827  		v.AddArg(v0)
 32828  		v.AddArg(x)
 32829  		return true
 32830  	}
 32831  	// match: (Xor8 (Const8 <t> [c]) (Xor8 x (Const8 <t> [d])))
 32832  	// cond:
 32833  	// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 32834  	for {
 32835  		_ = v.Args[1]
 32836  		v_0 := v.Args[0]
 32837  		if v_0.Op != OpConst8 {
 32838  			break
 32839  		}
 32840  		t := v_0.Type
 32841  		c := v_0.AuxInt
 32842  		v_1 := v.Args[1]
 32843  		if v_1.Op != OpXor8 {
 32844  			break
 32845  		}
 32846  		_ = v_1.Args[1]
 32847  		x := v_1.Args[0]
 32848  		v_1_1 := v_1.Args[1]
 32849  		if v_1_1.Op != OpConst8 {
 32850  			break
 32851  		}
 32852  		if v_1_1.Type != t {
 32853  			break
 32854  		}
 32855  		d := v_1_1.AuxInt
 32856  		v.reset(OpXor8)
 32857  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 32858  		v0.AuxInt = int64(int8(c ^ d))
 32859  		v.AddArg(v0)
 32860  		v.AddArg(x)
 32861  		return true
 32862  	}
 32863  	// match: (Xor8 (Xor8 (Const8 <t> [d]) x) (Const8 <t> [c]))
 32864  	// cond:
 32865  	// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 32866  	for {
 32867  		_ = v.Args[1]
 32868  		v_0 := v.Args[0]
 32869  		if v_0.Op != OpXor8 {
 32870  			break
 32871  		}
 32872  		_ = v_0.Args[1]
 32873  		v_0_0 := v_0.Args[0]
 32874  		if v_0_0.Op != OpConst8 {
 32875  			break
 32876  		}
 32877  		t := v_0_0.Type
 32878  		d := v_0_0.AuxInt
 32879  		x := v_0.Args[1]
 32880  		v_1 := v.Args[1]
 32881  		if v_1.Op != OpConst8 {
 32882  			break
 32883  		}
 32884  		if v_1.Type != t {
 32885  			break
 32886  		}
 32887  		c := v_1.AuxInt
 32888  		v.reset(OpXor8)
 32889  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 32890  		v0.AuxInt = int64(int8(c ^ d))
 32891  		v.AddArg(v0)
 32892  		v.AddArg(x)
 32893  		return true
 32894  	}
 32895  	// match: (Xor8 (Xor8 x (Const8 <t> [d])) (Const8 <t> [c]))
 32896  	// cond:
 32897  	// result: (Xor8 (Const8 <t> [int64(int8(c^d))]) x)
 32898  	for {
 32899  		_ = v.Args[1]
 32900  		v_0 := v.Args[0]
 32901  		if v_0.Op != OpXor8 {
 32902  			break
 32903  		}
 32904  		_ = v_0.Args[1]
 32905  		x := v_0.Args[0]
 32906  		v_0_1 := v_0.Args[1]
 32907  		if v_0_1.Op != OpConst8 {
 32908  			break
 32909  		}
 32910  		t := v_0_1.Type
 32911  		d := v_0_1.AuxInt
 32912  		v_1 := v.Args[1]
 32913  		if v_1.Op != OpConst8 {
 32914  			break
 32915  		}
 32916  		if v_1.Type != t {
 32917  			break
 32918  		}
 32919  		c := v_1.AuxInt
 32920  		v.reset(OpXor8)
 32921  		v0 := b.NewValue0(v.Pos, OpConst8, t)
 32922  		v0.AuxInt = int64(int8(c ^ d))
 32923  		v.AddArg(v0)
 32924  		v.AddArg(x)
 32925  		return true
 32926  	}
 32927  	return false
 32928  }
 32929  func rewriteValuegeneric_OpZero_0(v *Value) bool {
 32930  	b := v.Block
 32931  	_ = b
 32932  	config := b.Func.Config
 32933  	_ = config
 32934  	// match: (Zero (Load (OffPtr [c] (SP)) mem) mem)
 32935  	// cond: mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
 32936  	// result: mem
 32937  	for {
 32938  		_ = v.Args[1]
 32939  		v_0 := v.Args[0]
 32940  		if v_0.Op != OpLoad {
 32941  			break
 32942  		}
 32943  		_ = v_0.Args[1]
 32944  		v_0_0 := v_0.Args[0]
 32945  		if v_0_0.Op != OpOffPtr {
 32946  			break
 32947  		}
 32948  		c := v_0_0.AuxInt
 32949  		v_0_0_0 := v_0_0.Args[0]
 32950  		if v_0_0_0.Op != OpSP {
 32951  			break
 32952  		}
 32953  		mem := v_0.Args[1]
 32954  		if mem != v.Args[1] {
 32955  			break
 32956  		}
 32957  		if !(mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize()+config.RegSize) {
 32958  			break
 32959  		}
 32960  		v.reset(OpCopy)
 32961  		v.Type = mem.Type
 32962  		v.AddArg(mem)
 32963  		return true
 32964  	}
 32965  	// match: (Zero {t1} [n] p1 store:(Store {t2} (OffPtr [o2] p2) _ mem))
 32966  	// cond: isSamePtr(p1, p2) && store.Uses == 1 && n >= o2 + sizeof(t2) && clobber(store)
 32967  	// result: (Zero {t1} [n] p1 mem)
 32968  	for {
 32969  		n := v.AuxInt
 32970  		t1 := v.Aux
 32971  		_ = v.Args[1]
 32972  		p1 := v.Args[0]
 32973  		store := v.Args[1]
 32974  		if store.Op != OpStore {
 32975  			break
 32976  		}
 32977  		t2 := store.Aux
 32978  		_ = store.Args[2]
 32979  		store_0 := store.Args[0]
 32980  		if store_0.Op != OpOffPtr {
 32981  			break
 32982  		}
 32983  		o2 := store_0.AuxInt
 32984  		p2 := store_0.Args[0]
 32985  		mem := store.Args[2]
 32986  		if !(isSamePtr(p1, p2) && store.Uses == 1 && n >= o2+sizeof(t2) && clobber(store)) {
 32987  			break
 32988  		}
 32989  		v.reset(OpZero)
 32990  		v.AuxInt = n
 32991  		v.Aux = t1
 32992  		v.AddArg(p1)
 32993  		v.AddArg(mem)
 32994  		return true
 32995  	}
 32996  	// match: (Zero {t} [n] dst1 move:(Move {t} [n] dst2 _ mem))
 32997  	// cond: move.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move)
 32998  	// result: (Zero {t} [n] dst1 mem)
 32999  	for {
 33000  		n := v.AuxInt
 33001  		t := v.Aux
 33002  		_ = v.Args[1]
 33003  		dst1 := v.Args[0]
 33004  		move := v.Args[1]
 33005  		if move.Op != OpMove {
 33006  			break
 33007  		}
 33008  		if move.AuxInt != n {
 33009  			break
 33010  		}
 33011  		if move.Aux != t {
 33012  			break
 33013  		}
 33014  		_ = move.Args[2]
 33015  		dst2 := move.Args[0]
 33016  		mem := move.Args[2]
 33017  		if !(move.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move)) {
 33018  			break
 33019  		}
 33020  		v.reset(OpZero)
 33021  		v.AuxInt = n
 33022  		v.Aux = t
 33023  		v.AddArg(dst1)
 33024  		v.AddArg(mem)
 33025  		return true
 33026  	}
 33027  	// match: (Zero {t} [n] dst1 vardef:(VarDef {x} move:(Move {t} [n] dst2 _ mem)))
 33028  	// cond: move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) && clobber(vardef)
 33029  	// result: (Zero {t} [n] dst1 (VarDef {x} mem))
 33030  	for {
 33031  		n := v.AuxInt
 33032  		t := v.Aux
 33033  		_ = v.Args[1]
 33034  		dst1 := v.Args[0]
 33035  		vardef := v.Args[1]
 33036  		if vardef.Op != OpVarDef {
 33037  			break
 33038  		}
 33039  		x := vardef.Aux
 33040  		move := vardef.Args[0]
 33041  		if move.Op != OpMove {
 33042  			break
 33043  		}
 33044  		if move.AuxInt != n {
 33045  			break
 33046  		}
 33047  		if move.Aux != t {
 33048  			break
 33049  		}
 33050  		_ = move.Args[2]
 33051  		dst2 := move.Args[0]
 33052  		mem := move.Args[2]
 33053  		if !(move.Uses == 1 && vardef.Uses == 1 && isSamePtr(dst1, dst2) && clobber(move) && clobber(vardef)) {
 33054  			break
 33055  		}
 33056  		v.reset(OpZero)
 33057  		v.AuxInt = n
 33058  		v.Aux = t
 33059  		v.AddArg(dst1)
 33060  		v0 := b.NewValue0(v.Pos, OpVarDef, types.TypeMem)
 33061  		v0.Aux = x
 33062  		v0.AddArg(mem)
 33063  		v.AddArg(v0)
 33064  		return true
 33065  	}
 33066  	return false
 33067  }
 33068  func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool {
 33069  	// match: (ZeroExt16to32 (Const16 [c]))
 33070  	// cond:
 33071  	// result: (Const32 [int64(uint16(c))])
 33072  	for {
 33073  		v_0 := v.Args[0]
 33074  		if v_0.Op != OpConst16 {
 33075  			break
 33076  		}
 33077  		c := v_0.AuxInt
 33078  		v.reset(OpConst32)
 33079  		v.AuxInt = int64(uint16(c))
 33080  		return true
 33081  	}
 33082  	// match: (ZeroExt16to32 (Trunc32to16 x:(Rsh32Ux64 _ (Const64 [s]))))
 33083  	// cond: s >= 16
 33084  	// result: x
 33085  	for {
 33086  		v_0 := v.Args[0]
 33087  		if v_0.Op != OpTrunc32to16 {
 33088  			break
 33089  		}
 33090  		x := v_0.Args[0]
 33091  		if x.Op != OpRsh32Ux64 {
 33092  			break
 33093  		}
 33094  		_ = x.Args[1]
 33095  		x_1 := x.Args[1]
 33096  		if x_1.Op != OpConst64 {
 33097  			break
 33098  		}
 33099  		s := x_1.AuxInt
 33100  		if !(s >= 16) {
 33101  			break
 33102  		}
 33103  		v.reset(OpCopy)
 33104  		v.Type = x.Type
 33105  		v.AddArg(x)
 33106  		return true
 33107  	}
 33108  	return false
 33109  }
 33110  func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool {
 33111  	// match: (ZeroExt16to64 (Const16 [c]))
 33112  	// cond:
 33113  	// result: (Const64 [int64(uint16(c))])
 33114  	for {
 33115  		v_0 := v.Args[0]
 33116  		if v_0.Op != OpConst16 {
 33117  			break
 33118  		}
 33119  		c := v_0.AuxInt
 33120  		v.reset(OpConst64)
 33121  		v.AuxInt = int64(uint16(c))
 33122  		return true
 33123  	}
 33124  	// match: (ZeroExt16to64 (Trunc64to16 x:(Rsh64Ux64 _ (Const64 [s]))))
 33125  	// cond: s >= 48
 33126  	// result: x
 33127  	for {
 33128  		v_0 := v.Args[0]
 33129  		if v_0.Op != OpTrunc64to16 {
 33130  			break
 33131  		}
 33132  		x := v_0.Args[0]
 33133  		if x.Op != OpRsh64Ux64 {
 33134  			break
 33135  		}
 33136  		_ = x.Args[1]
 33137  		x_1 := x.Args[1]
 33138  		if x_1.Op != OpConst64 {
 33139  			break
 33140  		}
 33141  		s := x_1.AuxInt
 33142  		if !(s >= 48) {
 33143  			break
 33144  		}
 33145  		v.reset(OpCopy)
 33146  		v.Type = x.Type
 33147  		v.AddArg(x)
 33148  		return true
 33149  	}
 33150  	return false
 33151  }
 33152  func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool {
 33153  	// match: (ZeroExt32to64 (Const32 [c]))
 33154  	// cond:
 33155  	// result: (Const64 [int64(uint32(c))])
 33156  	for {
 33157  		v_0 := v.Args[0]
 33158  		if v_0.Op != OpConst32 {
 33159  			break
 33160  		}
 33161  		c := v_0.AuxInt
 33162  		v.reset(OpConst64)
 33163  		v.AuxInt = int64(uint32(c))
 33164  		return true
 33165  	}
 33166  	// match: (ZeroExt32to64 (Trunc64to32 x:(Rsh64Ux64 _ (Const64 [s]))))
 33167  	// cond: s >= 32
 33168  	// result: x
 33169  	for {
 33170  		v_0 := v.Args[0]
 33171  		if v_0.Op != OpTrunc64to32 {
 33172  			break
 33173  		}
 33174  		x := v_0.Args[0]
 33175  		if x.Op != OpRsh64Ux64 {
 33176  			break
 33177  		}
 33178  		_ = x.Args[1]
 33179  		x_1 := x.Args[1]
 33180  		if x_1.Op != OpConst64 {
 33181  			break
 33182  		}
 33183  		s := x_1.AuxInt
 33184  		if !(s >= 32) {
 33185  			break
 33186  		}
 33187  		v.reset(OpCopy)
 33188  		v.Type = x.Type
 33189  		v.AddArg(x)
 33190  		return true
 33191  	}
 33192  	return false
 33193  }
 33194  func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool {
 33195  	// match: (ZeroExt8to16 (Const8 [c]))
 33196  	// cond:
 33197  	// result: (Const16 [int64( uint8(c))])
 33198  	for {
 33199  		v_0 := v.Args[0]
 33200  		if v_0.Op != OpConst8 {
 33201  			break
 33202  		}
 33203  		c := v_0.AuxInt
 33204  		v.reset(OpConst16)
 33205  		v.AuxInt = int64(uint8(c))
 33206  		return true
 33207  	}
 33208  	// match: (ZeroExt8to16 (Trunc16to8 x:(Rsh16Ux64 _ (Const64 [s]))))
 33209  	// cond: s >= 8
 33210  	// result: x
 33211  	for {
 33212  		v_0 := v.Args[0]
 33213  		if v_0.Op != OpTrunc16to8 {
 33214  			break
 33215  		}
 33216  		x := v_0.Args[0]
 33217  		if x.Op != OpRsh16Ux64 {
 33218  			break
 33219  		}
 33220  		_ = x.Args[1]
 33221  		x_1 := x.Args[1]
 33222  		if x_1.Op != OpConst64 {
 33223  			break
 33224  		}
 33225  		s := x_1.AuxInt
 33226  		if !(s >= 8) {
 33227  			break
 33228  		}
 33229  		v.reset(OpCopy)
 33230  		v.Type = x.Type
 33231  		v.AddArg(x)
 33232  		return true
 33233  	}
 33234  	return false
 33235  }
 33236  func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool {
 33237  	// match: (ZeroExt8to32 (Const8 [c]))
 33238  	// cond:
 33239  	// result: (Const32 [int64( uint8(c))])
 33240  	for {
 33241  		v_0 := v.Args[0]
 33242  		if v_0.Op != OpConst8 {
 33243  			break
 33244  		}
 33245  		c := v_0.AuxInt
 33246  		v.reset(OpConst32)
 33247  		v.AuxInt = int64(uint8(c))
 33248  		return true
 33249  	}
 33250  	// match: (ZeroExt8to32 (Trunc32to8 x:(Rsh32Ux64 _ (Const64 [s]))))
 33251  	// cond: s >= 24
 33252  	// result: x
 33253  	for {
 33254  		v_0 := v.Args[0]
 33255  		if v_0.Op != OpTrunc32to8 {
 33256  			break
 33257  		}
 33258  		x := v_0.Args[0]
 33259  		if x.Op != OpRsh32Ux64 {
 33260  			break
 33261  		}
 33262  		_ = x.Args[1]
 33263  		x_1 := x.Args[1]
 33264  		if x_1.Op != OpConst64 {
 33265  			break
 33266  		}
 33267  		s := x_1.AuxInt
 33268  		if !(s >= 24) {
 33269  			break
 33270  		}
 33271  		v.reset(OpCopy)
 33272  		v.Type = x.Type
 33273  		v.AddArg(x)
 33274  		return true
 33275  	}
 33276  	return false
 33277  }
 33278  func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool {
 33279  	// match: (ZeroExt8to64 (Const8 [c]))
 33280  	// cond:
 33281  	// result: (Const64 [int64( uint8(c))])
 33282  	for {
 33283  		v_0 := v.Args[0]
 33284  		if v_0.Op != OpConst8 {
 33285  			break
 33286  		}
 33287  		c := v_0.AuxInt
 33288  		v.reset(OpConst64)
 33289  		v.AuxInt = int64(uint8(c))
 33290  		return true
 33291  	}
 33292  	// match: (ZeroExt8to64 (Trunc64to8 x:(Rsh64Ux64 _ (Const64 [s]))))
 33293  	// cond: s >= 56
 33294  	// result: x
 33295  	for {
 33296  		v_0 := v.Args[0]
 33297  		if v_0.Op != OpTrunc64to8 {
 33298  			break
 33299  		}
 33300  		x := v_0.Args[0]
 33301  		if x.Op != OpRsh64Ux64 {
 33302  			break
 33303  		}
 33304  		_ = x.Args[1]
 33305  		x_1 := x.Args[1]
 33306  		if x_1.Op != OpConst64 {
 33307  			break
 33308  		}
 33309  		s := x_1.AuxInt
 33310  		if !(s >= 56) {
 33311  			break
 33312  		}
 33313  		v.reset(OpCopy)
 33314  		v.Type = x.Type
 33315  		v.AddArg(x)
 33316  		return true
 33317  	}
 33318  	return false
 33319  }
 33320  func rewriteBlockgeneric(b *Block) bool {
 33321  	config := b.Func.Config
 33322  	_ = config
 33323  	fe := b.Func.fe
 33324  	_ = fe
 33325  	typ := &config.Types
 33326  	_ = typ
 33327  	switch b.Kind {
 33328  	case BlockIf:
 33329  		// match: (If (Not cond) yes no)
 33330  		// cond:
 33331  		// result: (If cond no yes)
 33332  		for {
 33333  			v := b.Control
 33334  			if v.Op != OpNot {
 33335  				break
 33336  			}
 33337  			cond := v.Args[0]
 33338  			b.Kind = BlockIf
 33339  			b.SetControl(cond)
 33340  			b.Aux = nil
 33341  			b.swapSuccessors()
 33342  			return true
 33343  		}
 33344  		// match: (If (ConstBool [c]) yes no)
 33345  		// cond: c == 1
 33346  		// result: (First nil yes no)
 33347  		for {
 33348  			v := b.Control
 33349  			if v.Op != OpConstBool {
 33350  				break
 33351  			}
 33352  			c := v.AuxInt
 33353  			if !(c == 1) {
 33354  				break
 33355  			}
 33356  			b.Kind = BlockFirst
 33357  			b.SetControl(nil)
 33358  			b.Aux = nil
 33359  			return true
 33360  		}
 33361  		// match: (If (ConstBool [c]) yes no)
 33362  		// cond: c == 0
 33363  		// result: (First nil no yes)
 33364  		for {
 33365  			v := b.Control
 33366  			if v.Op != OpConstBool {
 33367  				break
 33368  			}
 33369  			c := v.AuxInt
 33370  			if !(c == 0) {
 33371  				break
 33372  			}
 33373  			b.Kind = BlockFirst
 33374  			b.SetControl(nil)
 33375  			b.Aux = nil
 33376  			b.swapSuccessors()
 33377  			return true
 33378  		}
 33379  	}
 33380  	return false
 33381  }