Source file src/cmd/compile/internal/ssa/rewriteARM.go

     1  // Code generated from _gen/ARM.rules using 'go generate'; DO NOT EDIT.
     2  
     3  package ssa
     4  
     5  import "internal/buildcfg"
     6  import "cmd/compile/internal/types"
     7  
     8  func rewriteValueARM(v *Value) bool {
     9  	switch v.Op {
    10  	case OpARMADC:
    11  		return rewriteValueARM_OpARMADC(v)
    12  	case OpARMADCconst:
    13  		return rewriteValueARM_OpARMADCconst(v)
    14  	case OpARMADCshiftLL:
    15  		return rewriteValueARM_OpARMADCshiftLL(v)
    16  	case OpARMADCshiftLLreg:
    17  		return rewriteValueARM_OpARMADCshiftLLreg(v)
    18  	case OpARMADCshiftRA:
    19  		return rewriteValueARM_OpARMADCshiftRA(v)
    20  	case OpARMADCshiftRAreg:
    21  		return rewriteValueARM_OpARMADCshiftRAreg(v)
    22  	case OpARMADCshiftRL:
    23  		return rewriteValueARM_OpARMADCshiftRL(v)
    24  	case OpARMADCshiftRLreg:
    25  		return rewriteValueARM_OpARMADCshiftRLreg(v)
    26  	case OpARMADD:
    27  		return rewriteValueARM_OpARMADD(v)
    28  	case OpARMADDD:
    29  		return rewriteValueARM_OpARMADDD(v)
    30  	case OpARMADDF:
    31  		return rewriteValueARM_OpARMADDF(v)
    32  	case OpARMADDS:
    33  		return rewriteValueARM_OpARMADDS(v)
    34  	case OpARMADDSshiftLL:
    35  		return rewriteValueARM_OpARMADDSshiftLL(v)
    36  	case OpARMADDSshiftLLreg:
    37  		return rewriteValueARM_OpARMADDSshiftLLreg(v)
    38  	case OpARMADDSshiftRA:
    39  		return rewriteValueARM_OpARMADDSshiftRA(v)
    40  	case OpARMADDSshiftRAreg:
    41  		return rewriteValueARM_OpARMADDSshiftRAreg(v)
    42  	case OpARMADDSshiftRL:
    43  		return rewriteValueARM_OpARMADDSshiftRL(v)
    44  	case OpARMADDSshiftRLreg:
    45  		return rewriteValueARM_OpARMADDSshiftRLreg(v)
    46  	case OpARMADDconst:
    47  		return rewriteValueARM_OpARMADDconst(v)
    48  	case OpARMADDshiftLL:
    49  		return rewriteValueARM_OpARMADDshiftLL(v)
    50  	case OpARMADDshiftLLreg:
    51  		return rewriteValueARM_OpARMADDshiftLLreg(v)
    52  	case OpARMADDshiftRA:
    53  		return rewriteValueARM_OpARMADDshiftRA(v)
    54  	case OpARMADDshiftRAreg:
    55  		return rewriteValueARM_OpARMADDshiftRAreg(v)
    56  	case OpARMADDshiftRL:
    57  		return rewriteValueARM_OpARMADDshiftRL(v)
    58  	case OpARMADDshiftRLreg:
    59  		return rewriteValueARM_OpARMADDshiftRLreg(v)
    60  	case OpARMAND:
    61  		return rewriteValueARM_OpARMAND(v)
    62  	case OpARMANDconst:
    63  		return rewriteValueARM_OpARMANDconst(v)
    64  	case OpARMANDshiftLL:
    65  		return rewriteValueARM_OpARMANDshiftLL(v)
    66  	case OpARMANDshiftLLreg:
    67  		return rewriteValueARM_OpARMANDshiftLLreg(v)
    68  	case OpARMANDshiftRA:
    69  		return rewriteValueARM_OpARMANDshiftRA(v)
    70  	case OpARMANDshiftRAreg:
    71  		return rewriteValueARM_OpARMANDshiftRAreg(v)
    72  	case OpARMANDshiftRL:
    73  		return rewriteValueARM_OpARMANDshiftRL(v)
    74  	case OpARMANDshiftRLreg:
    75  		return rewriteValueARM_OpARMANDshiftRLreg(v)
    76  	case OpARMBFX:
    77  		return rewriteValueARM_OpARMBFX(v)
    78  	case OpARMBFXU:
    79  		return rewriteValueARM_OpARMBFXU(v)
    80  	case OpARMBIC:
    81  		return rewriteValueARM_OpARMBIC(v)
    82  	case OpARMBICconst:
    83  		return rewriteValueARM_OpARMBICconst(v)
    84  	case OpARMBICshiftLL:
    85  		return rewriteValueARM_OpARMBICshiftLL(v)
    86  	case OpARMBICshiftLLreg:
    87  		return rewriteValueARM_OpARMBICshiftLLreg(v)
    88  	case OpARMBICshiftRA:
    89  		return rewriteValueARM_OpARMBICshiftRA(v)
    90  	case OpARMBICshiftRAreg:
    91  		return rewriteValueARM_OpARMBICshiftRAreg(v)
    92  	case OpARMBICshiftRL:
    93  		return rewriteValueARM_OpARMBICshiftRL(v)
    94  	case OpARMBICshiftRLreg:
    95  		return rewriteValueARM_OpARMBICshiftRLreg(v)
    96  	case OpARMCMN:
    97  		return rewriteValueARM_OpARMCMN(v)
    98  	case OpARMCMNconst:
    99  		return rewriteValueARM_OpARMCMNconst(v)
   100  	case OpARMCMNshiftLL:
   101  		return rewriteValueARM_OpARMCMNshiftLL(v)
   102  	case OpARMCMNshiftLLreg:
   103  		return rewriteValueARM_OpARMCMNshiftLLreg(v)
   104  	case OpARMCMNshiftRA:
   105  		return rewriteValueARM_OpARMCMNshiftRA(v)
   106  	case OpARMCMNshiftRAreg:
   107  		return rewriteValueARM_OpARMCMNshiftRAreg(v)
   108  	case OpARMCMNshiftRL:
   109  		return rewriteValueARM_OpARMCMNshiftRL(v)
   110  	case OpARMCMNshiftRLreg:
   111  		return rewriteValueARM_OpARMCMNshiftRLreg(v)
   112  	case OpARMCMOVWHSconst:
   113  		return rewriteValueARM_OpARMCMOVWHSconst(v)
   114  	case OpARMCMOVWLSconst:
   115  		return rewriteValueARM_OpARMCMOVWLSconst(v)
   116  	case OpARMCMP:
   117  		return rewriteValueARM_OpARMCMP(v)
   118  	case OpARMCMPD:
   119  		return rewriteValueARM_OpARMCMPD(v)
   120  	case OpARMCMPF:
   121  		return rewriteValueARM_OpARMCMPF(v)
   122  	case OpARMCMPconst:
   123  		return rewriteValueARM_OpARMCMPconst(v)
   124  	case OpARMCMPshiftLL:
   125  		return rewriteValueARM_OpARMCMPshiftLL(v)
   126  	case OpARMCMPshiftLLreg:
   127  		return rewriteValueARM_OpARMCMPshiftLLreg(v)
   128  	case OpARMCMPshiftRA:
   129  		return rewriteValueARM_OpARMCMPshiftRA(v)
   130  	case OpARMCMPshiftRAreg:
   131  		return rewriteValueARM_OpARMCMPshiftRAreg(v)
   132  	case OpARMCMPshiftRL:
   133  		return rewriteValueARM_OpARMCMPshiftRL(v)
   134  	case OpARMCMPshiftRLreg:
   135  		return rewriteValueARM_OpARMCMPshiftRLreg(v)
   136  	case OpARMEqual:
   137  		return rewriteValueARM_OpARMEqual(v)
   138  	case OpARMGreaterEqual:
   139  		return rewriteValueARM_OpARMGreaterEqual(v)
   140  	case OpARMGreaterEqualU:
   141  		return rewriteValueARM_OpARMGreaterEqualU(v)
   142  	case OpARMGreaterThan:
   143  		return rewriteValueARM_OpARMGreaterThan(v)
   144  	case OpARMGreaterThanU:
   145  		return rewriteValueARM_OpARMGreaterThanU(v)
   146  	case OpARMLessEqual:
   147  		return rewriteValueARM_OpARMLessEqual(v)
   148  	case OpARMLessEqualU:
   149  		return rewriteValueARM_OpARMLessEqualU(v)
   150  	case OpARMLessThan:
   151  		return rewriteValueARM_OpARMLessThan(v)
   152  	case OpARMLessThanU:
   153  		return rewriteValueARM_OpARMLessThanU(v)
   154  	case OpARMLoweredPanicBoundsRC:
   155  		return rewriteValueARM_OpARMLoweredPanicBoundsRC(v)
   156  	case OpARMLoweredPanicBoundsRR:
   157  		return rewriteValueARM_OpARMLoweredPanicBoundsRR(v)
   158  	case OpARMLoweredPanicExtendRC:
   159  		return rewriteValueARM_OpARMLoweredPanicExtendRC(v)
   160  	case OpARMLoweredPanicExtendRR:
   161  		return rewriteValueARM_OpARMLoweredPanicExtendRR(v)
   162  	case OpARMMOVBUload:
   163  		return rewriteValueARM_OpARMMOVBUload(v)
   164  	case OpARMMOVBUloadidx:
   165  		return rewriteValueARM_OpARMMOVBUloadidx(v)
   166  	case OpARMMOVBUreg:
   167  		return rewriteValueARM_OpARMMOVBUreg(v)
   168  	case OpARMMOVBload:
   169  		return rewriteValueARM_OpARMMOVBload(v)
   170  	case OpARMMOVBloadidx:
   171  		return rewriteValueARM_OpARMMOVBloadidx(v)
   172  	case OpARMMOVBreg:
   173  		return rewriteValueARM_OpARMMOVBreg(v)
   174  	case OpARMMOVBstore:
   175  		return rewriteValueARM_OpARMMOVBstore(v)
   176  	case OpARMMOVBstoreidx:
   177  		return rewriteValueARM_OpARMMOVBstoreidx(v)
   178  	case OpARMMOVDload:
   179  		return rewriteValueARM_OpARMMOVDload(v)
   180  	case OpARMMOVDstore:
   181  		return rewriteValueARM_OpARMMOVDstore(v)
   182  	case OpARMMOVFload:
   183  		return rewriteValueARM_OpARMMOVFload(v)
   184  	case OpARMMOVFstore:
   185  		return rewriteValueARM_OpARMMOVFstore(v)
   186  	case OpARMMOVHUload:
   187  		return rewriteValueARM_OpARMMOVHUload(v)
   188  	case OpARMMOVHUloadidx:
   189  		return rewriteValueARM_OpARMMOVHUloadidx(v)
   190  	case OpARMMOVHUreg:
   191  		return rewriteValueARM_OpARMMOVHUreg(v)
   192  	case OpARMMOVHload:
   193  		return rewriteValueARM_OpARMMOVHload(v)
   194  	case OpARMMOVHloadidx:
   195  		return rewriteValueARM_OpARMMOVHloadidx(v)
   196  	case OpARMMOVHreg:
   197  		return rewriteValueARM_OpARMMOVHreg(v)
   198  	case OpARMMOVHstore:
   199  		return rewriteValueARM_OpARMMOVHstore(v)
   200  	case OpARMMOVHstoreidx:
   201  		return rewriteValueARM_OpARMMOVHstoreidx(v)
   202  	case OpARMMOVWload:
   203  		return rewriteValueARM_OpARMMOVWload(v)
   204  	case OpARMMOVWloadidx:
   205  		return rewriteValueARM_OpARMMOVWloadidx(v)
   206  	case OpARMMOVWloadshiftLL:
   207  		return rewriteValueARM_OpARMMOVWloadshiftLL(v)
   208  	case OpARMMOVWloadshiftRA:
   209  		return rewriteValueARM_OpARMMOVWloadshiftRA(v)
   210  	case OpARMMOVWloadshiftRL:
   211  		return rewriteValueARM_OpARMMOVWloadshiftRL(v)
   212  	case OpARMMOVWnop:
   213  		return rewriteValueARM_OpARMMOVWnop(v)
   214  	case OpARMMOVWreg:
   215  		return rewriteValueARM_OpARMMOVWreg(v)
   216  	case OpARMMOVWstore:
   217  		return rewriteValueARM_OpARMMOVWstore(v)
   218  	case OpARMMOVWstoreidx:
   219  		return rewriteValueARM_OpARMMOVWstoreidx(v)
   220  	case OpARMMOVWstoreshiftLL:
   221  		return rewriteValueARM_OpARMMOVWstoreshiftLL(v)
   222  	case OpARMMOVWstoreshiftRA:
   223  		return rewriteValueARM_OpARMMOVWstoreshiftRA(v)
   224  	case OpARMMOVWstoreshiftRL:
   225  		return rewriteValueARM_OpARMMOVWstoreshiftRL(v)
   226  	case OpARMMUL:
   227  		return rewriteValueARM_OpARMMUL(v)
   228  	case OpARMMULA:
   229  		return rewriteValueARM_OpARMMULA(v)
   230  	case OpARMMULD:
   231  		return rewriteValueARM_OpARMMULD(v)
   232  	case OpARMMULF:
   233  		return rewriteValueARM_OpARMMULF(v)
   234  	case OpARMMULS:
   235  		return rewriteValueARM_OpARMMULS(v)
   236  	case OpARMMVN:
   237  		return rewriteValueARM_OpARMMVN(v)
   238  	case OpARMMVNshiftLL:
   239  		return rewriteValueARM_OpARMMVNshiftLL(v)
   240  	case OpARMMVNshiftLLreg:
   241  		return rewriteValueARM_OpARMMVNshiftLLreg(v)
   242  	case OpARMMVNshiftRA:
   243  		return rewriteValueARM_OpARMMVNshiftRA(v)
   244  	case OpARMMVNshiftRAreg:
   245  		return rewriteValueARM_OpARMMVNshiftRAreg(v)
   246  	case OpARMMVNshiftRL:
   247  		return rewriteValueARM_OpARMMVNshiftRL(v)
   248  	case OpARMMVNshiftRLreg:
   249  		return rewriteValueARM_OpARMMVNshiftRLreg(v)
   250  	case OpARMNEGD:
   251  		return rewriteValueARM_OpARMNEGD(v)
   252  	case OpARMNEGF:
   253  		return rewriteValueARM_OpARMNEGF(v)
   254  	case OpARMNMULD:
   255  		return rewriteValueARM_OpARMNMULD(v)
   256  	case OpARMNMULF:
   257  		return rewriteValueARM_OpARMNMULF(v)
   258  	case OpARMNotEqual:
   259  		return rewriteValueARM_OpARMNotEqual(v)
   260  	case OpARMOR:
   261  		return rewriteValueARM_OpARMOR(v)
   262  	case OpARMORconst:
   263  		return rewriteValueARM_OpARMORconst(v)
   264  	case OpARMORshiftLL:
   265  		return rewriteValueARM_OpARMORshiftLL(v)
   266  	case OpARMORshiftLLreg:
   267  		return rewriteValueARM_OpARMORshiftLLreg(v)
   268  	case OpARMORshiftRA:
   269  		return rewriteValueARM_OpARMORshiftRA(v)
   270  	case OpARMORshiftRAreg:
   271  		return rewriteValueARM_OpARMORshiftRAreg(v)
   272  	case OpARMORshiftRL:
   273  		return rewriteValueARM_OpARMORshiftRL(v)
   274  	case OpARMORshiftRLreg:
   275  		return rewriteValueARM_OpARMORshiftRLreg(v)
   276  	case OpARMRSB:
   277  		return rewriteValueARM_OpARMRSB(v)
   278  	case OpARMRSBSshiftLL:
   279  		return rewriteValueARM_OpARMRSBSshiftLL(v)
   280  	case OpARMRSBSshiftLLreg:
   281  		return rewriteValueARM_OpARMRSBSshiftLLreg(v)
   282  	case OpARMRSBSshiftRA:
   283  		return rewriteValueARM_OpARMRSBSshiftRA(v)
   284  	case OpARMRSBSshiftRAreg:
   285  		return rewriteValueARM_OpARMRSBSshiftRAreg(v)
   286  	case OpARMRSBSshiftRL:
   287  		return rewriteValueARM_OpARMRSBSshiftRL(v)
   288  	case OpARMRSBSshiftRLreg:
   289  		return rewriteValueARM_OpARMRSBSshiftRLreg(v)
   290  	case OpARMRSBconst:
   291  		return rewriteValueARM_OpARMRSBconst(v)
   292  	case OpARMRSBshiftLL:
   293  		return rewriteValueARM_OpARMRSBshiftLL(v)
   294  	case OpARMRSBshiftLLreg:
   295  		return rewriteValueARM_OpARMRSBshiftLLreg(v)
   296  	case OpARMRSBshiftRA:
   297  		return rewriteValueARM_OpARMRSBshiftRA(v)
   298  	case OpARMRSBshiftRAreg:
   299  		return rewriteValueARM_OpARMRSBshiftRAreg(v)
   300  	case OpARMRSBshiftRL:
   301  		return rewriteValueARM_OpARMRSBshiftRL(v)
   302  	case OpARMRSBshiftRLreg:
   303  		return rewriteValueARM_OpARMRSBshiftRLreg(v)
   304  	case OpARMRSCconst:
   305  		return rewriteValueARM_OpARMRSCconst(v)
   306  	case OpARMRSCshiftLL:
   307  		return rewriteValueARM_OpARMRSCshiftLL(v)
   308  	case OpARMRSCshiftLLreg:
   309  		return rewriteValueARM_OpARMRSCshiftLLreg(v)
   310  	case OpARMRSCshiftRA:
   311  		return rewriteValueARM_OpARMRSCshiftRA(v)
   312  	case OpARMRSCshiftRAreg:
   313  		return rewriteValueARM_OpARMRSCshiftRAreg(v)
   314  	case OpARMRSCshiftRL:
   315  		return rewriteValueARM_OpARMRSCshiftRL(v)
   316  	case OpARMRSCshiftRLreg:
   317  		return rewriteValueARM_OpARMRSCshiftRLreg(v)
   318  	case OpARMSBC:
   319  		return rewriteValueARM_OpARMSBC(v)
   320  	case OpARMSBCconst:
   321  		return rewriteValueARM_OpARMSBCconst(v)
   322  	case OpARMSBCshiftLL:
   323  		return rewriteValueARM_OpARMSBCshiftLL(v)
   324  	case OpARMSBCshiftLLreg:
   325  		return rewriteValueARM_OpARMSBCshiftLLreg(v)
   326  	case OpARMSBCshiftRA:
   327  		return rewriteValueARM_OpARMSBCshiftRA(v)
   328  	case OpARMSBCshiftRAreg:
   329  		return rewriteValueARM_OpARMSBCshiftRAreg(v)
   330  	case OpARMSBCshiftRL:
   331  		return rewriteValueARM_OpARMSBCshiftRL(v)
   332  	case OpARMSBCshiftRLreg:
   333  		return rewriteValueARM_OpARMSBCshiftRLreg(v)
   334  	case OpARMSLL:
   335  		return rewriteValueARM_OpARMSLL(v)
   336  	case OpARMSLLconst:
   337  		return rewriteValueARM_OpARMSLLconst(v)
   338  	case OpARMSRA:
   339  		return rewriteValueARM_OpARMSRA(v)
   340  	case OpARMSRAcond:
   341  		return rewriteValueARM_OpARMSRAcond(v)
   342  	case OpARMSRAconst:
   343  		return rewriteValueARM_OpARMSRAconst(v)
   344  	case OpARMSRL:
   345  		return rewriteValueARM_OpARMSRL(v)
   346  	case OpARMSRLconst:
   347  		return rewriteValueARM_OpARMSRLconst(v)
   348  	case OpARMSRR:
   349  		return rewriteValueARM_OpARMSRR(v)
   350  	case OpARMSUB:
   351  		return rewriteValueARM_OpARMSUB(v)
   352  	case OpARMSUBD:
   353  		return rewriteValueARM_OpARMSUBD(v)
   354  	case OpARMSUBF:
   355  		return rewriteValueARM_OpARMSUBF(v)
   356  	case OpARMSUBS:
   357  		return rewriteValueARM_OpARMSUBS(v)
   358  	case OpARMSUBSshiftLL:
   359  		return rewriteValueARM_OpARMSUBSshiftLL(v)
   360  	case OpARMSUBSshiftLLreg:
   361  		return rewriteValueARM_OpARMSUBSshiftLLreg(v)
   362  	case OpARMSUBSshiftRA:
   363  		return rewriteValueARM_OpARMSUBSshiftRA(v)
   364  	case OpARMSUBSshiftRAreg:
   365  		return rewriteValueARM_OpARMSUBSshiftRAreg(v)
   366  	case OpARMSUBSshiftRL:
   367  		return rewriteValueARM_OpARMSUBSshiftRL(v)
   368  	case OpARMSUBSshiftRLreg:
   369  		return rewriteValueARM_OpARMSUBSshiftRLreg(v)
   370  	case OpARMSUBconst:
   371  		return rewriteValueARM_OpARMSUBconst(v)
   372  	case OpARMSUBshiftLL:
   373  		return rewriteValueARM_OpARMSUBshiftLL(v)
   374  	case OpARMSUBshiftLLreg:
   375  		return rewriteValueARM_OpARMSUBshiftLLreg(v)
   376  	case OpARMSUBshiftRA:
   377  		return rewriteValueARM_OpARMSUBshiftRA(v)
   378  	case OpARMSUBshiftRAreg:
   379  		return rewriteValueARM_OpARMSUBshiftRAreg(v)
   380  	case OpARMSUBshiftRL:
   381  		return rewriteValueARM_OpARMSUBshiftRL(v)
   382  	case OpARMSUBshiftRLreg:
   383  		return rewriteValueARM_OpARMSUBshiftRLreg(v)
   384  	case OpARMTEQ:
   385  		return rewriteValueARM_OpARMTEQ(v)
   386  	case OpARMTEQconst:
   387  		return rewriteValueARM_OpARMTEQconst(v)
   388  	case OpARMTEQshiftLL:
   389  		return rewriteValueARM_OpARMTEQshiftLL(v)
   390  	case OpARMTEQshiftLLreg:
   391  		return rewriteValueARM_OpARMTEQshiftLLreg(v)
   392  	case OpARMTEQshiftRA:
   393  		return rewriteValueARM_OpARMTEQshiftRA(v)
   394  	case OpARMTEQshiftRAreg:
   395  		return rewriteValueARM_OpARMTEQshiftRAreg(v)
   396  	case OpARMTEQshiftRL:
   397  		return rewriteValueARM_OpARMTEQshiftRL(v)
   398  	case OpARMTEQshiftRLreg:
   399  		return rewriteValueARM_OpARMTEQshiftRLreg(v)
   400  	case OpARMTST:
   401  		return rewriteValueARM_OpARMTST(v)
   402  	case OpARMTSTconst:
   403  		return rewriteValueARM_OpARMTSTconst(v)
   404  	case OpARMTSTshiftLL:
   405  		return rewriteValueARM_OpARMTSTshiftLL(v)
   406  	case OpARMTSTshiftLLreg:
   407  		return rewriteValueARM_OpARMTSTshiftLLreg(v)
   408  	case OpARMTSTshiftRA:
   409  		return rewriteValueARM_OpARMTSTshiftRA(v)
   410  	case OpARMTSTshiftRAreg:
   411  		return rewriteValueARM_OpARMTSTshiftRAreg(v)
   412  	case OpARMTSTshiftRL:
   413  		return rewriteValueARM_OpARMTSTshiftRL(v)
   414  	case OpARMTSTshiftRLreg:
   415  		return rewriteValueARM_OpARMTSTshiftRLreg(v)
   416  	case OpARMXOR:
   417  		return rewriteValueARM_OpARMXOR(v)
   418  	case OpARMXORconst:
   419  		return rewriteValueARM_OpARMXORconst(v)
   420  	case OpARMXORshiftLL:
   421  		return rewriteValueARM_OpARMXORshiftLL(v)
   422  	case OpARMXORshiftLLreg:
   423  		return rewriteValueARM_OpARMXORshiftLLreg(v)
   424  	case OpARMXORshiftRA:
   425  		return rewriteValueARM_OpARMXORshiftRA(v)
   426  	case OpARMXORshiftRAreg:
   427  		return rewriteValueARM_OpARMXORshiftRAreg(v)
   428  	case OpARMXORshiftRL:
   429  		return rewriteValueARM_OpARMXORshiftRL(v)
   430  	case OpARMXORshiftRLreg:
   431  		return rewriteValueARM_OpARMXORshiftRLreg(v)
   432  	case OpARMXORshiftRR:
   433  		return rewriteValueARM_OpARMXORshiftRR(v)
   434  	case OpAbs:
   435  		v.Op = OpARMABSD
   436  		return true
   437  	case OpAdd16:
   438  		v.Op = OpARMADD
   439  		return true
   440  	case OpAdd32:
   441  		v.Op = OpARMADD
   442  		return true
   443  	case OpAdd32F:
   444  		v.Op = OpARMADDF
   445  		return true
   446  	case OpAdd32carry:
   447  		v.Op = OpARMADDS
   448  		return true
   449  	case OpAdd32carrywithcarry:
   450  		v.Op = OpARMADCS
   451  		return true
   452  	case OpAdd32withcarry:
   453  		v.Op = OpARMADC
   454  		return true
   455  	case OpAdd64F:
   456  		v.Op = OpARMADDD
   457  		return true
   458  	case OpAdd8:
   459  		v.Op = OpARMADD
   460  		return true
   461  	case OpAddPtr:
   462  		v.Op = OpARMADD
   463  		return true
   464  	case OpAddr:
   465  		return rewriteValueARM_OpAddr(v)
   466  	case OpAnd16:
   467  		v.Op = OpARMAND
   468  		return true
   469  	case OpAnd32:
   470  		v.Op = OpARMAND
   471  		return true
   472  	case OpAnd8:
   473  		v.Op = OpARMAND
   474  		return true
   475  	case OpAndB:
   476  		v.Op = OpARMAND
   477  		return true
   478  	case OpAvg32u:
   479  		return rewriteValueARM_OpAvg32u(v)
   480  	case OpBitLen16:
   481  		return rewriteValueARM_OpBitLen16(v)
   482  	case OpBitLen32:
   483  		return rewriteValueARM_OpBitLen32(v)
   484  	case OpBitLen8:
   485  		return rewriteValueARM_OpBitLen8(v)
   486  	case OpBswap32:
   487  		return rewriteValueARM_OpBswap32(v)
   488  	case OpClosureCall:
   489  		v.Op = OpARMCALLclosure
   490  		return true
   491  	case OpCom16:
   492  		v.Op = OpARMMVN
   493  		return true
   494  	case OpCom32:
   495  		v.Op = OpARMMVN
   496  		return true
   497  	case OpCom8:
   498  		v.Op = OpARMMVN
   499  		return true
   500  	case OpConst16:
   501  		return rewriteValueARM_OpConst16(v)
   502  	case OpConst32:
   503  		return rewriteValueARM_OpConst32(v)
   504  	case OpConst32F:
   505  		return rewriteValueARM_OpConst32F(v)
   506  	case OpConst64F:
   507  		return rewriteValueARM_OpConst64F(v)
   508  	case OpConst8:
   509  		return rewriteValueARM_OpConst8(v)
   510  	case OpConstBool:
   511  		return rewriteValueARM_OpConstBool(v)
   512  	case OpConstNil:
   513  		return rewriteValueARM_OpConstNil(v)
   514  	case OpCtz16:
   515  		return rewriteValueARM_OpCtz16(v)
   516  	case OpCtz16NonZero:
   517  		v.Op = OpCtz32
   518  		return true
   519  	case OpCtz32:
   520  		return rewriteValueARM_OpCtz32(v)
   521  	case OpCtz32NonZero:
   522  		v.Op = OpCtz32
   523  		return true
   524  	case OpCtz8:
   525  		return rewriteValueARM_OpCtz8(v)
   526  	case OpCtz8NonZero:
   527  		v.Op = OpCtz32
   528  		return true
   529  	case OpCvt32Fto32:
   530  		v.Op = OpARMMOVFW
   531  		return true
   532  	case OpCvt32Fto32U:
   533  		v.Op = OpARMMOVFWU
   534  		return true
   535  	case OpCvt32Fto64F:
   536  		v.Op = OpARMMOVFD
   537  		return true
   538  	case OpCvt32Uto32F:
   539  		v.Op = OpARMMOVWUF
   540  		return true
   541  	case OpCvt32Uto64F:
   542  		v.Op = OpARMMOVWUD
   543  		return true
   544  	case OpCvt32to32F:
   545  		v.Op = OpARMMOVWF
   546  		return true
   547  	case OpCvt32to64F:
   548  		v.Op = OpARMMOVWD
   549  		return true
   550  	case OpCvt64Fto32:
   551  		v.Op = OpARMMOVDW
   552  		return true
   553  	case OpCvt64Fto32F:
   554  		v.Op = OpARMMOVDF
   555  		return true
   556  	case OpCvt64Fto32U:
   557  		v.Op = OpARMMOVDWU
   558  		return true
   559  	case OpCvtBoolToUint8:
   560  		v.Op = OpCopy
   561  		return true
   562  	case OpDiv16:
   563  		return rewriteValueARM_OpDiv16(v)
   564  	case OpDiv16u:
   565  		return rewriteValueARM_OpDiv16u(v)
   566  	case OpDiv32:
   567  		return rewriteValueARM_OpDiv32(v)
   568  	case OpDiv32F:
   569  		v.Op = OpARMDIVF
   570  		return true
   571  	case OpDiv32u:
   572  		return rewriteValueARM_OpDiv32u(v)
   573  	case OpDiv64F:
   574  		v.Op = OpARMDIVD
   575  		return true
   576  	case OpDiv8:
   577  		return rewriteValueARM_OpDiv8(v)
   578  	case OpDiv8u:
   579  		return rewriteValueARM_OpDiv8u(v)
   580  	case OpEq16:
   581  		return rewriteValueARM_OpEq16(v)
   582  	case OpEq32:
   583  		return rewriteValueARM_OpEq32(v)
   584  	case OpEq32F:
   585  		return rewriteValueARM_OpEq32F(v)
   586  	case OpEq64F:
   587  		return rewriteValueARM_OpEq64F(v)
   588  	case OpEq8:
   589  		return rewriteValueARM_OpEq8(v)
   590  	case OpEqB:
   591  		return rewriteValueARM_OpEqB(v)
   592  	case OpEqPtr:
   593  		return rewriteValueARM_OpEqPtr(v)
   594  	case OpFMA:
   595  		return rewriteValueARM_OpFMA(v)
   596  	case OpGetCallerPC:
   597  		v.Op = OpARMLoweredGetCallerPC
   598  		return true
   599  	case OpGetCallerSP:
   600  		v.Op = OpARMLoweredGetCallerSP
   601  		return true
   602  	case OpGetClosurePtr:
   603  		v.Op = OpARMLoweredGetClosurePtr
   604  		return true
   605  	case OpHmul32:
   606  		v.Op = OpARMHMUL
   607  		return true
   608  	case OpHmul32u:
   609  		v.Op = OpARMHMULU
   610  		return true
   611  	case OpInterCall:
   612  		v.Op = OpARMCALLinter
   613  		return true
   614  	case OpIsInBounds:
   615  		return rewriteValueARM_OpIsInBounds(v)
   616  	case OpIsNonNil:
   617  		return rewriteValueARM_OpIsNonNil(v)
   618  	case OpIsSliceInBounds:
   619  		return rewriteValueARM_OpIsSliceInBounds(v)
   620  	case OpLeq16:
   621  		return rewriteValueARM_OpLeq16(v)
   622  	case OpLeq16U:
   623  		return rewriteValueARM_OpLeq16U(v)
   624  	case OpLeq32:
   625  		return rewriteValueARM_OpLeq32(v)
   626  	case OpLeq32F:
   627  		return rewriteValueARM_OpLeq32F(v)
   628  	case OpLeq32U:
   629  		return rewriteValueARM_OpLeq32U(v)
   630  	case OpLeq64F:
   631  		return rewriteValueARM_OpLeq64F(v)
   632  	case OpLeq8:
   633  		return rewriteValueARM_OpLeq8(v)
   634  	case OpLeq8U:
   635  		return rewriteValueARM_OpLeq8U(v)
   636  	case OpLess16:
   637  		return rewriteValueARM_OpLess16(v)
   638  	case OpLess16U:
   639  		return rewriteValueARM_OpLess16U(v)
   640  	case OpLess32:
   641  		return rewriteValueARM_OpLess32(v)
   642  	case OpLess32F:
   643  		return rewriteValueARM_OpLess32F(v)
   644  	case OpLess32U:
   645  		return rewriteValueARM_OpLess32U(v)
   646  	case OpLess64F:
   647  		return rewriteValueARM_OpLess64F(v)
   648  	case OpLess8:
   649  		return rewriteValueARM_OpLess8(v)
   650  	case OpLess8U:
   651  		return rewriteValueARM_OpLess8U(v)
   652  	case OpLoad:
   653  		return rewriteValueARM_OpLoad(v)
   654  	case OpLocalAddr:
   655  		return rewriteValueARM_OpLocalAddr(v)
   656  	case OpLsh16x16:
   657  		return rewriteValueARM_OpLsh16x16(v)
   658  	case OpLsh16x32:
   659  		return rewriteValueARM_OpLsh16x32(v)
   660  	case OpLsh16x64:
   661  		return rewriteValueARM_OpLsh16x64(v)
   662  	case OpLsh16x8:
   663  		return rewriteValueARM_OpLsh16x8(v)
   664  	case OpLsh32x16:
   665  		return rewriteValueARM_OpLsh32x16(v)
   666  	case OpLsh32x32:
   667  		return rewriteValueARM_OpLsh32x32(v)
   668  	case OpLsh32x64:
   669  		return rewriteValueARM_OpLsh32x64(v)
   670  	case OpLsh32x8:
   671  		return rewriteValueARM_OpLsh32x8(v)
   672  	case OpLsh8x16:
   673  		return rewriteValueARM_OpLsh8x16(v)
   674  	case OpLsh8x32:
   675  		return rewriteValueARM_OpLsh8x32(v)
   676  	case OpLsh8x64:
   677  		return rewriteValueARM_OpLsh8x64(v)
   678  	case OpLsh8x8:
   679  		return rewriteValueARM_OpLsh8x8(v)
   680  	case OpMod16:
   681  		return rewriteValueARM_OpMod16(v)
   682  	case OpMod16u:
   683  		return rewriteValueARM_OpMod16u(v)
   684  	case OpMod32:
   685  		return rewriteValueARM_OpMod32(v)
   686  	case OpMod32u:
   687  		return rewriteValueARM_OpMod32u(v)
   688  	case OpMod8:
   689  		return rewriteValueARM_OpMod8(v)
   690  	case OpMod8u:
   691  		return rewriteValueARM_OpMod8u(v)
   692  	case OpMove:
   693  		return rewriteValueARM_OpMove(v)
   694  	case OpMul16:
   695  		v.Op = OpARMMUL
   696  		return true
   697  	case OpMul32:
   698  		v.Op = OpARMMUL
   699  		return true
   700  	case OpMul32F:
   701  		v.Op = OpARMMULF
   702  		return true
   703  	case OpMul32uhilo:
   704  		v.Op = OpARMMULLU
   705  		return true
   706  	case OpMul64F:
   707  		v.Op = OpARMMULD
   708  		return true
   709  	case OpMul8:
   710  		v.Op = OpARMMUL
   711  		return true
   712  	case OpNeg16:
   713  		return rewriteValueARM_OpNeg16(v)
   714  	case OpNeg32:
   715  		return rewriteValueARM_OpNeg32(v)
   716  	case OpNeg32F:
   717  		v.Op = OpARMNEGF
   718  		return true
   719  	case OpNeg64F:
   720  		v.Op = OpARMNEGD
   721  		return true
   722  	case OpNeg8:
   723  		return rewriteValueARM_OpNeg8(v)
   724  	case OpNeq16:
   725  		return rewriteValueARM_OpNeq16(v)
   726  	case OpNeq32:
   727  		return rewriteValueARM_OpNeq32(v)
   728  	case OpNeq32F:
   729  		return rewriteValueARM_OpNeq32F(v)
   730  	case OpNeq64F:
   731  		return rewriteValueARM_OpNeq64F(v)
   732  	case OpNeq8:
   733  		return rewriteValueARM_OpNeq8(v)
   734  	case OpNeqB:
   735  		v.Op = OpARMXOR
   736  		return true
   737  	case OpNeqPtr:
   738  		return rewriteValueARM_OpNeqPtr(v)
   739  	case OpNilCheck:
   740  		v.Op = OpARMLoweredNilCheck
   741  		return true
   742  	case OpNot:
   743  		return rewriteValueARM_OpNot(v)
   744  	case OpOffPtr:
   745  		return rewriteValueARM_OpOffPtr(v)
   746  	case OpOr16:
   747  		v.Op = OpARMOR
   748  		return true
   749  	case OpOr32:
   750  		v.Op = OpARMOR
   751  		return true
   752  	case OpOr8:
   753  		v.Op = OpARMOR
   754  		return true
   755  	case OpOrB:
   756  		v.Op = OpARMOR
   757  		return true
   758  	case OpPanicBounds:
   759  		v.Op = OpARMLoweredPanicBoundsRR
   760  		return true
   761  	case OpPanicExtend:
   762  		v.Op = OpARMLoweredPanicExtendRR
   763  		return true
   764  	case OpRotateLeft16:
   765  		return rewriteValueARM_OpRotateLeft16(v)
   766  	case OpRotateLeft32:
   767  		return rewriteValueARM_OpRotateLeft32(v)
   768  	case OpRotateLeft8:
   769  		return rewriteValueARM_OpRotateLeft8(v)
   770  	case OpRound32F:
   771  		v.Op = OpCopy
   772  		return true
   773  	case OpRound64F:
   774  		v.Op = OpCopy
   775  		return true
   776  	case OpRsh16Ux16:
   777  		return rewriteValueARM_OpRsh16Ux16(v)
   778  	case OpRsh16Ux32:
   779  		return rewriteValueARM_OpRsh16Ux32(v)
   780  	case OpRsh16Ux64:
   781  		return rewriteValueARM_OpRsh16Ux64(v)
   782  	case OpRsh16Ux8:
   783  		return rewriteValueARM_OpRsh16Ux8(v)
   784  	case OpRsh16x16:
   785  		return rewriteValueARM_OpRsh16x16(v)
   786  	case OpRsh16x32:
   787  		return rewriteValueARM_OpRsh16x32(v)
   788  	case OpRsh16x64:
   789  		return rewriteValueARM_OpRsh16x64(v)
   790  	case OpRsh16x8:
   791  		return rewriteValueARM_OpRsh16x8(v)
   792  	case OpRsh32Ux16:
   793  		return rewriteValueARM_OpRsh32Ux16(v)
   794  	case OpRsh32Ux32:
   795  		return rewriteValueARM_OpRsh32Ux32(v)
   796  	case OpRsh32Ux64:
   797  		return rewriteValueARM_OpRsh32Ux64(v)
   798  	case OpRsh32Ux8:
   799  		return rewriteValueARM_OpRsh32Ux8(v)
   800  	case OpRsh32x16:
   801  		return rewriteValueARM_OpRsh32x16(v)
   802  	case OpRsh32x32:
   803  		return rewriteValueARM_OpRsh32x32(v)
   804  	case OpRsh32x64:
   805  		return rewriteValueARM_OpRsh32x64(v)
   806  	case OpRsh32x8:
   807  		return rewriteValueARM_OpRsh32x8(v)
   808  	case OpRsh8Ux16:
   809  		return rewriteValueARM_OpRsh8Ux16(v)
   810  	case OpRsh8Ux32:
   811  		return rewriteValueARM_OpRsh8Ux32(v)
   812  	case OpRsh8Ux64:
   813  		return rewriteValueARM_OpRsh8Ux64(v)
   814  	case OpRsh8Ux8:
   815  		return rewriteValueARM_OpRsh8Ux8(v)
   816  	case OpRsh8x16:
   817  		return rewriteValueARM_OpRsh8x16(v)
   818  	case OpRsh8x32:
   819  		return rewriteValueARM_OpRsh8x32(v)
   820  	case OpRsh8x64:
   821  		return rewriteValueARM_OpRsh8x64(v)
   822  	case OpRsh8x8:
   823  		return rewriteValueARM_OpRsh8x8(v)
   824  	case OpSelect0:
   825  		return rewriteValueARM_OpSelect0(v)
   826  	case OpSelect1:
   827  		return rewriteValueARM_OpSelect1(v)
   828  	case OpSignExt16to32:
   829  		v.Op = OpARMMOVHreg
   830  		return true
   831  	case OpSignExt8to16:
   832  		v.Op = OpARMMOVBreg
   833  		return true
   834  	case OpSignExt8to32:
   835  		v.Op = OpARMMOVBreg
   836  		return true
   837  	case OpSignmask:
   838  		return rewriteValueARM_OpSignmask(v)
   839  	case OpSlicemask:
   840  		return rewriteValueARM_OpSlicemask(v)
   841  	case OpSqrt:
   842  		v.Op = OpARMSQRTD
   843  		return true
   844  	case OpSqrt32:
   845  		v.Op = OpARMSQRTF
   846  		return true
   847  	case OpStaticCall:
   848  		v.Op = OpARMCALLstatic
   849  		return true
   850  	case OpStore:
   851  		return rewriteValueARM_OpStore(v)
   852  	case OpSub16:
   853  		v.Op = OpARMSUB
   854  		return true
   855  	case OpSub32:
   856  		v.Op = OpARMSUB
   857  		return true
   858  	case OpSub32F:
   859  		v.Op = OpARMSUBF
   860  		return true
   861  	case OpSub32carry:
   862  		v.Op = OpARMSUBS
   863  		return true
   864  	case OpSub32withcarry:
   865  		v.Op = OpARMSBC
   866  		return true
   867  	case OpSub64F:
   868  		v.Op = OpARMSUBD
   869  		return true
   870  	case OpSub8:
   871  		v.Op = OpARMSUB
   872  		return true
   873  	case OpSubPtr:
   874  		v.Op = OpARMSUB
   875  		return true
   876  	case OpTailCall:
   877  		v.Op = OpARMCALLtail
   878  		return true
   879  	case OpTailCallInter:
   880  		v.Op = OpARMCALLtailinter
   881  		return true
   882  	case OpTrunc16to8:
   883  		v.Op = OpCopy
   884  		return true
   885  	case OpTrunc32to16:
   886  		v.Op = OpCopy
   887  		return true
   888  	case OpTrunc32to8:
   889  		v.Op = OpCopy
   890  		return true
   891  	case OpWB:
   892  		v.Op = OpARMLoweredWB
   893  		return true
   894  	case OpXor16:
   895  		v.Op = OpARMXOR
   896  		return true
   897  	case OpXor32:
   898  		v.Op = OpARMXOR
   899  		return true
   900  	case OpXor8:
   901  		v.Op = OpARMXOR
   902  		return true
   903  	case OpZero:
   904  		return rewriteValueARM_OpZero(v)
   905  	case OpZeroExt16to32:
   906  		v.Op = OpARMMOVHUreg
   907  		return true
   908  	case OpZeroExt8to16:
   909  		v.Op = OpARMMOVBUreg
   910  		return true
   911  	case OpZeroExt8to32:
   912  		v.Op = OpARMMOVBUreg
   913  		return true
   914  	case OpZeromask:
   915  		return rewriteValueARM_OpZeromask(v)
   916  	}
   917  	return false
   918  }
   919  func rewriteValueARM_OpARMADC(v *Value) bool {
   920  	v_2 := v.Args[2]
   921  	v_1 := v.Args[1]
   922  	v_0 := v.Args[0]
   923  	// match: (ADC (MOVWconst [c]) x flags)
   924  	// result: (ADCconst [c] x flags)
   925  	for {
   926  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   927  			if v_0.Op != OpARMMOVWconst {
   928  				continue
   929  			}
   930  			c := auxIntToInt32(v_0.AuxInt)
   931  			x := v_1
   932  			flags := v_2
   933  			v.reset(OpARMADCconst)
   934  			v.AuxInt = int32ToAuxInt(c)
   935  			v.AddArg2(x, flags)
   936  			return true
   937  		}
   938  		break
   939  	}
   940  	// match: (ADC x (SLLconst [c] y) flags)
   941  	// result: (ADCshiftLL x y [c] flags)
   942  	for {
   943  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   944  			x := v_0
   945  			if v_1.Op != OpARMSLLconst {
   946  				continue
   947  			}
   948  			c := auxIntToInt32(v_1.AuxInt)
   949  			y := v_1.Args[0]
   950  			flags := v_2
   951  			v.reset(OpARMADCshiftLL)
   952  			v.AuxInt = int32ToAuxInt(c)
   953  			v.AddArg3(x, y, flags)
   954  			return true
   955  		}
   956  		break
   957  	}
   958  	// match: (ADC x (SRLconst [c] y) flags)
   959  	// result: (ADCshiftRL x y [c] flags)
   960  	for {
   961  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   962  			x := v_0
   963  			if v_1.Op != OpARMSRLconst {
   964  				continue
   965  			}
   966  			c := auxIntToInt32(v_1.AuxInt)
   967  			y := v_1.Args[0]
   968  			flags := v_2
   969  			v.reset(OpARMADCshiftRL)
   970  			v.AuxInt = int32ToAuxInt(c)
   971  			v.AddArg3(x, y, flags)
   972  			return true
   973  		}
   974  		break
   975  	}
   976  	// match: (ADC x (SRAconst [c] y) flags)
   977  	// result: (ADCshiftRA x y [c] flags)
   978  	for {
   979  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   980  			x := v_0
   981  			if v_1.Op != OpARMSRAconst {
   982  				continue
   983  			}
   984  			c := auxIntToInt32(v_1.AuxInt)
   985  			y := v_1.Args[0]
   986  			flags := v_2
   987  			v.reset(OpARMADCshiftRA)
   988  			v.AuxInt = int32ToAuxInt(c)
   989  			v.AddArg3(x, y, flags)
   990  			return true
   991  		}
   992  		break
   993  	}
   994  	// match: (ADC x (SLL y z) flags)
   995  	// result: (ADCshiftLLreg x y z flags)
   996  	for {
   997  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
   998  			x := v_0
   999  			if v_1.Op != OpARMSLL {
  1000  				continue
  1001  			}
  1002  			z := v_1.Args[1]
  1003  			y := v_1.Args[0]
  1004  			flags := v_2
  1005  			v.reset(OpARMADCshiftLLreg)
  1006  			v.AddArg4(x, y, z, flags)
  1007  			return true
  1008  		}
  1009  		break
  1010  	}
  1011  	// match: (ADC x (SRL y z) flags)
  1012  	// result: (ADCshiftRLreg x y z flags)
  1013  	for {
  1014  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1015  			x := v_0
  1016  			if v_1.Op != OpARMSRL {
  1017  				continue
  1018  			}
  1019  			z := v_1.Args[1]
  1020  			y := v_1.Args[0]
  1021  			flags := v_2
  1022  			v.reset(OpARMADCshiftRLreg)
  1023  			v.AddArg4(x, y, z, flags)
  1024  			return true
  1025  		}
  1026  		break
  1027  	}
  1028  	// match: (ADC x (SRA y z) flags)
  1029  	// result: (ADCshiftRAreg x y z flags)
  1030  	for {
  1031  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1032  			x := v_0
  1033  			if v_1.Op != OpARMSRA {
  1034  				continue
  1035  			}
  1036  			z := v_1.Args[1]
  1037  			y := v_1.Args[0]
  1038  			flags := v_2
  1039  			v.reset(OpARMADCshiftRAreg)
  1040  			v.AddArg4(x, y, z, flags)
  1041  			return true
  1042  		}
  1043  		break
  1044  	}
  1045  	return false
  1046  }
  1047  func rewriteValueARM_OpARMADCconst(v *Value) bool {
  1048  	v_1 := v.Args[1]
  1049  	v_0 := v.Args[0]
  1050  	// match: (ADCconst [c] (ADDconst [d] x) flags)
  1051  	// result: (ADCconst [c+d] x flags)
  1052  	for {
  1053  		c := auxIntToInt32(v.AuxInt)
  1054  		if v_0.Op != OpARMADDconst {
  1055  			break
  1056  		}
  1057  		d := auxIntToInt32(v_0.AuxInt)
  1058  		x := v_0.Args[0]
  1059  		flags := v_1
  1060  		v.reset(OpARMADCconst)
  1061  		v.AuxInt = int32ToAuxInt(c + d)
  1062  		v.AddArg2(x, flags)
  1063  		return true
  1064  	}
  1065  	// match: (ADCconst [c] (SUBconst [d] x) flags)
  1066  	// result: (ADCconst [c-d] x flags)
  1067  	for {
  1068  		c := auxIntToInt32(v.AuxInt)
  1069  		if v_0.Op != OpARMSUBconst {
  1070  			break
  1071  		}
  1072  		d := auxIntToInt32(v_0.AuxInt)
  1073  		x := v_0.Args[0]
  1074  		flags := v_1
  1075  		v.reset(OpARMADCconst)
  1076  		v.AuxInt = int32ToAuxInt(c - d)
  1077  		v.AddArg2(x, flags)
  1078  		return true
  1079  	}
  1080  	return false
  1081  }
  1082  func rewriteValueARM_OpARMADCshiftLL(v *Value) bool {
  1083  	v_2 := v.Args[2]
  1084  	v_1 := v.Args[1]
  1085  	v_0 := v.Args[0]
  1086  	b := v.Block
  1087  	// match: (ADCshiftLL (MOVWconst [c]) x [d] flags)
  1088  	// result: (ADCconst [c] (SLLconst <x.Type> x [d]) flags)
  1089  	for {
  1090  		d := auxIntToInt32(v.AuxInt)
  1091  		if v_0.Op != OpARMMOVWconst {
  1092  			break
  1093  		}
  1094  		c := auxIntToInt32(v_0.AuxInt)
  1095  		x := v_1
  1096  		flags := v_2
  1097  		v.reset(OpARMADCconst)
  1098  		v.AuxInt = int32ToAuxInt(c)
  1099  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  1100  		v0.AuxInt = int32ToAuxInt(d)
  1101  		v0.AddArg(x)
  1102  		v.AddArg2(v0, flags)
  1103  		return true
  1104  	}
  1105  	// match: (ADCshiftLL x (MOVWconst [c]) [d] flags)
  1106  	// result: (ADCconst x [c<<uint64(d)] flags)
  1107  	for {
  1108  		d := auxIntToInt32(v.AuxInt)
  1109  		x := v_0
  1110  		if v_1.Op != OpARMMOVWconst {
  1111  			break
  1112  		}
  1113  		c := auxIntToInt32(v_1.AuxInt)
  1114  		flags := v_2
  1115  		v.reset(OpARMADCconst)
  1116  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  1117  		v.AddArg2(x, flags)
  1118  		return true
  1119  	}
  1120  	return false
  1121  }
  1122  func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool {
  1123  	v_3 := v.Args[3]
  1124  	v_2 := v.Args[2]
  1125  	v_1 := v.Args[1]
  1126  	v_0 := v.Args[0]
  1127  	b := v.Block
  1128  	// match: (ADCshiftLLreg (MOVWconst [c]) x y flags)
  1129  	// result: (ADCconst [c] (SLL <x.Type> x y) flags)
  1130  	for {
  1131  		if v_0.Op != OpARMMOVWconst {
  1132  			break
  1133  		}
  1134  		c := auxIntToInt32(v_0.AuxInt)
  1135  		x := v_1
  1136  		y := v_2
  1137  		flags := v_3
  1138  		v.reset(OpARMADCconst)
  1139  		v.AuxInt = int32ToAuxInt(c)
  1140  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  1141  		v0.AddArg2(x, y)
  1142  		v.AddArg2(v0, flags)
  1143  		return true
  1144  	}
  1145  	// match: (ADCshiftLLreg x y (MOVWconst [c]) flags)
  1146  	// cond: 0 <= c && c < 32
  1147  	// result: (ADCshiftLL x y [c] flags)
  1148  	for {
  1149  		x := v_0
  1150  		y := v_1
  1151  		if v_2.Op != OpARMMOVWconst {
  1152  			break
  1153  		}
  1154  		c := auxIntToInt32(v_2.AuxInt)
  1155  		flags := v_3
  1156  		if !(0 <= c && c < 32) {
  1157  			break
  1158  		}
  1159  		v.reset(OpARMADCshiftLL)
  1160  		v.AuxInt = int32ToAuxInt(c)
  1161  		v.AddArg3(x, y, flags)
  1162  		return true
  1163  	}
  1164  	return false
  1165  }
  1166  func rewriteValueARM_OpARMADCshiftRA(v *Value) bool {
  1167  	v_2 := v.Args[2]
  1168  	v_1 := v.Args[1]
  1169  	v_0 := v.Args[0]
  1170  	b := v.Block
  1171  	// match: (ADCshiftRA (MOVWconst [c]) x [d] flags)
  1172  	// result: (ADCconst [c] (SRAconst <x.Type> x [d]) flags)
  1173  	for {
  1174  		d := auxIntToInt32(v.AuxInt)
  1175  		if v_0.Op != OpARMMOVWconst {
  1176  			break
  1177  		}
  1178  		c := auxIntToInt32(v_0.AuxInt)
  1179  		x := v_1
  1180  		flags := v_2
  1181  		v.reset(OpARMADCconst)
  1182  		v.AuxInt = int32ToAuxInt(c)
  1183  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  1184  		v0.AuxInt = int32ToAuxInt(d)
  1185  		v0.AddArg(x)
  1186  		v.AddArg2(v0, flags)
  1187  		return true
  1188  	}
  1189  	// match: (ADCshiftRA x (MOVWconst [c]) [d] flags)
  1190  	// result: (ADCconst x [c>>uint64(d)] flags)
  1191  	for {
  1192  		d := auxIntToInt32(v.AuxInt)
  1193  		x := v_0
  1194  		if v_1.Op != OpARMMOVWconst {
  1195  			break
  1196  		}
  1197  		c := auxIntToInt32(v_1.AuxInt)
  1198  		flags := v_2
  1199  		v.reset(OpARMADCconst)
  1200  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  1201  		v.AddArg2(x, flags)
  1202  		return true
  1203  	}
  1204  	return false
  1205  }
  1206  func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool {
  1207  	v_3 := v.Args[3]
  1208  	v_2 := v.Args[2]
  1209  	v_1 := v.Args[1]
  1210  	v_0 := v.Args[0]
  1211  	b := v.Block
  1212  	// match: (ADCshiftRAreg (MOVWconst [c]) x y flags)
  1213  	// result: (ADCconst [c] (SRA <x.Type> x y) flags)
  1214  	for {
  1215  		if v_0.Op != OpARMMOVWconst {
  1216  			break
  1217  		}
  1218  		c := auxIntToInt32(v_0.AuxInt)
  1219  		x := v_1
  1220  		y := v_2
  1221  		flags := v_3
  1222  		v.reset(OpARMADCconst)
  1223  		v.AuxInt = int32ToAuxInt(c)
  1224  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  1225  		v0.AddArg2(x, y)
  1226  		v.AddArg2(v0, flags)
  1227  		return true
  1228  	}
  1229  	// match: (ADCshiftRAreg x y (MOVWconst [c]) flags)
  1230  	// cond: 0 <= c && c < 32
  1231  	// result: (ADCshiftRA x y [c] flags)
  1232  	for {
  1233  		x := v_0
  1234  		y := v_1
  1235  		if v_2.Op != OpARMMOVWconst {
  1236  			break
  1237  		}
  1238  		c := auxIntToInt32(v_2.AuxInt)
  1239  		flags := v_3
  1240  		if !(0 <= c && c < 32) {
  1241  			break
  1242  		}
  1243  		v.reset(OpARMADCshiftRA)
  1244  		v.AuxInt = int32ToAuxInt(c)
  1245  		v.AddArg3(x, y, flags)
  1246  		return true
  1247  	}
  1248  	return false
  1249  }
  1250  func rewriteValueARM_OpARMADCshiftRL(v *Value) bool {
  1251  	v_2 := v.Args[2]
  1252  	v_1 := v.Args[1]
  1253  	v_0 := v.Args[0]
  1254  	b := v.Block
  1255  	// match: (ADCshiftRL (MOVWconst [c]) x [d] flags)
  1256  	// result: (ADCconst [c] (SRLconst <x.Type> x [d]) flags)
  1257  	for {
  1258  		d := auxIntToInt32(v.AuxInt)
  1259  		if v_0.Op != OpARMMOVWconst {
  1260  			break
  1261  		}
  1262  		c := auxIntToInt32(v_0.AuxInt)
  1263  		x := v_1
  1264  		flags := v_2
  1265  		v.reset(OpARMADCconst)
  1266  		v.AuxInt = int32ToAuxInt(c)
  1267  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  1268  		v0.AuxInt = int32ToAuxInt(d)
  1269  		v0.AddArg(x)
  1270  		v.AddArg2(v0, flags)
  1271  		return true
  1272  	}
  1273  	// match: (ADCshiftRL x (MOVWconst [c]) [d] flags)
  1274  	// result: (ADCconst x [int32(uint32(c)>>uint64(d))] flags)
  1275  	for {
  1276  		d := auxIntToInt32(v.AuxInt)
  1277  		x := v_0
  1278  		if v_1.Op != OpARMMOVWconst {
  1279  			break
  1280  		}
  1281  		c := auxIntToInt32(v_1.AuxInt)
  1282  		flags := v_2
  1283  		v.reset(OpARMADCconst)
  1284  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  1285  		v.AddArg2(x, flags)
  1286  		return true
  1287  	}
  1288  	return false
  1289  }
  1290  func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool {
  1291  	v_3 := v.Args[3]
  1292  	v_2 := v.Args[2]
  1293  	v_1 := v.Args[1]
  1294  	v_0 := v.Args[0]
  1295  	b := v.Block
  1296  	// match: (ADCshiftRLreg (MOVWconst [c]) x y flags)
  1297  	// result: (ADCconst [c] (SRL <x.Type> x y) flags)
  1298  	for {
  1299  		if v_0.Op != OpARMMOVWconst {
  1300  			break
  1301  		}
  1302  		c := auxIntToInt32(v_0.AuxInt)
  1303  		x := v_1
  1304  		y := v_2
  1305  		flags := v_3
  1306  		v.reset(OpARMADCconst)
  1307  		v.AuxInt = int32ToAuxInt(c)
  1308  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  1309  		v0.AddArg2(x, y)
  1310  		v.AddArg2(v0, flags)
  1311  		return true
  1312  	}
  1313  	// match: (ADCshiftRLreg x y (MOVWconst [c]) flags)
  1314  	// cond: 0 <= c && c < 32
  1315  	// result: (ADCshiftRL x y [c] flags)
  1316  	for {
  1317  		x := v_0
  1318  		y := v_1
  1319  		if v_2.Op != OpARMMOVWconst {
  1320  			break
  1321  		}
  1322  		c := auxIntToInt32(v_2.AuxInt)
  1323  		flags := v_3
  1324  		if !(0 <= c && c < 32) {
  1325  			break
  1326  		}
  1327  		v.reset(OpARMADCshiftRL)
  1328  		v.AuxInt = int32ToAuxInt(c)
  1329  		v.AddArg3(x, y, flags)
  1330  		return true
  1331  	}
  1332  	return false
  1333  }
  1334  func rewriteValueARM_OpARMADD(v *Value) bool {
  1335  	v_1 := v.Args[1]
  1336  	v_0 := v.Args[0]
  1337  	b := v.Block
  1338  	// match: (ADD x (MOVWconst <t> [c]))
  1339  	// cond: !t.IsPtr()
  1340  	// result: (ADDconst [c] x)
  1341  	for {
  1342  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1343  			x := v_0
  1344  			if v_1.Op != OpARMMOVWconst {
  1345  				continue
  1346  			}
  1347  			t := v_1.Type
  1348  			c := auxIntToInt32(v_1.AuxInt)
  1349  			if !(!t.IsPtr()) {
  1350  				continue
  1351  			}
  1352  			v.reset(OpARMADDconst)
  1353  			v.AuxInt = int32ToAuxInt(c)
  1354  			v.AddArg(x)
  1355  			return true
  1356  		}
  1357  		break
  1358  	}
  1359  	// match: (ADD x (SLLconst [c] y))
  1360  	// result: (ADDshiftLL x y [c])
  1361  	for {
  1362  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1363  			x := v_0
  1364  			if v_1.Op != OpARMSLLconst {
  1365  				continue
  1366  			}
  1367  			c := auxIntToInt32(v_1.AuxInt)
  1368  			y := v_1.Args[0]
  1369  			v.reset(OpARMADDshiftLL)
  1370  			v.AuxInt = int32ToAuxInt(c)
  1371  			v.AddArg2(x, y)
  1372  			return true
  1373  		}
  1374  		break
  1375  	}
  1376  	// match: (ADD x (SRLconst [c] y))
  1377  	// result: (ADDshiftRL x y [c])
  1378  	for {
  1379  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1380  			x := v_0
  1381  			if v_1.Op != OpARMSRLconst {
  1382  				continue
  1383  			}
  1384  			c := auxIntToInt32(v_1.AuxInt)
  1385  			y := v_1.Args[0]
  1386  			v.reset(OpARMADDshiftRL)
  1387  			v.AuxInt = int32ToAuxInt(c)
  1388  			v.AddArg2(x, y)
  1389  			return true
  1390  		}
  1391  		break
  1392  	}
  1393  	// match: (ADD x (SRAconst [c] y))
  1394  	// result: (ADDshiftRA x y [c])
  1395  	for {
  1396  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1397  			x := v_0
  1398  			if v_1.Op != OpARMSRAconst {
  1399  				continue
  1400  			}
  1401  			c := auxIntToInt32(v_1.AuxInt)
  1402  			y := v_1.Args[0]
  1403  			v.reset(OpARMADDshiftRA)
  1404  			v.AuxInt = int32ToAuxInt(c)
  1405  			v.AddArg2(x, y)
  1406  			return true
  1407  		}
  1408  		break
  1409  	}
  1410  	// match: (ADD x (SLL y z))
  1411  	// result: (ADDshiftLLreg x y z)
  1412  	for {
  1413  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1414  			x := v_0
  1415  			if v_1.Op != OpARMSLL {
  1416  				continue
  1417  			}
  1418  			z := v_1.Args[1]
  1419  			y := v_1.Args[0]
  1420  			v.reset(OpARMADDshiftLLreg)
  1421  			v.AddArg3(x, y, z)
  1422  			return true
  1423  		}
  1424  		break
  1425  	}
  1426  	// match: (ADD x (SRL y z))
  1427  	// result: (ADDshiftRLreg x y z)
  1428  	for {
  1429  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1430  			x := v_0
  1431  			if v_1.Op != OpARMSRL {
  1432  				continue
  1433  			}
  1434  			z := v_1.Args[1]
  1435  			y := v_1.Args[0]
  1436  			v.reset(OpARMADDshiftRLreg)
  1437  			v.AddArg3(x, y, z)
  1438  			return true
  1439  		}
  1440  		break
  1441  	}
  1442  	// match: (ADD x (SRA y z))
  1443  	// result: (ADDshiftRAreg x y z)
  1444  	for {
  1445  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1446  			x := v_0
  1447  			if v_1.Op != OpARMSRA {
  1448  				continue
  1449  			}
  1450  			z := v_1.Args[1]
  1451  			y := v_1.Args[0]
  1452  			v.reset(OpARMADDshiftRAreg)
  1453  			v.AddArg3(x, y, z)
  1454  			return true
  1455  		}
  1456  		break
  1457  	}
  1458  	// match: (ADD x (RSBconst [0] y))
  1459  	// result: (SUB x y)
  1460  	for {
  1461  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1462  			x := v_0
  1463  			if v_1.Op != OpARMRSBconst || auxIntToInt32(v_1.AuxInt) != 0 {
  1464  				continue
  1465  			}
  1466  			y := v_1.Args[0]
  1467  			v.reset(OpARMSUB)
  1468  			v.AddArg2(x, y)
  1469  			return true
  1470  		}
  1471  		break
  1472  	}
  1473  	// match: (ADD <t> (RSBconst [c] x) (RSBconst [d] y))
  1474  	// result: (RSBconst [c+d] (ADD <t> x y))
  1475  	for {
  1476  		t := v.Type
  1477  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1478  			if v_0.Op != OpARMRSBconst {
  1479  				continue
  1480  			}
  1481  			c := auxIntToInt32(v_0.AuxInt)
  1482  			x := v_0.Args[0]
  1483  			if v_1.Op != OpARMRSBconst {
  1484  				continue
  1485  			}
  1486  			d := auxIntToInt32(v_1.AuxInt)
  1487  			y := v_1.Args[0]
  1488  			v.reset(OpARMRSBconst)
  1489  			v.AuxInt = int32ToAuxInt(c + d)
  1490  			v0 := b.NewValue0(v.Pos, OpARMADD, t)
  1491  			v0.AddArg2(x, y)
  1492  			v.AddArg(v0)
  1493  			return true
  1494  		}
  1495  		break
  1496  	}
  1497  	// match: (ADD (MUL x y) a)
  1498  	// result: (MULA x y a)
  1499  	for {
  1500  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1501  			if v_0.Op != OpARMMUL {
  1502  				continue
  1503  			}
  1504  			y := v_0.Args[1]
  1505  			x := v_0.Args[0]
  1506  			a := v_1
  1507  			v.reset(OpARMMULA)
  1508  			v.AddArg3(x, y, a)
  1509  			return true
  1510  		}
  1511  		break
  1512  	}
  1513  	return false
  1514  }
  1515  func rewriteValueARM_OpARMADDD(v *Value) bool {
  1516  	v_1 := v.Args[1]
  1517  	v_0 := v.Args[0]
  1518  	// match: (ADDD a (MULD x y))
  1519  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
  1520  	// result: (MULAD a x y)
  1521  	for {
  1522  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1523  			a := v_0
  1524  			if v_1.Op != OpARMMULD {
  1525  				continue
  1526  			}
  1527  			y := v_1.Args[1]
  1528  			x := v_1.Args[0]
  1529  			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
  1530  				continue
  1531  			}
  1532  			v.reset(OpARMMULAD)
  1533  			v.AddArg3(a, x, y)
  1534  			return true
  1535  		}
  1536  		break
  1537  	}
  1538  	// match: (ADDD a (NMULD x y))
  1539  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
  1540  	// result: (MULSD a x y)
  1541  	for {
  1542  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1543  			a := v_0
  1544  			if v_1.Op != OpARMNMULD {
  1545  				continue
  1546  			}
  1547  			y := v_1.Args[1]
  1548  			x := v_1.Args[0]
  1549  			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
  1550  				continue
  1551  			}
  1552  			v.reset(OpARMMULSD)
  1553  			v.AddArg3(a, x, y)
  1554  			return true
  1555  		}
  1556  		break
  1557  	}
  1558  	return false
  1559  }
  1560  func rewriteValueARM_OpARMADDF(v *Value) bool {
  1561  	v_1 := v.Args[1]
  1562  	v_0 := v.Args[0]
  1563  	// match: (ADDF a (MULF x y))
  1564  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
  1565  	// result: (MULAF a x y)
  1566  	for {
  1567  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1568  			a := v_0
  1569  			if v_1.Op != OpARMMULF {
  1570  				continue
  1571  			}
  1572  			y := v_1.Args[1]
  1573  			x := v_1.Args[0]
  1574  			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
  1575  				continue
  1576  			}
  1577  			v.reset(OpARMMULAF)
  1578  			v.AddArg3(a, x, y)
  1579  			return true
  1580  		}
  1581  		break
  1582  	}
  1583  	// match: (ADDF a (NMULF x y))
  1584  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
  1585  	// result: (MULSF a x y)
  1586  	for {
  1587  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1588  			a := v_0
  1589  			if v_1.Op != OpARMNMULF {
  1590  				continue
  1591  			}
  1592  			y := v_1.Args[1]
  1593  			x := v_1.Args[0]
  1594  			if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
  1595  				continue
  1596  			}
  1597  			v.reset(OpARMMULSF)
  1598  			v.AddArg3(a, x, y)
  1599  			return true
  1600  		}
  1601  		break
  1602  	}
  1603  	return false
  1604  }
  1605  func rewriteValueARM_OpARMADDS(v *Value) bool {
  1606  	v_1 := v.Args[1]
  1607  	v_0 := v.Args[0]
  1608  	// match: (ADDS x (MOVWconst [c]))
  1609  	// result: (ADDSconst [c] x)
  1610  	for {
  1611  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1612  			x := v_0
  1613  			if v_1.Op != OpARMMOVWconst {
  1614  				continue
  1615  			}
  1616  			c := auxIntToInt32(v_1.AuxInt)
  1617  			v.reset(OpARMADDSconst)
  1618  			v.AuxInt = int32ToAuxInt(c)
  1619  			v.AddArg(x)
  1620  			return true
  1621  		}
  1622  		break
  1623  	}
  1624  	// match: (ADDS x (SLLconst [c] y))
  1625  	// result: (ADDSshiftLL x y [c])
  1626  	for {
  1627  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1628  			x := v_0
  1629  			if v_1.Op != OpARMSLLconst {
  1630  				continue
  1631  			}
  1632  			c := auxIntToInt32(v_1.AuxInt)
  1633  			y := v_1.Args[0]
  1634  			v.reset(OpARMADDSshiftLL)
  1635  			v.AuxInt = int32ToAuxInt(c)
  1636  			v.AddArg2(x, y)
  1637  			return true
  1638  		}
  1639  		break
  1640  	}
  1641  	// match: (ADDS x (SRLconst [c] y))
  1642  	// result: (ADDSshiftRL x y [c])
  1643  	for {
  1644  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1645  			x := v_0
  1646  			if v_1.Op != OpARMSRLconst {
  1647  				continue
  1648  			}
  1649  			c := auxIntToInt32(v_1.AuxInt)
  1650  			y := v_1.Args[0]
  1651  			v.reset(OpARMADDSshiftRL)
  1652  			v.AuxInt = int32ToAuxInt(c)
  1653  			v.AddArg2(x, y)
  1654  			return true
  1655  		}
  1656  		break
  1657  	}
  1658  	// match: (ADDS x (SRAconst [c] y))
  1659  	// result: (ADDSshiftRA x y [c])
  1660  	for {
  1661  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1662  			x := v_0
  1663  			if v_1.Op != OpARMSRAconst {
  1664  				continue
  1665  			}
  1666  			c := auxIntToInt32(v_1.AuxInt)
  1667  			y := v_1.Args[0]
  1668  			v.reset(OpARMADDSshiftRA)
  1669  			v.AuxInt = int32ToAuxInt(c)
  1670  			v.AddArg2(x, y)
  1671  			return true
  1672  		}
  1673  		break
  1674  	}
  1675  	// match: (ADDS x (SLL y z))
  1676  	// result: (ADDSshiftLLreg x y z)
  1677  	for {
  1678  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1679  			x := v_0
  1680  			if v_1.Op != OpARMSLL {
  1681  				continue
  1682  			}
  1683  			z := v_1.Args[1]
  1684  			y := v_1.Args[0]
  1685  			v.reset(OpARMADDSshiftLLreg)
  1686  			v.AddArg3(x, y, z)
  1687  			return true
  1688  		}
  1689  		break
  1690  	}
  1691  	// match: (ADDS x (SRL y z))
  1692  	// result: (ADDSshiftRLreg x y z)
  1693  	for {
  1694  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1695  			x := v_0
  1696  			if v_1.Op != OpARMSRL {
  1697  				continue
  1698  			}
  1699  			z := v_1.Args[1]
  1700  			y := v_1.Args[0]
  1701  			v.reset(OpARMADDSshiftRLreg)
  1702  			v.AddArg3(x, y, z)
  1703  			return true
  1704  		}
  1705  		break
  1706  	}
  1707  	// match: (ADDS x (SRA y z))
  1708  	// result: (ADDSshiftRAreg x y z)
  1709  	for {
  1710  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  1711  			x := v_0
  1712  			if v_1.Op != OpARMSRA {
  1713  				continue
  1714  			}
  1715  			z := v_1.Args[1]
  1716  			y := v_1.Args[0]
  1717  			v.reset(OpARMADDSshiftRAreg)
  1718  			v.AddArg3(x, y, z)
  1719  			return true
  1720  		}
  1721  		break
  1722  	}
  1723  	return false
  1724  }
  1725  func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool {
  1726  	v_1 := v.Args[1]
  1727  	v_0 := v.Args[0]
  1728  	b := v.Block
  1729  	// match: (ADDSshiftLL (MOVWconst [c]) x [d])
  1730  	// result: (ADDSconst [c] (SLLconst <x.Type> x [d]))
  1731  	for {
  1732  		d := auxIntToInt32(v.AuxInt)
  1733  		if v_0.Op != OpARMMOVWconst {
  1734  			break
  1735  		}
  1736  		c := auxIntToInt32(v_0.AuxInt)
  1737  		x := v_1
  1738  		v.reset(OpARMADDSconst)
  1739  		v.AuxInt = int32ToAuxInt(c)
  1740  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  1741  		v0.AuxInt = int32ToAuxInt(d)
  1742  		v0.AddArg(x)
  1743  		v.AddArg(v0)
  1744  		return true
  1745  	}
  1746  	// match: (ADDSshiftLL x (MOVWconst [c]) [d])
  1747  	// result: (ADDSconst x [c<<uint64(d)])
  1748  	for {
  1749  		d := auxIntToInt32(v.AuxInt)
  1750  		x := v_0
  1751  		if v_1.Op != OpARMMOVWconst {
  1752  			break
  1753  		}
  1754  		c := auxIntToInt32(v_1.AuxInt)
  1755  		v.reset(OpARMADDSconst)
  1756  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  1757  		v.AddArg(x)
  1758  		return true
  1759  	}
  1760  	return false
  1761  }
  1762  func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool {
  1763  	v_2 := v.Args[2]
  1764  	v_1 := v.Args[1]
  1765  	v_0 := v.Args[0]
  1766  	b := v.Block
  1767  	// match: (ADDSshiftLLreg (MOVWconst [c]) x y)
  1768  	// result: (ADDSconst [c] (SLL <x.Type> x y))
  1769  	for {
  1770  		if v_0.Op != OpARMMOVWconst {
  1771  			break
  1772  		}
  1773  		c := auxIntToInt32(v_0.AuxInt)
  1774  		x := v_1
  1775  		y := v_2
  1776  		v.reset(OpARMADDSconst)
  1777  		v.AuxInt = int32ToAuxInt(c)
  1778  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  1779  		v0.AddArg2(x, y)
  1780  		v.AddArg(v0)
  1781  		return true
  1782  	}
  1783  	// match: (ADDSshiftLLreg x y (MOVWconst [c]))
  1784  	// cond: 0 <= c && c < 32
  1785  	// result: (ADDSshiftLL x y [c])
  1786  	for {
  1787  		x := v_0
  1788  		y := v_1
  1789  		if v_2.Op != OpARMMOVWconst {
  1790  			break
  1791  		}
  1792  		c := auxIntToInt32(v_2.AuxInt)
  1793  		if !(0 <= c && c < 32) {
  1794  			break
  1795  		}
  1796  		v.reset(OpARMADDSshiftLL)
  1797  		v.AuxInt = int32ToAuxInt(c)
  1798  		v.AddArg2(x, y)
  1799  		return true
  1800  	}
  1801  	return false
  1802  }
  1803  func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool {
  1804  	v_1 := v.Args[1]
  1805  	v_0 := v.Args[0]
  1806  	b := v.Block
  1807  	// match: (ADDSshiftRA (MOVWconst [c]) x [d])
  1808  	// result: (ADDSconst [c] (SRAconst <x.Type> x [d]))
  1809  	for {
  1810  		d := auxIntToInt32(v.AuxInt)
  1811  		if v_0.Op != OpARMMOVWconst {
  1812  			break
  1813  		}
  1814  		c := auxIntToInt32(v_0.AuxInt)
  1815  		x := v_1
  1816  		v.reset(OpARMADDSconst)
  1817  		v.AuxInt = int32ToAuxInt(c)
  1818  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  1819  		v0.AuxInt = int32ToAuxInt(d)
  1820  		v0.AddArg(x)
  1821  		v.AddArg(v0)
  1822  		return true
  1823  	}
  1824  	// match: (ADDSshiftRA x (MOVWconst [c]) [d])
  1825  	// result: (ADDSconst x [c>>uint64(d)])
  1826  	for {
  1827  		d := auxIntToInt32(v.AuxInt)
  1828  		x := v_0
  1829  		if v_1.Op != OpARMMOVWconst {
  1830  			break
  1831  		}
  1832  		c := auxIntToInt32(v_1.AuxInt)
  1833  		v.reset(OpARMADDSconst)
  1834  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  1835  		v.AddArg(x)
  1836  		return true
  1837  	}
  1838  	return false
  1839  }
  1840  func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool {
  1841  	v_2 := v.Args[2]
  1842  	v_1 := v.Args[1]
  1843  	v_0 := v.Args[0]
  1844  	b := v.Block
  1845  	// match: (ADDSshiftRAreg (MOVWconst [c]) x y)
  1846  	// result: (ADDSconst [c] (SRA <x.Type> x y))
  1847  	for {
  1848  		if v_0.Op != OpARMMOVWconst {
  1849  			break
  1850  		}
  1851  		c := auxIntToInt32(v_0.AuxInt)
  1852  		x := v_1
  1853  		y := v_2
  1854  		v.reset(OpARMADDSconst)
  1855  		v.AuxInt = int32ToAuxInt(c)
  1856  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  1857  		v0.AddArg2(x, y)
  1858  		v.AddArg(v0)
  1859  		return true
  1860  	}
  1861  	// match: (ADDSshiftRAreg x y (MOVWconst [c]))
  1862  	// cond: 0 <= c && c < 32
  1863  	// result: (ADDSshiftRA x y [c])
  1864  	for {
  1865  		x := v_0
  1866  		y := v_1
  1867  		if v_2.Op != OpARMMOVWconst {
  1868  			break
  1869  		}
  1870  		c := auxIntToInt32(v_2.AuxInt)
  1871  		if !(0 <= c && c < 32) {
  1872  			break
  1873  		}
  1874  		v.reset(OpARMADDSshiftRA)
  1875  		v.AuxInt = int32ToAuxInt(c)
  1876  		v.AddArg2(x, y)
  1877  		return true
  1878  	}
  1879  	return false
  1880  }
  1881  func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool {
  1882  	v_1 := v.Args[1]
  1883  	v_0 := v.Args[0]
  1884  	b := v.Block
  1885  	// match: (ADDSshiftRL (MOVWconst [c]) x [d])
  1886  	// result: (ADDSconst [c] (SRLconst <x.Type> x [d]))
  1887  	for {
  1888  		d := auxIntToInt32(v.AuxInt)
  1889  		if v_0.Op != OpARMMOVWconst {
  1890  			break
  1891  		}
  1892  		c := auxIntToInt32(v_0.AuxInt)
  1893  		x := v_1
  1894  		v.reset(OpARMADDSconst)
  1895  		v.AuxInt = int32ToAuxInt(c)
  1896  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  1897  		v0.AuxInt = int32ToAuxInt(d)
  1898  		v0.AddArg(x)
  1899  		v.AddArg(v0)
  1900  		return true
  1901  	}
  1902  	// match: (ADDSshiftRL x (MOVWconst [c]) [d])
  1903  	// result: (ADDSconst x [int32(uint32(c)>>uint64(d))])
  1904  	for {
  1905  		d := auxIntToInt32(v.AuxInt)
  1906  		x := v_0
  1907  		if v_1.Op != OpARMMOVWconst {
  1908  			break
  1909  		}
  1910  		c := auxIntToInt32(v_1.AuxInt)
  1911  		v.reset(OpARMADDSconst)
  1912  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  1913  		v.AddArg(x)
  1914  		return true
  1915  	}
  1916  	return false
  1917  }
  1918  func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool {
  1919  	v_2 := v.Args[2]
  1920  	v_1 := v.Args[1]
  1921  	v_0 := v.Args[0]
  1922  	b := v.Block
  1923  	// match: (ADDSshiftRLreg (MOVWconst [c]) x y)
  1924  	// result: (ADDSconst [c] (SRL <x.Type> x y))
  1925  	for {
  1926  		if v_0.Op != OpARMMOVWconst {
  1927  			break
  1928  		}
  1929  		c := auxIntToInt32(v_0.AuxInt)
  1930  		x := v_1
  1931  		y := v_2
  1932  		v.reset(OpARMADDSconst)
  1933  		v.AuxInt = int32ToAuxInt(c)
  1934  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  1935  		v0.AddArg2(x, y)
  1936  		v.AddArg(v0)
  1937  		return true
  1938  	}
  1939  	// match: (ADDSshiftRLreg x y (MOVWconst [c]))
  1940  	// cond: 0 <= c && c < 32
  1941  	// result: (ADDSshiftRL x y [c])
  1942  	for {
  1943  		x := v_0
  1944  		y := v_1
  1945  		if v_2.Op != OpARMMOVWconst {
  1946  			break
  1947  		}
  1948  		c := auxIntToInt32(v_2.AuxInt)
  1949  		if !(0 <= c && c < 32) {
  1950  			break
  1951  		}
  1952  		v.reset(OpARMADDSshiftRL)
  1953  		v.AuxInt = int32ToAuxInt(c)
  1954  		v.AddArg2(x, y)
  1955  		return true
  1956  	}
  1957  	return false
  1958  }
  1959  func rewriteValueARM_OpARMADDconst(v *Value) bool {
  1960  	v_0 := v.Args[0]
  1961  	// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
  1962  	// result: (MOVWaddr [off1+off2] {sym} ptr)
  1963  	for {
  1964  		off1 := auxIntToInt32(v.AuxInt)
  1965  		if v_0.Op != OpARMMOVWaddr {
  1966  			break
  1967  		}
  1968  		off2 := auxIntToInt32(v_0.AuxInt)
  1969  		sym := auxToSym(v_0.Aux)
  1970  		ptr := v_0.Args[0]
  1971  		v.reset(OpARMMOVWaddr)
  1972  		v.AuxInt = int32ToAuxInt(off1 + off2)
  1973  		v.Aux = symToAux(sym)
  1974  		v.AddArg(ptr)
  1975  		return true
  1976  	}
  1977  	// match: (ADDconst [0] x)
  1978  	// result: x
  1979  	for {
  1980  		if auxIntToInt32(v.AuxInt) != 0 {
  1981  			break
  1982  		}
  1983  		x := v_0
  1984  		v.copyOf(x)
  1985  		return true
  1986  	}
  1987  	// match: (ADDconst [c] x)
  1988  	// cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))
  1989  	// result: (SUBconst [-c] x)
  1990  	for {
  1991  		c := auxIntToInt32(v.AuxInt)
  1992  		x := v_0
  1993  		if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) {
  1994  			break
  1995  		}
  1996  		v.reset(OpARMSUBconst)
  1997  		v.AuxInt = int32ToAuxInt(-c)
  1998  		v.AddArg(x)
  1999  		return true
  2000  	}
  2001  	// match: (ADDconst [c] x)
  2002  	// cond: buildcfg.GOARM.Version==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
  2003  	// result: (SUBconst [-c] x)
  2004  	for {
  2005  		c := auxIntToInt32(v.AuxInt)
  2006  		x := v_0
  2007  		if !(buildcfg.GOARM.Version == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
  2008  			break
  2009  		}
  2010  		v.reset(OpARMSUBconst)
  2011  		v.AuxInt = int32ToAuxInt(-c)
  2012  		v.AddArg(x)
  2013  		return true
  2014  	}
  2015  	// match: (ADDconst [c] (MOVWconst [d]))
  2016  	// result: (MOVWconst [c+d])
  2017  	for {
  2018  		c := auxIntToInt32(v.AuxInt)
  2019  		if v_0.Op != OpARMMOVWconst {
  2020  			break
  2021  		}
  2022  		d := auxIntToInt32(v_0.AuxInt)
  2023  		v.reset(OpARMMOVWconst)
  2024  		v.AuxInt = int32ToAuxInt(c + d)
  2025  		return true
  2026  	}
  2027  	// match: (ADDconst [c] (ADDconst [d] x))
  2028  	// result: (ADDconst [c+d] x)
  2029  	for {
  2030  		c := auxIntToInt32(v.AuxInt)
  2031  		if v_0.Op != OpARMADDconst {
  2032  			break
  2033  		}
  2034  		d := auxIntToInt32(v_0.AuxInt)
  2035  		x := v_0.Args[0]
  2036  		v.reset(OpARMADDconst)
  2037  		v.AuxInt = int32ToAuxInt(c + d)
  2038  		v.AddArg(x)
  2039  		return true
  2040  	}
  2041  	// match: (ADDconst [c] (SUBconst [d] x))
  2042  	// result: (ADDconst [c-d] x)
  2043  	for {
  2044  		c := auxIntToInt32(v.AuxInt)
  2045  		if v_0.Op != OpARMSUBconst {
  2046  			break
  2047  		}
  2048  		d := auxIntToInt32(v_0.AuxInt)
  2049  		x := v_0.Args[0]
  2050  		v.reset(OpARMADDconst)
  2051  		v.AuxInt = int32ToAuxInt(c - d)
  2052  		v.AddArg(x)
  2053  		return true
  2054  	}
  2055  	// match: (ADDconst [c] (RSBconst [d] x))
  2056  	// result: (RSBconst [c+d] x)
  2057  	for {
  2058  		c := auxIntToInt32(v.AuxInt)
  2059  		if v_0.Op != OpARMRSBconst {
  2060  			break
  2061  		}
  2062  		d := auxIntToInt32(v_0.AuxInt)
  2063  		x := v_0.Args[0]
  2064  		v.reset(OpARMRSBconst)
  2065  		v.AuxInt = int32ToAuxInt(c + d)
  2066  		v.AddArg(x)
  2067  		return true
  2068  	}
  2069  	return false
  2070  }
  2071  func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
  2072  	v_1 := v.Args[1]
  2073  	v_0 := v.Args[0]
  2074  	b := v.Block
  2075  	typ := &b.Func.Config.Types
  2076  	// match: (ADDshiftLL (MOVWconst [c]) x [d])
  2077  	// result: (ADDconst [c] (SLLconst <x.Type> x [d]))
  2078  	for {
  2079  		d := auxIntToInt32(v.AuxInt)
  2080  		if v_0.Op != OpARMMOVWconst {
  2081  			break
  2082  		}
  2083  		c := auxIntToInt32(v_0.AuxInt)
  2084  		x := v_1
  2085  		v.reset(OpARMADDconst)
  2086  		v.AuxInt = int32ToAuxInt(c)
  2087  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  2088  		v0.AuxInt = int32ToAuxInt(d)
  2089  		v0.AddArg(x)
  2090  		v.AddArg(v0)
  2091  		return true
  2092  	}
  2093  	// match: (ADDshiftLL x (MOVWconst [c]) [d])
  2094  	// result: (ADDconst x [c<<uint64(d)])
  2095  	for {
  2096  		d := auxIntToInt32(v.AuxInt)
  2097  		x := v_0
  2098  		if v_1.Op != OpARMMOVWconst {
  2099  			break
  2100  		}
  2101  		c := auxIntToInt32(v_1.AuxInt)
  2102  		v.reset(OpARMADDconst)
  2103  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  2104  		v.AddArg(x)
  2105  		return true
  2106  	}
  2107  	// match: (ADDshiftLL <typ.UInt16> [8] (BFXU <typ.UInt16> [int32(armBFAuxInt(8, 8))] x) x)
  2108  	// result: (REV16 x)
  2109  	for {
  2110  		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMBFXU || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != int32(armBFAuxInt(8, 8)) {
  2111  			break
  2112  		}
  2113  		x := v_0.Args[0]
  2114  		if x != v_1 {
  2115  			break
  2116  		}
  2117  		v.reset(OpARMREV16)
  2118  		v.AddArg(x)
  2119  		return true
  2120  	}
  2121  	// match: (ADDshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
  2122  	// cond: buildcfg.GOARM.Version>=6
  2123  	// result: (REV16 x)
  2124  	for {
  2125  		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
  2126  			break
  2127  		}
  2128  		v_0_0 := v_0.Args[0]
  2129  		if v_0_0.Op != OpARMSLLconst || auxIntToInt32(v_0_0.AuxInt) != 16 {
  2130  			break
  2131  		}
  2132  		x := v_0_0.Args[0]
  2133  		if x != v_1 || !(buildcfg.GOARM.Version >= 6) {
  2134  			break
  2135  		}
  2136  		v.reset(OpARMREV16)
  2137  		v.AddArg(x)
  2138  		return true
  2139  	}
  2140  	return false
  2141  }
  2142  func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool {
  2143  	v_2 := v.Args[2]
  2144  	v_1 := v.Args[1]
  2145  	v_0 := v.Args[0]
  2146  	b := v.Block
  2147  	// match: (ADDshiftLLreg (MOVWconst [c]) x y)
  2148  	// result: (ADDconst [c] (SLL <x.Type> x y))
  2149  	for {
  2150  		if v_0.Op != OpARMMOVWconst {
  2151  			break
  2152  		}
  2153  		c := auxIntToInt32(v_0.AuxInt)
  2154  		x := v_1
  2155  		y := v_2
  2156  		v.reset(OpARMADDconst)
  2157  		v.AuxInt = int32ToAuxInt(c)
  2158  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  2159  		v0.AddArg2(x, y)
  2160  		v.AddArg(v0)
  2161  		return true
  2162  	}
  2163  	// match: (ADDshiftLLreg x y (MOVWconst [c]))
  2164  	// cond: 0 <= c && c < 32
  2165  	// result: (ADDshiftLL x y [c])
  2166  	for {
  2167  		x := v_0
  2168  		y := v_1
  2169  		if v_2.Op != OpARMMOVWconst {
  2170  			break
  2171  		}
  2172  		c := auxIntToInt32(v_2.AuxInt)
  2173  		if !(0 <= c && c < 32) {
  2174  			break
  2175  		}
  2176  		v.reset(OpARMADDshiftLL)
  2177  		v.AuxInt = int32ToAuxInt(c)
  2178  		v.AddArg2(x, y)
  2179  		return true
  2180  	}
  2181  	return false
  2182  }
  2183  func rewriteValueARM_OpARMADDshiftRA(v *Value) bool {
  2184  	v_1 := v.Args[1]
  2185  	v_0 := v.Args[0]
  2186  	b := v.Block
  2187  	// match: (ADDshiftRA (MOVWconst [c]) x [d])
  2188  	// result: (ADDconst [c] (SRAconst <x.Type> x [d]))
  2189  	for {
  2190  		d := auxIntToInt32(v.AuxInt)
  2191  		if v_0.Op != OpARMMOVWconst {
  2192  			break
  2193  		}
  2194  		c := auxIntToInt32(v_0.AuxInt)
  2195  		x := v_1
  2196  		v.reset(OpARMADDconst)
  2197  		v.AuxInt = int32ToAuxInt(c)
  2198  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  2199  		v0.AuxInt = int32ToAuxInt(d)
  2200  		v0.AddArg(x)
  2201  		v.AddArg(v0)
  2202  		return true
  2203  	}
  2204  	// match: (ADDshiftRA x (MOVWconst [c]) [d])
  2205  	// result: (ADDconst x [c>>uint64(d)])
  2206  	for {
  2207  		d := auxIntToInt32(v.AuxInt)
  2208  		x := v_0
  2209  		if v_1.Op != OpARMMOVWconst {
  2210  			break
  2211  		}
  2212  		c := auxIntToInt32(v_1.AuxInt)
  2213  		v.reset(OpARMADDconst)
  2214  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  2215  		v.AddArg(x)
  2216  		return true
  2217  	}
  2218  	return false
  2219  }
  2220  func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool {
  2221  	v_2 := v.Args[2]
  2222  	v_1 := v.Args[1]
  2223  	v_0 := v.Args[0]
  2224  	b := v.Block
  2225  	// match: (ADDshiftRAreg (MOVWconst [c]) x y)
  2226  	// result: (ADDconst [c] (SRA <x.Type> x y))
  2227  	for {
  2228  		if v_0.Op != OpARMMOVWconst {
  2229  			break
  2230  		}
  2231  		c := auxIntToInt32(v_0.AuxInt)
  2232  		x := v_1
  2233  		y := v_2
  2234  		v.reset(OpARMADDconst)
  2235  		v.AuxInt = int32ToAuxInt(c)
  2236  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  2237  		v0.AddArg2(x, y)
  2238  		v.AddArg(v0)
  2239  		return true
  2240  	}
  2241  	// match: (ADDshiftRAreg x y (MOVWconst [c]))
  2242  	// cond: 0 <= c && c < 32
  2243  	// result: (ADDshiftRA x y [c])
  2244  	for {
  2245  		x := v_0
  2246  		y := v_1
  2247  		if v_2.Op != OpARMMOVWconst {
  2248  			break
  2249  		}
  2250  		c := auxIntToInt32(v_2.AuxInt)
  2251  		if !(0 <= c && c < 32) {
  2252  			break
  2253  		}
  2254  		v.reset(OpARMADDshiftRA)
  2255  		v.AuxInt = int32ToAuxInt(c)
  2256  		v.AddArg2(x, y)
  2257  		return true
  2258  	}
  2259  	return false
  2260  }
  2261  func rewriteValueARM_OpARMADDshiftRL(v *Value) bool {
  2262  	v_1 := v.Args[1]
  2263  	v_0 := v.Args[0]
  2264  	b := v.Block
  2265  	// match: (ADDshiftRL (MOVWconst [c]) x [d])
  2266  	// result: (ADDconst [c] (SRLconst <x.Type> x [d]))
  2267  	for {
  2268  		d := auxIntToInt32(v.AuxInt)
  2269  		if v_0.Op != OpARMMOVWconst {
  2270  			break
  2271  		}
  2272  		c := auxIntToInt32(v_0.AuxInt)
  2273  		x := v_1
  2274  		v.reset(OpARMADDconst)
  2275  		v.AuxInt = int32ToAuxInt(c)
  2276  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  2277  		v0.AuxInt = int32ToAuxInt(d)
  2278  		v0.AddArg(x)
  2279  		v.AddArg(v0)
  2280  		return true
  2281  	}
  2282  	// match: (ADDshiftRL x (MOVWconst [c]) [d])
  2283  	// result: (ADDconst x [int32(uint32(c)>>uint64(d))])
  2284  	for {
  2285  		d := auxIntToInt32(v.AuxInt)
  2286  		x := v_0
  2287  		if v_1.Op != OpARMMOVWconst {
  2288  			break
  2289  		}
  2290  		c := auxIntToInt32(v_1.AuxInt)
  2291  		v.reset(OpARMADDconst)
  2292  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  2293  		v.AddArg(x)
  2294  		return true
  2295  	}
  2296  	return false
  2297  }
  2298  func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool {
  2299  	v_2 := v.Args[2]
  2300  	v_1 := v.Args[1]
  2301  	v_0 := v.Args[0]
  2302  	b := v.Block
  2303  	// match: (ADDshiftRLreg (MOVWconst [c]) x y)
  2304  	// result: (ADDconst [c] (SRL <x.Type> x y))
  2305  	for {
  2306  		if v_0.Op != OpARMMOVWconst {
  2307  			break
  2308  		}
  2309  		c := auxIntToInt32(v_0.AuxInt)
  2310  		x := v_1
  2311  		y := v_2
  2312  		v.reset(OpARMADDconst)
  2313  		v.AuxInt = int32ToAuxInt(c)
  2314  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  2315  		v0.AddArg2(x, y)
  2316  		v.AddArg(v0)
  2317  		return true
  2318  	}
  2319  	// match: (ADDshiftRLreg x y (MOVWconst [c]))
  2320  	// cond: 0 <= c && c < 32
  2321  	// result: (ADDshiftRL x y [c])
  2322  	for {
  2323  		x := v_0
  2324  		y := v_1
  2325  		if v_2.Op != OpARMMOVWconst {
  2326  			break
  2327  		}
  2328  		c := auxIntToInt32(v_2.AuxInt)
  2329  		if !(0 <= c && c < 32) {
  2330  			break
  2331  		}
  2332  		v.reset(OpARMADDshiftRL)
  2333  		v.AuxInt = int32ToAuxInt(c)
  2334  		v.AddArg2(x, y)
  2335  		return true
  2336  	}
  2337  	return false
  2338  }
  2339  func rewriteValueARM_OpARMAND(v *Value) bool {
  2340  	v_1 := v.Args[1]
  2341  	v_0 := v.Args[0]
  2342  	// match: (AND x (MOVWconst [c]))
  2343  	// result: (ANDconst [c] x)
  2344  	for {
  2345  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2346  			x := v_0
  2347  			if v_1.Op != OpARMMOVWconst {
  2348  				continue
  2349  			}
  2350  			c := auxIntToInt32(v_1.AuxInt)
  2351  			v.reset(OpARMANDconst)
  2352  			v.AuxInt = int32ToAuxInt(c)
  2353  			v.AddArg(x)
  2354  			return true
  2355  		}
  2356  		break
  2357  	}
  2358  	// match: (AND x (SLLconst [c] y))
  2359  	// result: (ANDshiftLL x y [c])
  2360  	for {
  2361  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2362  			x := v_0
  2363  			if v_1.Op != OpARMSLLconst {
  2364  				continue
  2365  			}
  2366  			c := auxIntToInt32(v_1.AuxInt)
  2367  			y := v_1.Args[0]
  2368  			v.reset(OpARMANDshiftLL)
  2369  			v.AuxInt = int32ToAuxInt(c)
  2370  			v.AddArg2(x, y)
  2371  			return true
  2372  		}
  2373  		break
  2374  	}
  2375  	// match: (AND x (SRLconst [c] y))
  2376  	// result: (ANDshiftRL x y [c])
  2377  	for {
  2378  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2379  			x := v_0
  2380  			if v_1.Op != OpARMSRLconst {
  2381  				continue
  2382  			}
  2383  			c := auxIntToInt32(v_1.AuxInt)
  2384  			y := v_1.Args[0]
  2385  			v.reset(OpARMANDshiftRL)
  2386  			v.AuxInt = int32ToAuxInt(c)
  2387  			v.AddArg2(x, y)
  2388  			return true
  2389  		}
  2390  		break
  2391  	}
  2392  	// match: (AND x (SRAconst [c] y))
  2393  	// result: (ANDshiftRA x y [c])
  2394  	for {
  2395  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2396  			x := v_0
  2397  			if v_1.Op != OpARMSRAconst {
  2398  				continue
  2399  			}
  2400  			c := auxIntToInt32(v_1.AuxInt)
  2401  			y := v_1.Args[0]
  2402  			v.reset(OpARMANDshiftRA)
  2403  			v.AuxInt = int32ToAuxInt(c)
  2404  			v.AddArg2(x, y)
  2405  			return true
  2406  		}
  2407  		break
  2408  	}
  2409  	// match: (AND x (SLL y z))
  2410  	// result: (ANDshiftLLreg x y z)
  2411  	for {
  2412  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2413  			x := v_0
  2414  			if v_1.Op != OpARMSLL {
  2415  				continue
  2416  			}
  2417  			z := v_1.Args[1]
  2418  			y := v_1.Args[0]
  2419  			v.reset(OpARMANDshiftLLreg)
  2420  			v.AddArg3(x, y, z)
  2421  			return true
  2422  		}
  2423  		break
  2424  	}
  2425  	// match: (AND x (SRL y z))
  2426  	// result: (ANDshiftRLreg x y z)
  2427  	for {
  2428  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2429  			x := v_0
  2430  			if v_1.Op != OpARMSRL {
  2431  				continue
  2432  			}
  2433  			z := v_1.Args[1]
  2434  			y := v_1.Args[0]
  2435  			v.reset(OpARMANDshiftRLreg)
  2436  			v.AddArg3(x, y, z)
  2437  			return true
  2438  		}
  2439  		break
  2440  	}
  2441  	// match: (AND x (SRA y z))
  2442  	// result: (ANDshiftRAreg x y z)
  2443  	for {
  2444  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2445  			x := v_0
  2446  			if v_1.Op != OpARMSRA {
  2447  				continue
  2448  			}
  2449  			z := v_1.Args[1]
  2450  			y := v_1.Args[0]
  2451  			v.reset(OpARMANDshiftRAreg)
  2452  			v.AddArg3(x, y, z)
  2453  			return true
  2454  		}
  2455  		break
  2456  	}
  2457  	// match: (AND x x)
  2458  	// result: x
  2459  	for {
  2460  		x := v_0
  2461  		if x != v_1 {
  2462  			break
  2463  		}
  2464  		v.copyOf(x)
  2465  		return true
  2466  	}
  2467  	// match: (AND x (MVN y))
  2468  	// result: (BIC x y)
  2469  	for {
  2470  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2471  			x := v_0
  2472  			if v_1.Op != OpARMMVN {
  2473  				continue
  2474  			}
  2475  			y := v_1.Args[0]
  2476  			v.reset(OpARMBIC)
  2477  			v.AddArg2(x, y)
  2478  			return true
  2479  		}
  2480  		break
  2481  	}
  2482  	// match: (AND x (MVNshiftLL y [c]))
  2483  	// result: (BICshiftLL x y [c])
  2484  	for {
  2485  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2486  			x := v_0
  2487  			if v_1.Op != OpARMMVNshiftLL {
  2488  				continue
  2489  			}
  2490  			c := auxIntToInt32(v_1.AuxInt)
  2491  			y := v_1.Args[0]
  2492  			v.reset(OpARMBICshiftLL)
  2493  			v.AuxInt = int32ToAuxInt(c)
  2494  			v.AddArg2(x, y)
  2495  			return true
  2496  		}
  2497  		break
  2498  	}
  2499  	// match: (AND x (MVNshiftRL y [c]))
  2500  	// result: (BICshiftRL x y [c])
  2501  	for {
  2502  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2503  			x := v_0
  2504  			if v_1.Op != OpARMMVNshiftRL {
  2505  				continue
  2506  			}
  2507  			c := auxIntToInt32(v_1.AuxInt)
  2508  			y := v_1.Args[0]
  2509  			v.reset(OpARMBICshiftRL)
  2510  			v.AuxInt = int32ToAuxInt(c)
  2511  			v.AddArg2(x, y)
  2512  			return true
  2513  		}
  2514  		break
  2515  	}
  2516  	// match: (AND x (MVNshiftRA y [c]))
  2517  	// result: (BICshiftRA x y [c])
  2518  	for {
  2519  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  2520  			x := v_0
  2521  			if v_1.Op != OpARMMVNshiftRA {
  2522  				continue
  2523  			}
  2524  			c := auxIntToInt32(v_1.AuxInt)
  2525  			y := v_1.Args[0]
  2526  			v.reset(OpARMBICshiftRA)
  2527  			v.AuxInt = int32ToAuxInt(c)
  2528  			v.AddArg2(x, y)
  2529  			return true
  2530  		}
  2531  		break
  2532  	}
  2533  	return false
  2534  }
  2535  func rewriteValueARM_OpARMANDconst(v *Value) bool {
  2536  	v_0 := v.Args[0]
  2537  	// match: (ANDconst [0] _)
  2538  	// result: (MOVWconst [0])
  2539  	for {
  2540  		if auxIntToInt32(v.AuxInt) != 0 {
  2541  			break
  2542  		}
  2543  		v.reset(OpARMMOVWconst)
  2544  		v.AuxInt = int32ToAuxInt(0)
  2545  		return true
  2546  	}
  2547  	// match: (ANDconst [c] x)
  2548  	// cond: int32(c)==-1
  2549  	// result: x
  2550  	for {
  2551  		c := auxIntToInt32(v.AuxInt)
  2552  		x := v_0
  2553  		if !(int32(c) == -1) {
  2554  			break
  2555  		}
  2556  		v.copyOf(x)
  2557  		return true
  2558  	}
  2559  	// match: (ANDconst [c] x)
  2560  	// cond: !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))
  2561  	// result: (BICconst [int32(^uint32(c))] x)
  2562  	for {
  2563  		c := auxIntToInt32(v.AuxInt)
  2564  		x := v_0
  2565  		if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) {
  2566  			break
  2567  		}
  2568  		v.reset(OpARMBICconst)
  2569  		v.AuxInt = int32ToAuxInt(int32(^uint32(c)))
  2570  		v.AddArg(x)
  2571  		return true
  2572  	}
  2573  	// match: (ANDconst [c] x)
  2574  	// cond: buildcfg.GOARM.Version==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
  2575  	// result: (BICconst [int32(^uint32(c))] x)
  2576  	for {
  2577  		c := auxIntToInt32(v.AuxInt)
  2578  		x := v_0
  2579  		if !(buildcfg.GOARM.Version == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
  2580  			break
  2581  		}
  2582  		v.reset(OpARMBICconst)
  2583  		v.AuxInt = int32ToAuxInt(int32(^uint32(c)))
  2584  		v.AddArg(x)
  2585  		return true
  2586  	}
  2587  	// match: (ANDconst [c] (MOVWconst [d]))
  2588  	// result: (MOVWconst [c&d])
  2589  	for {
  2590  		c := auxIntToInt32(v.AuxInt)
  2591  		if v_0.Op != OpARMMOVWconst {
  2592  			break
  2593  		}
  2594  		d := auxIntToInt32(v_0.AuxInt)
  2595  		v.reset(OpARMMOVWconst)
  2596  		v.AuxInt = int32ToAuxInt(c & d)
  2597  		return true
  2598  	}
  2599  	// match: (ANDconst [c] (ANDconst [d] x))
  2600  	// result: (ANDconst [c&d] x)
  2601  	for {
  2602  		c := auxIntToInt32(v.AuxInt)
  2603  		if v_0.Op != OpARMANDconst {
  2604  			break
  2605  		}
  2606  		d := auxIntToInt32(v_0.AuxInt)
  2607  		x := v_0.Args[0]
  2608  		v.reset(OpARMANDconst)
  2609  		v.AuxInt = int32ToAuxInt(c & d)
  2610  		v.AddArg(x)
  2611  		return true
  2612  	}
  2613  	return false
  2614  }
  2615  func rewriteValueARM_OpARMANDshiftLL(v *Value) bool {
  2616  	v_1 := v.Args[1]
  2617  	v_0 := v.Args[0]
  2618  	b := v.Block
  2619  	// match: (ANDshiftLL (MOVWconst [c]) x [d])
  2620  	// result: (ANDconst [c] (SLLconst <x.Type> x [d]))
  2621  	for {
  2622  		d := auxIntToInt32(v.AuxInt)
  2623  		if v_0.Op != OpARMMOVWconst {
  2624  			break
  2625  		}
  2626  		c := auxIntToInt32(v_0.AuxInt)
  2627  		x := v_1
  2628  		v.reset(OpARMANDconst)
  2629  		v.AuxInt = int32ToAuxInt(c)
  2630  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  2631  		v0.AuxInt = int32ToAuxInt(d)
  2632  		v0.AddArg(x)
  2633  		v.AddArg(v0)
  2634  		return true
  2635  	}
  2636  	// match: (ANDshiftLL x (MOVWconst [c]) [d])
  2637  	// result: (ANDconst x [c<<uint64(d)])
  2638  	for {
  2639  		d := auxIntToInt32(v.AuxInt)
  2640  		x := v_0
  2641  		if v_1.Op != OpARMMOVWconst {
  2642  			break
  2643  		}
  2644  		c := auxIntToInt32(v_1.AuxInt)
  2645  		v.reset(OpARMANDconst)
  2646  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  2647  		v.AddArg(x)
  2648  		return true
  2649  	}
  2650  	// match: (ANDshiftLL y:(SLLconst x [c]) x [c])
  2651  	// result: y
  2652  	for {
  2653  		c := auxIntToInt32(v.AuxInt)
  2654  		y := v_0
  2655  		if y.Op != OpARMSLLconst || auxIntToInt32(y.AuxInt) != c {
  2656  			break
  2657  		}
  2658  		x := y.Args[0]
  2659  		if x != v_1 {
  2660  			break
  2661  		}
  2662  		v.copyOf(y)
  2663  		return true
  2664  	}
  2665  	return false
  2666  }
  2667  func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool {
  2668  	v_2 := v.Args[2]
  2669  	v_1 := v.Args[1]
  2670  	v_0 := v.Args[0]
  2671  	b := v.Block
  2672  	// match: (ANDshiftLLreg (MOVWconst [c]) x y)
  2673  	// result: (ANDconst [c] (SLL <x.Type> x y))
  2674  	for {
  2675  		if v_0.Op != OpARMMOVWconst {
  2676  			break
  2677  		}
  2678  		c := auxIntToInt32(v_0.AuxInt)
  2679  		x := v_1
  2680  		y := v_2
  2681  		v.reset(OpARMANDconst)
  2682  		v.AuxInt = int32ToAuxInt(c)
  2683  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  2684  		v0.AddArg2(x, y)
  2685  		v.AddArg(v0)
  2686  		return true
  2687  	}
  2688  	// match: (ANDshiftLLreg x y (MOVWconst [c]))
  2689  	// cond: 0 <= c && c < 32
  2690  	// result: (ANDshiftLL x y [c])
  2691  	for {
  2692  		x := v_0
  2693  		y := v_1
  2694  		if v_2.Op != OpARMMOVWconst {
  2695  			break
  2696  		}
  2697  		c := auxIntToInt32(v_2.AuxInt)
  2698  		if !(0 <= c && c < 32) {
  2699  			break
  2700  		}
  2701  		v.reset(OpARMANDshiftLL)
  2702  		v.AuxInt = int32ToAuxInt(c)
  2703  		v.AddArg2(x, y)
  2704  		return true
  2705  	}
  2706  	return false
  2707  }
  2708  func rewriteValueARM_OpARMANDshiftRA(v *Value) bool {
  2709  	v_1 := v.Args[1]
  2710  	v_0 := v.Args[0]
  2711  	b := v.Block
  2712  	// match: (ANDshiftRA (MOVWconst [c]) x [d])
  2713  	// result: (ANDconst [c] (SRAconst <x.Type> x [d]))
  2714  	for {
  2715  		d := auxIntToInt32(v.AuxInt)
  2716  		if v_0.Op != OpARMMOVWconst {
  2717  			break
  2718  		}
  2719  		c := auxIntToInt32(v_0.AuxInt)
  2720  		x := v_1
  2721  		v.reset(OpARMANDconst)
  2722  		v.AuxInt = int32ToAuxInt(c)
  2723  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  2724  		v0.AuxInt = int32ToAuxInt(d)
  2725  		v0.AddArg(x)
  2726  		v.AddArg(v0)
  2727  		return true
  2728  	}
  2729  	// match: (ANDshiftRA x (MOVWconst [c]) [d])
  2730  	// result: (ANDconst x [c>>uint64(d)])
  2731  	for {
  2732  		d := auxIntToInt32(v.AuxInt)
  2733  		x := v_0
  2734  		if v_1.Op != OpARMMOVWconst {
  2735  			break
  2736  		}
  2737  		c := auxIntToInt32(v_1.AuxInt)
  2738  		v.reset(OpARMANDconst)
  2739  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  2740  		v.AddArg(x)
  2741  		return true
  2742  	}
  2743  	// match: (ANDshiftRA y:(SRAconst x [c]) x [c])
  2744  	// result: y
  2745  	for {
  2746  		c := auxIntToInt32(v.AuxInt)
  2747  		y := v_0
  2748  		if y.Op != OpARMSRAconst || auxIntToInt32(y.AuxInt) != c {
  2749  			break
  2750  		}
  2751  		x := y.Args[0]
  2752  		if x != v_1 {
  2753  			break
  2754  		}
  2755  		v.copyOf(y)
  2756  		return true
  2757  	}
  2758  	return false
  2759  }
  2760  func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool {
  2761  	v_2 := v.Args[2]
  2762  	v_1 := v.Args[1]
  2763  	v_0 := v.Args[0]
  2764  	b := v.Block
  2765  	// match: (ANDshiftRAreg (MOVWconst [c]) x y)
  2766  	// result: (ANDconst [c] (SRA <x.Type> x y))
  2767  	for {
  2768  		if v_0.Op != OpARMMOVWconst {
  2769  			break
  2770  		}
  2771  		c := auxIntToInt32(v_0.AuxInt)
  2772  		x := v_1
  2773  		y := v_2
  2774  		v.reset(OpARMANDconst)
  2775  		v.AuxInt = int32ToAuxInt(c)
  2776  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  2777  		v0.AddArg2(x, y)
  2778  		v.AddArg(v0)
  2779  		return true
  2780  	}
  2781  	// match: (ANDshiftRAreg x y (MOVWconst [c]))
  2782  	// cond: 0 <= c && c < 32
  2783  	// result: (ANDshiftRA x y [c])
  2784  	for {
  2785  		x := v_0
  2786  		y := v_1
  2787  		if v_2.Op != OpARMMOVWconst {
  2788  			break
  2789  		}
  2790  		c := auxIntToInt32(v_2.AuxInt)
  2791  		if !(0 <= c && c < 32) {
  2792  			break
  2793  		}
  2794  		v.reset(OpARMANDshiftRA)
  2795  		v.AuxInt = int32ToAuxInt(c)
  2796  		v.AddArg2(x, y)
  2797  		return true
  2798  	}
  2799  	return false
  2800  }
  2801  func rewriteValueARM_OpARMANDshiftRL(v *Value) bool {
  2802  	v_1 := v.Args[1]
  2803  	v_0 := v.Args[0]
  2804  	b := v.Block
  2805  	// match: (ANDshiftRL (MOVWconst [c]) x [d])
  2806  	// result: (ANDconst [c] (SRLconst <x.Type> x [d]))
  2807  	for {
  2808  		d := auxIntToInt32(v.AuxInt)
  2809  		if v_0.Op != OpARMMOVWconst {
  2810  			break
  2811  		}
  2812  		c := auxIntToInt32(v_0.AuxInt)
  2813  		x := v_1
  2814  		v.reset(OpARMANDconst)
  2815  		v.AuxInt = int32ToAuxInt(c)
  2816  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  2817  		v0.AuxInt = int32ToAuxInt(d)
  2818  		v0.AddArg(x)
  2819  		v.AddArg(v0)
  2820  		return true
  2821  	}
  2822  	// match: (ANDshiftRL x (MOVWconst [c]) [d])
  2823  	// result: (ANDconst x [int32(uint32(c)>>uint64(d))])
  2824  	for {
  2825  		d := auxIntToInt32(v.AuxInt)
  2826  		x := v_0
  2827  		if v_1.Op != OpARMMOVWconst {
  2828  			break
  2829  		}
  2830  		c := auxIntToInt32(v_1.AuxInt)
  2831  		v.reset(OpARMANDconst)
  2832  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  2833  		v.AddArg(x)
  2834  		return true
  2835  	}
  2836  	// match: (ANDshiftRL y:(SRLconst x [c]) x [c])
  2837  	// result: y
  2838  	for {
  2839  		c := auxIntToInt32(v.AuxInt)
  2840  		y := v_0
  2841  		if y.Op != OpARMSRLconst || auxIntToInt32(y.AuxInt) != c {
  2842  			break
  2843  		}
  2844  		x := y.Args[0]
  2845  		if x != v_1 {
  2846  			break
  2847  		}
  2848  		v.copyOf(y)
  2849  		return true
  2850  	}
  2851  	return false
  2852  }
  2853  func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool {
  2854  	v_2 := v.Args[2]
  2855  	v_1 := v.Args[1]
  2856  	v_0 := v.Args[0]
  2857  	b := v.Block
  2858  	// match: (ANDshiftRLreg (MOVWconst [c]) x y)
  2859  	// result: (ANDconst [c] (SRL <x.Type> x y))
  2860  	for {
  2861  		if v_0.Op != OpARMMOVWconst {
  2862  			break
  2863  		}
  2864  		c := auxIntToInt32(v_0.AuxInt)
  2865  		x := v_1
  2866  		y := v_2
  2867  		v.reset(OpARMANDconst)
  2868  		v.AuxInt = int32ToAuxInt(c)
  2869  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  2870  		v0.AddArg2(x, y)
  2871  		v.AddArg(v0)
  2872  		return true
  2873  	}
  2874  	// match: (ANDshiftRLreg x y (MOVWconst [c]))
  2875  	// cond: 0 <= c && c < 32
  2876  	// result: (ANDshiftRL x y [c])
  2877  	for {
  2878  		x := v_0
  2879  		y := v_1
  2880  		if v_2.Op != OpARMMOVWconst {
  2881  			break
  2882  		}
  2883  		c := auxIntToInt32(v_2.AuxInt)
  2884  		if !(0 <= c && c < 32) {
  2885  			break
  2886  		}
  2887  		v.reset(OpARMANDshiftRL)
  2888  		v.AuxInt = int32ToAuxInt(c)
  2889  		v.AddArg2(x, y)
  2890  		return true
  2891  	}
  2892  	return false
  2893  }
  2894  func rewriteValueARM_OpARMBFX(v *Value) bool {
  2895  	v_0 := v.Args[0]
  2896  	// match: (BFX [c] (MOVWconst [d]))
  2897  	// result: (MOVWconst [d<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8))])
  2898  	for {
  2899  		c := auxIntToInt32(v.AuxInt)
  2900  		if v_0.Op != OpARMMOVWconst {
  2901  			break
  2902  		}
  2903  		d := auxIntToInt32(v_0.AuxInt)
  2904  		v.reset(OpARMMOVWconst)
  2905  		v.AuxInt = int32ToAuxInt(d << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8)))
  2906  		return true
  2907  	}
  2908  	return false
  2909  }
  2910  func rewriteValueARM_OpARMBFXU(v *Value) bool {
  2911  	v_0 := v.Args[0]
  2912  	// match: (BFXU [c] (MOVWconst [d]))
  2913  	// result: (MOVWconst [int32(uint32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8)))])
  2914  	for {
  2915  		c := auxIntToInt32(v.AuxInt)
  2916  		if v_0.Op != OpARMMOVWconst {
  2917  			break
  2918  		}
  2919  		d := auxIntToInt32(v_0.AuxInt)
  2920  		v.reset(OpARMMOVWconst)
  2921  		v.AuxInt = int32ToAuxInt(int32(uint32(d) << (32 - uint32(c&0xff) - uint32(c>>8)) >> (32 - uint32(c>>8))))
  2922  		return true
  2923  	}
  2924  	return false
  2925  }
  2926  func rewriteValueARM_OpARMBIC(v *Value) bool {
  2927  	v_1 := v.Args[1]
  2928  	v_0 := v.Args[0]
  2929  	// match: (BIC x (MOVWconst [c]))
  2930  	// result: (BICconst [c] x)
  2931  	for {
  2932  		x := v_0
  2933  		if v_1.Op != OpARMMOVWconst {
  2934  			break
  2935  		}
  2936  		c := auxIntToInt32(v_1.AuxInt)
  2937  		v.reset(OpARMBICconst)
  2938  		v.AuxInt = int32ToAuxInt(c)
  2939  		v.AddArg(x)
  2940  		return true
  2941  	}
  2942  	// match: (BIC x (SLLconst [c] y))
  2943  	// result: (BICshiftLL x y [c])
  2944  	for {
  2945  		x := v_0
  2946  		if v_1.Op != OpARMSLLconst {
  2947  			break
  2948  		}
  2949  		c := auxIntToInt32(v_1.AuxInt)
  2950  		y := v_1.Args[0]
  2951  		v.reset(OpARMBICshiftLL)
  2952  		v.AuxInt = int32ToAuxInt(c)
  2953  		v.AddArg2(x, y)
  2954  		return true
  2955  	}
  2956  	// match: (BIC x (SRLconst [c] y))
  2957  	// result: (BICshiftRL x y [c])
  2958  	for {
  2959  		x := v_0
  2960  		if v_1.Op != OpARMSRLconst {
  2961  			break
  2962  		}
  2963  		c := auxIntToInt32(v_1.AuxInt)
  2964  		y := v_1.Args[0]
  2965  		v.reset(OpARMBICshiftRL)
  2966  		v.AuxInt = int32ToAuxInt(c)
  2967  		v.AddArg2(x, y)
  2968  		return true
  2969  	}
  2970  	// match: (BIC x (SRAconst [c] y))
  2971  	// result: (BICshiftRA x y [c])
  2972  	for {
  2973  		x := v_0
  2974  		if v_1.Op != OpARMSRAconst {
  2975  			break
  2976  		}
  2977  		c := auxIntToInt32(v_1.AuxInt)
  2978  		y := v_1.Args[0]
  2979  		v.reset(OpARMBICshiftRA)
  2980  		v.AuxInt = int32ToAuxInt(c)
  2981  		v.AddArg2(x, y)
  2982  		return true
  2983  	}
  2984  	// match: (BIC x (SLL y z))
  2985  	// result: (BICshiftLLreg x y z)
  2986  	for {
  2987  		x := v_0
  2988  		if v_1.Op != OpARMSLL {
  2989  			break
  2990  		}
  2991  		z := v_1.Args[1]
  2992  		y := v_1.Args[0]
  2993  		v.reset(OpARMBICshiftLLreg)
  2994  		v.AddArg3(x, y, z)
  2995  		return true
  2996  	}
  2997  	// match: (BIC x (SRL y z))
  2998  	// result: (BICshiftRLreg x y z)
  2999  	for {
  3000  		x := v_0
  3001  		if v_1.Op != OpARMSRL {
  3002  			break
  3003  		}
  3004  		z := v_1.Args[1]
  3005  		y := v_1.Args[0]
  3006  		v.reset(OpARMBICshiftRLreg)
  3007  		v.AddArg3(x, y, z)
  3008  		return true
  3009  	}
  3010  	// match: (BIC x (SRA y z))
  3011  	// result: (BICshiftRAreg x y z)
  3012  	for {
  3013  		x := v_0
  3014  		if v_1.Op != OpARMSRA {
  3015  			break
  3016  		}
  3017  		z := v_1.Args[1]
  3018  		y := v_1.Args[0]
  3019  		v.reset(OpARMBICshiftRAreg)
  3020  		v.AddArg3(x, y, z)
  3021  		return true
  3022  	}
  3023  	// match: (BIC x x)
  3024  	// result: (MOVWconst [0])
  3025  	for {
  3026  		x := v_0
  3027  		if x != v_1 {
  3028  			break
  3029  		}
  3030  		v.reset(OpARMMOVWconst)
  3031  		v.AuxInt = int32ToAuxInt(0)
  3032  		return true
  3033  	}
  3034  	return false
  3035  }
  3036  func rewriteValueARM_OpARMBICconst(v *Value) bool {
  3037  	v_0 := v.Args[0]
  3038  	// match: (BICconst [0] x)
  3039  	// result: x
  3040  	for {
  3041  		if auxIntToInt32(v.AuxInt) != 0 {
  3042  			break
  3043  		}
  3044  		x := v_0
  3045  		v.copyOf(x)
  3046  		return true
  3047  	}
  3048  	// match: (BICconst [c] _)
  3049  	// cond: int32(c)==-1
  3050  	// result: (MOVWconst [0])
  3051  	for {
  3052  		c := auxIntToInt32(v.AuxInt)
  3053  		if !(int32(c) == -1) {
  3054  			break
  3055  		}
  3056  		v.reset(OpARMMOVWconst)
  3057  		v.AuxInt = int32ToAuxInt(0)
  3058  		return true
  3059  	}
  3060  	// match: (BICconst [c] x)
  3061  	// cond: !isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))
  3062  	// result: (ANDconst [int32(^uint32(c))] x)
  3063  	for {
  3064  		c := auxIntToInt32(v.AuxInt)
  3065  		x := v_0
  3066  		if !(!isARMImmRot(uint32(c)) && isARMImmRot(^uint32(c))) {
  3067  			break
  3068  		}
  3069  		v.reset(OpARMANDconst)
  3070  		v.AuxInt = int32ToAuxInt(int32(^uint32(c)))
  3071  		v.AddArg(x)
  3072  		return true
  3073  	}
  3074  	// match: (BICconst [c] x)
  3075  	// cond: buildcfg.GOARM.Version==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && ^uint32(c)<=0xffff
  3076  	// result: (ANDconst [int32(^uint32(c))] x)
  3077  	for {
  3078  		c := auxIntToInt32(v.AuxInt)
  3079  		x := v_0
  3080  		if !(buildcfg.GOARM.Version == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && ^uint32(c) <= 0xffff) {
  3081  			break
  3082  		}
  3083  		v.reset(OpARMANDconst)
  3084  		v.AuxInt = int32ToAuxInt(int32(^uint32(c)))
  3085  		v.AddArg(x)
  3086  		return true
  3087  	}
  3088  	// match: (BICconst [c] (MOVWconst [d]))
  3089  	// result: (MOVWconst [d&^c])
  3090  	for {
  3091  		c := auxIntToInt32(v.AuxInt)
  3092  		if v_0.Op != OpARMMOVWconst {
  3093  			break
  3094  		}
  3095  		d := auxIntToInt32(v_0.AuxInt)
  3096  		v.reset(OpARMMOVWconst)
  3097  		v.AuxInt = int32ToAuxInt(d &^ c)
  3098  		return true
  3099  	}
  3100  	// match: (BICconst [c] (BICconst [d] x))
  3101  	// result: (BICconst [c|d] x)
  3102  	for {
  3103  		c := auxIntToInt32(v.AuxInt)
  3104  		if v_0.Op != OpARMBICconst {
  3105  			break
  3106  		}
  3107  		d := auxIntToInt32(v_0.AuxInt)
  3108  		x := v_0.Args[0]
  3109  		v.reset(OpARMBICconst)
  3110  		v.AuxInt = int32ToAuxInt(c | d)
  3111  		v.AddArg(x)
  3112  		return true
  3113  	}
  3114  	return false
  3115  }
  3116  func rewriteValueARM_OpARMBICshiftLL(v *Value) bool {
  3117  	v_1 := v.Args[1]
  3118  	v_0 := v.Args[0]
  3119  	// match: (BICshiftLL x (MOVWconst [c]) [d])
  3120  	// result: (BICconst x [c<<uint64(d)])
  3121  	for {
  3122  		d := auxIntToInt32(v.AuxInt)
  3123  		x := v_0
  3124  		if v_1.Op != OpARMMOVWconst {
  3125  			break
  3126  		}
  3127  		c := auxIntToInt32(v_1.AuxInt)
  3128  		v.reset(OpARMBICconst)
  3129  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  3130  		v.AddArg(x)
  3131  		return true
  3132  	}
  3133  	// match: (BICshiftLL (SLLconst x [c]) x [c])
  3134  	// result: (MOVWconst [0])
  3135  	for {
  3136  		c := auxIntToInt32(v.AuxInt)
  3137  		if v_0.Op != OpARMSLLconst || auxIntToInt32(v_0.AuxInt) != c {
  3138  			break
  3139  		}
  3140  		x := v_0.Args[0]
  3141  		if x != v_1 {
  3142  			break
  3143  		}
  3144  		v.reset(OpARMMOVWconst)
  3145  		v.AuxInt = int32ToAuxInt(0)
  3146  		return true
  3147  	}
  3148  	return false
  3149  }
  3150  func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool {
  3151  	v_2 := v.Args[2]
  3152  	v_1 := v.Args[1]
  3153  	v_0 := v.Args[0]
  3154  	// match: (BICshiftLLreg x y (MOVWconst [c]))
  3155  	// cond: 0 <= c && c < 32
  3156  	// result: (BICshiftLL x y [c])
  3157  	for {
  3158  		x := v_0
  3159  		y := v_1
  3160  		if v_2.Op != OpARMMOVWconst {
  3161  			break
  3162  		}
  3163  		c := auxIntToInt32(v_2.AuxInt)
  3164  		if !(0 <= c && c < 32) {
  3165  			break
  3166  		}
  3167  		v.reset(OpARMBICshiftLL)
  3168  		v.AuxInt = int32ToAuxInt(c)
  3169  		v.AddArg2(x, y)
  3170  		return true
  3171  	}
  3172  	return false
  3173  }
  3174  func rewriteValueARM_OpARMBICshiftRA(v *Value) bool {
  3175  	v_1 := v.Args[1]
  3176  	v_0 := v.Args[0]
  3177  	// match: (BICshiftRA x (MOVWconst [c]) [d])
  3178  	// result: (BICconst x [c>>uint64(d)])
  3179  	for {
  3180  		d := auxIntToInt32(v.AuxInt)
  3181  		x := v_0
  3182  		if v_1.Op != OpARMMOVWconst {
  3183  			break
  3184  		}
  3185  		c := auxIntToInt32(v_1.AuxInt)
  3186  		v.reset(OpARMBICconst)
  3187  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  3188  		v.AddArg(x)
  3189  		return true
  3190  	}
  3191  	// match: (BICshiftRA (SRAconst x [c]) x [c])
  3192  	// result: (MOVWconst [0])
  3193  	for {
  3194  		c := auxIntToInt32(v.AuxInt)
  3195  		if v_0.Op != OpARMSRAconst || auxIntToInt32(v_0.AuxInt) != c {
  3196  			break
  3197  		}
  3198  		x := v_0.Args[0]
  3199  		if x != v_1 {
  3200  			break
  3201  		}
  3202  		v.reset(OpARMMOVWconst)
  3203  		v.AuxInt = int32ToAuxInt(0)
  3204  		return true
  3205  	}
  3206  	return false
  3207  }
  3208  func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool {
  3209  	v_2 := v.Args[2]
  3210  	v_1 := v.Args[1]
  3211  	v_0 := v.Args[0]
  3212  	// match: (BICshiftRAreg x y (MOVWconst [c]))
  3213  	// cond: 0 <= c && c < 32
  3214  	// result: (BICshiftRA x y [c])
  3215  	for {
  3216  		x := v_0
  3217  		y := v_1
  3218  		if v_2.Op != OpARMMOVWconst {
  3219  			break
  3220  		}
  3221  		c := auxIntToInt32(v_2.AuxInt)
  3222  		if !(0 <= c && c < 32) {
  3223  			break
  3224  		}
  3225  		v.reset(OpARMBICshiftRA)
  3226  		v.AuxInt = int32ToAuxInt(c)
  3227  		v.AddArg2(x, y)
  3228  		return true
  3229  	}
  3230  	return false
  3231  }
  3232  func rewriteValueARM_OpARMBICshiftRL(v *Value) bool {
  3233  	v_1 := v.Args[1]
  3234  	v_0 := v.Args[0]
  3235  	// match: (BICshiftRL x (MOVWconst [c]) [d])
  3236  	// result: (BICconst x [int32(uint32(c)>>uint64(d))])
  3237  	for {
  3238  		d := auxIntToInt32(v.AuxInt)
  3239  		x := v_0
  3240  		if v_1.Op != OpARMMOVWconst {
  3241  			break
  3242  		}
  3243  		c := auxIntToInt32(v_1.AuxInt)
  3244  		v.reset(OpARMBICconst)
  3245  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  3246  		v.AddArg(x)
  3247  		return true
  3248  	}
  3249  	// match: (BICshiftRL (SRLconst x [c]) x [c])
  3250  	// result: (MOVWconst [0])
  3251  	for {
  3252  		c := auxIntToInt32(v.AuxInt)
  3253  		if v_0.Op != OpARMSRLconst || auxIntToInt32(v_0.AuxInt) != c {
  3254  			break
  3255  		}
  3256  		x := v_0.Args[0]
  3257  		if x != v_1 {
  3258  			break
  3259  		}
  3260  		v.reset(OpARMMOVWconst)
  3261  		v.AuxInt = int32ToAuxInt(0)
  3262  		return true
  3263  	}
  3264  	return false
  3265  }
  3266  func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool {
  3267  	v_2 := v.Args[2]
  3268  	v_1 := v.Args[1]
  3269  	v_0 := v.Args[0]
  3270  	// match: (BICshiftRLreg x y (MOVWconst [c]))
  3271  	// cond: 0 <= c && c < 32
  3272  	// result: (BICshiftRL x y [c])
  3273  	for {
  3274  		x := v_0
  3275  		y := v_1
  3276  		if v_2.Op != OpARMMOVWconst {
  3277  			break
  3278  		}
  3279  		c := auxIntToInt32(v_2.AuxInt)
  3280  		if !(0 <= c && c < 32) {
  3281  			break
  3282  		}
  3283  		v.reset(OpARMBICshiftRL)
  3284  		v.AuxInt = int32ToAuxInt(c)
  3285  		v.AddArg2(x, y)
  3286  		return true
  3287  	}
  3288  	return false
  3289  }
  3290  func rewriteValueARM_OpARMCMN(v *Value) bool {
  3291  	v_1 := v.Args[1]
  3292  	v_0 := v.Args[0]
  3293  	// match: (CMN x (MOVWconst [c]))
  3294  	// result: (CMNconst [c] x)
  3295  	for {
  3296  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3297  			x := v_0
  3298  			if v_1.Op != OpARMMOVWconst {
  3299  				continue
  3300  			}
  3301  			c := auxIntToInt32(v_1.AuxInt)
  3302  			v.reset(OpARMCMNconst)
  3303  			v.AuxInt = int32ToAuxInt(c)
  3304  			v.AddArg(x)
  3305  			return true
  3306  		}
  3307  		break
  3308  	}
  3309  	// match: (CMN x (SLLconst [c] y))
  3310  	// result: (CMNshiftLL x y [c])
  3311  	for {
  3312  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3313  			x := v_0
  3314  			if v_1.Op != OpARMSLLconst {
  3315  				continue
  3316  			}
  3317  			c := auxIntToInt32(v_1.AuxInt)
  3318  			y := v_1.Args[0]
  3319  			v.reset(OpARMCMNshiftLL)
  3320  			v.AuxInt = int32ToAuxInt(c)
  3321  			v.AddArg2(x, y)
  3322  			return true
  3323  		}
  3324  		break
  3325  	}
  3326  	// match: (CMN x (SRLconst [c] y))
  3327  	// result: (CMNshiftRL x y [c])
  3328  	for {
  3329  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3330  			x := v_0
  3331  			if v_1.Op != OpARMSRLconst {
  3332  				continue
  3333  			}
  3334  			c := auxIntToInt32(v_1.AuxInt)
  3335  			y := v_1.Args[0]
  3336  			v.reset(OpARMCMNshiftRL)
  3337  			v.AuxInt = int32ToAuxInt(c)
  3338  			v.AddArg2(x, y)
  3339  			return true
  3340  		}
  3341  		break
  3342  	}
  3343  	// match: (CMN x (SRAconst [c] y))
  3344  	// result: (CMNshiftRA x y [c])
  3345  	for {
  3346  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3347  			x := v_0
  3348  			if v_1.Op != OpARMSRAconst {
  3349  				continue
  3350  			}
  3351  			c := auxIntToInt32(v_1.AuxInt)
  3352  			y := v_1.Args[0]
  3353  			v.reset(OpARMCMNshiftRA)
  3354  			v.AuxInt = int32ToAuxInt(c)
  3355  			v.AddArg2(x, y)
  3356  			return true
  3357  		}
  3358  		break
  3359  	}
  3360  	// match: (CMN x (SLL y z))
  3361  	// result: (CMNshiftLLreg x y z)
  3362  	for {
  3363  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3364  			x := v_0
  3365  			if v_1.Op != OpARMSLL {
  3366  				continue
  3367  			}
  3368  			z := v_1.Args[1]
  3369  			y := v_1.Args[0]
  3370  			v.reset(OpARMCMNshiftLLreg)
  3371  			v.AddArg3(x, y, z)
  3372  			return true
  3373  		}
  3374  		break
  3375  	}
  3376  	// match: (CMN x (SRL y z))
  3377  	// result: (CMNshiftRLreg x y z)
  3378  	for {
  3379  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3380  			x := v_0
  3381  			if v_1.Op != OpARMSRL {
  3382  				continue
  3383  			}
  3384  			z := v_1.Args[1]
  3385  			y := v_1.Args[0]
  3386  			v.reset(OpARMCMNshiftRLreg)
  3387  			v.AddArg3(x, y, z)
  3388  			return true
  3389  		}
  3390  		break
  3391  	}
  3392  	// match: (CMN x (SRA y z))
  3393  	// result: (CMNshiftRAreg x y z)
  3394  	for {
  3395  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  3396  			x := v_0
  3397  			if v_1.Op != OpARMSRA {
  3398  				continue
  3399  			}
  3400  			z := v_1.Args[1]
  3401  			y := v_1.Args[0]
  3402  			v.reset(OpARMCMNshiftRAreg)
  3403  			v.AddArg3(x, y, z)
  3404  			return true
  3405  		}
  3406  		break
  3407  	}
  3408  	return false
  3409  }
  3410  func rewriteValueARM_OpARMCMNconst(v *Value) bool {
  3411  	v_0 := v.Args[0]
  3412  	// match: (CMNconst (MOVWconst [x]) [y])
  3413  	// result: (FlagConstant [addFlags32(x,y)])
  3414  	for {
  3415  		y := auxIntToInt32(v.AuxInt)
  3416  		if v_0.Op != OpARMMOVWconst {
  3417  			break
  3418  		}
  3419  		x := auxIntToInt32(v_0.AuxInt)
  3420  		v.reset(OpARMFlagConstant)
  3421  		v.AuxInt = flagConstantToAuxInt(addFlags32(x, y))
  3422  		return true
  3423  	}
  3424  	return false
  3425  }
  3426  func rewriteValueARM_OpARMCMNshiftLL(v *Value) bool {
  3427  	v_1 := v.Args[1]
  3428  	v_0 := v.Args[0]
  3429  	b := v.Block
  3430  	// match: (CMNshiftLL (MOVWconst [c]) x [d])
  3431  	// result: (CMNconst [c] (SLLconst <x.Type> x [d]))
  3432  	for {
  3433  		d := auxIntToInt32(v.AuxInt)
  3434  		if v_0.Op != OpARMMOVWconst {
  3435  			break
  3436  		}
  3437  		c := auxIntToInt32(v_0.AuxInt)
  3438  		x := v_1
  3439  		v.reset(OpARMCMNconst)
  3440  		v.AuxInt = int32ToAuxInt(c)
  3441  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  3442  		v0.AuxInt = int32ToAuxInt(d)
  3443  		v0.AddArg(x)
  3444  		v.AddArg(v0)
  3445  		return true
  3446  	}
  3447  	// match: (CMNshiftLL x (MOVWconst [c]) [d])
  3448  	// result: (CMNconst x [c<<uint64(d)])
  3449  	for {
  3450  		d := auxIntToInt32(v.AuxInt)
  3451  		x := v_0
  3452  		if v_1.Op != OpARMMOVWconst {
  3453  			break
  3454  		}
  3455  		c := auxIntToInt32(v_1.AuxInt)
  3456  		v.reset(OpARMCMNconst)
  3457  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  3458  		v.AddArg(x)
  3459  		return true
  3460  	}
  3461  	return false
  3462  }
  3463  func rewriteValueARM_OpARMCMNshiftLLreg(v *Value) bool {
  3464  	v_2 := v.Args[2]
  3465  	v_1 := v.Args[1]
  3466  	v_0 := v.Args[0]
  3467  	b := v.Block
  3468  	// match: (CMNshiftLLreg (MOVWconst [c]) x y)
  3469  	// result: (CMNconst [c] (SLL <x.Type> x y))
  3470  	for {
  3471  		if v_0.Op != OpARMMOVWconst {
  3472  			break
  3473  		}
  3474  		c := auxIntToInt32(v_0.AuxInt)
  3475  		x := v_1
  3476  		y := v_2
  3477  		v.reset(OpARMCMNconst)
  3478  		v.AuxInt = int32ToAuxInt(c)
  3479  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  3480  		v0.AddArg2(x, y)
  3481  		v.AddArg(v0)
  3482  		return true
  3483  	}
  3484  	// match: (CMNshiftLLreg x y (MOVWconst [c]))
  3485  	// cond: 0 <= c && c < 32
  3486  	// result: (CMNshiftLL x y [c])
  3487  	for {
  3488  		x := v_0
  3489  		y := v_1
  3490  		if v_2.Op != OpARMMOVWconst {
  3491  			break
  3492  		}
  3493  		c := auxIntToInt32(v_2.AuxInt)
  3494  		if !(0 <= c && c < 32) {
  3495  			break
  3496  		}
  3497  		v.reset(OpARMCMNshiftLL)
  3498  		v.AuxInt = int32ToAuxInt(c)
  3499  		v.AddArg2(x, y)
  3500  		return true
  3501  	}
  3502  	return false
  3503  }
  3504  func rewriteValueARM_OpARMCMNshiftRA(v *Value) bool {
  3505  	v_1 := v.Args[1]
  3506  	v_0 := v.Args[0]
  3507  	b := v.Block
  3508  	// match: (CMNshiftRA (MOVWconst [c]) x [d])
  3509  	// result: (CMNconst [c] (SRAconst <x.Type> x [d]))
  3510  	for {
  3511  		d := auxIntToInt32(v.AuxInt)
  3512  		if v_0.Op != OpARMMOVWconst {
  3513  			break
  3514  		}
  3515  		c := auxIntToInt32(v_0.AuxInt)
  3516  		x := v_1
  3517  		v.reset(OpARMCMNconst)
  3518  		v.AuxInt = int32ToAuxInt(c)
  3519  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  3520  		v0.AuxInt = int32ToAuxInt(d)
  3521  		v0.AddArg(x)
  3522  		v.AddArg(v0)
  3523  		return true
  3524  	}
  3525  	// match: (CMNshiftRA x (MOVWconst [c]) [d])
  3526  	// result: (CMNconst x [c>>uint64(d)])
  3527  	for {
  3528  		d := auxIntToInt32(v.AuxInt)
  3529  		x := v_0
  3530  		if v_1.Op != OpARMMOVWconst {
  3531  			break
  3532  		}
  3533  		c := auxIntToInt32(v_1.AuxInt)
  3534  		v.reset(OpARMCMNconst)
  3535  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  3536  		v.AddArg(x)
  3537  		return true
  3538  	}
  3539  	return false
  3540  }
  3541  func rewriteValueARM_OpARMCMNshiftRAreg(v *Value) bool {
  3542  	v_2 := v.Args[2]
  3543  	v_1 := v.Args[1]
  3544  	v_0 := v.Args[0]
  3545  	b := v.Block
  3546  	// match: (CMNshiftRAreg (MOVWconst [c]) x y)
  3547  	// result: (CMNconst [c] (SRA <x.Type> x y))
  3548  	for {
  3549  		if v_0.Op != OpARMMOVWconst {
  3550  			break
  3551  		}
  3552  		c := auxIntToInt32(v_0.AuxInt)
  3553  		x := v_1
  3554  		y := v_2
  3555  		v.reset(OpARMCMNconst)
  3556  		v.AuxInt = int32ToAuxInt(c)
  3557  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  3558  		v0.AddArg2(x, y)
  3559  		v.AddArg(v0)
  3560  		return true
  3561  	}
  3562  	// match: (CMNshiftRAreg x y (MOVWconst [c]))
  3563  	// cond: 0 <= c && c < 32
  3564  	// result: (CMNshiftRA x y [c])
  3565  	for {
  3566  		x := v_0
  3567  		y := v_1
  3568  		if v_2.Op != OpARMMOVWconst {
  3569  			break
  3570  		}
  3571  		c := auxIntToInt32(v_2.AuxInt)
  3572  		if !(0 <= c && c < 32) {
  3573  			break
  3574  		}
  3575  		v.reset(OpARMCMNshiftRA)
  3576  		v.AuxInt = int32ToAuxInt(c)
  3577  		v.AddArg2(x, y)
  3578  		return true
  3579  	}
  3580  	return false
  3581  }
  3582  func rewriteValueARM_OpARMCMNshiftRL(v *Value) bool {
  3583  	v_1 := v.Args[1]
  3584  	v_0 := v.Args[0]
  3585  	b := v.Block
  3586  	// match: (CMNshiftRL (MOVWconst [c]) x [d])
  3587  	// result: (CMNconst [c] (SRLconst <x.Type> x [d]))
  3588  	for {
  3589  		d := auxIntToInt32(v.AuxInt)
  3590  		if v_0.Op != OpARMMOVWconst {
  3591  			break
  3592  		}
  3593  		c := auxIntToInt32(v_0.AuxInt)
  3594  		x := v_1
  3595  		v.reset(OpARMCMNconst)
  3596  		v.AuxInt = int32ToAuxInt(c)
  3597  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  3598  		v0.AuxInt = int32ToAuxInt(d)
  3599  		v0.AddArg(x)
  3600  		v.AddArg(v0)
  3601  		return true
  3602  	}
  3603  	// match: (CMNshiftRL x (MOVWconst [c]) [d])
  3604  	// result: (CMNconst x [int32(uint32(c)>>uint64(d))])
  3605  	for {
  3606  		d := auxIntToInt32(v.AuxInt)
  3607  		x := v_0
  3608  		if v_1.Op != OpARMMOVWconst {
  3609  			break
  3610  		}
  3611  		c := auxIntToInt32(v_1.AuxInt)
  3612  		v.reset(OpARMCMNconst)
  3613  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  3614  		v.AddArg(x)
  3615  		return true
  3616  	}
  3617  	return false
  3618  }
  3619  func rewriteValueARM_OpARMCMNshiftRLreg(v *Value) bool {
  3620  	v_2 := v.Args[2]
  3621  	v_1 := v.Args[1]
  3622  	v_0 := v.Args[0]
  3623  	b := v.Block
  3624  	// match: (CMNshiftRLreg (MOVWconst [c]) x y)
  3625  	// result: (CMNconst [c] (SRL <x.Type> x y))
  3626  	for {
  3627  		if v_0.Op != OpARMMOVWconst {
  3628  			break
  3629  		}
  3630  		c := auxIntToInt32(v_0.AuxInt)
  3631  		x := v_1
  3632  		y := v_2
  3633  		v.reset(OpARMCMNconst)
  3634  		v.AuxInt = int32ToAuxInt(c)
  3635  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  3636  		v0.AddArg2(x, y)
  3637  		v.AddArg(v0)
  3638  		return true
  3639  	}
  3640  	// match: (CMNshiftRLreg x y (MOVWconst [c]))
  3641  	// cond: 0 <= c && c < 32
  3642  	// result: (CMNshiftRL x y [c])
  3643  	for {
  3644  		x := v_0
  3645  		y := v_1
  3646  		if v_2.Op != OpARMMOVWconst {
  3647  			break
  3648  		}
  3649  		c := auxIntToInt32(v_2.AuxInt)
  3650  		if !(0 <= c && c < 32) {
  3651  			break
  3652  		}
  3653  		v.reset(OpARMCMNshiftRL)
  3654  		v.AuxInt = int32ToAuxInt(c)
  3655  		v.AddArg2(x, y)
  3656  		return true
  3657  	}
  3658  	return false
  3659  }
  3660  func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool {
  3661  	v_1 := v.Args[1]
  3662  	v_0 := v.Args[0]
  3663  	// match: (CMOVWHSconst _ (FlagConstant [fc]) [c])
  3664  	// cond: fc.uge()
  3665  	// result: (MOVWconst [c])
  3666  	for {
  3667  		c := auxIntToInt32(v.AuxInt)
  3668  		if v_1.Op != OpARMFlagConstant {
  3669  			break
  3670  		}
  3671  		fc := auxIntToFlagConstant(v_1.AuxInt)
  3672  		if !(fc.uge()) {
  3673  			break
  3674  		}
  3675  		v.reset(OpARMMOVWconst)
  3676  		v.AuxInt = int32ToAuxInt(c)
  3677  		return true
  3678  	}
  3679  	// match: (CMOVWHSconst x (FlagConstant [fc]) [c])
  3680  	// cond: fc.ult()
  3681  	// result: x
  3682  	for {
  3683  		x := v_0
  3684  		if v_1.Op != OpARMFlagConstant {
  3685  			break
  3686  		}
  3687  		fc := auxIntToFlagConstant(v_1.AuxInt)
  3688  		if !(fc.ult()) {
  3689  			break
  3690  		}
  3691  		v.copyOf(x)
  3692  		return true
  3693  	}
  3694  	// match: (CMOVWHSconst x (InvertFlags flags) [c])
  3695  	// result: (CMOVWLSconst x flags [c])
  3696  	for {
  3697  		c := auxIntToInt32(v.AuxInt)
  3698  		x := v_0
  3699  		if v_1.Op != OpARMInvertFlags {
  3700  			break
  3701  		}
  3702  		flags := v_1.Args[0]
  3703  		v.reset(OpARMCMOVWLSconst)
  3704  		v.AuxInt = int32ToAuxInt(c)
  3705  		v.AddArg2(x, flags)
  3706  		return true
  3707  	}
  3708  	return false
  3709  }
  3710  func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool {
  3711  	v_1 := v.Args[1]
  3712  	v_0 := v.Args[0]
  3713  	// match: (CMOVWLSconst _ (FlagConstant [fc]) [c])
  3714  	// cond: fc.ule()
  3715  	// result: (MOVWconst [c])
  3716  	for {
  3717  		c := auxIntToInt32(v.AuxInt)
  3718  		if v_1.Op != OpARMFlagConstant {
  3719  			break
  3720  		}
  3721  		fc := auxIntToFlagConstant(v_1.AuxInt)
  3722  		if !(fc.ule()) {
  3723  			break
  3724  		}
  3725  		v.reset(OpARMMOVWconst)
  3726  		v.AuxInt = int32ToAuxInt(c)
  3727  		return true
  3728  	}
  3729  	// match: (CMOVWLSconst x (FlagConstant [fc]) [c])
  3730  	// cond: fc.ugt()
  3731  	// result: x
  3732  	for {
  3733  		x := v_0
  3734  		if v_1.Op != OpARMFlagConstant {
  3735  			break
  3736  		}
  3737  		fc := auxIntToFlagConstant(v_1.AuxInt)
  3738  		if !(fc.ugt()) {
  3739  			break
  3740  		}
  3741  		v.copyOf(x)
  3742  		return true
  3743  	}
  3744  	// match: (CMOVWLSconst x (InvertFlags flags) [c])
  3745  	// result: (CMOVWHSconst x flags [c])
  3746  	for {
  3747  		c := auxIntToInt32(v.AuxInt)
  3748  		x := v_0
  3749  		if v_1.Op != OpARMInvertFlags {
  3750  			break
  3751  		}
  3752  		flags := v_1.Args[0]
  3753  		v.reset(OpARMCMOVWHSconst)
  3754  		v.AuxInt = int32ToAuxInt(c)
  3755  		v.AddArg2(x, flags)
  3756  		return true
  3757  	}
  3758  	return false
  3759  }
  3760  func rewriteValueARM_OpARMCMP(v *Value) bool {
  3761  	v_1 := v.Args[1]
  3762  	v_0 := v.Args[0]
  3763  	b := v.Block
  3764  	// match: (CMP x (MOVWconst [c]))
  3765  	// result: (CMPconst [c] x)
  3766  	for {
  3767  		x := v_0
  3768  		if v_1.Op != OpARMMOVWconst {
  3769  			break
  3770  		}
  3771  		c := auxIntToInt32(v_1.AuxInt)
  3772  		v.reset(OpARMCMPconst)
  3773  		v.AuxInt = int32ToAuxInt(c)
  3774  		v.AddArg(x)
  3775  		return true
  3776  	}
  3777  	// match: (CMP (MOVWconst [c]) x)
  3778  	// result: (InvertFlags (CMPconst [c] x))
  3779  	for {
  3780  		if v_0.Op != OpARMMOVWconst {
  3781  			break
  3782  		}
  3783  		c := auxIntToInt32(v_0.AuxInt)
  3784  		x := v_1
  3785  		v.reset(OpARMInvertFlags)
  3786  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  3787  		v0.AuxInt = int32ToAuxInt(c)
  3788  		v0.AddArg(x)
  3789  		v.AddArg(v0)
  3790  		return true
  3791  	}
  3792  	// match: (CMP x y)
  3793  	// cond: canonLessThan(x,y)
  3794  	// result: (InvertFlags (CMP y x))
  3795  	for {
  3796  		x := v_0
  3797  		y := v_1
  3798  		if !(canonLessThan(x, y)) {
  3799  			break
  3800  		}
  3801  		v.reset(OpARMInvertFlags)
  3802  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
  3803  		v0.AddArg2(y, x)
  3804  		v.AddArg(v0)
  3805  		return true
  3806  	}
  3807  	// match: (CMP x (SLLconst [c] y))
  3808  	// result: (CMPshiftLL x y [c])
  3809  	for {
  3810  		x := v_0
  3811  		if v_1.Op != OpARMSLLconst {
  3812  			break
  3813  		}
  3814  		c := auxIntToInt32(v_1.AuxInt)
  3815  		y := v_1.Args[0]
  3816  		v.reset(OpARMCMPshiftLL)
  3817  		v.AuxInt = int32ToAuxInt(c)
  3818  		v.AddArg2(x, y)
  3819  		return true
  3820  	}
  3821  	// match: (CMP (SLLconst [c] y) x)
  3822  	// result: (InvertFlags (CMPshiftLL x y [c]))
  3823  	for {
  3824  		if v_0.Op != OpARMSLLconst {
  3825  			break
  3826  		}
  3827  		c := auxIntToInt32(v_0.AuxInt)
  3828  		y := v_0.Args[0]
  3829  		x := v_1
  3830  		v.reset(OpARMInvertFlags)
  3831  		v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
  3832  		v0.AuxInt = int32ToAuxInt(c)
  3833  		v0.AddArg2(x, y)
  3834  		v.AddArg(v0)
  3835  		return true
  3836  	}
  3837  	// match: (CMP x (SRLconst [c] y))
  3838  	// result: (CMPshiftRL x y [c])
  3839  	for {
  3840  		x := v_0
  3841  		if v_1.Op != OpARMSRLconst {
  3842  			break
  3843  		}
  3844  		c := auxIntToInt32(v_1.AuxInt)
  3845  		y := v_1.Args[0]
  3846  		v.reset(OpARMCMPshiftRL)
  3847  		v.AuxInt = int32ToAuxInt(c)
  3848  		v.AddArg2(x, y)
  3849  		return true
  3850  	}
  3851  	// match: (CMP (SRLconst [c] y) x)
  3852  	// result: (InvertFlags (CMPshiftRL x y [c]))
  3853  	for {
  3854  		if v_0.Op != OpARMSRLconst {
  3855  			break
  3856  		}
  3857  		c := auxIntToInt32(v_0.AuxInt)
  3858  		y := v_0.Args[0]
  3859  		x := v_1
  3860  		v.reset(OpARMInvertFlags)
  3861  		v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
  3862  		v0.AuxInt = int32ToAuxInt(c)
  3863  		v0.AddArg2(x, y)
  3864  		v.AddArg(v0)
  3865  		return true
  3866  	}
  3867  	// match: (CMP x (SRAconst [c] y))
  3868  	// result: (CMPshiftRA x y [c])
  3869  	for {
  3870  		x := v_0
  3871  		if v_1.Op != OpARMSRAconst {
  3872  			break
  3873  		}
  3874  		c := auxIntToInt32(v_1.AuxInt)
  3875  		y := v_1.Args[0]
  3876  		v.reset(OpARMCMPshiftRA)
  3877  		v.AuxInt = int32ToAuxInt(c)
  3878  		v.AddArg2(x, y)
  3879  		return true
  3880  	}
  3881  	// match: (CMP (SRAconst [c] y) x)
  3882  	// result: (InvertFlags (CMPshiftRA x y [c]))
  3883  	for {
  3884  		if v_0.Op != OpARMSRAconst {
  3885  			break
  3886  		}
  3887  		c := auxIntToInt32(v_0.AuxInt)
  3888  		y := v_0.Args[0]
  3889  		x := v_1
  3890  		v.reset(OpARMInvertFlags)
  3891  		v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
  3892  		v0.AuxInt = int32ToAuxInt(c)
  3893  		v0.AddArg2(x, y)
  3894  		v.AddArg(v0)
  3895  		return true
  3896  	}
  3897  	// match: (CMP x (SLL y z))
  3898  	// result: (CMPshiftLLreg x y z)
  3899  	for {
  3900  		x := v_0
  3901  		if v_1.Op != OpARMSLL {
  3902  			break
  3903  		}
  3904  		z := v_1.Args[1]
  3905  		y := v_1.Args[0]
  3906  		v.reset(OpARMCMPshiftLLreg)
  3907  		v.AddArg3(x, y, z)
  3908  		return true
  3909  	}
  3910  	// match: (CMP (SLL y z) x)
  3911  	// result: (InvertFlags (CMPshiftLLreg x y z))
  3912  	for {
  3913  		if v_0.Op != OpARMSLL {
  3914  			break
  3915  		}
  3916  		z := v_0.Args[1]
  3917  		y := v_0.Args[0]
  3918  		x := v_1
  3919  		v.reset(OpARMInvertFlags)
  3920  		v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
  3921  		v0.AddArg3(x, y, z)
  3922  		v.AddArg(v0)
  3923  		return true
  3924  	}
  3925  	// match: (CMP x (SRL y z))
  3926  	// result: (CMPshiftRLreg x y z)
  3927  	for {
  3928  		x := v_0
  3929  		if v_1.Op != OpARMSRL {
  3930  			break
  3931  		}
  3932  		z := v_1.Args[1]
  3933  		y := v_1.Args[0]
  3934  		v.reset(OpARMCMPshiftRLreg)
  3935  		v.AddArg3(x, y, z)
  3936  		return true
  3937  	}
  3938  	// match: (CMP (SRL y z) x)
  3939  	// result: (InvertFlags (CMPshiftRLreg x y z))
  3940  	for {
  3941  		if v_0.Op != OpARMSRL {
  3942  			break
  3943  		}
  3944  		z := v_0.Args[1]
  3945  		y := v_0.Args[0]
  3946  		x := v_1
  3947  		v.reset(OpARMInvertFlags)
  3948  		v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
  3949  		v0.AddArg3(x, y, z)
  3950  		v.AddArg(v0)
  3951  		return true
  3952  	}
  3953  	// match: (CMP x (SRA y z))
  3954  	// result: (CMPshiftRAreg x y z)
  3955  	for {
  3956  		x := v_0
  3957  		if v_1.Op != OpARMSRA {
  3958  			break
  3959  		}
  3960  		z := v_1.Args[1]
  3961  		y := v_1.Args[0]
  3962  		v.reset(OpARMCMPshiftRAreg)
  3963  		v.AddArg3(x, y, z)
  3964  		return true
  3965  	}
  3966  	// match: (CMP (SRA y z) x)
  3967  	// result: (InvertFlags (CMPshiftRAreg x y z))
  3968  	for {
  3969  		if v_0.Op != OpARMSRA {
  3970  			break
  3971  		}
  3972  		z := v_0.Args[1]
  3973  		y := v_0.Args[0]
  3974  		x := v_1
  3975  		v.reset(OpARMInvertFlags)
  3976  		v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
  3977  		v0.AddArg3(x, y, z)
  3978  		v.AddArg(v0)
  3979  		return true
  3980  	}
  3981  	return false
  3982  }
  3983  func rewriteValueARM_OpARMCMPD(v *Value) bool {
  3984  	v_1 := v.Args[1]
  3985  	v_0 := v.Args[0]
  3986  	// match: (CMPD x (MOVDconst [0]))
  3987  	// result: (CMPD0 x)
  3988  	for {
  3989  		x := v_0
  3990  		if v_1.Op != OpARMMOVDconst || auxIntToFloat64(v_1.AuxInt) != 0 {
  3991  			break
  3992  		}
  3993  		v.reset(OpARMCMPD0)
  3994  		v.AddArg(x)
  3995  		return true
  3996  	}
  3997  	return false
  3998  }
  3999  func rewriteValueARM_OpARMCMPF(v *Value) bool {
  4000  	v_1 := v.Args[1]
  4001  	v_0 := v.Args[0]
  4002  	// match: (CMPF x (MOVFconst [0]))
  4003  	// result: (CMPF0 x)
  4004  	for {
  4005  		x := v_0
  4006  		if v_1.Op != OpARMMOVFconst || auxIntToFloat64(v_1.AuxInt) != 0 {
  4007  			break
  4008  		}
  4009  		v.reset(OpARMCMPF0)
  4010  		v.AddArg(x)
  4011  		return true
  4012  	}
  4013  	return false
  4014  }
  4015  func rewriteValueARM_OpARMCMPconst(v *Value) bool {
  4016  	v_0 := v.Args[0]
  4017  	// match: (CMPconst (MOVWconst [x]) [y])
  4018  	// result: (FlagConstant [subFlags32(x,y)])
  4019  	for {
  4020  		y := auxIntToInt32(v.AuxInt)
  4021  		if v_0.Op != OpARMMOVWconst {
  4022  			break
  4023  		}
  4024  		x := auxIntToInt32(v_0.AuxInt)
  4025  		v.reset(OpARMFlagConstant)
  4026  		v.AuxInt = flagConstantToAuxInt(subFlags32(x, y))
  4027  		return true
  4028  	}
  4029  	// match: (CMPconst (MOVBUreg _) [c])
  4030  	// cond: 0xff < c
  4031  	// result: (FlagConstant [subFlags32(0, 1)])
  4032  	for {
  4033  		c := auxIntToInt32(v.AuxInt)
  4034  		if v_0.Op != OpARMMOVBUreg || !(0xff < c) {
  4035  			break
  4036  		}
  4037  		v.reset(OpARMFlagConstant)
  4038  		v.AuxInt = flagConstantToAuxInt(subFlags32(0, 1))
  4039  		return true
  4040  	}
  4041  	// match: (CMPconst (MOVHUreg _) [c])
  4042  	// cond: 0xffff < c
  4043  	// result: (FlagConstant [subFlags32(0, 1)])
  4044  	for {
  4045  		c := auxIntToInt32(v.AuxInt)
  4046  		if v_0.Op != OpARMMOVHUreg || !(0xffff < c) {
  4047  			break
  4048  		}
  4049  		v.reset(OpARMFlagConstant)
  4050  		v.AuxInt = flagConstantToAuxInt(subFlags32(0, 1))
  4051  		return true
  4052  	}
  4053  	// match: (CMPconst (ANDconst _ [m]) [n])
  4054  	// cond: 0 <= m && m < n
  4055  	// result: (FlagConstant [subFlags32(0, 1)])
  4056  	for {
  4057  		n := auxIntToInt32(v.AuxInt)
  4058  		if v_0.Op != OpARMANDconst {
  4059  			break
  4060  		}
  4061  		m := auxIntToInt32(v_0.AuxInt)
  4062  		if !(0 <= m && m < n) {
  4063  			break
  4064  		}
  4065  		v.reset(OpARMFlagConstant)
  4066  		v.AuxInt = flagConstantToAuxInt(subFlags32(0, 1))
  4067  		return true
  4068  	}
  4069  	// match: (CMPconst (SRLconst _ [c]) [n])
  4070  	// cond: 0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n)
  4071  	// result: (FlagConstant [subFlags32(0, 1)])
  4072  	for {
  4073  		n := auxIntToInt32(v.AuxInt)
  4074  		if v_0.Op != OpARMSRLconst {
  4075  			break
  4076  		}
  4077  		c := auxIntToInt32(v_0.AuxInt)
  4078  		if !(0 <= n && 0 < c && c <= 32 && (1<<uint32(32-c)) <= uint32(n)) {
  4079  			break
  4080  		}
  4081  		v.reset(OpARMFlagConstant)
  4082  		v.AuxInt = flagConstantToAuxInt(subFlags32(0, 1))
  4083  		return true
  4084  	}
  4085  	return false
  4086  }
  4087  func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool {
  4088  	v_1 := v.Args[1]
  4089  	v_0 := v.Args[0]
  4090  	b := v.Block
  4091  	// match: (CMPshiftLL (MOVWconst [c]) x [d])
  4092  	// result: (InvertFlags (CMPconst [c] (SLLconst <x.Type> x [d])))
  4093  	for {
  4094  		d := auxIntToInt32(v.AuxInt)
  4095  		if v_0.Op != OpARMMOVWconst {
  4096  			break
  4097  		}
  4098  		c := auxIntToInt32(v_0.AuxInt)
  4099  		x := v_1
  4100  		v.reset(OpARMInvertFlags)
  4101  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  4102  		v0.AuxInt = int32ToAuxInt(c)
  4103  		v1 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  4104  		v1.AuxInt = int32ToAuxInt(d)
  4105  		v1.AddArg(x)
  4106  		v0.AddArg(v1)
  4107  		v.AddArg(v0)
  4108  		return true
  4109  	}
  4110  	// match: (CMPshiftLL x (MOVWconst [c]) [d])
  4111  	// result: (CMPconst x [c<<uint64(d)])
  4112  	for {
  4113  		d := auxIntToInt32(v.AuxInt)
  4114  		x := v_0
  4115  		if v_1.Op != OpARMMOVWconst {
  4116  			break
  4117  		}
  4118  		c := auxIntToInt32(v_1.AuxInt)
  4119  		v.reset(OpARMCMPconst)
  4120  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  4121  		v.AddArg(x)
  4122  		return true
  4123  	}
  4124  	return false
  4125  }
  4126  func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool {
  4127  	v_2 := v.Args[2]
  4128  	v_1 := v.Args[1]
  4129  	v_0 := v.Args[0]
  4130  	b := v.Block
  4131  	// match: (CMPshiftLLreg (MOVWconst [c]) x y)
  4132  	// result: (InvertFlags (CMPconst [c] (SLL <x.Type> x y)))
  4133  	for {
  4134  		if v_0.Op != OpARMMOVWconst {
  4135  			break
  4136  		}
  4137  		c := auxIntToInt32(v_0.AuxInt)
  4138  		x := v_1
  4139  		y := v_2
  4140  		v.reset(OpARMInvertFlags)
  4141  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  4142  		v0.AuxInt = int32ToAuxInt(c)
  4143  		v1 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  4144  		v1.AddArg2(x, y)
  4145  		v0.AddArg(v1)
  4146  		v.AddArg(v0)
  4147  		return true
  4148  	}
  4149  	// match: (CMPshiftLLreg x y (MOVWconst [c]))
  4150  	// cond: 0 <= c && c < 32
  4151  	// result: (CMPshiftLL x y [c])
  4152  	for {
  4153  		x := v_0
  4154  		y := v_1
  4155  		if v_2.Op != OpARMMOVWconst {
  4156  			break
  4157  		}
  4158  		c := auxIntToInt32(v_2.AuxInt)
  4159  		if !(0 <= c && c < 32) {
  4160  			break
  4161  		}
  4162  		v.reset(OpARMCMPshiftLL)
  4163  		v.AuxInt = int32ToAuxInt(c)
  4164  		v.AddArg2(x, y)
  4165  		return true
  4166  	}
  4167  	return false
  4168  }
  4169  func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool {
  4170  	v_1 := v.Args[1]
  4171  	v_0 := v.Args[0]
  4172  	b := v.Block
  4173  	// match: (CMPshiftRA (MOVWconst [c]) x [d])
  4174  	// result: (InvertFlags (CMPconst [c] (SRAconst <x.Type> x [d])))
  4175  	for {
  4176  		d := auxIntToInt32(v.AuxInt)
  4177  		if v_0.Op != OpARMMOVWconst {
  4178  			break
  4179  		}
  4180  		c := auxIntToInt32(v_0.AuxInt)
  4181  		x := v_1
  4182  		v.reset(OpARMInvertFlags)
  4183  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  4184  		v0.AuxInt = int32ToAuxInt(c)
  4185  		v1 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  4186  		v1.AuxInt = int32ToAuxInt(d)
  4187  		v1.AddArg(x)
  4188  		v0.AddArg(v1)
  4189  		v.AddArg(v0)
  4190  		return true
  4191  	}
  4192  	// match: (CMPshiftRA x (MOVWconst [c]) [d])
  4193  	// result: (CMPconst x [c>>uint64(d)])
  4194  	for {
  4195  		d := auxIntToInt32(v.AuxInt)
  4196  		x := v_0
  4197  		if v_1.Op != OpARMMOVWconst {
  4198  			break
  4199  		}
  4200  		c := auxIntToInt32(v_1.AuxInt)
  4201  		v.reset(OpARMCMPconst)
  4202  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  4203  		v.AddArg(x)
  4204  		return true
  4205  	}
  4206  	return false
  4207  }
  4208  func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool {
  4209  	v_2 := v.Args[2]
  4210  	v_1 := v.Args[1]
  4211  	v_0 := v.Args[0]
  4212  	b := v.Block
  4213  	// match: (CMPshiftRAreg (MOVWconst [c]) x y)
  4214  	// result: (InvertFlags (CMPconst [c] (SRA <x.Type> x y)))
  4215  	for {
  4216  		if v_0.Op != OpARMMOVWconst {
  4217  			break
  4218  		}
  4219  		c := auxIntToInt32(v_0.AuxInt)
  4220  		x := v_1
  4221  		y := v_2
  4222  		v.reset(OpARMInvertFlags)
  4223  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  4224  		v0.AuxInt = int32ToAuxInt(c)
  4225  		v1 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  4226  		v1.AddArg2(x, y)
  4227  		v0.AddArg(v1)
  4228  		v.AddArg(v0)
  4229  		return true
  4230  	}
  4231  	// match: (CMPshiftRAreg x y (MOVWconst [c]))
  4232  	// cond: 0 <= c && c < 32
  4233  	// result: (CMPshiftRA x y [c])
  4234  	for {
  4235  		x := v_0
  4236  		y := v_1
  4237  		if v_2.Op != OpARMMOVWconst {
  4238  			break
  4239  		}
  4240  		c := auxIntToInt32(v_2.AuxInt)
  4241  		if !(0 <= c && c < 32) {
  4242  			break
  4243  		}
  4244  		v.reset(OpARMCMPshiftRA)
  4245  		v.AuxInt = int32ToAuxInt(c)
  4246  		v.AddArg2(x, y)
  4247  		return true
  4248  	}
  4249  	return false
  4250  }
  4251  func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool {
  4252  	v_1 := v.Args[1]
  4253  	v_0 := v.Args[0]
  4254  	b := v.Block
  4255  	// match: (CMPshiftRL (MOVWconst [c]) x [d])
  4256  	// result: (InvertFlags (CMPconst [c] (SRLconst <x.Type> x [d])))
  4257  	for {
  4258  		d := auxIntToInt32(v.AuxInt)
  4259  		if v_0.Op != OpARMMOVWconst {
  4260  			break
  4261  		}
  4262  		c := auxIntToInt32(v_0.AuxInt)
  4263  		x := v_1
  4264  		v.reset(OpARMInvertFlags)
  4265  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  4266  		v0.AuxInt = int32ToAuxInt(c)
  4267  		v1 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  4268  		v1.AuxInt = int32ToAuxInt(d)
  4269  		v1.AddArg(x)
  4270  		v0.AddArg(v1)
  4271  		v.AddArg(v0)
  4272  		return true
  4273  	}
  4274  	// match: (CMPshiftRL x (MOVWconst [c]) [d])
  4275  	// result: (CMPconst x [int32(uint32(c)>>uint64(d))])
  4276  	for {
  4277  		d := auxIntToInt32(v.AuxInt)
  4278  		x := v_0
  4279  		if v_1.Op != OpARMMOVWconst {
  4280  			break
  4281  		}
  4282  		c := auxIntToInt32(v_1.AuxInt)
  4283  		v.reset(OpARMCMPconst)
  4284  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  4285  		v.AddArg(x)
  4286  		return true
  4287  	}
  4288  	return false
  4289  }
  4290  func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool {
  4291  	v_2 := v.Args[2]
  4292  	v_1 := v.Args[1]
  4293  	v_0 := v.Args[0]
  4294  	b := v.Block
  4295  	// match: (CMPshiftRLreg (MOVWconst [c]) x y)
  4296  	// result: (InvertFlags (CMPconst [c] (SRL <x.Type> x y)))
  4297  	for {
  4298  		if v_0.Op != OpARMMOVWconst {
  4299  			break
  4300  		}
  4301  		c := auxIntToInt32(v_0.AuxInt)
  4302  		x := v_1
  4303  		y := v_2
  4304  		v.reset(OpARMInvertFlags)
  4305  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
  4306  		v0.AuxInt = int32ToAuxInt(c)
  4307  		v1 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  4308  		v1.AddArg2(x, y)
  4309  		v0.AddArg(v1)
  4310  		v.AddArg(v0)
  4311  		return true
  4312  	}
  4313  	// match: (CMPshiftRLreg x y (MOVWconst [c]))
  4314  	// cond: 0 <= c && c < 32
  4315  	// result: (CMPshiftRL x y [c])
  4316  	for {
  4317  		x := v_0
  4318  		y := v_1
  4319  		if v_2.Op != OpARMMOVWconst {
  4320  			break
  4321  		}
  4322  		c := auxIntToInt32(v_2.AuxInt)
  4323  		if !(0 <= c && c < 32) {
  4324  			break
  4325  		}
  4326  		v.reset(OpARMCMPshiftRL)
  4327  		v.AuxInt = int32ToAuxInt(c)
  4328  		v.AddArg2(x, y)
  4329  		return true
  4330  	}
  4331  	return false
  4332  }
  4333  func rewriteValueARM_OpARMEqual(v *Value) bool {
  4334  	v_0 := v.Args[0]
  4335  	// match: (Equal (FlagConstant [fc]))
  4336  	// result: (MOVWconst [b2i32(fc.eq())])
  4337  	for {
  4338  		if v_0.Op != OpARMFlagConstant {
  4339  			break
  4340  		}
  4341  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4342  		v.reset(OpARMMOVWconst)
  4343  		v.AuxInt = int32ToAuxInt(b2i32(fc.eq()))
  4344  		return true
  4345  	}
  4346  	// match: (Equal (InvertFlags x))
  4347  	// result: (Equal x)
  4348  	for {
  4349  		if v_0.Op != OpARMInvertFlags {
  4350  			break
  4351  		}
  4352  		x := v_0.Args[0]
  4353  		v.reset(OpARMEqual)
  4354  		v.AddArg(x)
  4355  		return true
  4356  	}
  4357  	return false
  4358  }
  4359  func rewriteValueARM_OpARMGreaterEqual(v *Value) bool {
  4360  	v_0 := v.Args[0]
  4361  	// match: (GreaterEqual (FlagConstant [fc]))
  4362  	// result: (MOVWconst [b2i32(fc.ge())])
  4363  	for {
  4364  		if v_0.Op != OpARMFlagConstant {
  4365  			break
  4366  		}
  4367  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4368  		v.reset(OpARMMOVWconst)
  4369  		v.AuxInt = int32ToAuxInt(b2i32(fc.ge()))
  4370  		return true
  4371  	}
  4372  	// match: (GreaterEqual (InvertFlags x))
  4373  	// result: (LessEqual x)
  4374  	for {
  4375  		if v_0.Op != OpARMInvertFlags {
  4376  			break
  4377  		}
  4378  		x := v_0.Args[0]
  4379  		v.reset(OpARMLessEqual)
  4380  		v.AddArg(x)
  4381  		return true
  4382  	}
  4383  	return false
  4384  }
  4385  func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool {
  4386  	v_0 := v.Args[0]
  4387  	// match: (GreaterEqualU (FlagConstant [fc]))
  4388  	// result: (MOVWconst [b2i32(fc.uge())])
  4389  	for {
  4390  		if v_0.Op != OpARMFlagConstant {
  4391  			break
  4392  		}
  4393  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4394  		v.reset(OpARMMOVWconst)
  4395  		v.AuxInt = int32ToAuxInt(b2i32(fc.uge()))
  4396  		return true
  4397  	}
  4398  	// match: (GreaterEqualU (InvertFlags x))
  4399  	// result: (LessEqualU x)
  4400  	for {
  4401  		if v_0.Op != OpARMInvertFlags {
  4402  			break
  4403  		}
  4404  		x := v_0.Args[0]
  4405  		v.reset(OpARMLessEqualU)
  4406  		v.AddArg(x)
  4407  		return true
  4408  	}
  4409  	return false
  4410  }
  4411  func rewriteValueARM_OpARMGreaterThan(v *Value) bool {
  4412  	v_0 := v.Args[0]
  4413  	// match: (GreaterThan (FlagConstant [fc]))
  4414  	// result: (MOVWconst [b2i32(fc.gt())])
  4415  	for {
  4416  		if v_0.Op != OpARMFlagConstant {
  4417  			break
  4418  		}
  4419  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4420  		v.reset(OpARMMOVWconst)
  4421  		v.AuxInt = int32ToAuxInt(b2i32(fc.gt()))
  4422  		return true
  4423  	}
  4424  	// match: (GreaterThan (InvertFlags x))
  4425  	// result: (LessThan x)
  4426  	for {
  4427  		if v_0.Op != OpARMInvertFlags {
  4428  			break
  4429  		}
  4430  		x := v_0.Args[0]
  4431  		v.reset(OpARMLessThan)
  4432  		v.AddArg(x)
  4433  		return true
  4434  	}
  4435  	return false
  4436  }
  4437  func rewriteValueARM_OpARMGreaterThanU(v *Value) bool {
  4438  	v_0 := v.Args[0]
  4439  	// match: (GreaterThanU (FlagConstant [fc]))
  4440  	// result: (MOVWconst [b2i32(fc.ugt())])
  4441  	for {
  4442  		if v_0.Op != OpARMFlagConstant {
  4443  			break
  4444  		}
  4445  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4446  		v.reset(OpARMMOVWconst)
  4447  		v.AuxInt = int32ToAuxInt(b2i32(fc.ugt()))
  4448  		return true
  4449  	}
  4450  	// match: (GreaterThanU (InvertFlags x))
  4451  	// result: (LessThanU x)
  4452  	for {
  4453  		if v_0.Op != OpARMInvertFlags {
  4454  			break
  4455  		}
  4456  		x := v_0.Args[0]
  4457  		v.reset(OpARMLessThanU)
  4458  		v.AddArg(x)
  4459  		return true
  4460  	}
  4461  	return false
  4462  }
  4463  func rewriteValueARM_OpARMLessEqual(v *Value) bool {
  4464  	v_0 := v.Args[0]
  4465  	// match: (LessEqual (FlagConstant [fc]))
  4466  	// result: (MOVWconst [b2i32(fc.le())])
  4467  	for {
  4468  		if v_0.Op != OpARMFlagConstant {
  4469  			break
  4470  		}
  4471  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4472  		v.reset(OpARMMOVWconst)
  4473  		v.AuxInt = int32ToAuxInt(b2i32(fc.le()))
  4474  		return true
  4475  	}
  4476  	// match: (LessEqual (InvertFlags x))
  4477  	// result: (GreaterEqual x)
  4478  	for {
  4479  		if v_0.Op != OpARMInvertFlags {
  4480  			break
  4481  		}
  4482  		x := v_0.Args[0]
  4483  		v.reset(OpARMGreaterEqual)
  4484  		v.AddArg(x)
  4485  		return true
  4486  	}
  4487  	return false
  4488  }
  4489  func rewriteValueARM_OpARMLessEqualU(v *Value) bool {
  4490  	v_0 := v.Args[0]
  4491  	// match: (LessEqualU (FlagConstant [fc]))
  4492  	// result: (MOVWconst [b2i32(fc.ule())])
  4493  	for {
  4494  		if v_0.Op != OpARMFlagConstant {
  4495  			break
  4496  		}
  4497  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4498  		v.reset(OpARMMOVWconst)
  4499  		v.AuxInt = int32ToAuxInt(b2i32(fc.ule()))
  4500  		return true
  4501  	}
  4502  	// match: (LessEqualU (InvertFlags x))
  4503  	// result: (GreaterEqualU x)
  4504  	for {
  4505  		if v_0.Op != OpARMInvertFlags {
  4506  			break
  4507  		}
  4508  		x := v_0.Args[0]
  4509  		v.reset(OpARMGreaterEqualU)
  4510  		v.AddArg(x)
  4511  		return true
  4512  	}
  4513  	return false
  4514  }
  4515  func rewriteValueARM_OpARMLessThan(v *Value) bool {
  4516  	v_0 := v.Args[0]
  4517  	// match: (LessThan (FlagConstant [fc]))
  4518  	// result: (MOVWconst [b2i32(fc.lt())])
  4519  	for {
  4520  		if v_0.Op != OpARMFlagConstant {
  4521  			break
  4522  		}
  4523  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4524  		v.reset(OpARMMOVWconst)
  4525  		v.AuxInt = int32ToAuxInt(b2i32(fc.lt()))
  4526  		return true
  4527  	}
  4528  	// match: (LessThan (InvertFlags x))
  4529  	// result: (GreaterThan x)
  4530  	for {
  4531  		if v_0.Op != OpARMInvertFlags {
  4532  			break
  4533  		}
  4534  		x := v_0.Args[0]
  4535  		v.reset(OpARMGreaterThan)
  4536  		v.AddArg(x)
  4537  		return true
  4538  	}
  4539  	return false
  4540  }
  4541  func rewriteValueARM_OpARMLessThanU(v *Value) bool {
  4542  	v_0 := v.Args[0]
  4543  	// match: (LessThanU (FlagConstant [fc]))
  4544  	// result: (MOVWconst [b2i32(fc.ult())])
  4545  	for {
  4546  		if v_0.Op != OpARMFlagConstant {
  4547  			break
  4548  		}
  4549  		fc := auxIntToFlagConstant(v_0.AuxInt)
  4550  		v.reset(OpARMMOVWconst)
  4551  		v.AuxInt = int32ToAuxInt(b2i32(fc.ult()))
  4552  		return true
  4553  	}
  4554  	// match: (LessThanU (InvertFlags x))
  4555  	// result: (GreaterThanU x)
  4556  	for {
  4557  		if v_0.Op != OpARMInvertFlags {
  4558  			break
  4559  		}
  4560  		x := v_0.Args[0]
  4561  		v.reset(OpARMGreaterThanU)
  4562  		v.AddArg(x)
  4563  		return true
  4564  	}
  4565  	return false
  4566  }
  4567  func rewriteValueARM_OpARMLoweredPanicBoundsRC(v *Value) bool {
  4568  	v_1 := v.Args[1]
  4569  	v_0 := v.Args[0]
  4570  	// match: (LoweredPanicBoundsRC [kind] {p} (MOVWconst [c]) mem)
  4571  	// result: (LoweredPanicBoundsCC [kind] {PanicBoundsCC{Cx:int64(c), Cy:p.C}} mem)
  4572  	for {
  4573  		kind := auxIntToInt64(v.AuxInt)
  4574  		p := auxToPanicBoundsC(v.Aux)
  4575  		if v_0.Op != OpARMMOVWconst {
  4576  			break
  4577  		}
  4578  		c := auxIntToInt32(v_0.AuxInt)
  4579  		mem := v_1
  4580  		v.reset(OpARMLoweredPanicBoundsCC)
  4581  		v.AuxInt = int64ToAuxInt(kind)
  4582  		v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: int64(c), Cy: p.C})
  4583  		v.AddArg(mem)
  4584  		return true
  4585  	}
  4586  	return false
  4587  }
  4588  func rewriteValueARM_OpARMLoweredPanicBoundsRR(v *Value) bool {
  4589  	v_2 := v.Args[2]
  4590  	v_1 := v.Args[1]
  4591  	v_0 := v.Args[0]
  4592  	// match: (LoweredPanicBoundsRR [kind] x (MOVWconst [c]) mem)
  4593  	// result: (LoweredPanicBoundsRC [kind] x {PanicBoundsC{C:int64(c)}} mem)
  4594  	for {
  4595  		kind := auxIntToInt64(v.AuxInt)
  4596  		x := v_0
  4597  		if v_1.Op != OpARMMOVWconst {
  4598  			break
  4599  		}
  4600  		c := auxIntToInt32(v_1.AuxInt)
  4601  		mem := v_2
  4602  		v.reset(OpARMLoweredPanicBoundsRC)
  4603  		v.AuxInt = int64ToAuxInt(kind)
  4604  		v.Aux = panicBoundsCToAux(PanicBoundsC{C: int64(c)})
  4605  		v.AddArg2(x, mem)
  4606  		return true
  4607  	}
  4608  	// match: (LoweredPanicBoundsRR [kind] (MOVWconst [c]) y mem)
  4609  	// result: (LoweredPanicBoundsCR [kind] {PanicBoundsC{C:int64(c)}} y mem)
  4610  	for {
  4611  		kind := auxIntToInt64(v.AuxInt)
  4612  		if v_0.Op != OpARMMOVWconst {
  4613  			break
  4614  		}
  4615  		c := auxIntToInt32(v_0.AuxInt)
  4616  		y := v_1
  4617  		mem := v_2
  4618  		v.reset(OpARMLoweredPanicBoundsCR)
  4619  		v.AuxInt = int64ToAuxInt(kind)
  4620  		v.Aux = panicBoundsCToAux(PanicBoundsC{C: int64(c)})
  4621  		v.AddArg2(y, mem)
  4622  		return true
  4623  	}
  4624  	return false
  4625  }
  4626  func rewriteValueARM_OpARMLoweredPanicExtendRC(v *Value) bool {
  4627  	v_2 := v.Args[2]
  4628  	v_1 := v.Args[1]
  4629  	v_0 := v.Args[0]
  4630  	// match: (LoweredPanicExtendRC [kind] {p} (MOVWconst [hi]) (MOVWconst [lo]) mem)
  4631  	// result: (LoweredPanicBoundsCC [kind] {PanicBoundsCC{Cx:int64(hi)<<32+int64(uint32(lo)), Cy:p.C}} mem)
  4632  	for {
  4633  		kind := auxIntToInt64(v.AuxInt)
  4634  		p := auxToPanicBoundsC(v.Aux)
  4635  		if v_0.Op != OpARMMOVWconst {
  4636  			break
  4637  		}
  4638  		hi := auxIntToInt32(v_0.AuxInt)
  4639  		if v_1.Op != OpARMMOVWconst {
  4640  			break
  4641  		}
  4642  		lo := auxIntToInt32(v_1.AuxInt)
  4643  		mem := v_2
  4644  		v.reset(OpARMLoweredPanicBoundsCC)
  4645  		v.AuxInt = int64ToAuxInt(kind)
  4646  		v.Aux = panicBoundsCCToAux(PanicBoundsCC{Cx: int64(hi)<<32 + int64(uint32(lo)), Cy: p.C})
  4647  		v.AddArg(mem)
  4648  		return true
  4649  	}
  4650  	return false
  4651  }
  4652  func rewriteValueARM_OpARMLoweredPanicExtendRR(v *Value) bool {
  4653  	v_3 := v.Args[3]
  4654  	v_2 := v.Args[2]
  4655  	v_1 := v.Args[1]
  4656  	v_0 := v.Args[0]
  4657  	// match: (LoweredPanicExtendRR [kind] hi lo (MOVWconst [c]) mem)
  4658  	// result: (LoweredPanicExtendRC [kind] hi lo {PanicBoundsC{C:int64(c)}} mem)
  4659  	for {
  4660  		kind := auxIntToInt64(v.AuxInt)
  4661  		hi := v_0
  4662  		lo := v_1
  4663  		if v_2.Op != OpARMMOVWconst {
  4664  			break
  4665  		}
  4666  		c := auxIntToInt32(v_2.AuxInt)
  4667  		mem := v_3
  4668  		v.reset(OpARMLoweredPanicExtendRC)
  4669  		v.AuxInt = int64ToAuxInt(kind)
  4670  		v.Aux = panicBoundsCToAux(PanicBoundsC{C: int64(c)})
  4671  		v.AddArg3(hi, lo, mem)
  4672  		return true
  4673  	}
  4674  	// match: (LoweredPanicExtendRR [kind] (MOVWconst [hi]) (MOVWconst [lo]) y mem)
  4675  	// result: (LoweredPanicBoundsCR [kind] {PanicBoundsC{C:int64(hi)<<32 + int64(uint32(lo))}} y mem)
  4676  	for {
  4677  		kind := auxIntToInt64(v.AuxInt)
  4678  		if v_0.Op != OpARMMOVWconst {
  4679  			break
  4680  		}
  4681  		hi := auxIntToInt32(v_0.AuxInt)
  4682  		if v_1.Op != OpARMMOVWconst {
  4683  			break
  4684  		}
  4685  		lo := auxIntToInt32(v_1.AuxInt)
  4686  		y := v_2
  4687  		mem := v_3
  4688  		v.reset(OpARMLoweredPanicBoundsCR)
  4689  		v.AuxInt = int64ToAuxInt(kind)
  4690  		v.Aux = panicBoundsCToAux(PanicBoundsC{C: int64(hi)<<32 + int64(uint32(lo))})
  4691  		v.AddArg2(y, mem)
  4692  		return true
  4693  	}
  4694  	return false
  4695  }
  4696  func rewriteValueARM_OpARMMOVBUload(v *Value) bool {
  4697  	v_1 := v.Args[1]
  4698  	v_0 := v.Args[0]
  4699  	// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
  4700  	// result: (MOVBUload [off1+off2] {sym} ptr mem)
  4701  	for {
  4702  		off1 := auxIntToInt32(v.AuxInt)
  4703  		sym := auxToSym(v.Aux)
  4704  		if v_0.Op != OpARMADDconst {
  4705  			break
  4706  		}
  4707  		off2 := auxIntToInt32(v_0.AuxInt)
  4708  		ptr := v_0.Args[0]
  4709  		mem := v_1
  4710  		v.reset(OpARMMOVBUload)
  4711  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4712  		v.Aux = symToAux(sym)
  4713  		v.AddArg2(ptr, mem)
  4714  		return true
  4715  	}
  4716  	// match: (MOVBUload [off1] {sym} (SUBconst [off2] ptr) mem)
  4717  	// result: (MOVBUload [off1-off2] {sym} ptr mem)
  4718  	for {
  4719  		off1 := auxIntToInt32(v.AuxInt)
  4720  		sym := auxToSym(v.Aux)
  4721  		if v_0.Op != OpARMSUBconst {
  4722  			break
  4723  		}
  4724  		off2 := auxIntToInt32(v_0.AuxInt)
  4725  		ptr := v_0.Args[0]
  4726  		mem := v_1
  4727  		v.reset(OpARMMOVBUload)
  4728  		v.AuxInt = int32ToAuxInt(off1 - off2)
  4729  		v.Aux = symToAux(sym)
  4730  		v.AddArg2(ptr, mem)
  4731  		return true
  4732  	}
  4733  	// match: (MOVBUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  4734  	// cond: canMergeSym(sym1,sym2)
  4735  	// result: (MOVBUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  4736  	for {
  4737  		off1 := auxIntToInt32(v.AuxInt)
  4738  		sym1 := auxToSym(v.Aux)
  4739  		if v_0.Op != OpARMMOVWaddr {
  4740  			break
  4741  		}
  4742  		off2 := auxIntToInt32(v_0.AuxInt)
  4743  		sym2 := auxToSym(v_0.Aux)
  4744  		ptr := v_0.Args[0]
  4745  		mem := v_1
  4746  		if !(canMergeSym(sym1, sym2)) {
  4747  			break
  4748  		}
  4749  		v.reset(OpARMMOVBUload)
  4750  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4751  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4752  		v.AddArg2(ptr, mem)
  4753  		return true
  4754  	}
  4755  	// match: (MOVBUload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
  4756  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  4757  	// result: (MOVBUreg x)
  4758  	for {
  4759  		off := auxIntToInt32(v.AuxInt)
  4760  		sym := auxToSym(v.Aux)
  4761  		ptr := v_0
  4762  		if v_1.Op != OpARMMOVBstore {
  4763  			break
  4764  		}
  4765  		off2 := auxIntToInt32(v_1.AuxInt)
  4766  		sym2 := auxToSym(v_1.Aux)
  4767  		x := v_1.Args[1]
  4768  		ptr2 := v_1.Args[0]
  4769  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  4770  			break
  4771  		}
  4772  		v.reset(OpARMMOVBUreg)
  4773  		v.AddArg(x)
  4774  		return true
  4775  	}
  4776  	// match: (MOVBUload [0] {sym} (ADD ptr idx) mem)
  4777  	// cond: sym == nil
  4778  	// result: (MOVBUloadidx ptr idx mem)
  4779  	for {
  4780  		if auxIntToInt32(v.AuxInt) != 0 {
  4781  			break
  4782  		}
  4783  		sym := auxToSym(v.Aux)
  4784  		if v_0.Op != OpARMADD {
  4785  			break
  4786  		}
  4787  		idx := v_0.Args[1]
  4788  		ptr := v_0.Args[0]
  4789  		mem := v_1
  4790  		if !(sym == nil) {
  4791  			break
  4792  		}
  4793  		v.reset(OpARMMOVBUloadidx)
  4794  		v.AddArg3(ptr, idx, mem)
  4795  		return true
  4796  	}
  4797  	// match: (MOVBUload [off] {sym} (SB) _)
  4798  	// cond: symIsRO(sym)
  4799  	// result: (MOVWconst [int32(read8(sym, int64(off)))])
  4800  	for {
  4801  		off := auxIntToInt32(v.AuxInt)
  4802  		sym := auxToSym(v.Aux)
  4803  		if v_0.Op != OpSB || !(symIsRO(sym)) {
  4804  			break
  4805  		}
  4806  		v.reset(OpARMMOVWconst)
  4807  		v.AuxInt = int32ToAuxInt(int32(read8(sym, int64(off))))
  4808  		return true
  4809  	}
  4810  	return false
  4811  }
  4812  func rewriteValueARM_OpARMMOVBUloadidx(v *Value) bool {
  4813  	v_2 := v.Args[2]
  4814  	v_1 := v.Args[1]
  4815  	v_0 := v.Args[0]
  4816  	// match: (MOVBUloadidx ptr idx (MOVBstoreidx ptr2 idx x _))
  4817  	// cond: isSamePtr(ptr, ptr2)
  4818  	// result: (MOVBUreg x)
  4819  	for {
  4820  		ptr := v_0
  4821  		idx := v_1
  4822  		if v_2.Op != OpARMMOVBstoreidx {
  4823  			break
  4824  		}
  4825  		x := v_2.Args[2]
  4826  		ptr2 := v_2.Args[0]
  4827  		if idx != v_2.Args[1] || !(isSamePtr(ptr, ptr2)) {
  4828  			break
  4829  		}
  4830  		v.reset(OpARMMOVBUreg)
  4831  		v.AddArg(x)
  4832  		return true
  4833  	}
  4834  	// match: (MOVBUloadidx ptr (MOVWconst [c]) mem)
  4835  	// result: (MOVBUload [c] ptr mem)
  4836  	for {
  4837  		ptr := v_0
  4838  		if v_1.Op != OpARMMOVWconst {
  4839  			break
  4840  		}
  4841  		c := auxIntToInt32(v_1.AuxInt)
  4842  		mem := v_2
  4843  		v.reset(OpARMMOVBUload)
  4844  		v.AuxInt = int32ToAuxInt(c)
  4845  		v.AddArg2(ptr, mem)
  4846  		return true
  4847  	}
  4848  	// match: (MOVBUloadidx (MOVWconst [c]) ptr mem)
  4849  	// result: (MOVBUload [c] ptr mem)
  4850  	for {
  4851  		if v_0.Op != OpARMMOVWconst {
  4852  			break
  4853  		}
  4854  		c := auxIntToInt32(v_0.AuxInt)
  4855  		ptr := v_1
  4856  		mem := v_2
  4857  		v.reset(OpARMMOVBUload)
  4858  		v.AuxInt = int32ToAuxInt(c)
  4859  		v.AddArg2(ptr, mem)
  4860  		return true
  4861  	}
  4862  	return false
  4863  }
  4864  func rewriteValueARM_OpARMMOVBUreg(v *Value) bool {
  4865  	v_0 := v.Args[0]
  4866  	// match: (MOVBUreg x:(MOVBUload _ _))
  4867  	// result: (MOVWreg x)
  4868  	for {
  4869  		x := v_0
  4870  		if x.Op != OpARMMOVBUload {
  4871  			break
  4872  		}
  4873  		v.reset(OpARMMOVWreg)
  4874  		v.AddArg(x)
  4875  		return true
  4876  	}
  4877  	// match: (MOVBUreg (ANDconst [c] x))
  4878  	// result: (ANDconst [c&0xff] x)
  4879  	for {
  4880  		if v_0.Op != OpARMANDconst {
  4881  			break
  4882  		}
  4883  		c := auxIntToInt32(v_0.AuxInt)
  4884  		x := v_0.Args[0]
  4885  		v.reset(OpARMANDconst)
  4886  		v.AuxInt = int32ToAuxInt(c & 0xff)
  4887  		v.AddArg(x)
  4888  		return true
  4889  	}
  4890  	// match: (MOVBUreg x:(MOVBUreg _))
  4891  	// result: (MOVWreg x)
  4892  	for {
  4893  		x := v_0
  4894  		if x.Op != OpARMMOVBUreg {
  4895  			break
  4896  		}
  4897  		v.reset(OpARMMOVWreg)
  4898  		v.AddArg(x)
  4899  		return true
  4900  	}
  4901  	// match: (MOVBUreg (MOVWconst [c]))
  4902  	// result: (MOVWconst [int32(uint8(c))])
  4903  	for {
  4904  		if v_0.Op != OpARMMOVWconst {
  4905  			break
  4906  		}
  4907  		c := auxIntToInt32(v_0.AuxInt)
  4908  		v.reset(OpARMMOVWconst)
  4909  		v.AuxInt = int32ToAuxInt(int32(uint8(c)))
  4910  		return true
  4911  	}
  4912  	return false
  4913  }
  4914  func rewriteValueARM_OpARMMOVBload(v *Value) bool {
  4915  	v_1 := v.Args[1]
  4916  	v_0 := v.Args[0]
  4917  	// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
  4918  	// result: (MOVBload [off1+off2] {sym} ptr mem)
  4919  	for {
  4920  		off1 := auxIntToInt32(v.AuxInt)
  4921  		sym := auxToSym(v.Aux)
  4922  		if v_0.Op != OpARMADDconst {
  4923  			break
  4924  		}
  4925  		off2 := auxIntToInt32(v_0.AuxInt)
  4926  		ptr := v_0.Args[0]
  4927  		mem := v_1
  4928  		v.reset(OpARMMOVBload)
  4929  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4930  		v.Aux = symToAux(sym)
  4931  		v.AddArg2(ptr, mem)
  4932  		return true
  4933  	}
  4934  	// match: (MOVBload [off1] {sym} (SUBconst [off2] ptr) mem)
  4935  	// result: (MOVBload [off1-off2] {sym} ptr mem)
  4936  	for {
  4937  		off1 := auxIntToInt32(v.AuxInt)
  4938  		sym := auxToSym(v.Aux)
  4939  		if v_0.Op != OpARMSUBconst {
  4940  			break
  4941  		}
  4942  		off2 := auxIntToInt32(v_0.AuxInt)
  4943  		ptr := v_0.Args[0]
  4944  		mem := v_1
  4945  		v.reset(OpARMMOVBload)
  4946  		v.AuxInt = int32ToAuxInt(off1 - off2)
  4947  		v.Aux = symToAux(sym)
  4948  		v.AddArg2(ptr, mem)
  4949  		return true
  4950  	}
  4951  	// match: (MOVBload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  4952  	// cond: canMergeSym(sym1,sym2)
  4953  	// result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  4954  	for {
  4955  		off1 := auxIntToInt32(v.AuxInt)
  4956  		sym1 := auxToSym(v.Aux)
  4957  		if v_0.Op != OpARMMOVWaddr {
  4958  			break
  4959  		}
  4960  		off2 := auxIntToInt32(v_0.AuxInt)
  4961  		sym2 := auxToSym(v_0.Aux)
  4962  		ptr := v_0.Args[0]
  4963  		mem := v_1
  4964  		if !(canMergeSym(sym1, sym2)) {
  4965  			break
  4966  		}
  4967  		v.reset(OpARMMOVBload)
  4968  		v.AuxInt = int32ToAuxInt(off1 + off2)
  4969  		v.Aux = symToAux(mergeSym(sym1, sym2))
  4970  		v.AddArg2(ptr, mem)
  4971  		return true
  4972  	}
  4973  	// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
  4974  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  4975  	// result: (MOVBreg x)
  4976  	for {
  4977  		off := auxIntToInt32(v.AuxInt)
  4978  		sym := auxToSym(v.Aux)
  4979  		ptr := v_0
  4980  		if v_1.Op != OpARMMOVBstore {
  4981  			break
  4982  		}
  4983  		off2 := auxIntToInt32(v_1.AuxInt)
  4984  		sym2 := auxToSym(v_1.Aux)
  4985  		x := v_1.Args[1]
  4986  		ptr2 := v_1.Args[0]
  4987  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  4988  			break
  4989  		}
  4990  		v.reset(OpARMMOVBreg)
  4991  		v.AddArg(x)
  4992  		return true
  4993  	}
  4994  	// match: (MOVBload [0] {sym} (ADD ptr idx) mem)
  4995  	// cond: sym == nil
  4996  	// result: (MOVBloadidx ptr idx mem)
  4997  	for {
  4998  		if auxIntToInt32(v.AuxInt) != 0 {
  4999  			break
  5000  		}
  5001  		sym := auxToSym(v.Aux)
  5002  		if v_0.Op != OpARMADD {
  5003  			break
  5004  		}
  5005  		idx := v_0.Args[1]
  5006  		ptr := v_0.Args[0]
  5007  		mem := v_1
  5008  		if !(sym == nil) {
  5009  			break
  5010  		}
  5011  		v.reset(OpARMMOVBloadidx)
  5012  		v.AddArg3(ptr, idx, mem)
  5013  		return true
  5014  	}
  5015  	// match: (MOVBload [off] {sym} (SB) _)
  5016  	// cond: symIsRO(sym)
  5017  	// result: (MOVWconst [int32(int8(read8(sym, int64(off))))])
  5018  	for {
  5019  		off := auxIntToInt32(v.AuxInt)
  5020  		sym := auxToSym(v.Aux)
  5021  		if v_0.Op != OpSB || !(symIsRO(sym)) {
  5022  			break
  5023  		}
  5024  		v.reset(OpARMMOVWconst)
  5025  		v.AuxInt = int32ToAuxInt(int32(int8(read8(sym, int64(off)))))
  5026  		return true
  5027  	}
  5028  	return false
  5029  }
  5030  func rewriteValueARM_OpARMMOVBloadidx(v *Value) bool {
  5031  	v_2 := v.Args[2]
  5032  	v_1 := v.Args[1]
  5033  	v_0 := v.Args[0]
  5034  	// match: (MOVBloadidx ptr idx (MOVBstoreidx ptr2 idx x _))
  5035  	// cond: isSamePtr(ptr, ptr2)
  5036  	// result: (MOVBreg x)
  5037  	for {
  5038  		ptr := v_0
  5039  		idx := v_1
  5040  		if v_2.Op != OpARMMOVBstoreidx {
  5041  			break
  5042  		}
  5043  		x := v_2.Args[2]
  5044  		ptr2 := v_2.Args[0]
  5045  		if idx != v_2.Args[1] || !(isSamePtr(ptr, ptr2)) {
  5046  			break
  5047  		}
  5048  		v.reset(OpARMMOVBreg)
  5049  		v.AddArg(x)
  5050  		return true
  5051  	}
  5052  	// match: (MOVBloadidx ptr (MOVWconst [c]) mem)
  5053  	// result: (MOVBload [c] ptr mem)
  5054  	for {
  5055  		ptr := v_0
  5056  		if v_1.Op != OpARMMOVWconst {
  5057  			break
  5058  		}
  5059  		c := auxIntToInt32(v_1.AuxInt)
  5060  		mem := v_2
  5061  		v.reset(OpARMMOVBload)
  5062  		v.AuxInt = int32ToAuxInt(c)
  5063  		v.AddArg2(ptr, mem)
  5064  		return true
  5065  	}
  5066  	// match: (MOVBloadidx (MOVWconst [c]) ptr mem)
  5067  	// result: (MOVBload [c] ptr mem)
  5068  	for {
  5069  		if v_0.Op != OpARMMOVWconst {
  5070  			break
  5071  		}
  5072  		c := auxIntToInt32(v_0.AuxInt)
  5073  		ptr := v_1
  5074  		mem := v_2
  5075  		v.reset(OpARMMOVBload)
  5076  		v.AuxInt = int32ToAuxInt(c)
  5077  		v.AddArg2(ptr, mem)
  5078  		return true
  5079  	}
  5080  	return false
  5081  }
  5082  func rewriteValueARM_OpARMMOVBreg(v *Value) bool {
  5083  	v_0 := v.Args[0]
  5084  	// match: (MOVBreg x:(MOVBload _ _))
  5085  	// result: (MOVWreg x)
  5086  	for {
  5087  		x := v_0
  5088  		if x.Op != OpARMMOVBload {
  5089  			break
  5090  		}
  5091  		v.reset(OpARMMOVWreg)
  5092  		v.AddArg(x)
  5093  		return true
  5094  	}
  5095  	// match: (MOVBreg (ANDconst [c] x))
  5096  	// cond: c & 0x80 == 0
  5097  	// result: (ANDconst [c&0x7f] x)
  5098  	for {
  5099  		if v_0.Op != OpARMANDconst {
  5100  			break
  5101  		}
  5102  		c := auxIntToInt32(v_0.AuxInt)
  5103  		x := v_0.Args[0]
  5104  		if !(c&0x80 == 0) {
  5105  			break
  5106  		}
  5107  		v.reset(OpARMANDconst)
  5108  		v.AuxInt = int32ToAuxInt(c & 0x7f)
  5109  		v.AddArg(x)
  5110  		return true
  5111  	}
  5112  	// match: (MOVBreg x:(MOVBreg _))
  5113  	// result: (MOVWreg x)
  5114  	for {
  5115  		x := v_0
  5116  		if x.Op != OpARMMOVBreg {
  5117  			break
  5118  		}
  5119  		v.reset(OpARMMOVWreg)
  5120  		v.AddArg(x)
  5121  		return true
  5122  	}
  5123  	// match: (MOVBreg (MOVWconst [c]))
  5124  	// result: (MOVWconst [int32(int8(c))])
  5125  	for {
  5126  		if v_0.Op != OpARMMOVWconst {
  5127  			break
  5128  		}
  5129  		c := auxIntToInt32(v_0.AuxInt)
  5130  		v.reset(OpARMMOVWconst)
  5131  		v.AuxInt = int32ToAuxInt(int32(int8(c)))
  5132  		return true
  5133  	}
  5134  	return false
  5135  }
  5136  func rewriteValueARM_OpARMMOVBstore(v *Value) bool {
  5137  	v_2 := v.Args[2]
  5138  	v_1 := v.Args[1]
  5139  	v_0 := v.Args[0]
  5140  	// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
  5141  	// result: (MOVBstore [off1+off2] {sym} ptr val mem)
  5142  	for {
  5143  		off1 := auxIntToInt32(v.AuxInt)
  5144  		sym := auxToSym(v.Aux)
  5145  		if v_0.Op != OpARMADDconst {
  5146  			break
  5147  		}
  5148  		off2 := auxIntToInt32(v_0.AuxInt)
  5149  		ptr := v_0.Args[0]
  5150  		val := v_1
  5151  		mem := v_2
  5152  		v.reset(OpARMMOVBstore)
  5153  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5154  		v.Aux = symToAux(sym)
  5155  		v.AddArg3(ptr, val, mem)
  5156  		return true
  5157  	}
  5158  	// match: (MOVBstore [off1] {sym} (SUBconst [off2] ptr) val mem)
  5159  	// result: (MOVBstore [off1-off2] {sym} ptr val mem)
  5160  	for {
  5161  		off1 := auxIntToInt32(v.AuxInt)
  5162  		sym := auxToSym(v.Aux)
  5163  		if v_0.Op != OpARMSUBconst {
  5164  			break
  5165  		}
  5166  		off2 := auxIntToInt32(v_0.AuxInt)
  5167  		ptr := v_0.Args[0]
  5168  		val := v_1
  5169  		mem := v_2
  5170  		v.reset(OpARMMOVBstore)
  5171  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5172  		v.Aux = symToAux(sym)
  5173  		v.AddArg3(ptr, val, mem)
  5174  		return true
  5175  	}
  5176  	// match: (MOVBstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem)
  5177  	// cond: canMergeSym(sym1,sym2)
  5178  	// result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
  5179  	for {
  5180  		off1 := auxIntToInt32(v.AuxInt)
  5181  		sym1 := auxToSym(v.Aux)
  5182  		if v_0.Op != OpARMMOVWaddr {
  5183  			break
  5184  		}
  5185  		off2 := auxIntToInt32(v_0.AuxInt)
  5186  		sym2 := auxToSym(v_0.Aux)
  5187  		ptr := v_0.Args[0]
  5188  		val := v_1
  5189  		mem := v_2
  5190  		if !(canMergeSym(sym1, sym2)) {
  5191  			break
  5192  		}
  5193  		v.reset(OpARMMOVBstore)
  5194  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5195  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5196  		v.AddArg3(ptr, val, mem)
  5197  		return true
  5198  	}
  5199  	// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
  5200  	// result: (MOVBstore [off] {sym} ptr x mem)
  5201  	for {
  5202  		off := auxIntToInt32(v.AuxInt)
  5203  		sym := auxToSym(v.Aux)
  5204  		ptr := v_0
  5205  		if v_1.Op != OpARMMOVBreg {
  5206  			break
  5207  		}
  5208  		x := v_1.Args[0]
  5209  		mem := v_2
  5210  		v.reset(OpARMMOVBstore)
  5211  		v.AuxInt = int32ToAuxInt(off)
  5212  		v.Aux = symToAux(sym)
  5213  		v.AddArg3(ptr, x, mem)
  5214  		return true
  5215  	}
  5216  	// match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem)
  5217  	// result: (MOVBstore [off] {sym} ptr x mem)
  5218  	for {
  5219  		off := auxIntToInt32(v.AuxInt)
  5220  		sym := auxToSym(v.Aux)
  5221  		ptr := v_0
  5222  		if v_1.Op != OpARMMOVBUreg {
  5223  			break
  5224  		}
  5225  		x := v_1.Args[0]
  5226  		mem := v_2
  5227  		v.reset(OpARMMOVBstore)
  5228  		v.AuxInt = int32ToAuxInt(off)
  5229  		v.Aux = symToAux(sym)
  5230  		v.AddArg3(ptr, x, mem)
  5231  		return true
  5232  	}
  5233  	// match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem)
  5234  	// result: (MOVBstore [off] {sym} ptr x mem)
  5235  	for {
  5236  		off := auxIntToInt32(v.AuxInt)
  5237  		sym := auxToSym(v.Aux)
  5238  		ptr := v_0
  5239  		if v_1.Op != OpARMMOVHreg {
  5240  			break
  5241  		}
  5242  		x := v_1.Args[0]
  5243  		mem := v_2
  5244  		v.reset(OpARMMOVBstore)
  5245  		v.AuxInt = int32ToAuxInt(off)
  5246  		v.Aux = symToAux(sym)
  5247  		v.AddArg3(ptr, x, mem)
  5248  		return true
  5249  	}
  5250  	// match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem)
  5251  	// result: (MOVBstore [off] {sym} ptr x mem)
  5252  	for {
  5253  		off := auxIntToInt32(v.AuxInt)
  5254  		sym := auxToSym(v.Aux)
  5255  		ptr := v_0
  5256  		if v_1.Op != OpARMMOVHUreg {
  5257  			break
  5258  		}
  5259  		x := v_1.Args[0]
  5260  		mem := v_2
  5261  		v.reset(OpARMMOVBstore)
  5262  		v.AuxInt = int32ToAuxInt(off)
  5263  		v.Aux = symToAux(sym)
  5264  		v.AddArg3(ptr, x, mem)
  5265  		return true
  5266  	}
  5267  	// match: (MOVBstore [0] {sym} (ADD ptr idx) val mem)
  5268  	// cond: sym == nil
  5269  	// result: (MOVBstoreidx ptr idx val mem)
  5270  	for {
  5271  		if auxIntToInt32(v.AuxInt) != 0 {
  5272  			break
  5273  		}
  5274  		sym := auxToSym(v.Aux)
  5275  		if v_0.Op != OpARMADD {
  5276  			break
  5277  		}
  5278  		idx := v_0.Args[1]
  5279  		ptr := v_0.Args[0]
  5280  		val := v_1
  5281  		mem := v_2
  5282  		if !(sym == nil) {
  5283  			break
  5284  		}
  5285  		v.reset(OpARMMOVBstoreidx)
  5286  		v.AddArg4(ptr, idx, val, mem)
  5287  		return true
  5288  	}
  5289  	return false
  5290  }
  5291  func rewriteValueARM_OpARMMOVBstoreidx(v *Value) bool {
  5292  	v_3 := v.Args[3]
  5293  	v_2 := v.Args[2]
  5294  	v_1 := v.Args[1]
  5295  	v_0 := v.Args[0]
  5296  	// match: (MOVBstoreidx ptr (MOVWconst [c]) val mem)
  5297  	// result: (MOVBstore [c] ptr val mem)
  5298  	for {
  5299  		ptr := v_0
  5300  		if v_1.Op != OpARMMOVWconst {
  5301  			break
  5302  		}
  5303  		c := auxIntToInt32(v_1.AuxInt)
  5304  		val := v_2
  5305  		mem := v_3
  5306  		v.reset(OpARMMOVBstore)
  5307  		v.AuxInt = int32ToAuxInt(c)
  5308  		v.AddArg3(ptr, val, mem)
  5309  		return true
  5310  	}
  5311  	// match: (MOVBstoreidx (MOVWconst [c]) ptr val mem)
  5312  	// result: (MOVBstore [c] ptr val mem)
  5313  	for {
  5314  		if v_0.Op != OpARMMOVWconst {
  5315  			break
  5316  		}
  5317  		c := auxIntToInt32(v_0.AuxInt)
  5318  		ptr := v_1
  5319  		val := v_2
  5320  		mem := v_3
  5321  		v.reset(OpARMMOVBstore)
  5322  		v.AuxInt = int32ToAuxInt(c)
  5323  		v.AddArg3(ptr, val, mem)
  5324  		return true
  5325  	}
  5326  	return false
  5327  }
  5328  func rewriteValueARM_OpARMMOVDload(v *Value) bool {
  5329  	v_1 := v.Args[1]
  5330  	v_0 := v.Args[0]
  5331  	// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
  5332  	// result: (MOVDload [off1+off2] {sym} ptr mem)
  5333  	for {
  5334  		off1 := auxIntToInt32(v.AuxInt)
  5335  		sym := auxToSym(v.Aux)
  5336  		if v_0.Op != OpARMADDconst {
  5337  			break
  5338  		}
  5339  		off2 := auxIntToInt32(v_0.AuxInt)
  5340  		ptr := v_0.Args[0]
  5341  		mem := v_1
  5342  		v.reset(OpARMMOVDload)
  5343  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5344  		v.Aux = symToAux(sym)
  5345  		v.AddArg2(ptr, mem)
  5346  		return true
  5347  	}
  5348  	// match: (MOVDload [off1] {sym} (SUBconst [off2] ptr) mem)
  5349  	// result: (MOVDload [off1-off2] {sym} ptr mem)
  5350  	for {
  5351  		off1 := auxIntToInt32(v.AuxInt)
  5352  		sym := auxToSym(v.Aux)
  5353  		if v_0.Op != OpARMSUBconst {
  5354  			break
  5355  		}
  5356  		off2 := auxIntToInt32(v_0.AuxInt)
  5357  		ptr := v_0.Args[0]
  5358  		mem := v_1
  5359  		v.reset(OpARMMOVDload)
  5360  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5361  		v.Aux = symToAux(sym)
  5362  		v.AddArg2(ptr, mem)
  5363  		return true
  5364  	}
  5365  	// match: (MOVDload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  5366  	// cond: canMergeSym(sym1,sym2)
  5367  	// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  5368  	for {
  5369  		off1 := auxIntToInt32(v.AuxInt)
  5370  		sym1 := auxToSym(v.Aux)
  5371  		if v_0.Op != OpARMMOVWaddr {
  5372  			break
  5373  		}
  5374  		off2 := auxIntToInt32(v_0.AuxInt)
  5375  		sym2 := auxToSym(v_0.Aux)
  5376  		ptr := v_0.Args[0]
  5377  		mem := v_1
  5378  		if !(canMergeSym(sym1, sym2)) {
  5379  			break
  5380  		}
  5381  		v.reset(OpARMMOVDload)
  5382  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5383  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5384  		v.AddArg2(ptr, mem)
  5385  		return true
  5386  	}
  5387  	// match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _))
  5388  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  5389  	// result: x
  5390  	for {
  5391  		off := auxIntToInt32(v.AuxInt)
  5392  		sym := auxToSym(v.Aux)
  5393  		ptr := v_0
  5394  		if v_1.Op != OpARMMOVDstore {
  5395  			break
  5396  		}
  5397  		off2 := auxIntToInt32(v_1.AuxInt)
  5398  		sym2 := auxToSym(v_1.Aux)
  5399  		x := v_1.Args[1]
  5400  		ptr2 := v_1.Args[0]
  5401  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  5402  			break
  5403  		}
  5404  		v.copyOf(x)
  5405  		return true
  5406  	}
  5407  	return false
  5408  }
  5409  func rewriteValueARM_OpARMMOVDstore(v *Value) bool {
  5410  	v_2 := v.Args[2]
  5411  	v_1 := v.Args[1]
  5412  	v_0 := v.Args[0]
  5413  	// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
  5414  	// result: (MOVDstore [off1+off2] {sym} ptr val mem)
  5415  	for {
  5416  		off1 := auxIntToInt32(v.AuxInt)
  5417  		sym := auxToSym(v.Aux)
  5418  		if v_0.Op != OpARMADDconst {
  5419  			break
  5420  		}
  5421  		off2 := auxIntToInt32(v_0.AuxInt)
  5422  		ptr := v_0.Args[0]
  5423  		val := v_1
  5424  		mem := v_2
  5425  		v.reset(OpARMMOVDstore)
  5426  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5427  		v.Aux = symToAux(sym)
  5428  		v.AddArg3(ptr, val, mem)
  5429  		return true
  5430  	}
  5431  	// match: (MOVDstore [off1] {sym} (SUBconst [off2] ptr) val mem)
  5432  	// result: (MOVDstore [off1-off2] {sym} ptr val mem)
  5433  	for {
  5434  		off1 := auxIntToInt32(v.AuxInt)
  5435  		sym := auxToSym(v.Aux)
  5436  		if v_0.Op != OpARMSUBconst {
  5437  			break
  5438  		}
  5439  		off2 := auxIntToInt32(v_0.AuxInt)
  5440  		ptr := v_0.Args[0]
  5441  		val := v_1
  5442  		mem := v_2
  5443  		v.reset(OpARMMOVDstore)
  5444  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5445  		v.Aux = symToAux(sym)
  5446  		v.AddArg3(ptr, val, mem)
  5447  		return true
  5448  	}
  5449  	// match: (MOVDstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem)
  5450  	// cond: canMergeSym(sym1,sym2)
  5451  	// result: (MOVDstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
  5452  	for {
  5453  		off1 := auxIntToInt32(v.AuxInt)
  5454  		sym1 := auxToSym(v.Aux)
  5455  		if v_0.Op != OpARMMOVWaddr {
  5456  			break
  5457  		}
  5458  		off2 := auxIntToInt32(v_0.AuxInt)
  5459  		sym2 := auxToSym(v_0.Aux)
  5460  		ptr := v_0.Args[0]
  5461  		val := v_1
  5462  		mem := v_2
  5463  		if !(canMergeSym(sym1, sym2)) {
  5464  			break
  5465  		}
  5466  		v.reset(OpARMMOVDstore)
  5467  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5468  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5469  		v.AddArg3(ptr, val, mem)
  5470  		return true
  5471  	}
  5472  	return false
  5473  }
  5474  func rewriteValueARM_OpARMMOVFload(v *Value) bool {
  5475  	v_1 := v.Args[1]
  5476  	v_0 := v.Args[0]
  5477  	// match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem)
  5478  	// result: (MOVFload [off1+off2] {sym} ptr mem)
  5479  	for {
  5480  		off1 := auxIntToInt32(v.AuxInt)
  5481  		sym := auxToSym(v.Aux)
  5482  		if v_0.Op != OpARMADDconst {
  5483  			break
  5484  		}
  5485  		off2 := auxIntToInt32(v_0.AuxInt)
  5486  		ptr := v_0.Args[0]
  5487  		mem := v_1
  5488  		v.reset(OpARMMOVFload)
  5489  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5490  		v.Aux = symToAux(sym)
  5491  		v.AddArg2(ptr, mem)
  5492  		return true
  5493  	}
  5494  	// match: (MOVFload [off1] {sym} (SUBconst [off2] ptr) mem)
  5495  	// result: (MOVFload [off1-off2] {sym} ptr mem)
  5496  	for {
  5497  		off1 := auxIntToInt32(v.AuxInt)
  5498  		sym := auxToSym(v.Aux)
  5499  		if v_0.Op != OpARMSUBconst {
  5500  			break
  5501  		}
  5502  		off2 := auxIntToInt32(v_0.AuxInt)
  5503  		ptr := v_0.Args[0]
  5504  		mem := v_1
  5505  		v.reset(OpARMMOVFload)
  5506  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5507  		v.Aux = symToAux(sym)
  5508  		v.AddArg2(ptr, mem)
  5509  		return true
  5510  	}
  5511  	// match: (MOVFload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  5512  	// cond: canMergeSym(sym1,sym2)
  5513  	// result: (MOVFload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  5514  	for {
  5515  		off1 := auxIntToInt32(v.AuxInt)
  5516  		sym1 := auxToSym(v.Aux)
  5517  		if v_0.Op != OpARMMOVWaddr {
  5518  			break
  5519  		}
  5520  		off2 := auxIntToInt32(v_0.AuxInt)
  5521  		sym2 := auxToSym(v_0.Aux)
  5522  		ptr := v_0.Args[0]
  5523  		mem := v_1
  5524  		if !(canMergeSym(sym1, sym2)) {
  5525  			break
  5526  		}
  5527  		v.reset(OpARMMOVFload)
  5528  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5529  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5530  		v.AddArg2(ptr, mem)
  5531  		return true
  5532  	}
  5533  	// match: (MOVFload [off] {sym} ptr (MOVFstore [off2] {sym2} ptr2 x _))
  5534  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  5535  	// result: x
  5536  	for {
  5537  		off := auxIntToInt32(v.AuxInt)
  5538  		sym := auxToSym(v.Aux)
  5539  		ptr := v_0
  5540  		if v_1.Op != OpARMMOVFstore {
  5541  			break
  5542  		}
  5543  		off2 := auxIntToInt32(v_1.AuxInt)
  5544  		sym2 := auxToSym(v_1.Aux)
  5545  		x := v_1.Args[1]
  5546  		ptr2 := v_1.Args[0]
  5547  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  5548  			break
  5549  		}
  5550  		v.copyOf(x)
  5551  		return true
  5552  	}
  5553  	return false
  5554  }
  5555  func rewriteValueARM_OpARMMOVFstore(v *Value) bool {
  5556  	v_2 := v.Args[2]
  5557  	v_1 := v.Args[1]
  5558  	v_0 := v.Args[0]
  5559  	// match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem)
  5560  	// result: (MOVFstore [off1+off2] {sym} ptr val mem)
  5561  	for {
  5562  		off1 := auxIntToInt32(v.AuxInt)
  5563  		sym := auxToSym(v.Aux)
  5564  		if v_0.Op != OpARMADDconst {
  5565  			break
  5566  		}
  5567  		off2 := auxIntToInt32(v_0.AuxInt)
  5568  		ptr := v_0.Args[0]
  5569  		val := v_1
  5570  		mem := v_2
  5571  		v.reset(OpARMMOVFstore)
  5572  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5573  		v.Aux = symToAux(sym)
  5574  		v.AddArg3(ptr, val, mem)
  5575  		return true
  5576  	}
  5577  	// match: (MOVFstore [off1] {sym} (SUBconst [off2] ptr) val mem)
  5578  	// result: (MOVFstore [off1-off2] {sym} ptr val mem)
  5579  	for {
  5580  		off1 := auxIntToInt32(v.AuxInt)
  5581  		sym := auxToSym(v.Aux)
  5582  		if v_0.Op != OpARMSUBconst {
  5583  			break
  5584  		}
  5585  		off2 := auxIntToInt32(v_0.AuxInt)
  5586  		ptr := v_0.Args[0]
  5587  		val := v_1
  5588  		mem := v_2
  5589  		v.reset(OpARMMOVFstore)
  5590  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5591  		v.Aux = symToAux(sym)
  5592  		v.AddArg3(ptr, val, mem)
  5593  		return true
  5594  	}
  5595  	// match: (MOVFstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem)
  5596  	// cond: canMergeSym(sym1,sym2)
  5597  	// result: (MOVFstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
  5598  	for {
  5599  		off1 := auxIntToInt32(v.AuxInt)
  5600  		sym1 := auxToSym(v.Aux)
  5601  		if v_0.Op != OpARMMOVWaddr {
  5602  			break
  5603  		}
  5604  		off2 := auxIntToInt32(v_0.AuxInt)
  5605  		sym2 := auxToSym(v_0.Aux)
  5606  		ptr := v_0.Args[0]
  5607  		val := v_1
  5608  		mem := v_2
  5609  		if !(canMergeSym(sym1, sym2)) {
  5610  			break
  5611  		}
  5612  		v.reset(OpARMMOVFstore)
  5613  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5614  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5615  		v.AddArg3(ptr, val, mem)
  5616  		return true
  5617  	}
  5618  	return false
  5619  }
  5620  func rewriteValueARM_OpARMMOVHUload(v *Value) bool {
  5621  	v_1 := v.Args[1]
  5622  	v_0 := v.Args[0]
  5623  	b := v.Block
  5624  	config := b.Func.Config
  5625  	// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
  5626  	// result: (MOVHUload [off1+off2] {sym} ptr mem)
  5627  	for {
  5628  		off1 := auxIntToInt32(v.AuxInt)
  5629  		sym := auxToSym(v.Aux)
  5630  		if v_0.Op != OpARMADDconst {
  5631  			break
  5632  		}
  5633  		off2 := auxIntToInt32(v_0.AuxInt)
  5634  		ptr := v_0.Args[0]
  5635  		mem := v_1
  5636  		v.reset(OpARMMOVHUload)
  5637  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5638  		v.Aux = symToAux(sym)
  5639  		v.AddArg2(ptr, mem)
  5640  		return true
  5641  	}
  5642  	// match: (MOVHUload [off1] {sym} (SUBconst [off2] ptr) mem)
  5643  	// result: (MOVHUload [off1-off2] {sym} ptr mem)
  5644  	for {
  5645  		off1 := auxIntToInt32(v.AuxInt)
  5646  		sym := auxToSym(v.Aux)
  5647  		if v_0.Op != OpARMSUBconst {
  5648  			break
  5649  		}
  5650  		off2 := auxIntToInt32(v_0.AuxInt)
  5651  		ptr := v_0.Args[0]
  5652  		mem := v_1
  5653  		v.reset(OpARMMOVHUload)
  5654  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5655  		v.Aux = symToAux(sym)
  5656  		v.AddArg2(ptr, mem)
  5657  		return true
  5658  	}
  5659  	// match: (MOVHUload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  5660  	// cond: canMergeSym(sym1,sym2)
  5661  	// result: (MOVHUload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  5662  	for {
  5663  		off1 := auxIntToInt32(v.AuxInt)
  5664  		sym1 := auxToSym(v.Aux)
  5665  		if v_0.Op != OpARMMOVWaddr {
  5666  			break
  5667  		}
  5668  		off2 := auxIntToInt32(v_0.AuxInt)
  5669  		sym2 := auxToSym(v_0.Aux)
  5670  		ptr := v_0.Args[0]
  5671  		mem := v_1
  5672  		if !(canMergeSym(sym1, sym2)) {
  5673  			break
  5674  		}
  5675  		v.reset(OpARMMOVHUload)
  5676  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5677  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5678  		v.AddArg2(ptr, mem)
  5679  		return true
  5680  	}
  5681  	// match: (MOVHUload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _))
  5682  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  5683  	// result: (MOVHUreg x)
  5684  	for {
  5685  		off := auxIntToInt32(v.AuxInt)
  5686  		sym := auxToSym(v.Aux)
  5687  		ptr := v_0
  5688  		if v_1.Op != OpARMMOVHstore {
  5689  			break
  5690  		}
  5691  		off2 := auxIntToInt32(v_1.AuxInt)
  5692  		sym2 := auxToSym(v_1.Aux)
  5693  		x := v_1.Args[1]
  5694  		ptr2 := v_1.Args[0]
  5695  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  5696  			break
  5697  		}
  5698  		v.reset(OpARMMOVHUreg)
  5699  		v.AddArg(x)
  5700  		return true
  5701  	}
  5702  	// match: (MOVHUload [0] {sym} (ADD ptr idx) mem)
  5703  	// cond: sym == nil
  5704  	// result: (MOVHUloadidx ptr idx mem)
  5705  	for {
  5706  		if auxIntToInt32(v.AuxInt) != 0 {
  5707  			break
  5708  		}
  5709  		sym := auxToSym(v.Aux)
  5710  		if v_0.Op != OpARMADD {
  5711  			break
  5712  		}
  5713  		idx := v_0.Args[1]
  5714  		ptr := v_0.Args[0]
  5715  		mem := v_1
  5716  		if !(sym == nil) {
  5717  			break
  5718  		}
  5719  		v.reset(OpARMMOVHUloadidx)
  5720  		v.AddArg3(ptr, idx, mem)
  5721  		return true
  5722  	}
  5723  	// match: (MOVHUload [off] {sym} (SB) _)
  5724  	// cond: symIsRO(sym)
  5725  	// result: (MOVWconst [int32(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])
  5726  	for {
  5727  		off := auxIntToInt32(v.AuxInt)
  5728  		sym := auxToSym(v.Aux)
  5729  		if v_0.Op != OpSB || !(symIsRO(sym)) {
  5730  			break
  5731  		}
  5732  		v.reset(OpARMMOVWconst)
  5733  		v.AuxInt = int32ToAuxInt(int32(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))
  5734  		return true
  5735  	}
  5736  	return false
  5737  }
  5738  func rewriteValueARM_OpARMMOVHUloadidx(v *Value) bool {
  5739  	v_2 := v.Args[2]
  5740  	v_1 := v.Args[1]
  5741  	v_0 := v.Args[0]
  5742  	// match: (MOVHUloadidx ptr idx (MOVHstoreidx ptr2 idx x _))
  5743  	// cond: isSamePtr(ptr, ptr2)
  5744  	// result: (MOVHUreg x)
  5745  	for {
  5746  		ptr := v_0
  5747  		idx := v_1
  5748  		if v_2.Op != OpARMMOVHstoreidx {
  5749  			break
  5750  		}
  5751  		x := v_2.Args[2]
  5752  		ptr2 := v_2.Args[0]
  5753  		if idx != v_2.Args[1] || !(isSamePtr(ptr, ptr2)) {
  5754  			break
  5755  		}
  5756  		v.reset(OpARMMOVHUreg)
  5757  		v.AddArg(x)
  5758  		return true
  5759  	}
  5760  	// match: (MOVHUloadidx ptr (MOVWconst [c]) mem)
  5761  	// result: (MOVHUload [c] ptr mem)
  5762  	for {
  5763  		ptr := v_0
  5764  		if v_1.Op != OpARMMOVWconst {
  5765  			break
  5766  		}
  5767  		c := auxIntToInt32(v_1.AuxInt)
  5768  		mem := v_2
  5769  		v.reset(OpARMMOVHUload)
  5770  		v.AuxInt = int32ToAuxInt(c)
  5771  		v.AddArg2(ptr, mem)
  5772  		return true
  5773  	}
  5774  	// match: (MOVHUloadidx (MOVWconst [c]) ptr mem)
  5775  	// result: (MOVHUload [c] ptr mem)
  5776  	for {
  5777  		if v_0.Op != OpARMMOVWconst {
  5778  			break
  5779  		}
  5780  		c := auxIntToInt32(v_0.AuxInt)
  5781  		ptr := v_1
  5782  		mem := v_2
  5783  		v.reset(OpARMMOVHUload)
  5784  		v.AuxInt = int32ToAuxInt(c)
  5785  		v.AddArg2(ptr, mem)
  5786  		return true
  5787  	}
  5788  	return false
  5789  }
  5790  func rewriteValueARM_OpARMMOVHUreg(v *Value) bool {
  5791  	v_0 := v.Args[0]
  5792  	// match: (MOVHUreg x:(MOVBUload _ _))
  5793  	// result: (MOVWreg x)
  5794  	for {
  5795  		x := v_0
  5796  		if x.Op != OpARMMOVBUload {
  5797  			break
  5798  		}
  5799  		v.reset(OpARMMOVWreg)
  5800  		v.AddArg(x)
  5801  		return true
  5802  	}
  5803  	// match: (MOVHUreg x:(MOVHUload _ _))
  5804  	// result: (MOVWreg x)
  5805  	for {
  5806  		x := v_0
  5807  		if x.Op != OpARMMOVHUload {
  5808  			break
  5809  		}
  5810  		v.reset(OpARMMOVWreg)
  5811  		v.AddArg(x)
  5812  		return true
  5813  	}
  5814  	// match: (MOVHUreg (ANDconst [c] x))
  5815  	// result: (ANDconst [c&0xffff] x)
  5816  	for {
  5817  		if v_0.Op != OpARMANDconst {
  5818  			break
  5819  		}
  5820  		c := auxIntToInt32(v_0.AuxInt)
  5821  		x := v_0.Args[0]
  5822  		v.reset(OpARMANDconst)
  5823  		v.AuxInt = int32ToAuxInt(c & 0xffff)
  5824  		v.AddArg(x)
  5825  		return true
  5826  	}
  5827  	// match: (MOVHUreg x:(MOVBUreg _))
  5828  	// result: (MOVWreg x)
  5829  	for {
  5830  		x := v_0
  5831  		if x.Op != OpARMMOVBUreg {
  5832  			break
  5833  		}
  5834  		v.reset(OpARMMOVWreg)
  5835  		v.AddArg(x)
  5836  		return true
  5837  	}
  5838  	// match: (MOVHUreg x:(MOVHUreg _))
  5839  	// result: (MOVWreg x)
  5840  	for {
  5841  		x := v_0
  5842  		if x.Op != OpARMMOVHUreg {
  5843  			break
  5844  		}
  5845  		v.reset(OpARMMOVWreg)
  5846  		v.AddArg(x)
  5847  		return true
  5848  	}
  5849  	// match: (MOVHUreg (MOVWconst [c]))
  5850  	// result: (MOVWconst [int32(uint16(c))])
  5851  	for {
  5852  		if v_0.Op != OpARMMOVWconst {
  5853  			break
  5854  		}
  5855  		c := auxIntToInt32(v_0.AuxInt)
  5856  		v.reset(OpARMMOVWconst)
  5857  		v.AuxInt = int32ToAuxInt(int32(uint16(c)))
  5858  		return true
  5859  	}
  5860  	return false
  5861  }
  5862  func rewriteValueARM_OpARMMOVHload(v *Value) bool {
  5863  	v_1 := v.Args[1]
  5864  	v_0 := v.Args[0]
  5865  	b := v.Block
  5866  	config := b.Func.Config
  5867  	// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
  5868  	// result: (MOVHload [off1+off2] {sym} ptr mem)
  5869  	for {
  5870  		off1 := auxIntToInt32(v.AuxInt)
  5871  		sym := auxToSym(v.Aux)
  5872  		if v_0.Op != OpARMADDconst {
  5873  			break
  5874  		}
  5875  		off2 := auxIntToInt32(v_0.AuxInt)
  5876  		ptr := v_0.Args[0]
  5877  		mem := v_1
  5878  		v.reset(OpARMMOVHload)
  5879  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5880  		v.Aux = symToAux(sym)
  5881  		v.AddArg2(ptr, mem)
  5882  		return true
  5883  	}
  5884  	// match: (MOVHload [off1] {sym} (SUBconst [off2] ptr) mem)
  5885  	// result: (MOVHload [off1-off2] {sym} ptr mem)
  5886  	for {
  5887  		off1 := auxIntToInt32(v.AuxInt)
  5888  		sym := auxToSym(v.Aux)
  5889  		if v_0.Op != OpARMSUBconst {
  5890  			break
  5891  		}
  5892  		off2 := auxIntToInt32(v_0.AuxInt)
  5893  		ptr := v_0.Args[0]
  5894  		mem := v_1
  5895  		v.reset(OpARMMOVHload)
  5896  		v.AuxInt = int32ToAuxInt(off1 - off2)
  5897  		v.Aux = symToAux(sym)
  5898  		v.AddArg2(ptr, mem)
  5899  		return true
  5900  	}
  5901  	// match: (MOVHload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  5902  	// cond: canMergeSym(sym1,sym2)
  5903  	// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  5904  	for {
  5905  		off1 := auxIntToInt32(v.AuxInt)
  5906  		sym1 := auxToSym(v.Aux)
  5907  		if v_0.Op != OpARMMOVWaddr {
  5908  			break
  5909  		}
  5910  		off2 := auxIntToInt32(v_0.AuxInt)
  5911  		sym2 := auxToSym(v_0.Aux)
  5912  		ptr := v_0.Args[0]
  5913  		mem := v_1
  5914  		if !(canMergeSym(sym1, sym2)) {
  5915  			break
  5916  		}
  5917  		v.reset(OpARMMOVHload)
  5918  		v.AuxInt = int32ToAuxInt(off1 + off2)
  5919  		v.Aux = symToAux(mergeSym(sym1, sym2))
  5920  		v.AddArg2(ptr, mem)
  5921  		return true
  5922  	}
  5923  	// match: (MOVHload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _))
  5924  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  5925  	// result: (MOVHreg x)
  5926  	for {
  5927  		off := auxIntToInt32(v.AuxInt)
  5928  		sym := auxToSym(v.Aux)
  5929  		ptr := v_0
  5930  		if v_1.Op != OpARMMOVHstore {
  5931  			break
  5932  		}
  5933  		off2 := auxIntToInt32(v_1.AuxInt)
  5934  		sym2 := auxToSym(v_1.Aux)
  5935  		x := v_1.Args[1]
  5936  		ptr2 := v_1.Args[0]
  5937  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  5938  			break
  5939  		}
  5940  		v.reset(OpARMMOVHreg)
  5941  		v.AddArg(x)
  5942  		return true
  5943  	}
  5944  	// match: (MOVHload [0] {sym} (ADD ptr idx) mem)
  5945  	// cond: sym == nil
  5946  	// result: (MOVHloadidx ptr idx mem)
  5947  	for {
  5948  		if auxIntToInt32(v.AuxInt) != 0 {
  5949  			break
  5950  		}
  5951  		sym := auxToSym(v.Aux)
  5952  		if v_0.Op != OpARMADD {
  5953  			break
  5954  		}
  5955  		idx := v_0.Args[1]
  5956  		ptr := v_0.Args[0]
  5957  		mem := v_1
  5958  		if !(sym == nil) {
  5959  			break
  5960  		}
  5961  		v.reset(OpARMMOVHloadidx)
  5962  		v.AddArg3(ptr, idx, mem)
  5963  		return true
  5964  	}
  5965  	// match: (MOVHload [off] {sym} (SB) _)
  5966  	// cond: symIsRO(sym)
  5967  	// result: (MOVWconst [int32(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder)))])
  5968  	for {
  5969  		off := auxIntToInt32(v.AuxInt)
  5970  		sym := auxToSym(v.Aux)
  5971  		if v_0.Op != OpSB || !(symIsRO(sym)) {
  5972  			break
  5973  		}
  5974  		v.reset(OpARMMOVWconst)
  5975  		v.AuxInt = int32ToAuxInt(int32(int16(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))))
  5976  		return true
  5977  	}
  5978  	return false
  5979  }
  5980  func rewriteValueARM_OpARMMOVHloadidx(v *Value) bool {
  5981  	v_2 := v.Args[2]
  5982  	v_1 := v.Args[1]
  5983  	v_0 := v.Args[0]
  5984  	// match: (MOVHloadidx ptr idx (MOVHstoreidx ptr2 idx x _))
  5985  	// cond: isSamePtr(ptr, ptr2)
  5986  	// result: (MOVHreg x)
  5987  	for {
  5988  		ptr := v_0
  5989  		idx := v_1
  5990  		if v_2.Op != OpARMMOVHstoreidx {
  5991  			break
  5992  		}
  5993  		x := v_2.Args[2]
  5994  		ptr2 := v_2.Args[0]
  5995  		if idx != v_2.Args[1] || !(isSamePtr(ptr, ptr2)) {
  5996  			break
  5997  		}
  5998  		v.reset(OpARMMOVHreg)
  5999  		v.AddArg(x)
  6000  		return true
  6001  	}
  6002  	// match: (MOVHloadidx ptr (MOVWconst [c]) mem)
  6003  	// result: (MOVHload [c] ptr mem)
  6004  	for {
  6005  		ptr := v_0
  6006  		if v_1.Op != OpARMMOVWconst {
  6007  			break
  6008  		}
  6009  		c := auxIntToInt32(v_1.AuxInt)
  6010  		mem := v_2
  6011  		v.reset(OpARMMOVHload)
  6012  		v.AuxInt = int32ToAuxInt(c)
  6013  		v.AddArg2(ptr, mem)
  6014  		return true
  6015  	}
  6016  	// match: (MOVHloadidx (MOVWconst [c]) ptr mem)
  6017  	// result: (MOVHload [c] ptr mem)
  6018  	for {
  6019  		if v_0.Op != OpARMMOVWconst {
  6020  			break
  6021  		}
  6022  		c := auxIntToInt32(v_0.AuxInt)
  6023  		ptr := v_1
  6024  		mem := v_2
  6025  		v.reset(OpARMMOVHload)
  6026  		v.AuxInt = int32ToAuxInt(c)
  6027  		v.AddArg2(ptr, mem)
  6028  		return true
  6029  	}
  6030  	return false
  6031  }
  6032  func rewriteValueARM_OpARMMOVHreg(v *Value) bool {
  6033  	v_0 := v.Args[0]
  6034  	// match: (MOVHreg x:(MOVBload _ _))
  6035  	// result: (MOVWreg x)
  6036  	for {
  6037  		x := v_0
  6038  		if x.Op != OpARMMOVBload {
  6039  			break
  6040  		}
  6041  		v.reset(OpARMMOVWreg)
  6042  		v.AddArg(x)
  6043  		return true
  6044  	}
  6045  	// match: (MOVHreg x:(MOVBUload _ _))
  6046  	// result: (MOVWreg x)
  6047  	for {
  6048  		x := v_0
  6049  		if x.Op != OpARMMOVBUload {
  6050  			break
  6051  		}
  6052  		v.reset(OpARMMOVWreg)
  6053  		v.AddArg(x)
  6054  		return true
  6055  	}
  6056  	// match: (MOVHreg x:(MOVHload _ _))
  6057  	// result: (MOVWreg x)
  6058  	for {
  6059  		x := v_0
  6060  		if x.Op != OpARMMOVHload {
  6061  			break
  6062  		}
  6063  		v.reset(OpARMMOVWreg)
  6064  		v.AddArg(x)
  6065  		return true
  6066  	}
  6067  	// match: (MOVHreg (ANDconst [c] x))
  6068  	// cond: c & 0x8000 == 0
  6069  	// result: (ANDconst [c&0x7fff] x)
  6070  	for {
  6071  		if v_0.Op != OpARMANDconst {
  6072  			break
  6073  		}
  6074  		c := auxIntToInt32(v_0.AuxInt)
  6075  		x := v_0.Args[0]
  6076  		if !(c&0x8000 == 0) {
  6077  			break
  6078  		}
  6079  		v.reset(OpARMANDconst)
  6080  		v.AuxInt = int32ToAuxInt(c & 0x7fff)
  6081  		v.AddArg(x)
  6082  		return true
  6083  	}
  6084  	// match: (MOVHreg x:(MOVBreg _))
  6085  	// result: (MOVWreg x)
  6086  	for {
  6087  		x := v_0
  6088  		if x.Op != OpARMMOVBreg {
  6089  			break
  6090  		}
  6091  		v.reset(OpARMMOVWreg)
  6092  		v.AddArg(x)
  6093  		return true
  6094  	}
  6095  	// match: (MOVHreg x:(MOVBUreg _))
  6096  	// result: (MOVWreg x)
  6097  	for {
  6098  		x := v_0
  6099  		if x.Op != OpARMMOVBUreg {
  6100  			break
  6101  		}
  6102  		v.reset(OpARMMOVWreg)
  6103  		v.AddArg(x)
  6104  		return true
  6105  	}
  6106  	// match: (MOVHreg x:(MOVHreg _))
  6107  	// result: (MOVWreg x)
  6108  	for {
  6109  		x := v_0
  6110  		if x.Op != OpARMMOVHreg {
  6111  			break
  6112  		}
  6113  		v.reset(OpARMMOVWreg)
  6114  		v.AddArg(x)
  6115  		return true
  6116  	}
  6117  	// match: (MOVHreg (MOVWconst [c]))
  6118  	// result: (MOVWconst [int32(int16(c))])
  6119  	for {
  6120  		if v_0.Op != OpARMMOVWconst {
  6121  			break
  6122  		}
  6123  		c := auxIntToInt32(v_0.AuxInt)
  6124  		v.reset(OpARMMOVWconst)
  6125  		v.AuxInt = int32ToAuxInt(int32(int16(c)))
  6126  		return true
  6127  	}
  6128  	return false
  6129  }
  6130  func rewriteValueARM_OpARMMOVHstore(v *Value) bool {
  6131  	v_2 := v.Args[2]
  6132  	v_1 := v.Args[1]
  6133  	v_0 := v.Args[0]
  6134  	// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
  6135  	// result: (MOVHstore [off1+off2] {sym} ptr val mem)
  6136  	for {
  6137  		off1 := auxIntToInt32(v.AuxInt)
  6138  		sym := auxToSym(v.Aux)
  6139  		if v_0.Op != OpARMADDconst {
  6140  			break
  6141  		}
  6142  		off2 := auxIntToInt32(v_0.AuxInt)
  6143  		ptr := v_0.Args[0]
  6144  		val := v_1
  6145  		mem := v_2
  6146  		v.reset(OpARMMOVHstore)
  6147  		v.AuxInt = int32ToAuxInt(off1 + off2)
  6148  		v.Aux = symToAux(sym)
  6149  		v.AddArg3(ptr, val, mem)
  6150  		return true
  6151  	}
  6152  	// match: (MOVHstore [off1] {sym} (SUBconst [off2] ptr) val mem)
  6153  	// result: (MOVHstore [off1-off2] {sym} ptr val mem)
  6154  	for {
  6155  		off1 := auxIntToInt32(v.AuxInt)
  6156  		sym := auxToSym(v.Aux)
  6157  		if v_0.Op != OpARMSUBconst {
  6158  			break
  6159  		}
  6160  		off2 := auxIntToInt32(v_0.AuxInt)
  6161  		ptr := v_0.Args[0]
  6162  		val := v_1
  6163  		mem := v_2
  6164  		v.reset(OpARMMOVHstore)
  6165  		v.AuxInt = int32ToAuxInt(off1 - off2)
  6166  		v.Aux = symToAux(sym)
  6167  		v.AddArg3(ptr, val, mem)
  6168  		return true
  6169  	}
  6170  	// match: (MOVHstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem)
  6171  	// cond: canMergeSym(sym1,sym2)
  6172  	// result: (MOVHstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
  6173  	for {
  6174  		off1 := auxIntToInt32(v.AuxInt)
  6175  		sym1 := auxToSym(v.Aux)
  6176  		if v_0.Op != OpARMMOVWaddr {
  6177  			break
  6178  		}
  6179  		off2 := auxIntToInt32(v_0.AuxInt)
  6180  		sym2 := auxToSym(v_0.Aux)
  6181  		ptr := v_0.Args[0]
  6182  		val := v_1
  6183  		mem := v_2
  6184  		if !(canMergeSym(sym1, sym2)) {
  6185  			break
  6186  		}
  6187  		v.reset(OpARMMOVHstore)
  6188  		v.AuxInt = int32ToAuxInt(off1 + off2)
  6189  		v.Aux = symToAux(mergeSym(sym1, sym2))
  6190  		v.AddArg3(ptr, val, mem)
  6191  		return true
  6192  	}
  6193  	// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
  6194  	// result: (MOVHstore [off] {sym} ptr x mem)
  6195  	for {
  6196  		off := auxIntToInt32(v.AuxInt)
  6197  		sym := auxToSym(v.Aux)
  6198  		ptr := v_0
  6199  		if v_1.Op != OpARMMOVHreg {
  6200  			break
  6201  		}
  6202  		x := v_1.Args[0]
  6203  		mem := v_2
  6204  		v.reset(OpARMMOVHstore)
  6205  		v.AuxInt = int32ToAuxInt(off)
  6206  		v.Aux = symToAux(sym)
  6207  		v.AddArg3(ptr, x, mem)
  6208  		return true
  6209  	}
  6210  	// match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem)
  6211  	// result: (MOVHstore [off] {sym} ptr x mem)
  6212  	for {
  6213  		off := auxIntToInt32(v.AuxInt)
  6214  		sym := auxToSym(v.Aux)
  6215  		ptr := v_0
  6216  		if v_1.Op != OpARMMOVHUreg {
  6217  			break
  6218  		}
  6219  		x := v_1.Args[0]
  6220  		mem := v_2
  6221  		v.reset(OpARMMOVHstore)
  6222  		v.AuxInt = int32ToAuxInt(off)
  6223  		v.Aux = symToAux(sym)
  6224  		v.AddArg3(ptr, x, mem)
  6225  		return true
  6226  	}
  6227  	// match: (MOVHstore [0] {sym} (ADD ptr idx) val mem)
  6228  	// cond: sym == nil
  6229  	// result: (MOVHstoreidx ptr idx val mem)
  6230  	for {
  6231  		if auxIntToInt32(v.AuxInt) != 0 {
  6232  			break
  6233  		}
  6234  		sym := auxToSym(v.Aux)
  6235  		if v_0.Op != OpARMADD {
  6236  			break
  6237  		}
  6238  		idx := v_0.Args[1]
  6239  		ptr := v_0.Args[0]
  6240  		val := v_1
  6241  		mem := v_2
  6242  		if !(sym == nil) {
  6243  			break
  6244  		}
  6245  		v.reset(OpARMMOVHstoreidx)
  6246  		v.AddArg4(ptr, idx, val, mem)
  6247  		return true
  6248  	}
  6249  	return false
  6250  }
  6251  func rewriteValueARM_OpARMMOVHstoreidx(v *Value) bool {
  6252  	v_3 := v.Args[3]
  6253  	v_2 := v.Args[2]
  6254  	v_1 := v.Args[1]
  6255  	v_0 := v.Args[0]
  6256  	// match: (MOVHstoreidx ptr (MOVWconst [c]) val mem)
  6257  	// result: (MOVHstore [c] ptr val mem)
  6258  	for {
  6259  		ptr := v_0
  6260  		if v_1.Op != OpARMMOVWconst {
  6261  			break
  6262  		}
  6263  		c := auxIntToInt32(v_1.AuxInt)
  6264  		val := v_2
  6265  		mem := v_3
  6266  		v.reset(OpARMMOVHstore)
  6267  		v.AuxInt = int32ToAuxInt(c)
  6268  		v.AddArg3(ptr, val, mem)
  6269  		return true
  6270  	}
  6271  	// match: (MOVHstoreidx (MOVWconst [c]) ptr val mem)
  6272  	// result: (MOVHstore [c] ptr val mem)
  6273  	for {
  6274  		if v_0.Op != OpARMMOVWconst {
  6275  			break
  6276  		}
  6277  		c := auxIntToInt32(v_0.AuxInt)
  6278  		ptr := v_1
  6279  		val := v_2
  6280  		mem := v_3
  6281  		v.reset(OpARMMOVHstore)
  6282  		v.AuxInt = int32ToAuxInt(c)
  6283  		v.AddArg3(ptr, val, mem)
  6284  		return true
  6285  	}
  6286  	return false
  6287  }
  6288  func rewriteValueARM_OpARMMOVWload(v *Value) bool {
  6289  	v_1 := v.Args[1]
  6290  	v_0 := v.Args[0]
  6291  	b := v.Block
  6292  	config := b.Func.Config
  6293  	// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
  6294  	// result: (MOVWload [off1+off2] {sym} ptr mem)
  6295  	for {
  6296  		off1 := auxIntToInt32(v.AuxInt)
  6297  		sym := auxToSym(v.Aux)
  6298  		if v_0.Op != OpARMADDconst {
  6299  			break
  6300  		}
  6301  		off2 := auxIntToInt32(v_0.AuxInt)
  6302  		ptr := v_0.Args[0]
  6303  		mem := v_1
  6304  		v.reset(OpARMMOVWload)
  6305  		v.AuxInt = int32ToAuxInt(off1 + off2)
  6306  		v.Aux = symToAux(sym)
  6307  		v.AddArg2(ptr, mem)
  6308  		return true
  6309  	}
  6310  	// match: (MOVWload [off1] {sym} (SUBconst [off2] ptr) mem)
  6311  	// result: (MOVWload [off1-off2] {sym} ptr mem)
  6312  	for {
  6313  		off1 := auxIntToInt32(v.AuxInt)
  6314  		sym := auxToSym(v.Aux)
  6315  		if v_0.Op != OpARMSUBconst {
  6316  			break
  6317  		}
  6318  		off2 := auxIntToInt32(v_0.AuxInt)
  6319  		ptr := v_0.Args[0]
  6320  		mem := v_1
  6321  		v.reset(OpARMMOVWload)
  6322  		v.AuxInt = int32ToAuxInt(off1 - off2)
  6323  		v.Aux = symToAux(sym)
  6324  		v.AddArg2(ptr, mem)
  6325  		return true
  6326  	}
  6327  	// match: (MOVWload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem)
  6328  	// cond: canMergeSym(sym1,sym2)
  6329  	// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
  6330  	for {
  6331  		off1 := auxIntToInt32(v.AuxInt)
  6332  		sym1 := auxToSym(v.Aux)
  6333  		if v_0.Op != OpARMMOVWaddr {
  6334  			break
  6335  		}
  6336  		off2 := auxIntToInt32(v_0.AuxInt)
  6337  		sym2 := auxToSym(v_0.Aux)
  6338  		ptr := v_0.Args[0]
  6339  		mem := v_1
  6340  		if !(canMergeSym(sym1, sym2)) {
  6341  			break
  6342  		}
  6343  		v.reset(OpARMMOVWload)
  6344  		v.AuxInt = int32ToAuxInt(off1 + off2)
  6345  		v.Aux = symToAux(mergeSym(sym1, sym2))
  6346  		v.AddArg2(ptr, mem)
  6347  		return true
  6348  	}
  6349  	// match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
  6350  	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
  6351  	// result: x
  6352  	for {
  6353  		off := auxIntToInt32(v.AuxInt)
  6354  		sym := auxToSym(v.Aux)
  6355  		ptr := v_0
  6356  		if v_1.Op != OpARMMOVWstore {
  6357  			break
  6358  		}
  6359  		off2 := auxIntToInt32(v_1.AuxInt)
  6360  		sym2 := auxToSym(v_1.Aux)
  6361  		x := v_1.Args[1]
  6362  		ptr2 := v_1.Args[0]
  6363  		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
  6364  			break
  6365  		}
  6366  		v.copyOf(x)
  6367  		return true
  6368  	}
  6369  	// match: (MOVWload [0] {sym} (ADD ptr idx) mem)
  6370  	// cond: sym == nil
  6371  	// result: (MOVWloadidx ptr idx mem)
  6372  	for {
  6373  		if auxIntToInt32(v.AuxInt) != 0 {
  6374  			break
  6375  		}
  6376  		sym := auxToSym(v.Aux)
  6377  		if v_0.Op != OpARMADD {
  6378  			break
  6379  		}
  6380  		idx := v_0.Args[1]
  6381  		ptr := v_0.Args[0]
  6382  		mem := v_1
  6383  		if !(sym == nil) {
  6384  			break
  6385  		}
  6386  		v.reset(OpARMMOVWloadidx)
  6387  		v.AddArg3(ptr, idx, mem)
  6388  		return true
  6389  	}
  6390  	// match: (MOVWload [0] {sym} (ADDshiftLL ptr idx [c]) mem)
  6391  	// cond: sym == nil
  6392  	// result: (MOVWloadshiftLL ptr idx [c] mem)
  6393  	for {
  6394  		if auxIntToInt32(v.AuxInt) != 0 {
  6395  			break
  6396  		}
  6397  		sym := auxToSym(v.Aux)
  6398  		if v_0.Op != OpARMADDshiftLL {
  6399  			break
  6400  		}
  6401  		c := auxIntToInt32(v_0.AuxInt)
  6402  		idx := v_0.Args[1]
  6403  		ptr := v_0.Args[0]
  6404  		mem := v_1
  6405  		if !(sym == nil) {
  6406  			break
  6407  		}
  6408  		v.reset(OpARMMOVWloadshiftLL)
  6409  		v.AuxInt = int32ToAuxInt(c)
  6410  		v.AddArg3(ptr, idx, mem)
  6411  		return true
  6412  	}
  6413  	// match: (MOVWload [0] {sym} (ADDshiftRL ptr idx [c]) mem)
  6414  	// cond: sym == nil
  6415  	// result: (MOVWloadshiftRL ptr idx [c] mem)
  6416  	for {
  6417  		if auxIntToInt32(v.AuxInt) != 0 {
  6418  			break
  6419  		}
  6420  		sym := auxToSym(v.Aux)
  6421  		if v_0.Op != OpARMADDshiftRL {
  6422  			break
  6423  		}
  6424  		c := auxIntToInt32(v_0.AuxInt)
  6425  		idx := v_0.Args[1]
  6426  		ptr := v_0.Args[0]
  6427  		mem := v_1
  6428  		if !(sym == nil) {
  6429  			break
  6430  		}
  6431  		v.reset(OpARMMOVWloadshiftRL)
  6432  		v.AuxInt = int32ToAuxInt(c)
  6433  		v.AddArg3(ptr, idx, mem)
  6434  		return true
  6435  	}
  6436  	// match: (MOVWload [0] {sym} (ADDshiftRA ptr idx [c]) mem)
  6437  	// cond: sym == nil
  6438  	// result: (MOVWloadshiftRA ptr idx [c] mem)
  6439  	for {
  6440  		if auxIntToInt32(v.AuxInt) != 0 {
  6441  			break
  6442  		}
  6443  		sym := auxToSym(v.Aux)
  6444  		if v_0.Op != OpARMADDshiftRA {
  6445  			break
  6446  		}
  6447  		c := auxIntToInt32(v_0.AuxInt)
  6448  		idx := v_0.Args[1]
  6449  		ptr := v_0.Args[0]
  6450  		mem := v_1
  6451  		if !(sym == nil) {
  6452  			break
  6453  		}
  6454  		v.reset(OpARMMOVWloadshiftRA)
  6455  		v.AuxInt = int32ToAuxInt(c)
  6456  		v.AddArg3(ptr, idx, mem)
  6457  		return true
  6458  	}
  6459  	// match: (MOVWload [off] {sym} (SB) _)
  6460  	// cond: symIsRO(sym)
  6461  	// result: (MOVWconst [int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder))])
  6462  	for {
  6463  		off := auxIntToInt32(v.AuxInt)
  6464  		sym := auxToSym(v.Aux)
  6465  		if v_0.Op != OpSB || !(symIsRO(sym)) {
  6466  			break
  6467  		}
  6468  		v.reset(OpARMMOVWconst)
  6469  		v.AuxInt = int32ToAuxInt(int32(read32(sym, int64(off), config.ctxt.Arch.ByteOrder)))
  6470  		return true
  6471  	}
  6472  	return false
  6473  }
  6474  func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool {
  6475  	v_2 := v.Args[2]
  6476  	v_1 := v.Args[1]
  6477  	v_0 := v.Args[0]
  6478  	// match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _))
  6479  	// cond: isSamePtr(ptr, ptr2)
  6480  	// result: x
  6481  	for {
  6482  		ptr := v_0
  6483  		idx := v_1
  6484  		if v_2.Op != OpARMMOVWstoreidx {
  6485  			break
  6486  		}
  6487  		x := v_2.Args[2]
  6488  		ptr2 := v_2.Args[0]
  6489  		if idx != v_2.Args[1] || !(isSamePtr(ptr, ptr2)) {
  6490  			break
  6491  		}
  6492  		v.copyOf(x)
  6493  		return true
  6494  	}
  6495  	// match: (MOVWloadidx ptr (MOVWconst [c]) mem)
  6496  	// result: (MOVWload [c] ptr mem)
  6497  	for {
  6498  		ptr := v_0
  6499  		if v_1.Op != OpARMMOVWconst {
  6500  			break
  6501  		}
  6502  		c := auxIntToInt32(v_1.AuxInt)
  6503  		mem := v_2
  6504  		v.reset(OpARMMOVWload)
  6505  		v.AuxInt = int32ToAuxInt(c)
  6506  		v.AddArg2(ptr, mem)
  6507  		return true
  6508  	}
  6509  	// match: (MOVWloadidx (MOVWconst [c]) ptr mem)
  6510  	// result: (MOVWload [c] ptr mem)
  6511  	for {
  6512  		if v_0.Op != OpARMMOVWconst {
  6513  			break
  6514  		}
  6515  		c := auxIntToInt32(v_0.AuxInt)
  6516  		ptr := v_1
  6517  		mem := v_2
  6518  		v.reset(OpARMMOVWload)
  6519  		v.AuxInt = int32ToAuxInt(c)
  6520  		v.AddArg2(ptr, mem)
  6521  		return true
  6522  	}
  6523  	// match: (MOVWloadidx ptr (SLLconst idx [c]) mem)
  6524  	// result: (MOVWloadshiftLL ptr idx [c] mem)
  6525  	for {
  6526  		ptr := v_0
  6527  		if v_1.Op != OpARMSLLconst {
  6528  			break
  6529  		}
  6530  		c := auxIntToInt32(v_1.AuxInt)
  6531  		idx := v_1.Args[0]
  6532  		mem := v_2
  6533  		v.reset(OpARMMOVWloadshiftLL)
  6534  		v.AuxInt = int32ToAuxInt(c)
  6535  		v.AddArg3(ptr, idx, mem)
  6536  		return true
  6537  	}
  6538  	// match: (MOVWloadidx (SLLconst idx [c]) ptr mem)
  6539  	// result: (MOVWloadshiftLL ptr idx [c] mem)
  6540  	for {
  6541  		if v_0.Op != OpARMSLLconst {
  6542  			break
  6543  		}
  6544  		c := auxIntToInt32(v_0.AuxInt)
  6545  		idx := v_0.Args[0]
  6546  		ptr := v_1
  6547  		mem := v_2
  6548  		v.reset(OpARMMOVWloadshiftLL)
  6549  		v.AuxInt = int32ToAuxInt(c)
  6550  		v.AddArg3(ptr, idx, mem)
  6551  		return true
  6552  	}
  6553  	// match: (MOVWloadidx ptr (SRLconst idx [c]) mem)
  6554  	// result: (MOVWloadshiftRL ptr idx [c] mem)
  6555  	for {
  6556  		ptr := v_0
  6557  		if v_1.Op != OpARMSRLconst {
  6558  			break
  6559  		}
  6560  		c := auxIntToInt32(v_1.AuxInt)
  6561  		idx := v_1.Args[0]
  6562  		mem := v_2
  6563  		v.reset(OpARMMOVWloadshiftRL)
  6564  		v.AuxInt = int32ToAuxInt(c)
  6565  		v.AddArg3(ptr, idx, mem)
  6566  		return true
  6567  	}
  6568  	// match: (MOVWloadidx (SRLconst idx [c]) ptr mem)
  6569  	// result: (MOVWloadshiftRL ptr idx [c] mem)
  6570  	for {
  6571  		if v_0.Op != OpARMSRLconst {
  6572  			break
  6573  		}
  6574  		c := auxIntToInt32(v_0.AuxInt)
  6575  		idx := v_0.Args[0]
  6576  		ptr := v_1
  6577  		mem := v_2
  6578  		v.reset(OpARMMOVWloadshiftRL)
  6579  		v.AuxInt = int32ToAuxInt(c)
  6580  		v.AddArg3(ptr, idx, mem)
  6581  		return true
  6582  	}
  6583  	// match: (MOVWloadidx ptr (SRAconst idx [c]) mem)
  6584  	// result: (MOVWloadshiftRA ptr idx [c] mem)
  6585  	for {
  6586  		ptr := v_0
  6587  		if v_1.Op != OpARMSRAconst {
  6588  			break
  6589  		}
  6590  		c := auxIntToInt32(v_1.AuxInt)
  6591  		idx := v_1.Args[0]
  6592  		mem := v_2
  6593  		v.reset(OpARMMOVWloadshiftRA)
  6594  		v.AuxInt = int32ToAuxInt(c)
  6595  		v.AddArg3(ptr, idx, mem)
  6596  		return true
  6597  	}
  6598  	// match: (MOVWloadidx (SRAconst idx [c]) ptr mem)
  6599  	// result: (MOVWloadshiftRA ptr idx [c] mem)
  6600  	for {
  6601  		if v_0.Op != OpARMSRAconst {
  6602  			break
  6603  		}
  6604  		c := auxIntToInt32(v_0.AuxInt)
  6605  		idx := v_0.Args[0]
  6606  		ptr := v_1
  6607  		mem := v_2
  6608  		v.reset(OpARMMOVWloadshiftRA)
  6609  		v.AuxInt = int32ToAuxInt(c)
  6610  		v.AddArg3(ptr, idx, mem)
  6611  		return true
  6612  	}
  6613  	return false
  6614  }
  6615  func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool {
  6616  	v_2 := v.Args[2]
  6617  	v_1 := v.Args[1]
  6618  	v_0 := v.Args[0]
  6619  	// match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _))
  6620  	// cond: c==d && isSamePtr(ptr, ptr2)
  6621  	// result: x
  6622  	for {
  6623  		c := auxIntToInt32(v.AuxInt)
  6624  		ptr := v_0
  6625  		idx := v_1
  6626  		if v_2.Op != OpARMMOVWstoreshiftLL {
  6627  			break
  6628  		}
  6629  		d := auxIntToInt32(v_2.AuxInt)
  6630  		x := v_2.Args[2]
  6631  		ptr2 := v_2.Args[0]
  6632  		if idx != v_2.Args[1] || !(c == d && isSamePtr(ptr, ptr2)) {
  6633  			break
  6634  		}
  6635  		v.copyOf(x)
  6636  		return true
  6637  	}
  6638  	// match: (MOVWloadshiftLL ptr (MOVWconst [c]) [d] mem)
  6639  	// result: (MOVWload [int32(uint32(c)<<uint64(d))] ptr mem)
  6640  	for {
  6641  		d := auxIntToInt32(v.AuxInt)
  6642  		ptr := v_0
  6643  		if v_1.Op != OpARMMOVWconst {
  6644  			break
  6645  		}
  6646  		c := auxIntToInt32(v_1.AuxInt)
  6647  		mem := v_2
  6648  		v.reset(OpARMMOVWload)
  6649  		v.AuxInt = int32ToAuxInt(int32(uint32(c) << uint64(d)))
  6650  		v.AddArg2(ptr, mem)
  6651  		return true
  6652  	}
  6653  	return false
  6654  }
  6655  func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool {
  6656  	v_2 := v.Args[2]
  6657  	v_1 := v.Args[1]
  6658  	v_0 := v.Args[0]
  6659  	// match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _))
  6660  	// cond: c==d && isSamePtr(ptr, ptr2)
  6661  	// result: x
  6662  	for {
  6663  		c := auxIntToInt32(v.AuxInt)
  6664  		ptr := v_0
  6665  		idx := v_1
  6666  		if v_2.Op != OpARMMOVWstoreshiftRA {
  6667  			break
  6668  		}
  6669  		d := auxIntToInt32(v_2.AuxInt)
  6670  		x := v_2.Args[2]
  6671  		ptr2 := v_2.Args[0]
  6672  		if idx != v_2.Args[1] || !(c == d && isSamePtr(ptr, ptr2)) {
  6673  			break
  6674  		}
  6675  		v.copyOf(x)
  6676  		return true
  6677  	}
  6678  	// match: (MOVWloadshiftRA ptr (MOVWconst [c]) [d] mem)
  6679  	// result: (MOVWload [c>>uint64(d)] ptr mem)
  6680  	for {
  6681  		d := auxIntToInt32(v.AuxInt)
  6682  		ptr := v_0
  6683  		if v_1.Op != OpARMMOVWconst {
  6684  			break
  6685  		}
  6686  		c := auxIntToInt32(v_1.AuxInt)
  6687  		mem := v_2
  6688  		v.reset(OpARMMOVWload)
  6689  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  6690  		v.AddArg2(ptr, mem)
  6691  		return true
  6692  	}
  6693  	return false
  6694  }
  6695  func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool {
  6696  	v_2 := v.Args[2]
  6697  	v_1 := v.Args[1]
  6698  	v_0 := v.Args[0]
  6699  	// match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _))
  6700  	// cond: c==d && isSamePtr(ptr, ptr2)
  6701  	// result: x
  6702  	for {
  6703  		c := auxIntToInt32(v.AuxInt)
  6704  		ptr := v_0
  6705  		idx := v_1
  6706  		if v_2.Op != OpARMMOVWstoreshiftRL {
  6707  			break
  6708  		}
  6709  		d := auxIntToInt32(v_2.AuxInt)
  6710  		x := v_2.Args[2]
  6711  		ptr2 := v_2.Args[0]
  6712  		if idx != v_2.Args[1] || !(c == d && isSamePtr(ptr, ptr2)) {
  6713  			break
  6714  		}
  6715  		v.copyOf(x)
  6716  		return true
  6717  	}
  6718  	// match: (MOVWloadshiftRL ptr (MOVWconst [c]) [d] mem)
  6719  	// result: (MOVWload [int32(uint32(c)>>uint64(d))] ptr mem)
  6720  	for {
  6721  		d := auxIntToInt32(v.AuxInt)
  6722  		ptr := v_0
  6723  		if v_1.Op != OpARMMOVWconst {
  6724  			break
  6725  		}
  6726  		c := auxIntToInt32(v_1.AuxInt)
  6727  		mem := v_2
  6728  		v.reset(OpARMMOVWload)
  6729  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  6730  		v.AddArg2(ptr, mem)
  6731  		return true
  6732  	}
  6733  	return false
  6734  }
  6735  func rewriteValueARM_OpARMMOVWnop(v *Value) bool {
  6736  	v_0 := v.Args[0]
  6737  	// match: (MOVWnop (MOVWconst [c]))
  6738  	// result: (MOVWconst [c])
  6739  	for {
  6740  		if v_0.Op != OpARMMOVWconst {
  6741  			break
  6742  		}
  6743  		c := auxIntToInt32(v_0.AuxInt)
  6744  		v.reset(OpARMMOVWconst)
  6745  		v.AuxInt = int32ToAuxInt(c)
  6746  		return true
  6747  	}
  6748  	return false
  6749  }
  6750  func rewriteValueARM_OpARMMOVWreg(v *Value) bool {
  6751  	v_0 := v.Args[0]
  6752  	// match: (MOVWreg x)
  6753  	// cond: x.Uses == 1
  6754  	// result: (MOVWnop x)
  6755  	for {
  6756  		x := v_0
  6757  		if !(x.Uses == 1) {
  6758  			break
  6759  		}
  6760  		v.reset(OpARMMOVWnop)
  6761  		v.AddArg(x)
  6762  		return true
  6763  	}
  6764  	// match: (MOVWreg (MOVWconst [c]))
  6765  	// result: (MOVWconst [c])
  6766  	for {
  6767  		if v_0.Op != OpARMMOVWconst {
  6768  			break
  6769  		}
  6770  		c := auxIntToInt32(v_0.AuxInt)
  6771  		v.reset(OpARMMOVWconst)
  6772  		v.AuxInt = int32ToAuxInt(c)
  6773  		return true
  6774  	}
  6775  	return false
  6776  }
  6777  func rewriteValueARM_OpARMMOVWstore(v *Value) bool {
  6778  	v_2 := v.Args[2]
  6779  	v_1 := v.Args[1]
  6780  	v_0 := v.Args[0]
  6781  	// match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem)
  6782  	// result: (MOVWstore [off1+off2] {sym} ptr val mem)
  6783  	for {
  6784  		off1 := auxIntToInt32(v.AuxInt)
  6785  		sym := auxToSym(v.Aux)
  6786  		if v_0.Op != OpARMADDconst {
  6787  			break
  6788  		}
  6789  		off2 := auxIntToInt32(v_0.AuxInt)
  6790  		ptr := v_0.Args[0]
  6791  		val := v_1
  6792  		mem := v_2
  6793  		v.reset(OpARMMOVWstore)
  6794  		v.AuxInt = int32ToAuxInt(off1 + off2)
  6795  		v.Aux = symToAux(sym)
  6796  		v.AddArg3(ptr, val, mem)
  6797  		return true
  6798  	}
  6799  	// match: (MOVWstore [off1] {sym} (SUBconst [off2] ptr) val mem)
  6800  	// result: (MOVWstore [off1-off2] {sym} ptr val mem)
  6801  	for {
  6802  		off1 := auxIntToInt32(v.AuxInt)
  6803  		sym := auxToSym(v.Aux)
  6804  		if v_0.Op != OpARMSUBconst {
  6805  			break
  6806  		}
  6807  		off2 := auxIntToInt32(v_0.AuxInt)
  6808  		ptr := v_0.Args[0]
  6809  		val := v_1
  6810  		mem := v_2
  6811  		v.reset(OpARMMOVWstore)
  6812  		v.AuxInt = int32ToAuxInt(off1 - off2)
  6813  		v.Aux = symToAux(sym)
  6814  		v.AddArg3(ptr, val, mem)
  6815  		return true
  6816  	}
  6817  	// match: (MOVWstore [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) val mem)
  6818  	// cond: canMergeSym(sym1,sym2)
  6819  	// result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} ptr val mem)
  6820  	for {
  6821  		off1 := auxIntToInt32(v.AuxInt)
  6822  		sym1 := auxToSym(v.Aux)
  6823  		if v_0.Op != OpARMMOVWaddr {
  6824  			break
  6825  		}
  6826  		off2 := auxIntToInt32(v_0.AuxInt)
  6827  		sym2 := auxToSym(v_0.Aux)
  6828  		ptr := v_0.Args[0]
  6829  		val := v_1
  6830  		mem := v_2
  6831  		if !(canMergeSym(sym1, sym2)) {
  6832  			break
  6833  		}
  6834  		v.reset(OpARMMOVWstore)
  6835  		v.AuxInt = int32ToAuxInt(off1 + off2)
  6836  		v.Aux = symToAux(mergeSym(sym1, sym2))
  6837  		v.AddArg3(ptr, val, mem)
  6838  		return true
  6839  	}
  6840  	// match: (MOVWstore [0] {sym} (ADD ptr idx) val mem)
  6841  	// cond: sym == nil
  6842  	// result: (MOVWstoreidx ptr idx val mem)
  6843  	for {
  6844  		if auxIntToInt32(v.AuxInt) != 0 {
  6845  			break
  6846  		}
  6847  		sym := auxToSym(v.Aux)
  6848  		if v_0.Op != OpARMADD {
  6849  			break
  6850  		}
  6851  		idx := v_0.Args[1]
  6852  		ptr := v_0.Args[0]
  6853  		val := v_1
  6854  		mem := v_2
  6855  		if !(sym == nil) {
  6856  			break
  6857  		}
  6858  		v.reset(OpARMMOVWstoreidx)
  6859  		v.AddArg4(ptr, idx, val, mem)
  6860  		return true
  6861  	}
  6862  	// match: (MOVWstore [0] {sym} (ADDshiftLL ptr idx [c]) val mem)
  6863  	// cond: sym == nil
  6864  	// result: (MOVWstoreshiftLL ptr idx [c] val mem)
  6865  	for {
  6866  		if auxIntToInt32(v.AuxInt) != 0 {
  6867  			break
  6868  		}
  6869  		sym := auxToSym(v.Aux)
  6870  		if v_0.Op != OpARMADDshiftLL {
  6871  			break
  6872  		}
  6873  		c := auxIntToInt32(v_0.AuxInt)
  6874  		idx := v_0.Args[1]
  6875  		ptr := v_0.Args[0]
  6876  		val := v_1
  6877  		mem := v_2
  6878  		if !(sym == nil) {
  6879  			break
  6880  		}
  6881  		v.reset(OpARMMOVWstoreshiftLL)
  6882  		v.AuxInt = int32ToAuxInt(c)
  6883  		v.AddArg4(ptr, idx, val, mem)
  6884  		return true
  6885  	}
  6886  	// match: (MOVWstore [0] {sym} (ADDshiftRL ptr idx [c]) val mem)
  6887  	// cond: sym == nil
  6888  	// result: (MOVWstoreshiftRL ptr idx [c] val mem)
  6889  	for {
  6890  		if auxIntToInt32(v.AuxInt) != 0 {
  6891  			break
  6892  		}
  6893  		sym := auxToSym(v.Aux)
  6894  		if v_0.Op != OpARMADDshiftRL {
  6895  			break
  6896  		}
  6897  		c := auxIntToInt32(v_0.AuxInt)
  6898  		idx := v_0.Args[1]
  6899  		ptr := v_0.Args[0]
  6900  		val := v_1
  6901  		mem := v_2
  6902  		if !(sym == nil) {
  6903  			break
  6904  		}
  6905  		v.reset(OpARMMOVWstoreshiftRL)
  6906  		v.AuxInt = int32ToAuxInt(c)
  6907  		v.AddArg4(ptr, idx, val, mem)
  6908  		return true
  6909  	}
  6910  	// match: (MOVWstore [0] {sym} (ADDshiftRA ptr idx [c]) val mem)
  6911  	// cond: sym == nil
  6912  	// result: (MOVWstoreshiftRA ptr idx [c] val mem)
  6913  	for {
  6914  		if auxIntToInt32(v.AuxInt) != 0 {
  6915  			break
  6916  		}
  6917  		sym := auxToSym(v.Aux)
  6918  		if v_0.Op != OpARMADDshiftRA {
  6919  			break
  6920  		}
  6921  		c := auxIntToInt32(v_0.AuxInt)
  6922  		idx := v_0.Args[1]
  6923  		ptr := v_0.Args[0]
  6924  		val := v_1
  6925  		mem := v_2
  6926  		if !(sym == nil) {
  6927  			break
  6928  		}
  6929  		v.reset(OpARMMOVWstoreshiftRA)
  6930  		v.AuxInt = int32ToAuxInt(c)
  6931  		v.AddArg4(ptr, idx, val, mem)
  6932  		return true
  6933  	}
  6934  	return false
  6935  }
  6936  func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool {
  6937  	v_3 := v.Args[3]
  6938  	v_2 := v.Args[2]
  6939  	v_1 := v.Args[1]
  6940  	v_0 := v.Args[0]
  6941  	// match: (MOVWstoreidx ptr (MOVWconst [c]) val mem)
  6942  	// result: (MOVWstore [c] ptr val mem)
  6943  	for {
  6944  		ptr := v_0
  6945  		if v_1.Op != OpARMMOVWconst {
  6946  			break
  6947  		}
  6948  		c := auxIntToInt32(v_1.AuxInt)
  6949  		val := v_2
  6950  		mem := v_3
  6951  		v.reset(OpARMMOVWstore)
  6952  		v.AuxInt = int32ToAuxInt(c)
  6953  		v.AddArg3(ptr, val, mem)
  6954  		return true
  6955  	}
  6956  	// match: (MOVWstoreidx (MOVWconst [c]) ptr val mem)
  6957  	// result: (MOVWstore [c] ptr val mem)
  6958  	for {
  6959  		if v_0.Op != OpARMMOVWconst {
  6960  			break
  6961  		}
  6962  		c := auxIntToInt32(v_0.AuxInt)
  6963  		ptr := v_1
  6964  		val := v_2
  6965  		mem := v_3
  6966  		v.reset(OpARMMOVWstore)
  6967  		v.AuxInt = int32ToAuxInt(c)
  6968  		v.AddArg3(ptr, val, mem)
  6969  		return true
  6970  	}
  6971  	// match: (MOVWstoreidx ptr (SLLconst idx [c]) val mem)
  6972  	// result: (MOVWstoreshiftLL ptr idx [c] val mem)
  6973  	for {
  6974  		ptr := v_0
  6975  		if v_1.Op != OpARMSLLconst {
  6976  			break
  6977  		}
  6978  		c := auxIntToInt32(v_1.AuxInt)
  6979  		idx := v_1.Args[0]
  6980  		val := v_2
  6981  		mem := v_3
  6982  		v.reset(OpARMMOVWstoreshiftLL)
  6983  		v.AuxInt = int32ToAuxInt(c)
  6984  		v.AddArg4(ptr, idx, val, mem)
  6985  		return true
  6986  	}
  6987  	// match: (MOVWstoreidx (SLLconst idx [c]) ptr val mem)
  6988  	// result: (MOVWstoreshiftLL ptr idx [c] val mem)
  6989  	for {
  6990  		if v_0.Op != OpARMSLLconst {
  6991  			break
  6992  		}
  6993  		c := auxIntToInt32(v_0.AuxInt)
  6994  		idx := v_0.Args[0]
  6995  		ptr := v_1
  6996  		val := v_2
  6997  		mem := v_3
  6998  		v.reset(OpARMMOVWstoreshiftLL)
  6999  		v.AuxInt = int32ToAuxInt(c)
  7000  		v.AddArg4(ptr, idx, val, mem)
  7001  		return true
  7002  	}
  7003  	// match: (MOVWstoreidx ptr (SRLconst idx [c]) val mem)
  7004  	// result: (MOVWstoreshiftRL ptr idx [c] val mem)
  7005  	for {
  7006  		ptr := v_0
  7007  		if v_1.Op != OpARMSRLconst {
  7008  			break
  7009  		}
  7010  		c := auxIntToInt32(v_1.AuxInt)
  7011  		idx := v_1.Args[0]
  7012  		val := v_2
  7013  		mem := v_3
  7014  		v.reset(OpARMMOVWstoreshiftRL)
  7015  		v.AuxInt = int32ToAuxInt(c)
  7016  		v.AddArg4(ptr, idx, val, mem)
  7017  		return true
  7018  	}
  7019  	// match: (MOVWstoreidx (SRLconst idx [c]) ptr val mem)
  7020  	// result: (MOVWstoreshiftRL ptr idx [c] val mem)
  7021  	for {
  7022  		if v_0.Op != OpARMSRLconst {
  7023  			break
  7024  		}
  7025  		c := auxIntToInt32(v_0.AuxInt)
  7026  		idx := v_0.Args[0]
  7027  		ptr := v_1
  7028  		val := v_2
  7029  		mem := v_3
  7030  		v.reset(OpARMMOVWstoreshiftRL)
  7031  		v.AuxInt = int32ToAuxInt(c)
  7032  		v.AddArg4(ptr, idx, val, mem)
  7033  		return true
  7034  	}
  7035  	// match: (MOVWstoreidx ptr (SRAconst idx [c]) val mem)
  7036  	// result: (MOVWstoreshiftRA ptr idx [c] val mem)
  7037  	for {
  7038  		ptr := v_0
  7039  		if v_1.Op != OpARMSRAconst {
  7040  			break
  7041  		}
  7042  		c := auxIntToInt32(v_1.AuxInt)
  7043  		idx := v_1.Args[0]
  7044  		val := v_2
  7045  		mem := v_3
  7046  		v.reset(OpARMMOVWstoreshiftRA)
  7047  		v.AuxInt = int32ToAuxInt(c)
  7048  		v.AddArg4(ptr, idx, val, mem)
  7049  		return true
  7050  	}
  7051  	// match: (MOVWstoreidx (SRAconst idx [c]) ptr val mem)
  7052  	// result: (MOVWstoreshiftRA ptr idx [c] val mem)
  7053  	for {
  7054  		if v_0.Op != OpARMSRAconst {
  7055  			break
  7056  		}
  7057  		c := auxIntToInt32(v_0.AuxInt)
  7058  		idx := v_0.Args[0]
  7059  		ptr := v_1
  7060  		val := v_2
  7061  		mem := v_3
  7062  		v.reset(OpARMMOVWstoreshiftRA)
  7063  		v.AuxInt = int32ToAuxInt(c)
  7064  		v.AddArg4(ptr, idx, val, mem)
  7065  		return true
  7066  	}
  7067  	return false
  7068  }
  7069  func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool {
  7070  	v_3 := v.Args[3]
  7071  	v_2 := v.Args[2]
  7072  	v_1 := v.Args[1]
  7073  	v_0 := v.Args[0]
  7074  	// match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem)
  7075  	// result: (MOVWstore [int32(uint32(c)<<uint64(d))] ptr val mem)
  7076  	for {
  7077  		d := auxIntToInt32(v.AuxInt)
  7078  		ptr := v_0
  7079  		if v_1.Op != OpARMMOVWconst {
  7080  			break
  7081  		}
  7082  		c := auxIntToInt32(v_1.AuxInt)
  7083  		val := v_2
  7084  		mem := v_3
  7085  		v.reset(OpARMMOVWstore)
  7086  		v.AuxInt = int32ToAuxInt(int32(uint32(c) << uint64(d)))
  7087  		v.AddArg3(ptr, val, mem)
  7088  		return true
  7089  	}
  7090  	return false
  7091  }
  7092  func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool {
  7093  	v_3 := v.Args[3]
  7094  	v_2 := v.Args[2]
  7095  	v_1 := v.Args[1]
  7096  	v_0 := v.Args[0]
  7097  	// match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem)
  7098  	// result: (MOVWstore [c>>uint64(d)] ptr val mem)
  7099  	for {
  7100  		d := auxIntToInt32(v.AuxInt)
  7101  		ptr := v_0
  7102  		if v_1.Op != OpARMMOVWconst {
  7103  			break
  7104  		}
  7105  		c := auxIntToInt32(v_1.AuxInt)
  7106  		val := v_2
  7107  		mem := v_3
  7108  		v.reset(OpARMMOVWstore)
  7109  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  7110  		v.AddArg3(ptr, val, mem)
  7111  		return true
  7112  	}
  7113  	return false
  7114  }
  7115  func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool {
  7116  	v_3 := v.Args[3]
  7117  	v_2 := v.Args[2]
  7118  	v_1 := v.Args[1]
  7119  	v_0 := v.Args[0]
  7120  	// match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem)
  7121  	// result: (MOVWstore [int32(uint32(c)>>uint64(d))] ptr val mem)
  7122  	for {
  7123  		d := auxIntToInt32(v.AuxInt)
  7124  		ptr := v_0
  7125  		if v_1.Op != OpARMMOVWconst {
  7126  			break
  7127  		}
  7128  		c := auxIntToInt32(v_1.AuxInt)
  7129  		val := v_2
  7130  		mem := v_3
  7131  		v.reset(OpARMMOVWstore)
  7132  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  7133  		v.AddArg3(ptr, val, mem)
  7134  		return true
  7135  	}
  7136  	return false
  7137  }
  7138  func rewriteValueARM_OpARMMUL(v *Value) bool {
  7139  	v_1 := v.Args[1]
  7140  	v_0 := v.Args[0]
  7141  	b := v.Block
  7142  	// match: (MUL x (MOVWconst [c]))
  7143  	// cond: int32(c) == -1
  7144  	// result: (RSBconst [0] x)
  7145  	for {
  7146  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7147  			x := v_0
  7148  			if v_1.Op != OpARMMOVWconst {
  7149  				continue
  7150  			}
  7151  			c := auxIntToInt32(v_1.AuxInt)
  7152  			if !(int32(c) == -1) {
  7153  				continue
  7154  			}
  7155  			v.reset(OpARMRSBconst)
  7156  			v.AuxInt = int32ToAuxInt(0)
  7157  			v.AddArg(x)
  7158  			return true
  7159  		}
  7160  		break
  7161  	}
  7162  	// match: (MUL _ (MOVWconst [0]))
  7163  	// result: (MOVWconst [0])
  7164  	for {
  7165  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7166  			if v_1.Op != OpARMMOVWconst || auxIntToInt32(v_1.AuxInt) != 0 {
  7167  				continue
  7168  			}
  7169  			v.reset(OpARMMOVWconst)
  7170  			v.AuxInt = int32ToAuxInt(0)
  7171  			return true
  7172  		}
  7173  		break
  7174  	}
  7175  	// match: (MUL x (MOVWconst [1]))
  7176  	// result: x
  7177  	for {
  7178  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7179  			x := v_0
  7180  			if v_1.Op != OpARMMOVWconst || auxIntToInt32(v_1.AuxInt) != 1 {
  7181  				continue
  7182  			}
  7183  			v.copyOf(x)
  7184  			return true
  7185  		}
  7186  		break
  7187  	}
  7188  	// match: (MUL x (MOVWconst [c]))
  7189  	// cond: isPowerOfTwo(c)
  7190  	// result: (SLLconst [int32(log32(c))] x)
  7191  	for {
  7192  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7193  			x := v_0
  7194  			if v_1.Op != OpARMMOVWconst {
  7195  				continue
  7196  			}
  7197  			c := auxIntToInt32(v_1.AuxInt)
  7198  			if !(isPowerOfTwo(c)) {
  7199  				continue
  7200  			}
  7201  			v.reset(OpARMSLLconst)
  7202  			v.AuxInt = int32ToAuxInt(int32(log32(c)))
  7203  			v.AddArg(x)
  7204  			return true
  7205  		}
  7206  		break
  7207  	}
  7208  	// match: (MUL x (MOVWconst [c]))
  7209  	// cond: isPowerOfTwo(c-1) && c >= 3
  7210  	// result: (ADDshiftLL x x [int32(log32(c-1))])
  7211  	for {
  7212  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7213  			x := v_0
  7214  			if v_1.Op != OpARMMOVWconst {
  7215  				continue
  7216  			}
  7217  			c := auxIntToInt32(v_1.AuxInt)
  7218  			if !(isPowerOfTwo(c-1) && c >= 3) {
  7219  				continue
  7220  			}
  7221  			v.reset(OpARMADDshiftLL)
  7222  			v.AuxInt = int32ToAuxInt(int32(log32(c - 1)))
  7223  			v.AddArg2(x, x)
  7224  			return true
  7225  		}
  7226  		break
  7227  	}
  7228  	// match: (MUL x (MOVWconst [c]))
  7229  	// cond: isPowerOfTwo(c+1) && c >= 7
  7230  	// result: (RSBshiftLL x x [int32(log32(c+1))])
  7231  	for {
  7232  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7233  			x := v_0
  7234  			if v_1.Op != OpARMMOVWconst {
  7235  				continue
  7236  			}
  7237  			c := auxIntToInt32(v_1.AuxInt)
  7238  			if !(isPowerOfTwo(c+1) && c >= 7) {
  7239  				continue
  7240  			}
  7241  			v.reset(OpARMRSBshiftLL)
  7242  			v.AuxInt = int32ToAuxInt(int32(log32(c + 1)))
  7243  			v.AddArg2(x, x)
  7244  			return true
  7245  		}
  7246  		break
  7247  	}
  7248  	// match: (MUL x (MOVWconst [c]))
  7249  	// cond: c%3 == 0 && isPowerOfTwo(c/3)
  7250  	// result: (SLLconst [int32(log32(c/3))] (ADDshiftLL <x.Type> x x [1]))
  7251  	for {
  7252  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7253  			x := v_0
  7254  			if v_1.Op != OpARMMOVWconst {
  7255  				continue
  7256  			}
  7257  			c := auxIntToInt32(v_1.AuxInt)
  7258  			if !(c%3 == 0 && isPowerOfTwo(c/3)) {
  7259  				continue
  7260  			}
  7261  			v.reset(OpARMSLLconst)
  7262  			v.AuxInt = int32ToAuxInt(int32(log32(c / 3)))
  7263  			v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7264  			v0.AuxInt = int32ToAuxInt(1)
  7265  			v0.AddArg2(x, x)
  7266  			v.AddArg(v0)
  7267  			return true
  7268  		}
  7269  		break
  7270  	}
  7271  	// match: (MUL x (MOVWconst [c]))
  7272  	// cond: c%5 == 0 && isPowerOfTwo(c/5)
  7273  	// result: (SLLconst [int32(log32(c/5))] (ADDshiftLL <x.Type> x x [2]))
  7274  	for {
  7275  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7276  			x := v_0
  7277  			if v_1.Op != OpARMMOVWconst {
  7278  				continue
  7279  			}
  7280  			c := auxIntToInt32(v_1.AuxInt)
  7281  			if !(c%5 == 0 && isPowerOfTwo(c/5)) {
  7282  				continue
  7283  			}
  7284  			v.reset(OpARMSLLconst)
  7285  			v.AuxInt = int32ToAuxInt(int32(log32(c / 5)))
  7286  			v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7287  			v0.AuxInt = int32ToAuxInt(2)
  7288  			v0.AddArg2(x, x)
  7289  			v.AddArg(v0)
  7290  			return true
  7291  		}
  7292  		break
  7293  	}
  7294  	// match: (MUL x (MOVWconst [c]))
  7295  	// cond: c%7 == 0 && isPowerOfTwo(c/7)
  7296  	// result: (SLLconst [int32(log32(c/7))] (RSBshiftLL <x.Type> x x [3]))
  7297  	for {
  7298  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7299  			x := v_0
  7300  			if v_1.Op != OpARMMOVWconst {
  7301  				continue
  7302  			}
  7303  			c := auxIntToInt32(v_1.AuxInt)
  7304  			if !(c%7 == 0 && isPowerOfTwo(c/7)) {
  7305  				continue
  7306  			}
  7307  			v.reset(OpARMSLLconst)
  7308  			v.AuxInt = int32ToAuxInt(int32(log32(c / 7)))
  7309  			v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7310  			v0.AuxInt = int32ToAuxInt(3)
  7311  			v0.AddArg2(x, x)
  7312  			v.AddArg(v0)
  7313  			return true
  7314  		}
  7315  		break
  7316  	}
  7317  	// match: (MUL x (MOVWconst [c]))
  7318  	// cond: c%9 == 0 && isPowerOfTwo(c/9)
  7319  	// result: (SLLconst [int32(log32(c/9))] (ADDshiftLL <x.Type> x x [3]))
  7320  	for {
  7321  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7322  			x := v_0
  7323  			if v_1.Op != OpARMMOVWconst {
  7324  				continue
  7325  			}
  7326  			c := auxIntToInt32(v_1.AuxInt)
  7327  			if !(c%9 == 0 && isPowerOfTwo(c/9)) {
  7328  				continue
  7329  			}
  7330  			v.reset(OpARMSLLconst)
  7331  			v.AuxInt = int32ToAuxInt(int32(log32(c / 9)))
  7332  			v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7333  			v0.AuxInt = int32ToAuxInt(3)
  7334  			v0.AddArg2(x, x)
  7335  			v.AddArg(v0)
  7336  			return true
  7337  		}
  7338  		break
  7339  	}
  7340  	// match: (MUL (MOVWconst [c]) (MOVWconst [d]))
  7341  	// result: (MOVWconst [c*d])
  7342  	for {
  7343  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7344  			if v_0.Op != OpARMMOVWconst {
  7345  				continue
  7346  			}
  7347  			c := auxIntToInt32(v_0.AuxInt)
  7348  			if v_1.Op != OpARMMOVWconst {
  7349  				continue
  7350  			}
  7351  			d := auxIntToInt32(v_1.AuxInt)
  7352  			v.reset(OpARMMOVWconst)
  7353  			v.AuxInt = int32ToAuxInt(c * d)
  7354  			return true
  7355  		}
  7356  		break
  7357  	}
  7358  	return false
  7359  }
  7360  func rewriteValueARM_OpARMMULA(v *Value) bool {
  7361  	v_2 := v.Args[2]
  7362  	v_1 := v.Args[1]
  7363  	v_0 := v.Args[0]
  7364  	b := v.Block
  7365  	// match: (MULA x (MOVWconst [c]) a)
  7366  	// cond: c == -1
  7367  	// result: (SUB a x)
  7368  	for {
  7369  		x := v_0
  7370  		if v_1.Op != OpARMMOVWconst {
  7371  			break
  7372  		}
  7373  		c := auxIntToInt32(v_1.AuxInt)
  7374  		a := v_2
  7375  		if !(c == -1) {
  7376  			break
  7377  		}
  7378  		v.reset(OpARMSUB)
  7379  		v.AddArg2(a, x)
  7380  		return true
  7381  	}
  7382  	// match: (MULA _ (MOVWconst [0]) a)
  7383  	// result: a
  7384  	for {
  7385  		if v_1.Op != OpARMMOVWconst || auxIntToInt32(v_1.AuxInt) != 0 {
  7386  			break
  7387  		}
  7388  		a := v_2
  7389  		v.copyOf(a)
  7390  		return true
  7391  	}
  7392  	// match: (MULA x (MOVWconst [1]) a)
  7393  	// result: (ADD x a)
  7394  	for {
  7395  		x := v_0
  7396  		if v_1.Op != OpARMMOVWconst || auxIntToInt32(v_1.AuxInt) != 1 {
  7397  			break
  7398  		}
  7399  		a := v_2
  7400  		v.reset(OpARMADD)
  7401  		v.AddArg2(x, a)
  7402  		return true
  7403  	}
  7404  	// match: (MULA x (MOVWconst [c]) a)
  7405  	// cond: isPowerOfTwo(c)
  7406  	// result: (ADD (SLLconst <x.Type> [int32(log32(c))] x) a)
  7407  	for {
  7408  		x := v_0
  7409  		if v_1.Op != OpARMMOVWconst {
  7410  			break
  7411  		}
  7412  		c := auxIntToInt32(v_1.AuxInt)
  7413  		a := v_2
  7414  		if !(isPowerOfTwo(c)) {
  7415  			break
  7416  		}
  7417  		v.reset(OpARMADD)
  7418  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7419  		v0.AuxInt = int32ToAuxInt(int32(log32(c)))
  7420  		v0.AddArg(x)
  7421  		v.AddArg2(v0, a)
  7422  		return true
  7423  	}
  7424  	// match: (MULA x (MOVWconst [c]) a)
  7425  	// cond: isPowerOfTwo(c-1) && c >= 3
  7426  	// result: (ADD (ADDshiftLL <x.Type> x x [int32(log32(c-1))]) a)
  7427  	for {
  7428  		x := v_0
  7429  		if v_1.Op != OpARMMOVWconst {
  7430  			break
  7431  		}
  7432  		c := auxIntToInt32(v_1.AuxInt)
  7433  		a := v_2
  7434  		if !(isPowerOfTwo(c-1) && c >= 3) {
  7435  			break
  7436  		}
  7437  		v.reset(OpARMADD)
  7438  		v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7439  		v0.AuxInt = int32ToAuxInt(int32(log32(c - 1)))
  7440  		v0.AddArg2(x, x)
  7441  		v.AddArg2(v0, a)
  7442  		return true
  7443  	}
  7444  	// match: (MULA x (MOVWconst [c]) a)
  7445  	// cond: isPowerOfTwo(c+1) && c >= 7
  7446  	// result: (ADD (RSBshiftLL <x.Type> x x [int32(log32(c+1))]) a)
  7447  	for {
  7448  		x := v_0
  7449  		if v_1.Op != OpARMMOVWconst {
  7450  			break
  7451  		}
  7452  		c := auxIntToInt32(v_1.AuxInt)
  7453  		a := v_2
  7454  		if !(isPowerOfTwo(c+1) && c >= 7) {
  7455  			break
  7456  		}
  7457  		v.reset(OpARMADD)
  7458  		v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7459  		v0.AuxInt = int32ToAuxInt(int32(log32(c + 1)))
  7460  		v0.AddArg2(x, x)
  7461  		v.AddArg2(v0, a)
  7462  		return true
  7463  	}
  7464  	// match: (MULA x (MOVWconst [c]) a)
  7465  	// cond: c%3 == 0 && isPowerOfTwo(c/3)
  7466  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/3))] (ADDshiftLL <x.Type> x x [1])) a)
  7467  	for {
  7468  		x := v_0
  7469  		if v_1.Op != OpARMMOVWconst {
  7470  			break
  7471  		}
  7472  		c := auxIntToInt32(v_1.AuxInt)
  7473  		a := v_2
  7474  		if !(c%3 == 0 && isPowerOfTwo(c/3)) {
  7475  			break
  7476  		}
  7477  		v.reset(OpARMADD)
  7478  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7479  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 3)))
  7480  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7481  		v1.AuxInt = int32ToAuxInt(1)
  7482  		v1.AddArg2(x, x)
  7483  		v0.AddArg(v1)
  7484  		v.AddArg2(v0, a)
  7485  		return true
  7486  	}
  7487  	// match: (MULA x (MOVWconst [c]) a)
  7488  	// cond: c%5 == 0 && isPowerOfTwo(c/5)
  7489  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/5))] (ADDshiftLL <x.Type> x x [2])) a)
  7490  	for {
  7491  		x := v_0
  7492  		if v_1.Op != OpARMMOVWconst {
  7493  			break
  7494  		}
  7495  		c := auxIntToInt32(v_1.AuxInt)
  7496  		a := v_2
  7497  		if !(c%5 == 0 && isPowerOfTwo(c/5)) {
  7498  			break
  7499  		}
  7500  		v.reset(OpARMADD)
  7501  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7502  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 5)))
  7503  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7504  		v1.AuxInt = int32ToAuxInt(2)
  7505  		v1.AddArg2(x, x)
  7506  		v0.AddArg(v1)
  7507  		v.AddArg2(v0, a)
  7508  		return true
  7509  	}
  7510  	// match: (MULA x (MOVWconst [c]) a)
  7511  	// cond: c%7 == 0 && isPowerOfTwo(c/7)
  7512  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/7))] (RSBshiftLL <x.Type> x x [3])) a)
  7513  	for {
  7514  		x := v_0
  7515  		if v_1.Op != OpARMMOVWconst {
  7516  			break
  7517  		}
  7518  		c := auxIntToInt32(v_1.AuxInt)
  7519  		a := v_2
  7520  		if !(c%7 == 0 && isPowerOfTwo(c/7)) {
  7521  			break
  7522  		}
  7523  		v.reset(OpARMADD)
  7524  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7525  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 7)))
  7526  		v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7527  		v1.AuxInt = int32ToAuxInt(3)
  7528  		v1.AddArg2(x, x)
  7529  		v0.AddArg(v1)
  7530  		v.AddArg2(v0, a)
  7531  		return true
  7532  	}
  7533  	// match: (MULA x (MOVWconst [c]) a)
  7534  	// cond: c%9 == 0 && isPowerOfTwo(c/9)
  7535  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/9))] (ADDshiftLL <x.Type> x x [3])) a)
  7536  	for {
  7537  		x := v_0
  7538  		if v_1.Op != OpARMMOVWconst {
  7539  			break
  7540  		}
  7541  		c := auxIntToInt32(v_1.AuxInt)
  7542  		a := v_2
  7543  		if !(c%9 == 0 && isPowerOfTwo(c/9)) {
  7544  			break
  7545  		}
  7546  		v.reset(OpARMADD)
  7547  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7548  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 9)))
  7549  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7550  		v1.AuxInt = int32ToAuxInt(3)
  7551  		v1.AddArg2(x, x)
  7552  		v0.AddArg(v1)
  7553  		v.AddArg2(v0, a)
  7554  		return true
  7555  	}
  7556  	// match: (MULA (MOVWconst [c]) x a)
  7557  	// cond: c == -1
  7558  	// result: (SUB a x)
  7559  	for {
  7560  		if v_0.Op != OpARMMOVWconst {
  7561  			break
  7562  		}
  7563  		c := auxIntToInt32(v_0.AuxInt)
  7564  		x := v_1
  7565  		a := v_2
  7566  		if !(c == -1) {
  7567  			break
  7568  		}
  7569  		v.reset(OpARMSUB)
  7570  		v.AddArg2(a, x)
  7571  		return true
  7572  	}
  7573  	// match: (MULA (MOVWconst [0]) _ a)
  7574  	// result: a
  7575  	for {
  7576  		if v_0.Op != OpARMMOVWconst || auxIntToInt32(v_0.AuxInt) != 0 {
  7577  			break
  7578  		}
  7579  		a := v_2
  7580  		v.copyOf(a)
  7581  		return true
  7582  	}
  7583  	// match: (MULA (MOVWconst [1]) x a)
  7584  	// result: (ADD x a)
  7585  	for {
  7586  		if v_0.Op != OpARMMOVWconst || auxIntToInt32(v_0.AuxInt) != 1 {
  7587  			break
  7588  		}
  7589  		x := v_1
  7590  		a := v_2
  7591  		v.reset(OpARMADD)
  7592  		v.AddArg2(x, a)
  7593  		return true
  7594  	}
  7595  	// match: (MULA (MOVWconst [c]) x a)
  7596  	// cond: isPowerOfTwo(c)
  7597  	// result: (ADD (SLLconst <x.Type> [int32(log32(c))] x) a)
  7598  	for {
  7599  		if v_0.Op != OpARMMOVWconst {
  7600  			break
  7601  		}
  7602  		c := auxIntToInt32(v_0.AuxInt)
  7603  		x := v_1
  7604  		a := v_2
  7605  		if !(isPowerOfTwo(c)) {
  7606  			break
  7607  		}
  7608  		v.reset(OpARMADD)
  7609  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7610  		v0.AuxInt = int32ToAuxInt(int32(log32(c)))
  7611  		v0.AddArg(x)
  7612  		v.AddArg2(v0, a)
  7613  		return true
  7614  	}
  7615  	// match: (MULA (MOVWconst [c]) x a)
  7616  	// cond: isPowerOfTwo(c-1) && c >= 3
  7617  	// result: (ADD (ADDshiftLL <x.Type> x x [int32(log32(c-1))]) a)
  7618  	for {
  7619  		if v_0.Op != OpARMMOVWconst {
  7620  			break
  7621  		}
  7622  		c := auxIntToInt32(v_0.AuxInt)
  7623  		x := v_1
  7624  		a := v_2
  7625  		if !(isPowerOfTwo(c-1) && c >= 3) {
  7626  			break
  7627  		}
  7628  		v.reset(OpARMADD)
  7629  		v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7630  		v0.AuxInt = int32ToAuxInt(int32(log32(c - 1)))
  7631  		v0.AddArg2(x, x)
  7632  		v.AddArg2(v0, a)
  7633  		return true
  7634  	}
  7635  	// match: (MULA (MOVWconst [c]) x a)
  7636  	// cond: isPowerOfTwo(c+1) && c >= 7
  7637  	// result: (ADD (RSBshiftLL <x.Type> x x [int32(log32(c+1))]) a)
  7638  	for {
  7639  		if v_0.Op != OpARMMOVWconst {
  7640  			break
  7641  		}
  7642  		c := auxIntToInt32(v_0.AuxInt)
  7643  		x := v_1
  7644  		a := v_2
  7645  		if !(isPowerOfTwo(c+1) && c >= 7) {
  7646  			break
  7647  		}
  7648  		v.reset(OpARMADD)
  7649  		v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7650  		v0.AuxInt = int32ToAuxInt(int32(log32(c + 1)))
  7651  		v0.AddArg2(x, x)
  7652  		v.AddArg2(v0, a)
  7653  		return true
  7654  	}
  7655  	// match: (MULA (MOVWconst [c]) x a)
  7656  	// cond: c%3 == 0 && isPowerOfTwo(c/3)
  7657  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/3))] (ADDshiftLL <x.Type> x x [1])) a)
  7658  	for {
  7659  		if v_0.Op != OpARMMOVWconst {
  7660  			break
  7661  		}
  7662  		c := auxIntToInt32(v_0.AuxInt)
  7663  		x := v_1
  7664  		a := v_2
  7665  		if !(c%3 == 0 && isPowerOfTwo(c/3)) {
  7666  			break
  7667  		}
  7668  		v.reset(OpARMADD)
  7669  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7670  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 3)))
  7671  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7672  		v1.AuxInt = int32ToAuxInt(1)
  7673  		v1.AddArg2(x, x)
  7674  		v0.AddArg(v1)
  7675  		v.AddArg2(v0, a)
  7676  		return true
  7677  	}
  7678  	// match: (MULA (MOVWconst [c]) x a)
  7679  	// cond: c%5 == 0 && isPowerOfTwo(c/5)
  7680  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/5))] (ADDshiftLL <x.Type> x x [2])) a)
  7681  	for {
  7682  		if v_0.Op != OpARMMOVWconst {
  7683  			break
  7684  		}
  7685  		c := auxIntToInt32(v_0.AuxInt)
  7686  		x := v_1
  7687  		a := v_2
  7688  		if !(c%5 == 0 && isPowerOfTwo(c/5)) {
  7689  			break
  7690  		}
  7691  		v.reset(OpARMADD)
  7692  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7693  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 5)))
  7694  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7695  		v1.AuxInt = int32ToAuxInt(2)
  7696  		v1.AddArg2(x, x)
  7697  		v0.AddArg(v1)
  7698  		v.AddArg2(v0, a)
  7699  		return true
  7700  	}
  7701  	// match: (MULA (MOVWconst [c]) x a)
  7702  	// cond: c%7 == 0 && isPowerOfTwo(c/7)
  7703  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/7))] (RSBshiftLL <x.Type> x x [3])) a)
  7704  	for {
  7705  		if v_0.Op != OpARMMOVWconst {
  7706  			break
  7707  		}
  7708  		c := auxIntToInt32(v_0.AuxInt)
  7709  		x := v_1
  7710  		a := v_2
  7711  		if !(c%7 == 0 && isPowerOfTwo(c/7)) {
  7712  			break
  7713  		}
  7714  		v.reset(OpARMADD)
  7715  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7716  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 7)))
  7717  		v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7718  		v1.AuxInt = int32ToAuxInt(3)
  7719  		v1.AddArg2(x, x)
  7720  		v0.AddArg(v1)
  7721  		v.AddArg2(v0, a)
  7722  		return true
  7723  	}
  7724  	// match: (MULA (MOVWconst [c]) x a)
  7725  	// cond: c%9 == 0 && isPowerOfTwo(c/9)
  7726  	// result: (ADD (SLLconst <x.Type> [int32(log32(c/9))] (ADDshiftLL <x.Type> x x [3])) a)
  7727  	for {
  7728  		if v_0.Op != OpARMMOVWconst {
  7729  			break
  7730  		}
  7731  		c := auxIntToInt32(v_0.AuxInt)
  7732  		x := v_1
  7733  		a := v_2
  7734  		if !(c%9 == 0 && isPowerOfTwo(c/9)) {
  7735  			break
  7736  		}
  7737  		v.reset(OpARMADD)
  7738  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7739  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 9)))
  7740  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7741  		v1.AuxInt = int32ToAuxInt(3)
  7742  		v1.AddArg2(x, x)
  7743  		v0.AddArg(v1)
  7744  		v.AddArg2(v0, a)
  7745  		return true
  7746  	}
  7747  	// match: (MULA (MOVWconst [c]) (MOVWconst [d]) a)
  7748  	// result: (ADDconst [c*d] a)
  7749  	for {
  7750  		if v_0.Op != OpARMMOVWconst {
  7751  			break
  7752  		}
  7753  		c := auxIntToInt32(v_0.AuxInt)
  7754  		if v_1.Op != OpARMMOVWconst {
  7755  			break
  7756  		}
  7757  		d := auxIntToInt32(v_1.AuxInt)
  7758  		a := v_2
  7759  		v.reset(OpARMADDconst)
  7760  		v.AuxInt = int32ToAuxInt(c * d)
  7761  		v.AddArg(a)
  7762  		return true
  7763  	}
  7764  	return false
  7765  }
  7766  func rewriteValueARM_OpARMMULD(v *Value) bool {
  7767  	v_1 := v.Args[1]
  7768  	v_0 := v.Args[0]
  7769  	// match: (MULD (NEGD x) y)
  7770  	// cond: buildcfg.GOARM.Version >= 6
  7771  	// result: (NMULD x y)
  7772  	for {
  7773  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7774  			if v_0.Op != OpARMNEGD {
  7775  				continue
  7776  			}
  7777  			x := v_0.Args[0]
  7778  			y := v_1
  7779  			if !(buildcfg.GOARM.Version >= 6) {
  7780  				continue
  7781  			}
  7782  			v.reset(OpARMNMULD)
  7783  			v.AddArg2(x, y)
  7784  			return true
  7785  		}
  7786  		break
  7787  	}
  7788  	return false
  7789  }
  7790  func rewriteValueARM_OpARMMULF(v *Value) bool {
  7791  	v_1 := v.Args[1]
  7792  	v_0 := v.Args[0]
  7793  	// match: (MULF (NEGF x) y)
  7794  	// cond: buildcfg.GOARM.Version >= 6
  7795  	// result: (NMULF x y)
  7796  	for {
  7797  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  7798  			if v_0.Op != OpARMNEGF {
  7799  				continue
  7800  			}
  7801  			x := v_0.Args[0]
  7802  			y := v_1
  7803  			if !(buildcfg.GOARM.Version >= 6) {
  7804  				continue
  7805  			}
  7806  			v.reset(OpARMNMULF)
  7807  			v.AddArg2(x, y)
  7808  			return true
  7809  		}
  7810  		break
  7811  	}
  7812  	return false
  7813  }
  7814  func rewriteValueARM_OpARMMULS(v *Value) bool {
  7815  	v_2 := v.Args[2]
  7816  	v_1 := v.Args[1]
  7817  	v_0 := v.Args[0]
  7818  	b := v.Block
  7819  	// match: (MULS x (MOVWconst [c]) a)
  7820  	// cond: c == -1
  7821  	// result: (ADD a x)
  7822  	for {
  7823  		x := v_0
  7824  		if v_1.Op != OpARMMOVWconst {
  7825  			break
  7826  		}
  7827  		c := auxIntToInt32(v_1.AuxInt)
  7828  		a := v_2
  7829  		if !(c == -1) {
  7830  			break
  7831  		}
  7832  		v.reset(OpARMADD)
  7833  		v.AddArg2(a, x)
  7834  		return true
  7835  	}
  7836  	// match: (MULS _ (MOVWconst [0]) a)
  7837  	// result: a
  7838  	for {
  7839  		if v_1.Op != OpARMMOVWconst || auxIntToInt32(v_1.AuxInt) != 0 {
  7840  			break
  7841  		}
  7842  		a := v_2
  7843  		v.copyOf(a)
  7844  		return true
  7845  	}
  7846  	// match: (MULS x (MOVWconst [1]) a)
  7847  	// result: (RSB x a)
  7848  	for {
  7849  		x := v_0
  7850  		if v_1.Op != OpARMMOVWconst || auxIntToInt32(v_1.AuxInt) != 1 {
  7851  			break
  7852  		}
  7853  		a := v_2
  7854  		v.reset(OpARMRSB)
  7855  		v.AddArg2(x, a)
  7856  		return true
  7857  	}
  7858  	// match: (MULS x (MOVWconst [c]) a)
  7859  	// cond: isPowerOfTwo(c)
  7860  	// result: (RSB (SLLconst <x.Type> [int32(log32(c))] x) a)
  7861  	for {
  7862  		x := v_0
  7863  		if v_1.Op != OpARMMOVWconst {
  7864  			break
  7865  		}
  7866  		c := auxIntToInt32(v_1.AuxInt)
  7867  		a := v_2
  7868  		if !(isPowerOfTwo(c)) {
  7869  			break
  7870  		}
  7871  		v.reset(OpARMRSB)
  7872  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7873  		v0.AuxInt = int32ToAuxInt(int32(log32(c)))
  7874  		v0.AddArg(x)
  7875  		v.AddArg2(v0, a)
  7876  		return true
  7877  	}
  7878  	// match: (MULS x (MOVWconst [c]) a)
  7879  	// cond: isPowerOfTwo(c-1) && c >= 3
  7880  	// result: (RSB (ADDshiftLL <x.Type> x x [int32(log32(c-1))]) a)
  7881  	for {
  7882  		x := v_0
  7883  		if v_1.Op != OpARMMOVWconst {
  7884  			break
  7885  		}
  7886  		c := auxIntToInt32(v_1.AuxInt)
  7887  		a := v_2
  7888  		if !(isPowerOfTwo(c-1) && c >= 3) {
  7889  			break
  7890  		}
  7891  		v.reset(OpARMRSB)
  7892  		v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7893  		v0.AuxInt = int32ToAuxInt(int32(log32(c - 1)))
  7894  		v0.AddArg2(x, x)
  7895  		v.AddArg2(v0, a)
  7896  		return true
  7897  	}
  7898  	// match: (MULS x (MOVWconst [c]) a)
  7899  	// cond: isPowerOfTwo(c+1) && c >= 7
  7900  	// result: (RSB (RSBshiftLL <x.Type> x x [int32(log32(c+1))]) a)
  7901  	for {
  7902  		x := v_0
  7903  		if v_1.Op != OpARMMOVWconst {
  7904  			break
  7905  		}
  7906  		c := auxIntToInt32(v_1.AuxInt)
  7907  		a := v_2
  7908  		if !(isPowerOfTwo(c+1) && c >= 7) {
  7909  			break
  7910  		}
  7911  		v.reset(OpARMRSB)
  7912  		v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7913  		v0.AuxInt = int32ToAuxInt(int32(log32(c + 1)))
  7914  		v0.AddArg2(x, x)
  7915  		v.AddArg2(v0, a)
  7916  		return true
  7917  	}
  7918  	// match: (MULS x (MOVWconst [c]) a)
  7919  	// cond: c%3 == 0 && isPowerOfTwo(c/3)
  7920  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/3))] (ADDshiftLL <x.Type> x x [1])) a)
  7921  	for {
  7922  		x := v_0
  7923  		if v_1.Op != OpARMMOVWconst {
  7924  			break
  7925  		}
  7926  		c := auxIntToInt32(v_1.AuxInt)
  7927  		a := v_2
  7928  		if !(c%3 == 0 && isPowerOfTwo(c/3)) {
  7929  			break
  7930  		}
  7931  		v.reset(OpARMRSB)
  7932  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7933  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 3)))
  7934  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7935  		v1.AuxInt = int32ToAuxInt(1)
  7936  		v1.AddArg2(x, x)
  7937  		v0.AddArg(v1)
  7938  		v.AddArg2(v0, a)
  7939  		return true
  7940  	}
  7941  	// match: (MULS x (MOVWconst [c]) a)
  7942  	// cond: c%5 == 0 && isPowerOfTwo(c/5)
  7943  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/5))] (ADDshiftLL <x.Type> x x [2])) a)
  7944  	for {
  7945  		x := v_0
  7946  		if v_1.Op != OpARMMOVWconst {
  7947  			break
  7948  		}
  7949  		c := auxIntToInt32(v_1.AuxInt)
  7950  		a := v_2
  7951  		if !(c%5 == 0 && isPowerOfTwo(c/5)) {
  7952  			break
  7953  		}
  7954  		v.reset(OpARMRSB)
  7955  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7956  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 5)))
  7957  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  7958  		v1.AuxInt = int32ToAuxInt(2)
  7959  		v1.AddArg2(x, x)
  7960  		v0.AddArg(v1)
  7961  		v.AddArg2(v0, a)
  7962  		return true
  7963  	}
  7964  	// match: (MULS x (MOVWconst [c]) a)
  7965  	// cond: c%7 == 0 && isPowerOfTwo(c/7)
  7966  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/7))] (RSBshiftLL <x.Type> x x [3])) a)
  7967  	for {
  7968  		x := v_0
  7969  		if v_1.Op != OpARMMOVWconst {
  7970  			break
  7971  		}
  7972  		c := auxIntToInt32(v_1.AuxInt)
  7973  		a := v_2
  7974  		if !(c%7 == 0 && isPowerOfTwo(c/7)) {
  7975  			break
  7976  		}
  7977  		v.reset(OpARMRSB)
  7978  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  7979  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 7)))
  7980  		v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  7981  		v1.AuxInt = int32ToAuxInt(3)
  7982  		v1.AddArg2(x, x)
  7983  		v0.AddArg(v1)
  7984  		v.AddArg2(v0, a)
  7985  		return true
  7986  	}
  7987  	// match: (MULS x (MOVWconst [c]) a)
  7988  	// cond: c%9 == 0 && isPowerOfTwo(c/9)
  7989  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/9))] (ADDshiftLL <x.Type> x x [3])) a)
  7990  	for {
  7991  		x := v_0
  7992  		if v_1.Op != OpARMMOVWconst {
  7993  			break
  7994  		}
  7995  		c := auxIntToInt32(v_1.AuxInt)
  7996  		a := v_2
  7997  		if !(c%9 == 0 && isPowerOfTwo(c/9)) {
  7998  			break
  7999  		}
  8000  		v.reset(OpARMRSB)
  8001  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8002  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 9)))
  8003  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  8004  		v1.AuxInt = int32ToAuxInt(3)
  8005  		v1.AddArg2(x, x)
  8006  		v0.AddArg(v1)
  8007  		v.AddArg2(v0, a)
  8008  		return true
  8009  	}
  8010  	// match: (MULS (MOVWconst [c]) x a)
  8011  	// cond: c == -1
  8012  	// result: (ADD a x)
  8013  	for {
  8014  		if v_0.Op != OpARMMOVWconst {
  8015  			break
  8016  		}
  8017  		c := auxIntToInt32(v_0.AuxInt)
  8018  		x := v_1
  8019  		a := v_2
  8020  		if !(c == -1) {
  8021  			break
  8022  		}
  8023  		v.reset(OpARMADD)
  8024  		v.AddArg2(a, x)
  8025  		return true
  8026  	}
  8027  	// match: (MULS (MOVWconst [0]) _ a)
  8028  	// result: a
  8029  	for {
  8030  		if v_0.Op != OpARMMOVWconst || auxIntToInt32(v_0.AuxInt) != 0 {
  8031  			break
  8032  		}
  8033  		a := v_2
  8034  		v.copyOf(a)
  8035  		return true
  8036  	}
  8037  	// match: (MULS (MOVWconst [1]) x a)
  8038  	// result: (RSB x a)
  8039  	for {
  8040  		if v_0.Op != OpARMMOVWconst || auxIntToInt32(v_0.AuxInt) != 1 {
  8041  			break
  8042  		}
  8043  		x := v_1
  8044  		a := v_2
  8045  		v.reset(OpARMRSB)
  8046  		v.AddArg2(x, a)
  8047  		return true
  8048  	}
  8049  	// match: (MULS (MOVWconst [c]) x a)
  8050  	// cond: isPowerOfTwo(c)
  8051  	// result: (RSB (SLLconst <x.Type> [int32(log32(c))] x) a)
  8052  	for {
  8053  		if v_0.Op != OpARMMOVWconst {
  8054  			break
  8055  		}
  8056  		c := auxIntToInt32(v_0.AuxInt)
  8057  		x := v_1
  8058  		a := v_2
  8059  		if !(isPowerOfTwo(c)) {
  8060  			break
  8061  		}
  8062  		v.reset(OpARMRSB)
  8063  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8064  		v0.AuxInt = int32ToAuxInt(int32(log32(c)))
  8065  		v0.AddArg(x)
  8066  		v.AddArg2(v0, a)
  8067  		return true
  8068  	}
  8069  	// match: (MULS (MOVWconst [c]) x a)
  8070  	// cond: isPowerOfTwo(c-1) && c >= 3
  8071  	// result: (RSB (ADDshiftLL <x.Type> x x [int32(log32(c-1))]) a)
  8072  	for {
  8073  		if v_0.Op != OpARMMOVWconst {
  8074  			break
  8075  		}
  8076  		c := auxIntToInt32(v_0.AuxInt)
  8077  		x := v_1
  8078  		a := v_2
  8079  		if !(isPowerOfTwo(c-1) && c >= 3) {
  8080  			break
  8081  		}
  8082  		v.reset(OpARMRSB)
  8083  		v0 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  8084  		v0.AuxInt = int32ToAuxInt(int32(log32(c - 1)))
  8085  		v0.AddArg2(x, x)
  8086  		v.AddArg2(v0, a)
  8087  		return true
  8088  	}
  8089  	// match: (MULS (MOVWconst [c]) x a)
  8090  	// cond: isPowerOfTwo(c+1) && c >= 7
  8091  	// result: (RSB (RSBshiftLL <x.Type> x x [int32(log32(c+1))]) a)
  8092  	for {
  8093  		if v_0.Op != OpARMMOVWconst {
  8094  			break
  8095  		}
  8096  		c := auxIntToInt32(v_0.AuxInt)
  8097  		x := v_1
  8098  		a := v_2
  8099  		if !(isPowerOfTwo(c+1) && c >= 7) {
  8100  			break
  8101  		}
  8102  		v.reset(OpARMRSB)
  8103  		v0 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  8104  		v0.AuxInt = int32ToAuxInt(int32(log32(c + 1)))
  8105  		v0.AddArg2(x, x)
  8106  		v.AddArg2(v0, a)
  8107  		return true
  8108  	}
  8109  	// match: (MULS (MOVWconst [c]) x a)
  8110  	// cond: c%3 == 0 && isPowerOfTwo(c/3)
  8111  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/3))] (ADDshiftLL <x.Type> x x [1])) a)
  8112  	for {
  8113  		if v_0.Op != OpARMMOVWconst {
  8114  			break
  8115  		}
  8116  		c := auxIntToInt32(v_0.AuxInt)
  8117  		x := v_1
  8118  		a := v_2
  8119  		if !(c%3 == 0 && isPowerOfTwo(c/3)) {
  8120  			break
  8121  		}
  8122  		v.reset(OpARMRSB)
  8123  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8124  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 3)))
  8125  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  8126  		v1.AuxInt = int32ToAuxInt(1)
  8127  		v1.AddArg2(x, x)
  8128  		v0.AddArg(v1)
  8129  		v.AddArg2(v0, a)
  8130  		return true
  8131  	}
  8132  	// match: (MULS (MOVWconst [c]) x a)
  8133  	// cond: c%5 == 0 && isPowerOfTwo(c/5)
  8134  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/5))] (ADDshiftLL <x.Type> x x [2])) a)
  8135  	for {
  8136  		if v_0.Op != OpARMMOVWconst {
  8137  			break
  8138  		}
  8139  		c := auxIntToInt32(v_0.AuxInt)
  8140  		x := v_1
  8141  		a := v_2
  8142  		if !(c%5 == 0 && isPowerOfTwo(c/5)) {
  8143  			break
  8144  		}
  8145  		v.reset(OpARMRSB)
  8146  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8147  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 5)))
  8148  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  8149  		v1.AuxInt = int32ToAuxInt(2)
  8150  		v1.AddArg2(x, x)
  8151  		v0.AddArg(v1)
  8152  		v.AddArg2(v0, a)
  8153  		return true
  8154  	}
  8155  	// match: (MULS (MOVWconst [c]) x a)
  8156  	// cond: c%7 == 0 && isPowerOfTwo(c/7)
  8157  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/7))] (RSBshiftLL <x.Type> x x [3])) a)
  8158  	for {
  8159  		if v_0.Op != OpARMMOVWconst {
  8160  			break
  8161  		}
  8162  		c := auxIntToInt32(v_0.AuxInt)
  8163  		x := v_1
  8164  		a := v_2
  8165  		if !(c%7 == 0 && isPowerOfTwo(c/7)) {
  8166  			break
  8167  		}
  8168  		v.reset(OpARMRSB)
  8169  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8170  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 7)))
  8171  		v1 := b.NewValue0(v.Pos, OpARMRSBshiftLL, x.Type)
  8172  		v1.AuxInt = int32ToAuxInt(3)
  8173  		v1.AddArg2(x, x)
  8174  		v0.AddArg(v1)
  8175  		v.AddArg2(v0, a)
  8176  		return true
  8177  	}
  8178  	// match: (MULS (MOVWconst [c]) x a)
  8179  	// cond: c%9 == 0 && isPowerOfTwo(c/9)
  8180  	// result: (RSB (SLLconst <x.Type> [int32(log32(c/9))] (ADDshiftLL <x.Type> x x [3])) a)
  8181  	for {
  8182  		if v_0.Op != OpARMMOVWconst {
  8183  			break
  8184  		}
  8185  		c := auxIntToInt32(v_0.AuxInt)
  8186  		x := v_1
  8187  		a := v_2
  8188  		if !(c%9 == 0 && isPowerOfTwo(c/9)) {
  8189  			break
  8190  		}
  8191  		v.reset(OpARMRSB)
  8192  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8193  		v0.AuxInt = int32ToAuxInt(int32(log32(c / 9)))
  8194  		v1 := b.NewValue0(v.Pos, OpARMADDshiftLL, x.Type)
  8195  		v1.AuxInt = int32ToAuxInt(3)
  8196  		v1.AddArg2(x, x)
  8197  		v0.AddArg(v1)
  8198  		v.AddArg2(v0, a)
  8199  		return true
  8200  	}
  8201  	// match: (MULS (MOVWconst [c]) (MOVWconst [d]) a)
  8202  	// result: (SUBconst [c*d] a)
  8203  	for {
  8204  		if v_0.Op != OpARMMOVWconst {
  8205  			break
  8206  		}
  8207  		c := auxIntToInt32(v_0.AuxInt)
  8208  		if v_1.Op != OpARMMOVWconst {
  8209  			break
  8210  		}
  8211  		d := auxIntToInt32(v_1.AuxInt)
  8212  		a := v_2
  8213  		v.reset(OpARMSUBconst)
  8214  		v.AuxInt = int32ToAuxInt(c * d)
  8215  		v.AddArg(a)
  8216  		return true
  8217  	}
  8218  	return false
  8219  }
  8220  func rewriteValueARM_OpARMMVN(v *Value) bool {
  8221  	v_0 := v.Args[0]
  8222  	// match: (MVN (MOVWconst [c]))
  8223  	// result: (MOVWconst [^c])
  8224  	for {
  8225  		if v_0.Op != OpARMMOVWconst {
  8226  			break
  8227  		}
  8228  		c := auxIntToInt32(v_0.AuxInt)
  8229  		v.reset(OpARMMOVWconst)
  8230  		v.AuxInt = int32ToAuxInt(^c)
  8231  		return true
  8232  	}
  8233  	// match: (MVN (SLLconst [c] x))
  8234  	// result: (MVNshiftLL x [c])
  8235  	for {
  8236  		if v_0.Op != OpARMSLLconst {
  8237  			break
  8238  		}
  8239  		c := auxIntToInt32(v_0.AuxInt)
  8240  		x := v_0.Args[0]
  8241  		v.reset(OpARMMVNshiftLL)
  8242  		v.AuxInt = int32ToAuxInt(c)
  8243  		v.AddArg(x)
  8244  		return true
  8245  	}
  8246  	// match: (MVN (SRLconst [c] x))
  8247  	// result: (MVNshiftRL x [c])
  8248  	for {
  8249  		if v_0.Op != OpARMSRLconst {
  8250  			break
  8251  		}
  8252  		c := auxIntToInt32(v_0.AuxInt)
  8253  		x := v_0.Args[0]
  8254  		v.reset(OpARMMVNshiftRL)
  8255  		v.AuxInt = int32ToAuxInt(c)
  8256  		v.AddArg(x)
  8257  		return true
  8258  	}
  8259  	// match: (MVN (SRAconst [c] x))
  8260  	// result: (MVNshiftRA x [c])
  8261  	for {
  8262  		if v_0.Op != OpARMSRAconst {
  8263  			break
  8264  		}
  8265  		c := auxIntToInt32(v_0.AuxInt)
  8266  		x := v_0.Args[0]
  8267  		v.reset(OpARMMVNshiftRA)
  8268  		v.AuxInt = int32ToAuxInt(c)
  8269  		v.AddArg(x)
  8270  		return true
  8271  	}
  8272  	// match: (MVN (SLL x y))
  8273  	// result: (MVNshiftLLreg x y)
  8274  	for {
  8275  		if v_0.Op != OpARMSLL {
  8276  			break
  8277  		}
  8278  		y := v_0.Args[1]
  8279  		x := v_0.Args[0]
  8280  		v.reset(OpARMMVNshiftLLreg)
  8281  		v.AddArg2(x, y)
  8282  		return true
  8283  	}
  8284  	// match: (MVN (SRL x y))
  8285  	// result: (MVNshiftRLreg x y)
  8286  	for {
  8287  		if v_0.Op != OpARMSRL {
  8288  			break
  8289  		}
  8290  		y := v_0.Args[1]
  8291  		x := v_0.Args[0]
  8292  		v.reset(OpARMMVNshiftRLreg)
  8293  		v.AddArg2(x, y)
  8294  		return true
  8295  	}
  8296  	// match: (MVN (SRA x y))
  8297  	// result: (MVNshiftRAreg x y)
  8298  	for {
  8299  		if v_0.Op != OpARMSRA {
  8300  			break
  8301  		}
  8302  		y := v_0.Args[1]
  8303  		x := v_0.Args[0]
  8304  		v.reset(OpARMMVNshiftRAreg)
  8305  		v.AddArg2(x, y)
  8306  		return true
  8307  	}
  8308  	return false
  8309  }
  8310  func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool {
  8311  	v_0 := v.Args[0]
  8312  	// match: (MVNshiftLL (MOVWconst [c]) [d])
  8313  	// result: (MOVWconst [^(c<<uint64(d))])
  8314  	for {
  8315  		d := auxIntToInt32(v.AuxInt)
  8316  		if v_0.Op != OpARMMOVWconst {
  8317  			break
  8318  		}
  8319  		c := auxIntToInt32(v_0.AuxInt)
  8320  		v.reset(OpARMMOVWconst)
  8321  		v.AuxInt = int32ToAuxInt(^(c << uint64(d)))
  8322  		return true
  8323  	}
  8324  	return false
  8325  }
  8326  func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool {
  8327  	v_1 := v.Args[1]
  8328  	v_0 := v.Args[0]
  8329  	// match: (MVNshiftLLreg x (MOVWconst [c]))
  8330  	// cond: 0 <= c && c < 32
  8331  	// result: (MVNshiftLL x [c])
  8332  	for {
  8333  		x := v_0
  8334  		if v_1.Op != OpARMMOVWconst {
  8335  			break
  8336  		}
  8337  		c := auxIntToInt32(v_1.AuxInt)
  8338  		if !(0 <= c && c < 32) {
  8339  			break
  8340  		}
  8341  		v.reset(OpARMMVNshiftLL)
  8342  		v.AuxInt = int32ToAuxInt(c)
  8343  		v.AddArg(x)
  8344  		return true
  8345  	}
  8346  	return false
  8347  }
  8348  func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool {
  8349  	v_0 := v.Args[0]
  8350  	// match: (MVNshiftRA (MOVWconst [c]) [d])
  8351  	// result: (MOVWconst [int32(c)>>uint64(d)])
  8352  	for {
  8353  		d := auxIntToInt32(v.AuxInt)
  8354  		if v_0.Op != OpARMMOVWconst {
  8355  			break
  8356  		}
  8357  		c := auxIntToInt32(v_0.AuxInt)
  8358  		v.reset(OpARMMOVWconst)
  8359  		v.AuxInt = int32ToAuxInt(int32(c) >> uint64(d))
  8360  		return true
  8361  	}
  8362  	return false
  8363  }
  8364  func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool {
  8365  	v_1 := v.Args[1]
  8366  	v_0 := v.Args[0]
  8367  	// match: (MVNshiftRAreg x (MOVWconst [c]))
  8368  	// cond: 0 <= c && c < 32
  8369  	// result: (MVNshiftRA x [c])
  8370  	for {
  8371  		x := v_0
  8372  		if v_1.Op != OpARMMOVWconst {
  8373  			break
  8374  		}
  8375  		c := auxIntToInt32(v_1.AuxInt)
  8376  		if !(0 <= c && c < 32) {
  8377  			break
  8378  		}
  8379  		v.reset(OpARMMVNshiftRA)
  8380  		v.AuxInt = int32ToAuxInt(c)
  8381  		v.AddArg(x)
  8382  		return true
  8383  	}
  8384  	return false
  8385  }
  8386  func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool {
  8387  	v_0 := v.Args[0]
  8388  	// match: (MVNshiftRL (MOVWconst [c]) [d])
  8389  	// result: (MOVWconst [^int32(uint32(c)>>uint64(d))])
  8390  	for {
  8391  		d := auxIntToInt32(v.AuxInt)
  8392  		if v_0.Op != OpARMMOVWconst {
  8393  			break
  8394  		}
  8395  		c := auxIntToInt32(v_0.AuxInt)
  8396  		v.reset(OpARMMOVWconst)
  8397  		v.AuxInt = int32ToAuxInt(^int32(uint32(c) >> uint64(d)))
  8398  		return true
  8399  	}
  8400  	return false
  8401  }
  8402  func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool {
  8403  	v_1 := v.Args[1]
  8404  	v_0 := v.Args[0]
  8405  	// match: (MVNshiftRLreg x (MOVWconst [c]))
  8406  	// cond: 0 <= c && c < 32
  8407  	// result: (MVNshiftRL x [c])
  8408  	for {
  8409  		x := v_0
  8410  		if v_1.Op != OpARMMOVWconst {
  8411  			break
  8412  		}
  8413  		c := auxIntToInt32(v_1.AuxInt)
  8414  		if !(0 <= c && c < 32) {
  8415  			break
  8416  		}
  8417  		v.reset(OpARMMVNshiftRL)
  8418  		v.AuxInt = int32ToAuxInt(c)
  8419  		v.AddArg(x)
  8420  		return true
  8421  	}
  8422  	return false
  8423  }
  8424  func rewriteValueARM_OpARMNEGD(v *Value) bool {
  8425  	v_0 := v.Args[0]
  8426  	// match: (NEGD (MULD x y))
  8427  	// cond: buildcfg.GOARM.Version >= 6
  8428  	// result: (NMULD x y)
  8429  	for {
  8430  		if v_0.Op != OpARMMULD {
  8431  			break
  8432  		}
  8433  		y := v_0.Args[1]
  8434  		x := v_0.Args[0]
  8435  		if !(buildcfg.GOARM.Version >= 6) {
  8436  			break
  8437  		}
  8438  		v.reset(OpARMNMULD)
  8439  		v.AddArg2(x, y)
  8440  		return true
  8441  	}
  8442  	return false
  8443  }
  8444  func rewriteValueARM_OpARMNEGF(v *Value) bool {
  8445  	v_0 := v.Args[0]
  8446  	// match: (NEGF (MULF x y))
  8447  	// cond: buildcfg.GOARM.Version >= 6
  8448  	// result: (NMULF x y)
  8449  	for {
  8450  		if v_0.Op != OpARMMULF {
  8451  			break
  8452  		}
  8453  		y := v_0.Args[1]
  8454  		x := v_0.Args[0]
  8455  		if !(buildcfg.GOARM.Version >= 6) {
  8456  			break
  8457  		}
  8458  		v.reset(OpARMNMULF)
  8459  		v.AddArg2(x, y)
  8460  		return true
  8461  	}
  8462  	return false
  8463  }
  8464  func rewriteValueARM_OpARMNMULD(v *Value) bool {
  8465  	v_1 := v.Args[1]
  8466  	v_0 := v.Args[0]
  8467  	// match: (NMULD (NEGD x) y)
  8468  	// result: (MULD x y)
  8469  	for {
  8470  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8471  			if v_0.Op != OpARMNEGD {
  8472  				continue
  8473  			}
  8474  			x := v_0.Args[0]
  8475  			y := v_1
  8476  			v.reset(OpARMMULD)
  8477  			v.AddArg2(x, y)
  8478  			return true
  8479  		}
  8480  		break
  8481  	}
  8482  	return false
  8483  }
  8484  func rewriteValueARM_OpARMNMULF(v *Value) bool {
  8485  	v_1 := v.Args[1]
  8486  	v_0 := v.Args[0]
  8487  	// match: (NMULF (NEGF x) y)
  8488  	// result: (MULF x y)
  8489  	for {
  8490  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8491  			if v_0.Op != OpARMNEGF {
  8492  				continue
  8493  			}
  8494  			x := v_0.Args[0]
  8495  			y := v_1
  8496  			v.reset(OpARMMULF)
  8497  			v.AddArg2(x, y)
  8498  			return true
  8499  		}
  8500  		break
  8501  	}
  8502  	return false
  8503  }
  8504  func rewriteValueARM_OpARMNotEqual(v *Value) bool {
  8505  	v_0 := v.Args[0]
  8506  	// match: (NotEqual (FlagConstant [fc]))
  8507  	// result: (MOVWconst [b2i32(fc.ne())])
  8508  	for {
  8509  		if v_0.Op != OpARMFlagConstant {
  8510  			break
  8511  		}
  8512  		fc := auxIntToFlagConstant(v_0.AuxInt)
  8513  		v.reset(OpARMMOVWconst)
  8514  		v.AuxInt = int32ToAuxInt(b2i32(fc.ne()))
  8515  		return true
  8516  	}
  8517  	// match: (NotEqual (InvertFlags x))
  8518  	// result: (NotEqual x)
  8519  	for {
  8520  		if v_0.Op != OpARMInvertFlags {
  8521  			break
  8522  		}
  8523  		x := v_0.Args[0]
  8524  		v.reset(OpARMNotEqual)
  8525  		v.AddArg(x)
  8526  		return true
  8527  	}
  8528  	return false
  8529  }
  8530  func rewriteValueARM_OpARMOR(v *Value) bool {
  8531  	v_1 := v.Args[1]
  8532  	v_0 := v.Args[0]
  8533  	// match: (OR x (MOVWconst [c]))
  8534  	// result: (ORconst [c] x)
  8535  	for {
  8536  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8537  			x := v_0
  8538  			if v_1.Op != OpARMMOVWconst {
  8539  				continue
  8540  			}
  8541  			c := auxIntToInt32(v_1.AuxInt)
  8542  			v.reset(OpARMORconst)
  8543  			v.AuxInt = int32ToAuxInt(c)
  8544  			v.AddArg(x)
  8545  			return true
  8546  		}
  8547  		break
  8548  	}
  8549  	// match: (OR x (SLLconst [c] y))
  8550  	// result: (ORshiftLL x y [c])
  8551  	for {
  8552  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8553  			x := v_0
  8554  			if v_1.Op != OpARMSLLconst {
  8555  				continue
  8556  			}
  8557  			c := auxIntToInt32(v_1.AuxInt)
  8558  			y := v_1.Args[0]
  8559  			v.reset(OpARMORshiftLL)
  8560  			v.AuxInt = int32ToAuxInt(c)
  8561  			v.AddArg2(x, y)
  8562  			return true
  8563  		}
  8564  		break
  8565  	}
  8566  	// match: (OR x (SRLconst [c] y))
  8567  	// result: (ORshiftRL x y [c])
  8568  	for {
  8569  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8570  			x := v_0
  8571  			if v_1.Op != OpARMSRLconst {
  8572  				continue
  8573  			}
  8574  			c := auxIntToInt32(v_1.AuxInt)
  8575  			y := v_1.Args[0]
  8576  			v.reset(OpARMORshiftRL)
  8577  			v.AuxInt = int32ToAuxInt(c)
  8578  			v.AddArg2(x, y)
  8579  			return true
  8580  		}
  8581  		break
  8582  	}
  8583  	// match: (OR x (SRAconst [c] y))
  8584  	// result: (ORshiftRA x y [c])
  8585  	for {
  8586  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8587  			x := v_0
  8588  			if v_1.Op != OpARMSRAconst {
  8589  				continue
  8590  			}
  8591  			c := auxIntToInt32(v_1.AuxInt)
  8592  			y := v_1.Args[0]
  8593  			v.reset(OpARMORshiftRA)
  8594  			v.AuxInt = int32ToAuxInt(c)
  8595  			v.AddArg2(x, y)
  8596  			return true
  8597  		}
  8598  		break
  8599  	}
  8600  	// match: (OR x (SLL y z))
  8601  	// result: (ORshiftLLreg x y z)
  8602  	for {
  8603  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8604  			x := v_0
  8605  			if v_1.Op != OpARMSLL {
  8606  				continue
  8607  			}
  8608  			z := v_1.Args[1]
  8609  			y := v_1.Args[0]
  8610  			v.reset(OpARMORshiftLLreg)
  8611  			v.AddArg3(x, y, z)
  8612  			return true
  8613  		}
  8614  		break
  8615  	}
  8616  	// match: (OR x (SRL y z))
  8617  	// result: (ORshiftRLreg x y z)
  8618  	for {
  8619  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8620  			x := v_0
  8621  			if v_1.Op != OpARMSRL {
  8622  				continue
  8623  			}
  8624  			z := v_1.Args[1]
  8625  			y := v_1.Args[0]
  8626  			v.reset(OpARMORshiftRLreg)
  8627  			v.AddArg3(x, y, z)
  8628  			return true
  8629  		}
  8630  		break
  8631  	}
  8632  	// match: (OR x (SRA y z))
  8633  	// result: (ORshiftRAreg x y z)
  8634  	for {
  8635  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
  8636  			x := v_0
  8637  			if v_1.Op != OpARMSRA {
  8638  				continue
  8639  			}
  8640  			z := v_1.Args[1]
  8641  			y := v_1.Args[0]
  8642  			v.reset(OpARMORshiftRAreg)
  8643  			v.AddArg3(x, y, z)
  8644  			return true
  8645  		}
  8646  		break
  8647  	}
  8648  	// match: (OR x x)
  8649  	// result: x
  8650  	for {
  8651  		x := v_0
  8652  		if x != v_1 {
  8653  			break
  8654  		}
  8655  		v.copyOf(x)
  8656  		return true
  8657  	}
  8658  	return false
  8659  }
  8660  func rewriteValueARM_OpARMORconst(v *Value) bool {
  8661  	v_0 := v.Args[0]
  8662  	// match: (ORconst [0] x)
  8663  	// result: x
  8664  	for {
  8665  		if auxIntToInt32(v.AuxInt) != 0 {
  8666  			break
  8667  		}
  8668  		x := v_0
  8669  		v.copyOf(x)
  8670  		return true
  8671  	}
  8672  	// match: (ORconst [c] _)
  8673  	// cond: int32(c)==-1
  8674  	// result: (MOVWconst [-1])
  8675  	for {
  8676  		c := auxIntToInt32(v.AuxInt)
  8677  		if !(int32(c) == -1) {
  8678  			break
  8679  		}
  8680  		v.reset(OpARMMOVWconst)
  8681  		v.AuxInt = int32ToAuxInt(-1)
  8682  		return true
  8683  	}
  8684  	// match: (ORconst [c] (MOVWconst [d]))
  8685  	// result: (MOVWconst [c|d])
  8686  	for {
  8687  		c := auxIntToInt32(v.AuxInt)
  8688  		if v_0.Op != OpARMMOVWconst {
  8689  			break
  8690  		}
  8691  		d := auxIntToInt32(v_0.AuxInt)
  8692  		v.reset(OpARMMOVWconst)
  8693  		v.AuxInt = int32ToAuxInt(c | d)
  8694  		return true
  8695  	}
  8696  	// match: (ORconst [c] (ORconst [d] x))
  8697  	// result: (ORconst [c|d] x)
  8698  	for {
  8699  		c := auxIntToInt32(v.AuxInt)
  8700  		if v_0.Op != OpARMORconst {
  8701  			break
  8702  		}
  8703  		d := auxIntToInt32(v_0.AuxInt)
  8704  		x := v_0.Args[0]
  8705  		v.reset(OpARMORconst)
  8706  		v.AuxInt = int32ToAuxInt(c | d)
  8707  		v.AddArg(x)
  8708  		return true
  8709  	}
  8710  	return false
  8711  }
  8712  func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
  8713  	v_1 := v.Args[1]
  8714  	v_0 := v.Args[0]
  8715  	b := v.Block
  8716  	typ := &b.Func.Config.Types
  8717  	// match: (ORshiftLL (MOVWconst [c]) x [d])
  8718  	// result: (ORconst [c] (SLLconst <x.Type> x [d]))
  8719  	for {
  8720  		d := auxIntToInt32(v.AuxInt)
  8721  		if v_0.Op != OpARMMOVWconst {
  8722  			break
  8723  		}
  8724  		c := auxIntToInt32(v_0.AuxInt)
  8725  		x := v_1
  8726  		v.reset(OpARMORconst)
  8727  		v.AuxInt = int32ToAuxInt(c)
  8728  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  8729  		v0.AuxInt = int32ToAuxInt(d)
  8730  		v0.AddArg(x)
  8731  		v.AddArg(v0)
  8732  		return true
  8733  	}
  8734  	// match: (ORshiftLL x (MOVWconst [c]) [d])
  8735  	// result: (ORconst x [c<<uint64(d)])
  8736  	for {
  8737  		d := auxIntToInt32(v.AuxInt)
  8738  		x := v_0
  8739  		if v_1.Op != OpARMMOVWconst {
  8740  			break
  8741  		}
  8742  		c := auxIntToInt32(v_1.AuxInt)
  8743  		v.reset(OpARMORconst)
  8744  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  8745  		v.AddArg(x)
  8746  		return true
  8747  	}
  8748  	// match: (ORshiftLL <typ.UInt16> [8] (BFXU <typ.UInt16> [int32(armBFAuxInt(8, 8))] x) x)
  8749  	// result: (REV16 x)
  8750  	for {
  8751  		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMBFXU || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != int32(armBFAuxInt(8, 8)) {
  8752  			break
  8753  		}
  8754  		x := v_0.Args[0]
  8755  		if x != v_1 {
  8756  			break
  8757  		}
  8758  		v.reset(OpARMREV16)
  8759  		v.AddArg(x)
  8760  		return true
  8761  	}
  8762  	// match: (ORshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
  8763  	// cond: buildcfg.GOARM.Version>=6
  8764  	// result: (REV16 x)
  8765  	for {
  8766  		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
  8767  			break
  8768  		}
  8769  		v_0_0 := v_0.Args[0]
  8770  		if v_0_0.Op != OpARMSLLconst || auxIntToInt32(v_0_0.AuxInt) != 16 {
  8771  			break
  8772  		}
  8773  		x := v_0_0.Args[0]
  8774  		if x != v_1 || !(buildcfg.GOARM.Version >= 6) {
  8775  			break
  8776  		}
  8777  		v.reset(OpARMREV16)
  8778  		v.AddArg(x)
  8779  		return true
  8780  	}
  8781  	// match: (ORshiftLL y:(SLLconst x [c]) x [c])
  8782  	// result: y
  8783  	for {
  8784  		c := auxIntToInt32(v.AuxInt)
  8785  		y := v_0
  8786  		if y.Op != OpARMSLLconst || auxIntToInt32(y.AuxInt) != c {
  8787  			break
  8788  		}
  8789  		x := y.Args[0]
  8790  		if x != v_1 {
  8791  			break
  8792  		}
  8793  		v.copyOf(y)
  8794  		return true
  8795  	}
  8796  	return false
  8797  }
  8798  func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool {
  8799  	v_2 := v.Args[2]
  8800  	v_1 := v.Args[1]
  8801  	v_0 := v.Args[0]
  8802  	b := v.Block
  8803  	// match: (ORshiftLLreg (MOVWconst [c]) x y)
  8804  	// result: (ORconst [c] (SLL <x.Type> x y))
  8805  	for {
  8806  		if v_0.Op != OpARMMOVWconst {
  8807  			break
  8808  		}
  8809  		c := auxIntToInt32(v_0.AuxInt)
  8810  		x := v_1
  8811  		y := v_2
  8812  		v.reset(OpARMORconst)
  8813  		v.AuxInt = int32ToAuxInt(c)
  8814  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  8815  		v0.AddArg2(x, y)
  8816  		v.AddArg(v0)
  8817  		return true
  8818  	}
  8819  	// match: (ORshiftLLreg x y (MOVWconst [c]))
  8820  	// cond: 0 <= c && c < 32
  8821  	// result: (ORshiftLL x y [c])
  8822  	for {
  8823  		x := v_0
  8824  		y := v_1
  8825  		if v_2.Op != OpARMMOVWconst {
  8826  			break
  8827  		}
  8828  		c := auxIntToInt32(v_2.AuxInt)
  8829  		if !(0 <= c && c < 32) {
  8830  			break
  8831  		}
  8832  		v.reset(OpARMORshiftLL)
  8833  		v.AuxInt = int32ToAuxInt(c)
  8834  		v.AddArg2(x, y)
  8835  		return true
  8836  	}
  8837  	return false
  8838  }
  8839  func rewriteValueARM_OpARMORshiftRA(v *Value) bool {
  8840  	v_1 := v.Args[1]
  8841  	v_0 := v.Args[0]
  8842  	b := v.Block
  8843  	// match: (ORshiftRA (MOVWconst [c]) x [d])
  8844  	// result: (ORconst [c] (SRAconst <x.Type> x [d]))
  8845  	for {
  8846  		d := auxIntToInt32(v.AuxInt)
  8847  		if v_0.Op != OpARMMOVWconst {
  8848  			break
  8849  		}
  8850  		c := auxIntToInt32(v_0.AuxInt)
  8851  		x := v_1
  8852  		v.reset(OpARMORconst)
  8853  		v.AuxInt = int32ToAuxInt(c)
  8854  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  8855  		v0.AuxInt = int32ToAuxInt(d)
  8856  		v0.AddArg(x)
  8857  		v.AddArg(v0)
  8858  		return true
  8859  	}
  8860  	// match: (ORshiftRA x (MOVWconst [c]) [d])
  8861  	// result: (ORconst x [c>>uint64(d)])
  8862  	for {
  8863  		d := auxIntToInt32(v.AuxInt)
  8864  		x := v_0
  8865  		if v_1.Op != OpARMMOVWconst {
  8866  			break
  8867  		}
  8868  		c := auxIntToInt32(v_1.AuxInt)
  8869  		v.reset(OpARMORconst)
  8870  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  8871  		v.AddArg(x)
  8872  		return true
  8873  	}
  8874  	// match: (ORshiftRA y:(SRAconst x [c]) x [c])
  8875  	// result: y
  8876  	for {
  8877  		c := auxIntToInt32(v.AuxInt)
  8878  		y := v_0
  8879  		if y.Op != OpARMSRAconst || auxIntToInt32(y.AuxInt) != c {
  8880  			break
  8881  		}
  8882  		x := y.Args[0]
  8883  		if x != v_1 {
  8884  			break
  8885  		}
  8886  		v.copyOf(y)
  8887  		return true
  8888  	}
  8889  	return false
  8890  }
  8891  func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool {
  8892  	v_2 := v.Args[2]
  8893  	v_1 := v.Args[1]
  8894  	v_0 := v.Args[0]
  8895  	b := v.Block
  8896  	// match: (ORshiftRAreg (MOVWconst [c]) x y)
  8897  	// result: (ORconst [c] (SRA <x.Type> x y))
  8898  	for {
  8899  		if v_0.Op != OpARMMOVWconst {
  8900  			break
  8901  		}
  8902  		c := auxIntToInt32(v_0.AuxInt)
  8903  		x := v_1
  8904  		y := v_2
  8905  		v.reset(OpARMORconst)
  8906  		v.AuxInt = int32ToAuxInt(c)
  8907  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  8908  		v0.AddArg2(x, y)
  8909  		v.AddArg(v0)
  8910  		return true
  8911  	}
  8912  	// match: (ORshiftRAreg x y (MOVWconst [c]))
  8913  	// cond: 0 <= c && c < 32
  8914  	// result: (ORshiftRA x y [c])
  8915  	for {
  8916  		x := v_0
  8917  		y := v_1
  8918  		if v_2.Op != OpARMMOVWconst {
  8919  			break
  8920  		}
  8921  		c := auxIntToInt32(v_2.AuxInt)
  8922  		if !(0 <= c && c < 32) {
  8923  			break
  8924  		}
  8925  		v.reset(OpARMORshiftRA)
  8926  		v.AuxInt = int32ToAuxInt(c)
  8927  		v.AddArg2(x, y)
  8928  		return true
  8929  	}
  8930  	return false
  8931  }
  8932  func rewriteValueARM_OpARMORshiftRL(v *Value) bool {
  8933  	v_1 := v.Args[1]
  8934  	v_0 := v.Args[0]
  8935  	b := v.Block
  8936  	// match: (ORshiftRL (MOVWconst [c]) x [d])
  8937  	// result: (ORconst [c] (SRLconst <x.Type> x [d]))
  8938  	for {
  8939  		d := auxIntToInt32(v.AuxInt)
  8940  		if v_0.Op != OpARMMOVWconst {
  8941  			break
  8942  		}
  8943  		c := auxIntToInt32(v_0.AuxInt)
  8944  		x := v_1
  8945  		v.reset(OpARMORconst)
  8946  		v.AuxInt = int32ToAuxInt(c)
  8947  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  8948  		v0.AuxInt = int32ToAuxInt(d)
  8949  		v0.AddArg(x)
  8950  		v.AddArg(v0)
  8951  		return true
  8952  	}
  8953  	// match: (ORshiftRL x (MOVWconst [c]) [d])
  8954  	// result: (ORconst x [int32(uint32(c)>>uint64(d))])
  8955  	for {
  8956  		d := auxIntToInt32(v.AuxInt)
  8957  		x := v_0
  8958  		if v_1.Op != OpARMMOVWconst {
  8959  			break
  8960  		}
  8961  		c := auxIntToInt32(v_1.AuxInt)
  8962  		v.reset(OpARMORconst)
  8963  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  8964  		v.AddArg(x)
  8965  		return true
  8966  	}
  8967  	// match: (ORshiftRL y:(SRLconst x [c]) x [c])
  8968  	// result: y
  8969  	for {
  8970  		c := auxIntToInt32(v.AuxInt)
  8971  		y := v_0
  8972  		if y.Op != OpARMSRLconst || auxIntToInt32(y.AuxInt) != c {
  8973  			break
  8974  		}
  8975  		x := y.Args[0]
  8976  		if x != v_1 {
  8977  			break
  8978  		}
  8979  		v.copyOf(y)
  8980  		return true
  8981  	}
  8982  	return false
  8983  }
  8984  func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool {
  8985  	v_2 := v.Args[2]
  8986  	v_1 := v.Args[1]
  8987  	v_0 := v.Args[0]
  8988  	b := v.Block
  8989  	// match: (ORshiftRLreg (MOVWconst [c]) x y)
  8990  	// result: (ORconst [c] (SRL <x.Type> x y))
  8991  	for {
  8992  		if v_0.Op != OpARMMOVWconst {
  8993  			break
  8994  		}
  8995  		c := auxIntToInt32(v_0.AuxInt)
  8996  		x := v_1
  8997  		y := v_2
  8998  		v.reset(OpARMORconst)
  8999  		v.AuxInt = int32ToAuxInt(c)
  9000  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  9001  		v0.AddArg2(x, y)
  9002  		v.AddArg(v0)
  9003  		return true
  9004  	}
  9005  	// match: (ORshiftRLreg x y (MOVWconst [c]))
  9006  	// cond: 0 <= c && c < 32
  9007  	// result: (ORshiftRL x y [c])
  9008  	for {
  9009  		x := v_0
  9010  		y := v_1
  9011  		if v_2.Op != OpARMMOVWconst {
  9012  			break
  9013  		}
  9014  		c := auxIntToInt32(v_2.AuxInt)
  9015  		if !(0 <= c && c < 32) {
  9016  			break
  9017  		}
  9018  		v.reset(OpARMORshiftRL)
  9019  		v.AuxInt = int32ToAuxInt(c)
  9020  		v.AddArg2(x, y)
  9021  		return true
  9022  	}
  9023  	return false
  9024  }
  9025  func rewriteValueARM_OpARMRSB(v *Value) bool {
  9026  	v_1 := v.Args[1]
  9027  	v_0 := v.Args[0]
  9028  	// match: (RSB (MOVWconst [c]) x)
  9029  	// result: (SUBconst [c] x)
  9030  	for {
  9031  		if v_0.Op != OpARMMOVWconst {
  9032  			break
  9033  		}
  9034  		c := auxIntToInt32(v_0.AuxInt)
  9035  		x := v_1
  9036  		v.reset(OpARMSUBconst)
  9037  		v.AuxInt = int32ToAuxInt(c)
  9038  		v.AddArg(x)
  9039  		return true
  9040  	}
  9041  	// match: (RSB x (MOVWconst [c]))
  9042  	// result: (RSBconst [c] x)
  9043  	for {
  9044  		x := v_0
  9045  		if v_1.Op != OpARMMOVWconst {
  9046  			break
  9047  		}
  9048  		c := auxIntToInt32(v_1.AuxInt)
  9049  		v.reset(OpARMRSBconst)
  9050  		v.AuxInt = int32ToAuxInt(c)
  9051  		v.AddArg(x)
  9052  		return true
  9053  	}
  9054  	// match: (RSB x (SLLconst [c] y))
  9055  	// result: (RSBshiftLL x y [c])
  9056  	for {
  9057  		x := v_0
  9058  		if v_1.Op != OpARMSLLconst {
  9059  			break
  9060  		}
  9061  		c := auxIntToInt32(v_1.AuxInt)
  9062  		y := v_1.Args[0]
  9063  		v.reset(OpARMRSBshiftLL)
  9064  		v.AuxInt = int32ToAuxInt(c)
  9065  		v.AddArg2(x, y)
  9066  		return true
  9067  	}
  9068  	// match: (RSB (SLLconst [c] y) x)
  9069  	// result: (SUBshiftLL x y [c])
  9070  	for {
  9071  		if v_0.Op != OpARMSLLconst {
  9072  			break
  9073  		}
  9074  		c := auxIntToInt32(v_0.AuxInt)
  9075  		y := v_0.Args[0]
  9076  		x := v_1
  9077  		v.reset(OpARMSUBshiftLL)
  9078  		v.AuxInt = int32ToAuxInt(c)
  9079  		v.AddArg2(x, y)
  9080  		return true
  9081  	}
  9082  	// match: (RSB x (SRLconst [c] y))
  9083  	// result: (RSBshiftRL x y [c])
  9084  	for {
  9085  		x := v_0
  9086  		if v_1.Op != OpARMSRLconst {
  9087  			break
  9088  		}
  9089  		c := auxIntToInt32(v_1.AuxInt)
  9090  		y := v_1.Args[0]
  9091  		v.reset(OpARMRSBshiftRL)
  9092  		v.AuxInt = int32ToAuxInt(c)
  9093  		v.AddArg2(x, y)
  9094  		return true
  9095  	}
  9096  	// match: (RSB (SRLconst [c] y) x)
  9097  	// result: (SUBshiftRL x y [c])
  9098  	for {
  9099  		if v_0.Op != OpARMSRLconst {
  9100  			break
  9101  		}
  9102  		c := auxIntToInt32(v_0.AuxInt)
  9103  		y := v_0.Args[0]
  9104  		x := v_1
  9105  		v.reset(OpARMSUBshiftRL)
  9106  		v.AuxInt = int32ToAuxInt(c)
  9107  		v.AddArg2(x, y)
  9108  		return true
  9109  	}
  9110  	// match: (RSB x (SRAconst [c] y))
  9111  	// result: (RSBshiftRA x y [c])
  9112  	for {
  9113  		x := v_0
  9114  		if v_1.Op != OpARMSRAconst {
  9115  			break
  9116  		}
  9117  		c := auxIntToInt32(v_1.AuxInt)
  9118  		y := v_1.Args[0]
  9119  		v.reset(OpARMRSBshiftRA)
  9120  		v.AuxInt = int32ToAuxInt(c)
  9121  		v.AddArg2(x, y)
  9122  		return true
  9123  	}
  9124  	// match: (RSB (SRAconst [c] y) x)
  9125  	// result: (SUBshiftRA x y [c])
  9126  	for {
  9127  		if v_0.Op != OpARMSRAconst {
  9128  			break
  9129  		}
  9130  		c := auxIntToInt32(v_0.AuxInt)
  9131  		y := v_0.Args[0]
  9132  		x := v_1
  9133  		v.reset(OpARMSUBshiftRA)
  9134  		v.AuxInt = int32ToAuxInt(c)
  9135  		v.AddArg2(x, y)
  9136  		return true
  9137  	}
  9138  	// match: (RSB x (SLL y z))
  9139  	// result: (RSBshiftLLreg x y z)
  9140  	for {
  9141  		x := v_0
  9142  		if v_1.Op != OpARMSLL {
  9143  			break
  9144  		}
  9145  		z := v_1.Args[1]
  9146  		y := v_1.Args[0]
  9147  		v.reset(OpARMRSBshiftLLreg)
  9148  		v.AddArg3(x, y, z)
  9149  		return true
  9150  	}
  9151  	// match: (RSB (SLL y z) x)
  9152  	// result: (SUBshiftLLreg x y z)
  9153  	for {
  9154  		if v_0.Op != OpARMSLL {
  9155  			break
  9156  		}
  9157  		z := v_0.Args[1]
  9158  		y := v_0.Args[0]
  9159  		x := v_1
  9160  		v.reset(OpARMSUBshiftLLreg)
  9161  		v.AddArg3(x, y, z)
  9162  		return true
  9163  	}
  9164  	// match: (RSB x (SRL y z))
  9165  	// result: (RSBshiftRLreg x y z)
  9166  	for {
  9167  		x := v_0
  9168  		if v_1.Op != OpARMSRL {
  9169  			break
  9170  		}
  9171  		z := v_1.Args[1]
  9172  		y := v_1.Args[0]
  9173  		v.reset(OpARMRSBshiftRLreg)
  9174  		v.AddArg3(x, y, z)
  9175  		return true
  9176  	}
  9177  	// match: (RSB (SRL y z) x)
  9178  	// result: (SUBshiftRLreg x y z)
  9179  	for {
  9180  		if v_0.Op != OpARMSRL {
  9181  			break
  9182  		}
  9183  		z := v_0.Args[1]
  9184  		y := v_0.Args[0]
  9185  		x := v_1
  9186  		v.reset(OpARMSUBshiftRLreg)
  9187  		v.AddArg3(x, y, z)
  9188  		return true
  9189  	}
  9190  	// match: (RSB x (SRA y z))
  9191  	// result: (RSBshiftRAreg x y z)
  9192  	for {
  9193  		x := v_0
  9194  		if v_1.Op != OpARMSRA {
  9195  			break
  9196  		}
  9197  		z := v_1.Args[1]
  9198  		y := v_1.Args[0]
  9199  		v.reset(OpARMRSBshiftRAreg)
  9200  		v.AddArg3(x, y, z)
  9201  		return true
  9202  	}
  9203  	// match: (RSB (SRA y z) x)
  9204  	// result: (SUBshiftRAreg x y z)
  9205  	for {
  9206  		if v_0.Op != OpARMSRA {
  9207  			break
  9208  		}
  9209  		z := v_0.Args[1]
  9210  		y := v_0.Args[0]
  9211  		x := v_1
  9212  		v.reset(OpARMSUBshiftRAreg)
  9213  		v.AddArg3(x, y, z)
  9214  		return true
  9215  	}
  9216  	// match: (RSB x x)
  9217  	// result: (MOVWconst [0])
  9218  	for {
  9219  		x := v_0
  9220  		if x != v_1 {
  9221  			break
  9222  		}
  9223  		v.reset(OpARMMOVWconst)
  9224  		v.AuxInt = int32ToAuxInt(0)
  9225  		return true
  9226  	}
  9227  	// match: (RSB (MUL x y) a)
  9228  	// cond: buildcfg.GOARM.Version == 7
  9229  	// result: (MULS x y a)
  9230  	for {
  9231  		if v_0.Op != OpARMMUL {
  9232  			break
  9233  		}
  9234  		y := v_0.Args[1]
  9235  		x := v_0.Args[0]
  9236  		a := v_1
  9237  		if !(buildcfg.GOARM.Version == 7) {
  9238  			break
  9239  		}
  9240  		v.reset(OpARMMULS)
  9241  		v.AddArg3(x, y, a)
  9242  		return true
  9243  	}
  9244  	return false
  9245  }
  9246  func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool {
  9247  	v_1 := v.Args[1]
  9248  	v_0 := v.Args[0]
  9249  	b := v.Block
  9250  	// match: (RSBSshiftLL (MOVWconst [c]) x [d])
  9251  	// result: (SUBSconst [c] (SLLconst <x.Type> x [d]))
  9252  	for {
  9253  		d := auxIntToInt32(v.AuxInt)
  9254  		if v_0.Op != OpARMMOVWconst {
  9255  			break
  9256  		}
  9257  		c := auxIntToInt32(v_0.AuxInt)
  9258  		x := v_1
  9259  		v.reset(OpARMSUBSconst)
  9260  		v.AuxInt = int32ToAuxInt(c)
  9261  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  9262  		v0.AuxInt = int32ToAuxInt(d)
  9263  		v0.AddArg(x)
  9264  		v.AddArg(v0)
  9265  		return true
  9266  	}
  9267  	// match: (RSBSshiftLL x (MOVWconst [c]) [d])
  9268  	// result: (RSBSconst x [c<<uint64(d)])
  9269  	for {
  9270  		d := auxIntToInt32(v.AuxInt)
  9271  		x := v_0
  9272  		if v_1.Op != OpARMMOVWconst {
  9273  			break
  9274  		}
  9275  		c := auxIntToInt32(v_1.AuxInt)
  9276  		v.reset(OpARMRSBSconst)
  9277  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  9278  		v.AddArg(x)
  9279  		return true
  9280  	}
  9281  	return false
  9282  }
  9283  func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool {
  9284  	v_2 := v.Args[2]
  9285  	v_1 := v.Args[1]
  9286  	v_0 := v.Args[0]
  9287  	b := v.Block
  9288  	// match: (RSBSshiftLLreg (MOVWconst [c]) x y)
  9289  	// result: (SUBSconst [c] (SLL <x.Type> x y))
  9290  	for {
  9291  		if v_0.Op != OpARMMOVWconst {
  9292  			break
  9293  		}
  9294  		c := auxIntToInt32(v_0.AuxInt)
  9295  		x := v_1
  9296  		y := v_2
  9297  		v.reset(OpARMSUBSconst)
  9298  		v.AuxInt = int32ToAuxInt(c)
  9299  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  9300  		v0.AddArg2(x, y)
  9301  		v.AddArg(v0)
  9302  		return true
  9303  	}
  9304  	// match: (RSBSshiftLLreg x y (MOVWconst [c]))
  9305  	// cond: 0 <= c && c < 32
  9306  	// result: (RSBSshiftLL x y [c])
  9307  	for {
  9308  		x := v_0
  9309  		y := v_1
  9310  		if v_2.Op != OpARMMOVWconst {
  9311  			break
  9312  		}
  9313  		c := auxIntToInt32(v_2.AuxInt)
  9314  		if !(0 <= c && c < 32) {
  9315  			break
  9316  		}
  9317  		v.reset(OpARMRSBSshiftLL)
  9318  		v.AuxInt = int32ToAuxInt(c)
  9319  		v.AddArg2(x, y)
  9320  		return true
  9321  	}
  9322  	return false
  9323  }
  9324  func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool {
  9325  	v_1 := v.Args[1]
  9326  	v_0 := v.Args[0]
  9327  	b := v.Block
  9328  	// match: (RSBSshiftRA (MOVWconst [c]) x [d])
  9329  	// result: (SUBSconst [c] (SRAconst <x.Type> x [d]))
  9330  	for {
  9331  		d := auxIntToInt32(v.AuxInt)
  9332  		if v_0.Op != OpARMMOVWconst {
  9333  			break
  9334  		}
  9335  		c := auxIntToInt32(v_0.AuxInt)
  9336  		x := v_1
  9337  		v.reset(OpARMSUBSconst)
  9338  		v.AuxInt = int32ToAuxInt(c)
  9339  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  9340  		v0.AuxInt = int32ToAuxInt(d)
  9341  		v0.AddArg(x)
  9342  		v.AddArg(v0)
  9343  		return true
  9344  	}
  9345  	// match: (RSBSshiftRA x (MOVWconst [c]) [d])
  9346  	// result: (RSBSconst x [c>>uint64(d)])
  9347  	for {
  9348  		d := auxIntToInt32(v.AuxInt)
  9349  		x := v_0
  9350  		if v_1.Op != OpARMMOVWconst {
  9351  			break
  9352  		}
  9353  		c := auxIntToInt32(v_1.AuxInt)
  9354  		v.reset(OpARMRSBSconst)
  9355  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  9356  		v.AddArg(x)
  9357  		return true
  9358  	}
  9359  	return false
  9360  }
  9361  func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool {
  9362  	v_2 := v.Args[2]
  9363  	v_1 := v.Args[1]
  9364  	v_0 := v.Args[0]
  9365  	b := v.Block
  9366  	// match: (RSBSshiftRAreg (MOVWconst [c]) x y)
  9367  	// result: (SUBSconst [c] (SRA <x.Type> x y))
  9368  	for {
  9369  		if v_0.Op != OpARMMOVWconst {
  9370  			break
  9371  		}
  9372  		c := auxIntToInt32(v_0.AuxInt)
  9373  		x := v_1
  9374  		y := v_2
  9375  		v.reset(OpARMSUBSconst)
  9376  		v.AuxInt = int32ToAuxInt(c)
  9377  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  9378  		v0.AddArg2(x, y)
  9379  		v.AddArg(v0)
  9380  		return true
  9381  	}
  9382  	// match: (RSBSshiftRAreg x y (MOVWconst [c]))
  9383  	// cond: 0 <= c && c < 32
  9384  	// result: (RSBSshiftRA x y [c])
  9385  	for {
  9386  		x := v_0
  9387  		y := v_1
  9388  		if v_2.Op != OpARMMOVWconst {
  9389  			break
  9390  		}
  9391  		c := auxIntToInt32(v_2.AuxInt)
  9392  		if !(0 <= c && c < 32) {
  9393  			break
  9394  		}
  9395  		v.reset(OpARMRSBSshiftRA)
  9396  		v.AuxInt = int32ToAuxInt(c)
  9397  		v.AddArg2(x, y)
  9398  		return true
  9399  	}
  9400  	return false
  9401  }
  9402  func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool {
  9403  	v_1 := v.Args[1]
  9404  	v_0 := v.Args[0]
  9405  	b := v.Block
  9406  	// match: (RSBSshiftRL (MOVWconst [c]) x [d])
  9407  	// result: (SUBSconst [c] (SRLconst <x.Type> x [d]))
  9408  	for {
  9409  		d := auxIntToInt32(v.AuxInt)
  9410  		if v_0.Op != OpARMMOVWconst {
  9411  			break
  9412  		}
  9413  		c := auxIntToInt32(v_0.AuxInt)
  9414  		x := v_1
  9415  		v.reset(OpARMSUBSconst)
  9416  		v.AuxInt = int32ToAuxInt(c)
  9417  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  9418  		v0.AuxInt = int32ToAuxInt(d)
  9419  		v0.AddArg(x)
  9420  		v.AddArg(v0)
  9421  		return true
  9422  	}
  9423  	// match: (RSBSshiftRL x (MOVWconst [c]) [d])
  9424  	// result: (RSBSconst x [int32(uint32(c)>>uint64(d))])
  9425  	for {
  9426  		d := auxIntToInt32(v.AuxInt)
  9427  		x := v_0
  9428  		if v_1.Op != OpARMMOVWconst {
  9429  			break
  9430  		}
  9431  		c := auxIntToInt32(v_1.AuxInt)
  9432  		v.reset(OpARMRSBSconst)
  9433  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  9434  		v.AddArg(x)
  9435  		return true
  9436  	}
  9437  	return false
  9438  }
  9439  func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool {
  9440  	v_2 := v.Args[2]
  9441  	v_1 := v.Args[1]
  9442  	v_0 := v.Args[0]
  9443  	b := v.Block
  9444  	// match: (RSBSshiftRLreg (MOVWconst [c]) x y)
  9445  	// result: (SUBSconst [c] (SRL <x.Type> x y))
  9446  	for {
  9447  		if v_0.Op != OpARMMOVWconst {
  9448  			break
  9449  		}
  9450  		c := auxIntToInt32(v_0.AuxInt)
  9451  		x := v_1
  9452  		y := v_2
  9453  		v.reset(OpARMSUBSconst)
  9454  		v.AuxInt = int32ToAuxInt(c)
  9455  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  9456  		v0.AddArg2(x, y)
  9457  		v.AddArg(v0)
  9458  		return true
  9459  	}
  9460  	// match: (RSBSshiftRLreg x y (MOVWconst [c]))
  9461  	// cond: 0 <= c && c < 32
  9462  	// result: (RSBSshiftRL x y [c])
  9463  	for {
  9464  		x := v_0
  9465  		y := v_1
  9466  		if v_2.Op != OpARMMOVWconst {
  9467  			break
  9468  		}
  9469  		c := auxIntToInt32(v_2.AuxInt)
  9470  		if !(0 <= c && c < 32) {
  9471  			break
  9472  		}
  9473  		v.reset(OpARMRSBSshiftRL)
  9474  		v.AuxInt = int32ToAuxInt(c)
  9475  		v.AddArg2(x, y)
  9476  		return true
  9477  	}
  9478  	return false
  9479  }
  9480  func rewriteValueARM_OpARMRSBconst(v *Value) bool {
  9481  	v_0 := v.Args[0]
  9482  	// match: (RSBconst [c] (MOVWconst [d]))
  9483  	// result: (MOVWconst [c-d])
  9484  	for {
  9485  		c := auxIntToInt32(v.AuxInt)
  9486  		if v_0.Op != OpARMMOVWconst {
  9487  			break
  9488  		}
  9489  		d := auxIntToInt32(v_0.AuxInt)
  9490  		v.reset(OpARMMOVWconst)
  9491  		v.AuxInt = int32ToAuxInt(c - d)
  9492  		return true
  9493  	}
  9494  	// match: (RSBconst [c] (RSBconst [d] x))
  9495  	// result: (ADDconst [c-d] x)
  9496  	for {
  9497  		c := auxIntToInt32(v.AuxInt)
  9498  		if v_0.Op != OpARMRSBconst {
  9499  			break
  9500  		}
  9501  		d := auxIntToInt32(v_0.AuxInt)
  9502  		x := v_0.Args[0]
  9503  		v.reset(OpARMADDconst)
  9504  		v.AuxInt = int32ToAuxInt(c - d)
  9505  		v.AddArg(x)
  9506  		return true
  9507  	}
  9508  	// match: (RSBconst [c] (ADDconst [d] x))
  9509  	// result: (RSBconst [c-d] x)
  9510  	for {
  9511  		c := auxIntToInt32(v.AuxInt)
  9512  		if v_0.Op != OpARMADDconst {
  9513  			break
  9514  		}
  9515  		d := auxIntToInt32(v_0.AuxInt)
  9516  		x := v_0.Args[0]
  9517  		v.reset(OpARMRSBconst)
  9518  		v.AuxInt = int32ToAuxInt(c - d)
  9519  		v.AddArg(x)
  9520  		return true
  9521  	}
  9522  	// match: (RSBconst [c] (SUBconst [d] x))
  9523  	// result: (RSBconst [c+d] x)
  9524  	for {
  9525  		c := auxIntToInt32(v.AuxInt)
  9526  		if v_0.Op != OpARMSUBconst {
  9527  			break
  9528  		}
  9529  		d := auxIntToInt32(v_0.AuxInt)
  9530  		x := v_0.Args[0]
  9531  		v.reset(OpARMRSBconst)
  9532  		v.AuxInt = int32ToAuxInt(c + d)
  9533  		v.AddArg(x)
  9534  		return true
  9535  	}
  9536  	return false
  9537  }
  9538  func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool {
  9539  	v_1 := v.Args[1]
  9540  	v_0 := v.Args[0]
  9541  	b := v.Block
  9542  	// match: (RSBshiftLL (MOVWconst [c]) x [d])
  9543  	// result: (SUBconst [c] (SLLconst <x.Type> x [d]))
  9544  	for {
  9545  		d := auxIntToInt32(v.AuxInt)
  9546  		if v_0.Op != OpARMMOVWconst {
  9547  			break
  9548  		}
  9549  		c := auxIntToInt32(v_0.AuxInt)
  9550  		x := v_1
  9551  		v.reset(OpARMSUBconst)
  9552  		v.AuxInt = int32ToAuxInt(c)
  9553  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  9554  		v0.AuxInt = int32ToAuxInt(d)
  9555  		v0.AddArg(x)
  9556  		v.AddArg(v0)
  9557  		return true
  9558  	}
  9559  	// match: (RSBshiftLL x (MOVWconst [c]) [d])
  9560  	// result: (RSBconst x [c<<uint64(d)])
  9561  	for {
  9562  		d := auxIntToInt32(v.AuxInt)
  9563  		x := v_0
  9564  		if v_1.Op != OpARMMOVWconst {
  9565  			break
  9566  		}
  9567  		c := auxIntToInt32(v_1.AuxInt)
  9568  		v.reset(OpARMRSBconst)
  9569  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  9570  		v.AddArg(x)
  9571  		return true
  9572  	}
  9573  	// match: (RSBshiftLL (SLLconst x [c]) x [c])
  9574  	// result: (MOVWconst [0])
  9575  	for {
  9576  		c := auxIntToInt32(v.AuxInt)
  9577  		if v_0.Op != OpARMSLLconst || auxIntToInt32(v_0.AuxInt) != c {
  9578  			break
  9579  		}
  9580  		x := v_0.Args[0]
  9581  		if x != v_1 {
  9582  			break
  9583  		}
  9584  		v.reset(OpARMMOVWconst)
  9585  		v.AuxInt = int32ToAuxInt(0)
  9586  		return true
  9587  	}
  9588  	return false
  9589  }
  9590  func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool {
  9591  	v_2 := v.Args[2]
  9592  	v_1 := v.Args[1]
  9593  	v_0 := v.Args[0]
  9594  	b := v.Block
  9595  	// match: (RSBshiftLLreg (MOVWconst [c]) x y)
  9596  	// result: (SUBconst [c] (SLL <x.Type> x y))
  9597  	for {
  9598  		if v_0.Op != OpARMMOVWconst {
  9599  			break
  9600  		}
  9601  		c := auxIntToInt32(v_0.AuxInt)
  9602  		x := v_1
  9603  		y := v_2
  9604  		v.reset(OpARMSUBconst)
  9605  		v.AuxInt = int32ToAuxInt(c)
  9606  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  9607  		v0.AddArg2(x, y)
  9608  		v.AddArg(v0)
  9609  		return true
  9610  	}
  9611  	// match: (RSBshiftLLreg x y (MOVWconst [c]))
  9612  	// cond: 0 <= c && c < 32
  9613  	// result: (RSBshiftLL x y [c])
  9614  	for {
  9615  		x := v_0
  9616  		y := v_1
  9617  		if v_2.Op != OpARMMOVWconst {
  9618  			break
  9619  		}
  9620  		c := auxIntToInt32(v_2.AuxInt)
  9621  		if !(0 <= c && c < 32) {
  9622  			break
  9623  		}
  9624  		v.reset(OpARMRSBshiftLL)
  9625  		v.AuxInt = int32ToAuxInt(c)
  9626  		v.AddArg2(x, y)
  9627  		return true
  9628  	}
  9629  	return false
  9630  }
  9631  func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool {
  9632  	v_1 := v.Args[1]
  9633  	v_0 := v.Args[0]
  9634  	b := v.Block
  9635  	// match: (RSBshiftRA (MOVWconst [c]) x [d])
  9636  	// result: (SUBconst [c] (SRAconst <x.Type> x [d]))
  9637  	for {
  9638  		d := auxIntToInt32(v.AuxInt)
  9639  		if v_0.Op != OpARMMOVWconst {
  9640  			break
  9641  		}
  9642  		c := auxIntToInt32(v_0.AuxInt)
  9643  		x := v_1
  9644  		v.reset(OpARMSUBconst)
  9645  		v.AuxInt = int32ToAuxInt(c)
  9646  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  9647  		v0.AuxInt = int32ToAuxInt(d)
  9648  		v0.AddArg(x)
  9649  		v.AddArg(v0)
  9650  		return true
  9651  	}
  9652  	// match: (RSBshiftRA x (MOVWconst [c]) [d])
  9653  	// result: (RSBconst x [c>>uint64(d)])
  9654  	for {
  9655  		d := auxIntToInt32(v.AuxInt)
  9656  		x := v_0
  9657  		if v_1.Op != OpARMMOVWconst {
  9658  			break
  9659  		}
  9660  		c := auxIntToInt32(v_1.AuxInt)
  9661  		v.reset(OpARMRSBconst)
  9662  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  9663  		v.AddArg(x)
  9664  		return true
  9665  	}
  9666  	// match: (RSBshiftRA (SRAconst x [c]) x [c])
  9667  	// result: (MOVWconst [0])
  9668  	for {
  9669  		c := auxIntToInt32(v.AuxInt)
  9670  		if v_0.Op != OpARMSRAconst || auxIntToInt32(v_0.AuxInt) != c {
  9671  			break
  9672  		}
  9673  		x := v_0.Args[0]
  9674  		if x != v_1 {
  9675  			break
  9676  		}
  9677  		v.reset(OpARMMOVWconst)
  9678  		v.AuxInt = int32ToAuxInt(0)
  9679  		return true
  9680  	}
  9681  	return false
  9682  }
  9683  func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool {
  9684  	v_2 := v.Args[2]
  9685  	v_1 := v.Args[1]
  9686  	v_0 := v.Args[0]
  9687  	b := v.Block
  9688  	// match: (RSBshiftRAreg (MOVWconst [c]) x y)
  9689  	// result: (SUBconst [c] (SRA <x.Type> x y))
  9690  	for {
  9691  		if v_0.Op != OpARMMOVWconst {
  9692  			break
  9693  		}
  9694  		c := auxIntToInt32(v_0.AuxInt)
  9695  		x := v_1
  9696  		y := v_2
  9697  		v.reset(OpARMSUBconst)
  9698  		v.AuxInt = int32ToAuxInt(c)
  9699  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  9700  		v0.AddArg2(x, y)
  9701  		v.AddArg(v0)
  9702  		return true
  9703  	}
  9704  	// match: (RSBshiftRAreg x y (MOVWconst [c]))
  9705  	// cond: 0 <= c && c < 32
  9706  	// result: (RSBshiftRA x y [c])
  9707  	for {
  9708  		x := v_0
  9709  		y := v_1
  9710  		if v_2.Op != OpARMMOVWconst {
  9711  			break
  9712  		}
  9713  		c := auxIntToInt32(v_2.AuxInt)
  9714  		if !(0 <= c && c < 32) {
  9715  			break
  9716  		}
  9717  		v.reset(OpARMRSBshiftRA)
  9718  		v.AuxInt = int32ToAuxInt(c)
  9719  		v.AddArg2(x, y)
  9720  		return true
  9721  	}
  9722  	return false
  9723  }
  9724  func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool {
  9725  	v_1 := v.Args[1]
  9726  	v_0 := v.Args[0]
  9727  	b := v.Block
  9728  	// match: (RSBshiftRL (MOVWconst [c]) x [d])
  9729  	// result: (SUBconst [c] (SRLconst <x.Type> x [d]))
  9730  	for {
  9731  		d := auxIntToInt32(v.AuxInt)
  9732  		if v_0.Op != OpARMMOVWconst {
  9733  			break
  9734  		}
  9735  		c := auxIntToInt32(v_0.AuxInt)
  9736  		x := v_1
  9737  		v.reset(OpARMSUBconst)
  9738  		v.AuxInt = int32ToAuxInt(c)
  9739  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
  9740  		v0.AuxInt = int32ToAuxInt(d)
  9741  		v0.AddArg(x)
  9742  		v.AddArg(v0)
  9743  		return true
  9744  	}
  9745  	// match: (RSBshiftRL x (MOVWconst [c]) [d])
  9746  	// result: (RSBconst x [int32(uint32(c)>>uint64(d))])
  9747  	for {
  9748  		d := auxIntToInt32(v.AuxInt)
  9749  		x := v_0
  9750  		if v_1.Op != OpARMMOVWconst {
  9751  			break
  9752  		}
  9753  		c := auxIntToInt32(v_1.AuxInt)
  9754  		v.reset(OpARMRSBconst)
  9755  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
  9756  		v.AddArg(x)
  9757  		return true
  9758  	}
  9759  	// match: (RSBshiftRL (SRLconst x [c]) x [c])
  9760  	// result: (MOVWconst [0])
  9761  	for {
  9762  		c := auxIntToInt32(v.AuxInt)
  9763  		if v_0.Op != OpARMSRLconst || auxIntToInt32(v_0.AuxInt) != c {
  9764  			break
  9765  		}
  9766  		x := v_0.Args[0]
  9767  		if x != v_1 {
  9768  			break
  9769  		}
  9770  		v.reset(OpARMMOVWconst)
  9771  		v.AuxInt = int32ToAuxInt(0)
  9772  		return true
  9773  	}
  9774  	return false
  9775  }
  9776  func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool {
  9777  	v_2 := v.Args[2]
  9778  	v_1 := v.Args[1]
  9779  	v_0 := v.Args[0]
  9780  	b := v.Block
  9781  	// match: (RSBshiftRLreg (MOVWconst [c]) x y)
  9782  	// result: (SUBconst [c] (SRL <x.Type> x y))
  9783  	for {
  9784  		if v_0.Op != OpARMMOVWconst {
  9785  			break
  9786  		}
  9787  		c := auxIntToInt32(v_0.AuxInt)
  9788  		x := v_1
  9789  		y := v_2
  9790  		v.reset(OpARMSUBconst)
  9791  		v.AuxInt = int32ToAuxInt(c)
  9792  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
  9793  		v0.AddArg2(x, y)
  9794  		v.AddArg(v0)
  9795  		return true
  9796  	}
  9797  	// match: (RSBshiftRLreg x y (MOVWconst [c]))
  9798  	// cond: 0 <= c && c < 32
  9799  	// result: (RSBshiftRL x y [c])
  9800  	for {
  9801  		x := v_0
  9802  		y := v_1
  9803  		if v_2.Op != OpARMMOVWconst {
  9804  			break
  9805  		}
  9806  		c := auxIntToInt32(v_2.AuxInt)
  9807  		if !(0 <= c && c < 32) {
  9808  			break
  9809  		}
  9810  		v.reset(OpARMRSBshiftRL)
  9811  		v.AuxInt = int32ToAuxInt(c)
  9812  		v.AddArg2(x, y)
  9813  		return true
  9814  	}
  9815  	return false
  9816  }
  9817  func rewriteValueARM_OpARMRSCconst(v *Value) bool {
  9818  	v_1 := v.Args[1]
  9819  	v_0 := v.Args[0]
  9820  	// match: (RSCconst [c] (ADDconst [d] x) flags)
  9821  	// result: (RSCconst [c-d] x flags)
  9822  	for {
  9823  		c := auxIntToInt32(v.AuxInt)
  9824  		if v_0.Op != OpARMADDconst {
  9825  			break
  9826  		}
  9827  		d := auxIntToInt32(v_0.AuxInt)
  9828  		x := v_0.Args[0]
  9829  		flags := v_1
  9830  		v.reset(OpARMRSCconst)
  9831  		v.AuxInt = int32ToAuxInt(c - d)
  9832  		v.AddArg2(x, flags)
  9833  		return true
  9834  	}
  9835  	// match: (RSCconst [c] (SUBconst [d] x) flags)
  9836  	// result: (RSCconst [c+d] x flags)
  9837  	for {
  9838  		c := auxIntToInt32(v.AuxInt)
  9839  		if v_0.Op != OpARMSUBconst {
  9840  			break
  9841  		}
  9842  		d := auxIntToInt32(v_0.AuxInt)
  9843  		x := v_0.Args[0]
  9844  		flags := v_1
  9845  		v.reset(OpARMRSCconst)
  9846  		v.AuxInt = int32ToAuxInt(c + d)
  9847  		v.AddArg2(x, flags)
  9848  		return true
  9849  	}
  9850  	return false
  9851  }
  9852  func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool {
  9853  	v_2 := v.Args[2]
  9854  	v_1 := v.Args[1]
  9855  	v_0 := v.Args[0]
  9856  	b := v.Block
  9857  	// match: (RSCshiftLL (MOVWconst [c]) x [d] flags)
  9858  	// result: (SBCconst [c] (SLLconst <x.Type> x [d]) flags)
  9859  	for {
  9860  		d := auxIntToInt32(v.AuxInt)
  9861  		if v_0.Op != OpARMMOVWconst {
  9862  			break
  9863  		}
  9864  		c := auxIntToInt32(v_0.AuxInt)
  9865  		x := v_1
  9866  		flags := v_2
  9867  		v.reset(OpARMSBCconst)
  9868  		v.AuxInt = int32ToAuxInt(c)
  9869  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
  9870  		v0.AuxInt = int32ToAuxInt(d)
  9871  		v0.AddArg(x)
  9872  		v.AddArg2(v0, flags)
  9873  		return true
  9874  	}
  9875  	// match: (RSCshiftLL x (MOVWconst [c]) [d] flags)
  9876  	// result: (RSCconst x [c<<uint64(d)] flags)
  9877  	for {
  9878  		d := auxIntToInt32(v.AuxInt)
  9879  		x := v_0
  9880  		if v_1.Op != OpARMMOVWconst {
  9881  			break
  9882  		}
  9883  		c := auxIntToInt32(v_1.AuxInt)
  9884  		flags := v_2
  9885  		v.reset(OpARMRSCconst)
  9886  		v.AuxInt = int32ToAuxInt(c << uint64(d))
  9887  		v.AddArg2(x, flags)
  9888  		return true
  9889  	}
  9890  	return false
  9891  }
  9892  func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool {
  9893  	v_3 := v.Args[3]
  9894  	v_2 := v.Args[2]
  9895  	v_1 := v.Args[1]
  9896  	v_0 := v.Args[0]
  9897  	b := v.Block
  9898  	// match: (RSCshiftLLreg (MOVWconst [c]) x y flags)
  9899  	// result: (SBCconst [c] (SLL <x.Type> x y) flags)
  9900  	for {
  9901  		if v_0.Op != OpARMMOVWconst {
  9902  			break
  9903  		}
  9904  		c := auxIntToInt32(v_0.AuxInt)
  9905  		x := v_1
  9906  		y := v_2
  9907  		flags := v_3
  9908  		v.reset(OpARMSBCconst)
  9909  		v.AuxInt = int32ToAuxInt(c)
  9910  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
  9911  		v0.AddArg2(x, y)
  9912  		v.AddArg2(v0, flags)
  9913  		return true
  9914  	}
  9915  	// match: (RSCshiftLLreg x y (MOVWconst [c]) flags)
  9916  	// cond: 0 <= c && c < 32
  9917  	// result: (RSCshiftLL x y [c] flags)
  9918  	for {
  9919  		x := v_0
  9920  		y := v_1
  9921  		if v_2.Op != OpARMMOVWconst {
  9922  			break
  9923  		}
  9924  		c := auxIntToInt32(v_2.AuxInt)
  9925  		flags := v_3
  9926  		if !(0 <= c && c < 32) {
  9927  			break
  9928  		}
  9929  		v.reset(OpARMRSCshiftLL)
  9930  		v.AuxInt = int32ToAuxInt(c)
  9931  		v.AddArg3(x, y, flags)
  9932  		return true
  9933  	}
  9934  	return false
  9935  }
  9936  func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool {
  9937  	v_2 := v.Args[2]
  9938  	v_1 := v.Args[1]
  9939  	v_0 := v.Args[0]
  9940  	b := v.Block
  9941  	// match: (RSCshiftRA (MOVWconst [c]) x [d] flags)
  9942  	// result: (SBCconst [c] (SRAconst <x.Type> x [d]) flags)
  9943  	for {
  9944  		d := auxIntToInt32(v.AuxInt)
  9945  		if v_0.Op != OpARMMOVWconst {
  9946  			break
  9947  		}
  9948  		c := auxIntToInt32(v_0.AuxInt)
  9949  		x := v_1
  9950  		flags := v_2
  9951  		v.reset(OpARMSBCconst)
  9952  		v.AuxInt = int32ToAuxInt(c)
  9953  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
  9954  		v0.AuxInt = int32ToAuxInt(d)
  9955  		v0.AddArg(x)
  9956  		v.AddArg2(v0, flags)
  9957  		return true
  9958  	}
  9959  	// match: (RSCshiftRA x (MOVWconst [c]) [d] flags)
  9960  	// result: (RSCconst x [c>>uint64(d)] flags)
  9961  	for {
  9962  		d := auxIntToInt32(v.AuxInt)
  9963  		x := v_0
  9964  		if v_1.Op != OpARMMOVWconst {
  9965  			break
  9966  		}
  9967  		c := auxIntToInt32(v_1.AuxInt)
  9968  		flags := v_2
  9969  		v.reset(OpARMRSCconst)
  9970  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
  9971  		v.AddArg2(x, flags)
  9972  		return true
  9973  	}
  9974  	return false
  9975  }
  9976  func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool {
  9977  	v_3 := v.Args[3]
  9978  	v_2 := v.Args[2]
  9979  	v_1 := v.Args[1]
  9980  	v_0 := v.Args[0]
  9981  	b := v.Block
  9982  	// match: (RSCshiftRAreg (MOVWconst [c]) x y flags)
  9983  	// result: (SBCconst [c] (SRA <x.Type> x y) flags)
  9984  	for {
  9985  		if v_0.Op != OpARMMOVWconst {
  9986  			break
  9987  		}
  9988  		c := auxIntToInt32(v_0.AuxInt)
  9989  		x := v_1
  9990  		y := v_2
  9991  		flags := v_3
  9992  		v.reset(OpARMSBCconst)
  9993  		v.AuxInt = int32ToAuxInt(c)
  9994  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
  9995  		v0.AddArg2(x, y)
  9996  		v.AddArg2(v0, flags)
  9997  		return true
  9998  	}
  9999  	// match: (RSCshiftRAreg x y (MOVWconst [c]) flags)
 10000  	// cond: 0 <= c && c < 32
 10001  	// result: (RSCshiftRA x y [c] flags)
 10002  	for {
 10003  		x := v_0
 10004  		y := v_1
 10005  		if v_2.Op != OpARMMOVWconst {
 10006  			break
 10007  		}
 10008  		c := auxIntToInt32(v_2.AuxInt)
 10009  		flags := v_3
 10010  		if !(0 <= c && c < 32) {
 10011  			break
 10012  		}
 10013  		v.reset(OpARMRSCshiftRA)
 10014  		v.AuxInt = int32ToAuxInt(c)
 10015  		v.AddArg3(x, y, flags)
 10016  		return true
 10017  	}
 10018  	return false
 10019  }
 10020  func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool {
 10021  	v_2 := v.Args[2]
 10022  	v_1 := v.Args[1]
 10023  	v_0 := v.Args[0]
 10024  	b := v.Block
 10025  	// match: (RSCshiftRL (MOVWconst [c]) x [d] flags)
 10026  	// result: (SBCconst [c] (SRLconst <x.Type> x [d]) flags)
 10027  	for {
 10028  		d := auxIntToInt32(v.AuxInt)
 10029  		if v_0.Op != OpARMMOVWconst {
 10030  			break
 10031  		}
 10032  		c := auxIntToInt32(v_0.AuxInt)
 10033  		x := v_1
 10034  		flags := v_2
 10035  		v.reset(OpARMSBCconst)
 10036  		v.AuxInt = int32ToAuxInt(c)
 10037  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 10038  		v0.AuxInt = int32ToAuxInt(d)
 10039  		v0.AddArg(x)
 10040  		v.AddArg2(v0, flags)
 10041  		return true
 10042  	}
 10043  	// match: (RSCshiftRL x (MOVWconst [c]) [d] flags)
 10044  	// result: (RSCconst x [int32(uint32(c)>>uint64(d))] flags)
 10045  	for {
 10046  		d := auxIntToInt32(v.AuxInt)
 10047  		x := v_0
 10048  		if v_1.Op != OpARMMOVWconst {
 10049  			break
 10050  		}
 10051  		c := auxIntToInt32(v_1.AuxInt)
 10052  		flags := v_2
 10053  		v.reset(OpARMRSCconst)
 10054  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 10055  		v.AddArg2(x, flags)
 10056  		return true
 10057  	}
 10058  	return false
 10059  }
 10060  func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool {
 10061  	v_3 := v.Args[3]
 10062  	v_2 := v.Args[2]
 10063  	v_1 := v.Args[1]
 10064  	v_0 := v.Args[0]
 10065  	b := v.Block
 10066  	// match: (RSCshiftRLreg (MOVWconst [c]) x y flags)
 10067  	// result: (SBCconst [c] (SRL <x.Type> x y) flags)
 10068  	for {
 10069  		if v_0.Op != OpARMMOVWconst {
 10070  			break
 10071  		}
 10072  		c := auxIntToInt32(v_0.AuxInt)
 10073  		x := v_1
 10074  		y := v_2
 10075  		flags := v_3
 10076  		v.reset(OpARMSBCconst)
 10077  		v.AuxInt = int32ToAuxInt(c)
 10078  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 10079  		v0.AddArg2(x, y)
 10080  		v.AddArg2(v0, flags)
 10081  		return true
 10082  	}
 10083  	// match: (RSCshiftRLreg x y (MOVWconst [c]) flags)
 10084  	// cond: 0 <= c && c < 32
 10085  	// result: (RSCshiftRL x y [c] flags)
 10086  	for {
 10087  		x := v_0
 10088  		y := v_1
 10089  		if v_2.Op != OpARMMOVWconst {
 10090  			break
 10091  		}
 10092  		c := auxIntToInt32(v_2.AuxInt)
 10093  		flags := v_3
 10094  		if !(0 <= c && c < 32) {
 10095  			break
 10096  		}
 10097  		v.reset(OpARMRSCshiftRL)
 10098  		v.AuxInt = int32ToAuxInt(c)
 10099  		v.AddArg3(x, y, flags)
 10100  		return true
 10101  	}
 10102  	return false
 10103  }
 10104  func rewriteValueARM_OpARMSBC(v *Value) bool {
 10105  	v_2 := v.Args[2]
 10106  	v_1 := v.Args[1]
 10107  	v_0 := v.Args[0]
 10108  	// match: (SBC (MOVWconst [c]) x flags)
 10109  	// result: (RSCconst [c] x flags)
 10110  	for {
 10111  		if v_0.Op != OpARMMOVWconst {
 10112  			break
 10113  		}
 10114  		c := auxIntToInt32(v_0.AuxInt)
 10115  		x := v_1
 10116  		flags := v_2
 10117  		v.reset(OpARMRSCconst)
 10118  		v.AuxInt = int32ToAuxInt(c)
 10119  		v.AddArg2(x, flags)
 10120  		return true
 10121  	}
 10122  	// match: (SBC x (MOVWconst [c]) flags)
 10123  	// result: (SBCconst [c] x flags)
 10124  	for {
 10125  		x := v_0
 10126  		if v_1.Op != OpARMMOVWconst {
 10127  			break
 10128  		}
 10129  		c := auxIntToInt32(v_1.AuxInt)
 10130  		flags := v_2
 10131  		v.reset(OpARMSBCconst)
 10132  		v.AuxInt = int32ToAuxInt(c)
 10133  		v.AddArg2(x, flags)
 10134  		return true
 10135  	}
 10136  	// match: (SBC x (SLLconst [c] y) flags)
 10137  	// result: (SBCshiftLL x y [c] flags)
 10138  	for {
 10139  		x := v_0
 10140  		if v_1.Op != OpARMSLLconst {
 10141  			break
 10142  		}
 10143  		c := auxIntToInt32(v_1.AuxInt)
 10144  		y := v_1.Args[0]
 10145  		flags := v_2
 10146  		v.reset(OpARMSBCshiftLL)
 10147  		v.AuxInt = int32ToAuxInt(c)
 10148  		v.AddArg3(x, y, flags)
 10149  		return true
 10150  	}
 10151  	// match: (SBC (SLLconst [c] y) x flags)
 10152  	// result: (RSCshiftLL x y [c] flags)
 10153  	for {
 10154  		if v_0.Op != OpARMSLLconst {
 10155  			break
 10156  		}
 10157  		c := auxIntToInt32(v_0.AuxInt)
 10158  		y := v_0.Args[0]
 10159  		x := v_1
 10160  		flags := v_2
 10161  		v.reset(OpARMRSCshiftLL)
 10162  		v.AuxInt = int32ToAuxInt(c)
 10163  		v.AddArg3(x, y, flags)
 10164  		return true
 10165  	}
 10166  	// match: (SBC x (SRLconst [c] y) flags)
 10167  	// result: (SBCshiftRL x y [c] flags)
 10168  	for {
 10169  		x := v_0
 10170  		if v_1.Op != OpARMSRLconst {
 10171  			break
 10172  		}
 10173  		c := auxIntToInt32(v_1.AuxInt)
 10174  		y := v_1.Args[0]
 10175  		flags := v_2
 10176  		v.reset(OpARMSBCshiftRL)
 10177  		v.AuxInt = int32ToAuxInt(c)
 10178  		v.AddArg3(x, y, flags)
 10179  		return true
 10180  	}
 10181  	// match: (SBC (SRLconst [c] y) x flags)
 10182  	// result: (RSCshiftRL x y [c] flags)
 10183  	for {
 10184  		if v_0.Op != OpARMSRLconst {
 10185  			break
 10186  		}
 10187  		c := auxIntToInt32(v_0.AuxInt)
 10188  		y := v_0.Args[0]
 10189  		x := v_1
 10190  		flags := v_2
 10191  		v.reset(OpARMRSCshiftRL)
 10192  		v.AuxInt = int32ToAuxInt(c)
 10193  		v.AddArg3(x, y, flags)
 10194  		return true
 10195  	}
 10196  	// match: (SBC x (SRAconst [c] y) flags)
 10197  	// result: (SBCshiftRA x y [c] flags)
 10198  	for {
 10199  		x := v_0
 10200  		if v_1.Op != OpARMSRAconst {
 10201  			break
 10202  		}
 10203  		c := auxIntToInt32(v_1.AuxInt)
 10204  		y := v_1.Args[0]
 10205  		flags := v_2
 10206  		v.reset(OpARMSBCshiftRA)
 10207  		v.AuxInt = int32ToAuxInt(c)
 10208  		v.AddArg3(x, y, flags)
 10209  		return true
 10210  	}
 10211  	// match: (SBC (SRAconst [c] y) x flags)
 10212  	// result: (RSCshiftRA x y [c] flags)
 10213  	for {
 10214  		if v_0.Op != OpARMSRAconst {
 10215  			break
 10216  		}
 10217  		c := auxIntToInt32(v_0.AuxInt)
 10218  		y := v_0.Args[0]
 10219  		x := v_1
 10220  		flags := v_2
 10221  		v.reset(OpARMRSCshiftRA)
 10222  		v.AuxInt = int32ToAuxInt(c)
 10223  		v.AddArg3(x, y, flags)
 10224  		return true
 10225  	}
 10226  	// match: (SBC x (SLL y z) flags)
 10227  	// result: (SBCshiftLLreg x y z flags)
 10228  	for {
 10229  		x := v_0
 10230  		if v_1.Op != OpARMSLL {
 10231  			break
 10232  		}
 10233  		z := v_1.Args[1]
 10234  		y := v_1.Args[0]
 10235  		flags := v_2
 10236  		v.reset(OpARMSBCshiftLLreg)
 10237  		v.AddArg4(x, y, z, flags)
 10238  		return true
 10239  	}
 10240  	// match: (SBC (SLL y z) x flags)
 10241  	// result: (RSCshiftLLreg x y z flags)
 10242  	for {
 10243  		if v_0.Op != OpARMSLL {
 10244  			break
 10245  		}
 10246  		z := v_0.Args[1]
 10247  		y := v_0.Args[0]
 10248  		x := v_1
 10249  		flags := v_2
 10250  		v.reset(OpARMRSCshiftLLreg)
 10251  		v.AddArg4(x, y, z, flags)
 10252  		return true
 10253  	}
 10254  	// match: (SBC x (SRL y z) flags)
 10255  	// result: (SBCshiftRLreg x y z flags)
 10256  	for {
 10257  		x := v_0
 10258  		if v_1.Op != OpARMSRL {
 10259  			break
 10260  		}
 10261  		z := v_1.Args[1]
 10262  		y := v_1.Args[0]
 10263  		flags := v_2
 10264  		v.reset(OpARMSBCshiftRLreg)
 10265  		v.AddArg4(x, y, z, flags)
 10266  		return true
 10267  	}
 10268  	// match: (SBC (SRL y z) x flags)
 10269  	// result: (RSCshiftRLreg x y z flags)
 10270  	for {
 10271  		if v_0.Op != OpARMSRL {
 10272  			break
 10273  		}
 10274  		z := v_0.Args[1]
 10275  		y := v_0.Args[0]
 10276  		x := v_1
 10277  		flags := v_2
 10278  		v.reset(OpARMRSCshiftRLreg)
 10279  		v.AddArg4(x, y, z, flags)
 10280  		return true
 10281  	}
 10282  	// match: (SBC x (SRA y z) flags)
 10283  	// result: (SBCshiftRAreg x y z flags)
 10284  	for {
 10285  		x := v_0
 10286  		if v_1.Op != OpARMSRA {
 10287  			break
 10288  		}
 10289  		z := v_1.Args[1]
 10290  		y := v_1.Args[0]
 10291  		flags := v_2
 10292  		v.reset(OpARMSBCshiftRAreg)
 10293  		v.AddArg4(x, y, z, flags)
 10294  		return true
 10295  	}
 10296  	// match: (SBC (SRA y z) x flags)
 10297  	// result: (RSCshiftRAreg x y z flags)
 10298  	for {
 10299  		if v_0.Op != OpARMSRA {
 10300  			break
 10301  		}
 10302  		z := v_0.Args[1]
 10303  		y := v_0.Args[0]
 10304  		x := v_1
 10305  		flags := v_2
 10306  		v.reset(OpARMRSCshiftRAreg)
 10307  		v.AddArg4(x, y, z, flags)
 10308  		return true
 10309  	}
 10310  	return false
 10311  }
 10312  func rewriteValueARM_OpARMSBCconst(v *Value) bool {
 10313  	v_1 := v.Args[1]
 10314  	v_0 := v.Args[0]
 10315  	// match: (SBCconst [c] (ADDconst [d] x) flags)
 10316  	// result: (SBCconst [c-d] x flags)
 10317  	for {
 10318  		c := auxIntToInt32(v.AuxInt)
 10319  		if v_0.Op != OpARMADDconst {
 10320  			break
 10321  		}
 10322  		d := auxIntToInt32(v_0.AuxInt)
 10323  		x := v_0.Args[0]
 10324  		flags := v_1
 10325  		v.reset(OpARMSBCconst)
 10326  		v.AuxInt = int32ToAuxInt(c - d)
 10327  		v.AddArg2(x, flags)
 10328  		return true
 10329  	}
 10330  	// match: (SBCconst [c] (SUBconst [d] x) flags)
 10331  	// result: (SBCconst [c+d] x flags)
 10332  	for {
 10333  		c := auxIntToInt32(v.AuxInt)
 10334  		if v_0.Op != OpARMSUBconst {
 10335  			break
 10336  		}
 10337  		d := auxIntToInt32(v_0.AuxInt)
 10338  		x := v_0.Args[0]
 10339  		flags := v_1
 10340  		v.reset(OpARMSBCconst)
 10341  		v.AuxInt = int32ToAuxInt(c + d)
 10342  		v.AddArg2(x, flags)
 10343  		return true
 10344  	}
 10345  	return false
 10346  }
 10347  func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool {
 10348  	v_2 := v.Args[2]
 10349  	v_1 := v.Args[1]
 10350  	v_0 := v.Args[0]
 10351  	b := v.Block
 10352  	// match: (SBCshiftLL (MOVWconst [c]) x [d] flags)
 10353  	// result: (RSCconst [c] (SLLconst <x.Type> x [d]) flags)
 10354  	for {
 10355  		d := auxIntToInt32(v.AuxInt)
 10356  		if v_0.Op != OpARMMOVWconst {
 10357  			break
 10358  		}
 10359  		c := auxIntToInt32(v_0.AuxInt)
 10360  		x := v_1
 10361  		flags := v_2
 10362  		v.reset(OpARMRSCconst)
 10363  		v.AuxInt = int32ToAuxInt(c)
 10364  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
 10365  		v0.AuxInt = int32ToAuxInt(d)
 10366  		v0.AddArg(x)
 10367  		v.AddArg2(v0, flags)
 10368  		return true
 10369  	}
 10370  	// match: (SBCshiftLL x (MOVWconst [c]) [d] flags)
 10371  	// result: (SBCconst x [c<<uint64(d)] flags)
 10372  	for {
 10373  		d := auxIntToInt32(v.AuxInt)
 10374  		x := v_0
 10375  		if v_1.Op != OpARMMOVWconst {
 10376  			break
 10377  		}
 10378  		c := auxIntToInt32(v_1.AuxInt)
 10379  		flags := v_2
 10380  		v.reset(OpARMSBCconst)
 10381  		v.AuxInt = int32ToAuxInt(c << uint64(d))
 10382  		v.AddArg2(x, flags)
 10383  		return true
 10384  	}
 10385  	return false
 10386  }
 10387  func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool {
 10388  	v_3 := v.Args[3]
 10389  	v_2 := v.Args[2]
 10390  	v_1 := v.Args[1]
 10391  	v_0 := v.Args[0]
 10392  	b := v.Block
 10393  	// match: (SBCshiftLLreg (MOVWconst [c]) x y flags)
 10394  	// result: (RSCconst [c] (SLL <x.Type> x y) flags)
 10395  	for {
 10396  		if v_0.Op != OpARMMOVWconst {
 10397  			break
 10398  		}
 10399  		c := auxIntToInt32(v_0.AuxInt)
 10400  		x := v_1
 10401  		y := v_2
 10402  		flags := v_3
 10403  		v.reset(OpARMRSCconst)
 10404  		v.AuxInt = int32ToAuxInt(c)
 10405  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 10406  		v0.AddArg2(x, y)
 10407  		v.AddArg2(v0, flags)
 10408  		return true
 10409  	}
 10410  	// match: (SBCshiftLLreg x y (MOVWconst [c]) flags)
 10411  	// cond: 0 <= c && c < 32
 10412  	// result: (SBCshiftLL x y [c] flags)
 10413  	for {
 10414  		x := v_0
 10415  		y := v_1
 10416  		if v_2.Op != OpARMMOVWconst {
 10417  			break
 10418  		}
 10419  		c := auxIntToInt32(v_2.AuxInt)
 10420  		flags := v_3
 10421  		if !(0 <= c && c < 32) {
 10422  			break
 10423  		}
 10424  		v.reset(OpARMSBCshiftLL)
 10425  		v.AuxInt = int32ToAuxInt(c)
 10426  		v.AddArg3(x, y, flags)
 10427  		return true
 10428  	}
 10429  	return false
 10430  }
 10431  func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool {
 10432  	v_2 := v.Args[2]
 10433  	v_1 := v.Args[1]
 10434  	v_0 := v.Args[0]
 10435  	b := v.Block
 10436  	// match: (SBCshiftRA (MOVWconst [c]) x [d] flags)
 10437  	// result: (RSCconst [c] (SRAconst <x.Type> x [d]) flags)
 10438  	for {
 10439  		d := auxIntToInt32(v.AuxInt)
 10440  		if v_0.Op != OpARMMOVWconst {
 10441  			break
 10442  		}
 10443  		c := auxIntToInt32(v_0.AuxInt)
 10444  		x := v_1
 10445  		flags := v_2
 10446  		v.reset(OpARMRSCconst)
 10447  		v.AuxInt = int32ToAuxInt(c)
 10448  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
 10449  		v0.AuxInt = int32ToAuxInt(d)
 10450  		v0.AddArg(x)
 10451  		v.AddArg2(v0, flags)
 10452  		return true
 10453  	}
 10454  	// match: (SBCshiftRA x (MOVWconst [c]) [d] flags)
 10455  	// result: (SBCconst x [c>>uint64(d)] flags)
 10456  	for {
 10457  		d := auxIntToInt32(v.AuxInt)
 10458  		x := v_0
 10459  		if v_1.Op != OpARMMOVWconst {
 10460  			break
 10461  		}
 10462  		c := auxIntToInt32(v_1.AuxInt)
 10463  		flags := v_2
 10464  		v.reset(OpARMSBCconst)
 10465  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
 10466  		v.AddArg2(x, flags)
 10467  		return true
 10468  	}
 10469  	return false
 10470  }
 10471  func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool {
 10472  	v_3 := v.Args[3]
 10473  	v_2 := v.Args[2]
 10474  	v_1 := v.Args[1]
 10475  	v_0 := v.Args[0]
 10476  	b := v.Block
 10477  	// match: (SBCshiftRAreg (MOVWconst [c]) x y flags)
 10478  	// result: (RSCconst [c] (SRA <x.Type> x y) flags)
 10479  	for {
 10480  		if v_0.Op != OpARMMOVWconst {
 10481  			break
 10482  		}
 10483  		c := auxIntToInt32(v_0.AuxInt)
 10484  		x := v_1
 10485  		y := v_2
 10486  		flags := v_3
 10487  		v.reset(OpARMRSCconst)
 10488  		v.AuxInt = int32ToAuxInt(c)
 10489  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
 10490  		v0.AddArg2(x, y)
 10491  		v.AddArg2(v0, flags)
 10492  		return true
 10493  	}
 10494  	// match: (SBCshiftRAreg x y (MOVWconst [c]) flags)
 10495  	// cond: 0 <= c && c < 32
 10496  	// result: (SBCshiftRA x y [c] flags)
 10497  	for {
 10498  		x := v_0
 10499  		y := v_1
 10500  		if v_2.Op != OpARMMOVWconst {
 10501  			break
 10502  		}
 10503  		c := auxIntToInt32(v_2.AuxInt)
 10504  		flags := v_3
 10505  		if !(0 <= c && c < 32) {
 10506  			break
 10507  		}
 10508  		v.reset(OpARMSBCshiftRA)
 10509  		v.AuxInt = int32ToAuxInt(c)
 10510  		v.AddArg3(x, y, flags)
 10511  		return true
 10512  	}
 10513  	return false
 10514  }
 10515  func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool {
 10516  	v_2 := v.Args[2]
 10517  	v_1 := v.Args[1]
 10518  	v_0 := v.Args[0]
 10519  	b := v.Block
 10520  	// match: (SBCshiftRL (MOVWconst [c]) x [d] flags)
 10521  	// result: (RSCconst [c] (SRLconst <x.Type> x [d]) flags)
 10522  	for {
 10523  		d := auxIntToInt32(v.AuxInt)
 10524  		if v_0.Op != OpARMMOVWconst {
 10525  			break
 10526  		}
 10527  		c := auxIntToInt32(v_0.AuxInt)
 10528  		x := v_1
 10529  		flags := v_2
 10530  		v.reset(OpARMRSCconst)
 10531  		v.AuxInt = int32ToAuxInt(c)
 10532  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 10533  		v0.AuxInt = int32ToAuxInt(d)
 10534  		v0.AddArg(x)
 10535  		v.AddArg2(v0, flags)
 10536  		return true
 10537  	}
 10538  	// match: (SBCshiftRL x (MOVWconst [c]) [d] flags)
 10539  	// result: (SBCconst x [int32(uint32(c)>>uint64(d))] flags)
 10540  	for {
 10541  		d := auxIntToInt32(v.AuxInt)
 10542  		x := v_0
 10543  		if v_1.Op != OpARMMOVWconst {
 10544  			break
 10545  		}
 10546  		c := auxIntToInt32(v_1.AuxInt)
 10547  		flags := v_2
 10548  		v.reset(OpARMSBCconst)
 10549  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 10550  		v.AddArg2(x, flags)
 10551  		return true
 10552  	}
 10553  	return false
 10554  }
 10555  func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool {
 10556  	v_3 := v.Args[3]
 10557  	v_2 := v.Args[2]
 10558  	v_1 := v.Args[1]
 10559  	v_0 := v.Args[0]
 10560  	b := v.Block
 10561  	// match: (SBCshiftRLreg (MOVWconst [c]) x y flags)
 10562  	// result: (RSCconst [c] (SRL <x.Type> x y) flags)
 10563  	for {
 10564  		if v_0.Op != OpARMMOVWconst {
 10565  			break
 10566  		}
 10567  		c := auxIntToInt32(v_0.AuxInt)
 10568  		x := v_1
 10569  		y := v_2
 10570  		flags := v_3
 10571  		v.reset(OpARMRSCconst)
 10572  		v.AuxInt = int32ToAuxInt(c)
 10573  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 10574  		v0.AddArg2(x, y)
 10575  		v.AddArg2(v0, flags)
 10576  		return true
 10577  	}
 10578  	// match: (SBCshiftRLreg x y (MOVWconst [c]) flags)
 10579  	// cond: 0 <= c && c < 32
 10580  	// result: (SBCshiftRL x y [c] flags)
 10581  	for {
 10582  		x := v_0
 10583  		y := v_1
 10584  		if v_2.Op != OpARMMOVWconst {
 10585  			break
 10586  		}
 10587  		c := auxIntToInt32(v_2.AuxInt)
 10588  		flags := v_3
 10589  		if !(0 <= c && c < 32) {
 10590  			break
 10591  		}
 10592  		v.reset(OpARMSBCshiftRL)
 10593  		v.AuxInt = int32ToAuxInt(c)
 10594  		v.AddArg3(x, y, flags)
 10595  		return true
 10596  	}
 10597  	return false
 10598  }
 10599  func rewriteValueARM_OpARMSLL(v *Value) bool {
 10600  	v_1 := v.Args[1]
 10601  	v_0 := v.Args[0]
 10602  	// match: (SLL x (MOVWconst [c]))
 10603  	// cond: 0 <= c && c < 32
 10604  	// result: (SLLconst x [c])
 10605  	for {
 10606  		x := v_0
 10607  		if v_1.Op != OpARMMOVWconst {
 10608  			break
 10609  		}
 10610  		c := auxIntToInt32(v_1.AuxInt)
 10611  		if !(0 <= c && c < 32) {
 10612  			break
 10613  		}
 10614  		v.reset(OpARMSLLconst)
 10615  		v.AuxInt = int32ToAuxInt(c)
 10616  		v.AddArg(x)
 10617  		return true
 10618  	}
 10619  	return false
 10620  }
 10621  func rewriteValueARM_OpARMSLLconst(v *Value) bool {
 10622  	v_0 := v.Args[0]
 10623  	// match: (SLLconst [c] (MOVWconst [d]))
 10624  	// result: (MOVWconst [d<<uint64(c)])
 10625  	for {
 10626  		c := auxIntToInt32(v.AuxInt)
 10627  		if v_0.Op != OpARMMOVWconst {
 10628  			break
 10629  		}
 10630  		d := auxIntToInt32(v_0.AuxInt)
 10631  		v.reset(OpARMMOVWconst)
 10632  		v.AuxInt = int32ToAuxInt(d << uint64(c))
 10633  		return true
 10634  	}
 10635  	return false
 10636  }
 10637  func rewriteValueARM_OpARMSRA(v *Value) bool {
 10638  	v_1 := v.Args[1]
 10639  	v_0 := v.Args[0]
 10640  	// match: (SRA x (MOVWconst [c]))
 10641  	// cond: 0 <= c && c < 32
 10642  	// result: (SRAconst x [c])
 10643  	for {
 10644  		x := v_0
 10645  		if v_1.Op != OpARMMOVWconst {
 10646  			break
 10647  		}
 10648  		c := auxIntToInt32(v_1.AuxInt)
 10649  		if !(0 <= c && c < 32) {
 10650  			break
 10651  		}
 10652  		v.reset(OpARMSRAconst)
 10653  		v.AuxInt = int32ToAuxInt(c)
 10654  		v.AddArg(x)
 10655  		return true
 10656  	}
 10657  	return false
 10658  }
 10659  func rewriteValueARM_OpARMSRAcond(v *Value) bool {
 10660  	v_2 := v.Args[2]
 10661  	v_1 := v.Args[1]
 10662  	v_0 := v.Args[0]
 10663  	// match: (SRAcond x _ (FlagConstant [fc]))
 10664  	// cond: fc.uge()
 10665  	// result: (SRAconst x [31])
 10666  	for {
 10667  		x := v_0
 10668  		if v_2.Op != OpARMFlagConstant {
 10669  			break
 10670  		}
 10671  		fc := auxIntToFlagConstant(v_2.AuxInt)
 10672  		if !(fc.uge()) {
 10673  			break
 10674  		}
 10675  		v.reset(OpARMSRAconst)
 10676  		v.AuxInt = int32ToAuxInt(31)
 10677  		v.AddArg(x)
 10678  		return true
 10679  	}
 10680  	// match: (SRAcond x y (FlagConstant [fc]))
 10681  	// cond: fc.ult()
 10682  	// result: (SRA x y)
 10683  	for {
 10684  		x := v_0
 10685  		y := v_1
 10686  		if v_2.Op != OpARMFlagConstant {
 10687  			break
 10688  		}
 10689  		fc := auxIntToFlagConstant(v_2.AuxInt)
 10690  		if !(fc.ult()) {
 10691  			break
 10692  		}
 10693  		v.reset(OpARMSRA)
 10694  		v.AddArg2(x, y)
 10695  		return true
 10696  	}
 10697  	return false
 10698  }
 10699  func rewriteValueARM_OpARMSRAconst(v *Value) bool {
 10700  	v_0 := v.Args[0]
 10701  	// match: (SRAconst [c] (MOVWconst [d]))
 10702  	// result: (MOVWconst [d>>uint64(c)])
 10703  	for {
 10704  		c := auxIntToInt32(v.AuxInt)
 10705  		if v_0.Op != OpARMMOVWconst {
 10706  			break
 10707  		}
 10708  		d := auxIntToInt32(v_0.AuxInt)
 10709  		v.reset(OpARMMOVWconst)
 10710  		v.AuxInt = int32ToAuxInt(d >> uint64(c))
 10711  		return true
 10712  	}
 10713  	// match: (SRAconst (SLLconst x [c]) [d])
 10714  	// cond: buildcfg.GOARM.Version==7 && uint64(d)>=uint64(c) && uint64(d)<=31
 10715  	// result: (BFX [(d-c)|(32-d)<<8] x)
 10716  	for {
 10717  		d := auxIntToInt32(v.AuxInt)
 10718  		if v_0.Op != OpARMSLLconst {
 10719  			break
 10720  		}
 10721  		c := auxIntToInt32(v_0.AuxInt)
 10722  		x := v_0.Args[0]
 10723  		if !(buildcfg.GOARM.Version == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
 10724  			break
 10725  		}
 10726  		v.reset(OpARMBFX)
 10727  		v.AuxInt = int32ToAuxInt((d - c) | (32-d)<<8)
 10728  		v.AddArg(x)
 10729  		return true
 10730  	}
 10731  	return false
 10732  }
 10733  func rewriteValueARM_OpARMSRL(v *Value) bool {
 10734  	v_1 := v.Args[1]
 10735  	v_0 := v.Args[0]
 10736  	// match: (SRL x (MOVWconst [c]))
 10737  	// cond: 0 <= c && c < 32
 10738  	// result: (SRLconst x [c])
 10739  	for {
 10740  		x := v_0
 10741  		if v_1.Op != OpARMMOVWconst {
 10742  			break
 10743  		}
 10744  		c := auxIntToInt32(v_1.AuxInt)
 10745  		if !(0 <= c && c < 32) {
 10746  			break
 10747  		}
 10748  		v.reset(OpARMSRLconst)
 10749  		v.AuxInt = int32ToAuxInt(c)
 10750  		v.AddArg(x)
 10751  		return true
 10752  	}
 10753  	return false
 10754  }
 10755  func rewriteValueARM_OpARMSRLconst(v *Value) bool {
 10756  	v_0 := v.Args[0]
 10757  	// match: (SRLconst [c] (MOVWconst [d]))
 10758  	// result: (MOVWconst [int32(uint32(d)>>uint64(c))])
 10759  	for {
 10760  		c := auxIntToInt32(v.AuxInt)
 10761  		if v_0.Op != OpARMMOVWconst {
 10762  			break
 10763  		}
 10764  		d := auxIntToInt32(v_0.AuxInt)
 10765  		v.reset(OpARMMOVWconst)
 10766  		v.AuxInt = int32ToAuxInt(int32(uint32(d) >> uint64(c)))
 10767  		return true
 10768  	}
 10769  	// match: (SRLconst (SLLconst x [c]) [d])
 10770  	// cond: buildcfg.GOARM.Version==7 && uint64(d)>=uint64(c) && uint64(d)<=31
 10771  	// result: (BFXU [(d-c)|(32-d)<<8] x)
 10772  	for {
 10773  		d := auxIntToInt32(v.AuxInt)
 10774  		if v_0.Op != OpARMSLLconst {
 10775  			break
 10776  		}
 10777  		c := auxIntToInt32(v_0.AuxInt)
 10778  		x := v_0.Args[0]
 10779  		if !(buildcfg.GOARM.Version == 7 && uint64(d) >= uint64(c) && uint64(d) <= 31) {
 10780  			break
 10781  		}
 10782  		v.reset(OpARMBFXU)
 10783  		v.AuxInt = int32ToAuxInt((d - c) | (32-d)<<8)
 10784  		v.AddArg(x)
 10785  		return true
 10786  	}
 10787  	return false
 10788  }
 10789  func rewriteValueARM_OpARMSRR(v *Value) bool {
 10790  	v_1 := v.Args[1]
 10791  	v_0 := v.Args[0]
 10792  	// match: (SRR x (MOVWconst [c]))
 10793  	// result: (SRRconst x [c&31])
 10794  	for {
 10795  		x := v_0
 10796  		if v_1.Op != OpARMMOVWconst {
 10797  			break
 10798  		}
 10799  		c := auxIntToInt32(v_1.AuxInt)
 10800  		v.reset(OpARMSRRconst)
 10801  		v.AuxInt = int32ToAuxInt(c & 31)
 10802  		v.AddArg(x)
 10803  		return true
 10804  	}
 10805  	return false
 10806  }
 10807  func rewriteValueARM_OpARMSUB(v *Value) bool {
 10808  	v_1 := v.Args[1]
 10809  	v_0 := v.Args[0]
 10810  	// match: (SUB (MOVWconst [c]) x)
 10811  	// result: (RSBconst [c] x)
 10812  	for {
 10813  		if v_0.Op != OpARMMOVWconst {
 10814  			break
 10815  		}
 10816  		c := auxIntToInt32(v_0.AuxInt)
 10817  		x := v_1
 10818  		v.reset(OpARMRSBconst)
 10819  		v.AuxInt = int32ToAuxInt(c)
 10820  		v.AddArg(x)
 10821  		return true
 10822  	}
 10823  	// match: (SUB x (MOVWconst [c]))
 10824  	// result: (SUBconst [c] x)
 10825  	for {
 10826  		x := v_0
 10827  		if v_1.Op != OpARMMOVWconst {
 10828  			break
 10829  		}
 10830  		c := auxIntToInt32(v_1.AuxInt)
 10831  		v.reset(OpARMSUBconst)
 10832  		v.AuxInt = int32ToAuxInt(c)
 10833  		v.AddArg(x)
 10834  		return true
 10835  	}
 10836  	// match: (SUB x (SLLconst [c] y))
 10837  	// result: (SUBshiftLL x y [c])
 10838  	for {
 10839  		x := v_0
 10840  		if v_1.Op != OpARMSLLconst {
 10841  			break
 10842  		}
 10843  		c := auxIntToInt32(v_1.AuxInt)
 10844  		y := v_1.Args[0]
 10845  		v.reset(OpARMSUBshiftLL)
 10846  		v.AuxInt = int32ToAuxInt(c)
 10847  		v.AddArg2(x, y)
 10848  		return true
 10849  	}
 10850  	// match: (SUB (SLLconst [c] y) x)
 10851  	// result: (RSBshiftLL x y [c])
 10852  	for {
 10853  		if v_0.Op != OpARMSLLconst {
 10854  			break
 10855  		}
 10856  		c := auxIntToInt32(v_0.AuxInt)
 10857  		y := v_0.Args[0]
 10858  		x := v_1
 10859  		v.reset(OpARMRSBshiftLL)
 10860  		v.AuxInt = int32ToAuxInt(c)
 10861  		v.AddArg2(x, y)
 10862  		return true
 10863  	}
 10864  	// match: (SUB x (SRLconst [c] y))
 10865  	// result: (SUBshiftRL x y [c])
 10866  	for {
 10867  		x := v_0
 10868  		if v_1.Op != OpARMSRLconst {
 10869  			break
 10870  		}
 10871  		c := auxIntToInt32(v_1.AuxInt)
 10872  		y := v_1.Args[0]
 10873  		v.reset(OpARMSUBshiftRL)
 10874  		v.AuxInt = int32ToAuxInt(c)
 10875  		v.AddArg2(x, y)
 10876  		return true
 10877  	}
 10878  	// match: (SUB (SRLconst [c] y) x)
 10879  	// result: (RSBshiftRL x y [c])
 10880  	for {
 10881  		if v_0.Op != OpARMSRLconst {
 10882  			break
 10883  		}
 10884  		c := auxIntToInt32(v_0.AuxInt)
 10885  		y := v_0.Args[0]
 10886  		x := v_1
 10887  		v.reset(OpARMRSBshiftRL)
 10888  		v.AuxInt = int32ToAuxInt(c)
 10889  		v.AddArg2(x, y)
 10890  		return true
 10891  	}
 10892  	// match: (SUB x (SRAconst [c] y))
 10893  	// result: (SUBshiftRA x y [c])
 10894  	for {
 10895  		x := v_0
 10896  		if v_1.Op != OpARMSRAconst {
 10897  			break
 10898  		}
 10899  		c := auxIntToInt32(v_1.AuxInt)
 10900  		y := v_1.Args[0]
 10901  		v.reset(OpARMSUBshiftRA)
 10902  		v.AuxInt = int32ToAuxInt(c)
 10903  		v.AddArg2(x, y)
 10904  		return true
 10905  	}
 10906  	// match: (SUB (SRAconst [c] y) x)
 10907  	// result: (RSBshiftRA x y [c])
 10908  	for {
 10909  		if v_0.Op != OpARMSRAconst {
 10910  			break
 10911  		}
 10912  		c := auxIntToInt32(v_0.AuxInt)
 10913  		y := v_0.Args[0]
 10914  		x := v_1
 10915  		v.reset(OpARMRSBshiftRA)
 10916  		v.AuxInt = int32ToAuxInt(c)
 10917  		v.AddArg2(x, y)
 10918  		return true
 10919  	}
 10920  	// match: (SUB x (SLL y z))
 10921  	// result: (SUBshiftLLreg x y z)
 10922  	for {
 10923  		x := v_0
 10924  		if v_1.Op != OpARMSLL {
 10925  			break
 10926  		}
 10927  		z := v_1.Args[1]
 10928  		y := v_1.Args[0]
 10929  		v.reset(OpARMSUBshiftLLreg)
 10930  		v.AddArg3(x, y, z)
 10931  		return true
 10932  	}
 10933  	// match: (SUB (SLL y z) x)
 10934  	// result: (RSBshiftLLreg x y z)
 10935  	for {
 10936  		if v_0.Op != OpARMSLL {
 10937  			break
 10938  		}
 10939  		z := v_0.Args[1]
 10940  		y := v_0.Args[0]
 10941  		x := v_1
 10942  		v.reset(OpARMRSBshiftLLreg)
 10943  		v.AddArg3(x, y, z)
 10944  		return true
 10945  	}
 10946  	// match: (SUB x (SRL y z))
 10947  	// result: (SUBshiftRLreg x y z)
 10948  	for {
 10949  		x := v_0
 10950  		if v_1.Op != OpARMSRL {
 10951  			break
 10952  		}
 10953  		z := v_1.Args[1]
 10954  		y := v_1.Args[0]
 10955  		v.reset(OpARMSUBshiftRLreg)
 10956  		v.AddArg3(x, y, z)
 10957  		return true
 10958  	}
 10959  	// match: (SUB (SRL y z) x)
 10960  	// result: (RSBshiftRLreg x y z)
 10961  	for {
 10962  		if v_0.Op != OpARMSRL {
 10963  			break
 10964  		}
 10965  		z := v_0.Args[1]
 10966  		y := v_0.Args[0]
 10967  		x := v_1
 10968  		v.reset(OpARMRSBshiftRLreg)
 10969  		v.AddArg3(x, y, z)
 10970  		return true
 10971  	}
 10972  	// match: (SUB x (SRA y z))
 10973  	// result: (SUBshiftRAreg x y z)
 10974  	for {
 10975  		x := v_0
 10976  		if v_1.Op != OpARMSRA {
 10977  			break
 10978  		}
 10979  		z := v_1.Args[1]
 10980  		y := v_1.Args[0]
 10981  		v.reset(OpARMSUBshiftRAreg)
 10982  		v.AddArg3(x, y, z)
 10983  		return true
 10984  	}
 10985  	// match: (SUB (SRA y z) x)
 10986  	// result: (RSBshiftRAreg x y z)
 10987  	for {
 10988  		if v_0.Op != OpARMSRA {
 10989  			break
 10990  		}
 10991  		z := v_0.Args[1]
 10992  		y := v_0.Args[0]
 10993  		x := v_1
 10994  		v.reset(OpARMRSBshiftRAreg)
 10995  		v.AddArg3(x, y, z)
 10996  		return true
 10997  	}
 10998  	// match: (SUB x x)
 10999  	// result: (MOVWconst [0])
 11000  	for {
 11001  		x := v_0
 11002  		if x != v_1 {
 11003  			break
 11004  		}
 11005  		v.reset(OpARMMOVWconst)
 11006  		v.AuxInt = int32ToAuxInt(0)
 11007  		return true
 11008  	}
 11009  	// match: (SUB a (MUL x y))
 11010  	// cond: buildcfg.GOARM.Version == 7
 11011  	// result: (MULS x y a)
 11012  	for {
 11013  		a := v_0
 11014  		if v_1.Op != OpARMMUL {
 11015  			break
 11016  		}
 11017  		y := v_1.Args[1]
 11018  		x := v_1.Args[0]
 11019  		if !(buildcfg.GOARM.Version == 7) {
 11020  			break
 11021  		}
 11022  		v.reset(OpARMMULS)
 11023  		v.AddArg3(x, y, a)
 11024  		return true
 11025  	}
 11026  	return false
 11027  }
 11028  func rewriteValueARM_OpARMSUBD(v *Value) bool {
 11029  	v_1 := v.Args[1]
 11030  	v_0 := v.Args[0]
 11031  	// match: (SUBD a (MULD x y))
 11032  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
 11033  	// result: (MULSD a x y)
 11034  	for {
 11035  		a := v_0
 11036  		if v_1.Op != OpARMMULD {
 11037  			break
 11038  		}
 11039  		y := v_1.Args[1]
 11040  		x := v_1.Args[0]
 11041  		if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
 11042  			break
 11043  		}
 11044  		v.reset(OpARMMULSD)
 11045  		v.AddArg3(a, x, y)
 11046  		return true
 11047  	}
 11048  	// match: (SUBD a (NMULD x y))
 11049  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
 11050  	// result: (MULAD a x y)
 11051  	for {
 11052  		a := v_0
 11053  		if v_1.Op != OpARMNMULD {
 11054  			break
 11055  		}
 11056  		y := v_1.Args[1]
 11057  		x := v_1.Args[0]
 11058  		if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
 11059  			break
 11060  		}
 11061  		v.reset(OpARMMULAD)
 11062  		v.AddArg3(a, x, y)
 11063  		return true
 11064  	}
 11065  	return false
 11066  }
 11067  func rewriteValueARM_OpARMSUBF(v *Value) bool {
 11068  	v_1 := v.Args[1]
 11069  	v_0 := v.Args[0]
 11070  	// match: (SUBF a (MULF x y))
 11071  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
 11072  	// result: (MULSF a x y)
 11073  	for {
 11074  		a := v_0
 11075  		if v_1.Op != OpARMMULF {
 11076  			break
 11077  		}
 11078  		y := v_1.Args[1]
 11079  		x := v_1.Args[0]
 11080  		if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
 11081  			break
 11082  		}
 11083  		v.reset(OpARMMULSF)
 11084  		v.AddArg3(a, x, y)
 11085  		return true
 11086  	}
 11087  	// match: (SUBF a (NMULF x y))
 11088  	// cond: a.Uses == 1 && buildcfg.GOARM.Version >= 6
 11089  	// result: (MULAF a x y)
 11090  	for {
 11091  		a := v_0
 11092  		if v_1.Op != OpARMNMULF {
 11093  			break
 11094  		}
 11095  		y := v_1.Args[1]
 11096  		x := v_1.Args[0]
 11097  		if !(a.Uses == 1 && buildcfg.GOARM.Version >= 6) {
 11098  			break
 11099  		}
 11100  		v.reset(OpARMMULAF)
 11101  		v.AddArg3(a, x, y)
 11102  		return true
 11103  	}
 11104  	return false
 11105  }
 11106  func rewriteValueARM_OpARMSUBS(v *Value) bool {
 11107  	v_1 := v.Args[1]
 11108  	v_0 := v.Args[0]
 11109  	// match: (SUBS x (MOVWconst [c]))
 11110  	// result: (SUBSconst [c] x)
 11111  	for {
 11112  		x := v_0
 11113  		if v_1.Op != OpARMMOVWconst {
 11114  			break
 11115  		}
 11116  		c := auxIntToInt32(v_1.AuxInt)
 11117  		v.reset(OpARMSUBSconst)
 11118  		v.AuxInt = int32ToAuxInt(c)
 11119  		v.AddArg(x)
 11120  		return true
 11121  	}
 11122  	// match: (SUBS x (SLLconst [c] y))
 11123  	// result: (SUBSshiftLL x y [c])
 11124  	for {
 11125  		x := v_0
 11126  		if v_1.Op != OpARMSLLconst {
 11127  			break
 11128  		}
 11129  		c := auxIntToInt32(v_1.AuxInt)
 11130  		y := v_1.Args[0]
 11131  		v.reset(OpARMSUBSshiftLL)
 11132  		v.AuxInt = int32ToAuxInt(c)
 11133  		v.AddArg2(x, y)
 11134  		return true
 11135  	}
 11136  	// match: (SUBS (SLLconst [c] y) x)
 11137  	// result: (RSBSshiftLL x y [c])
 11138  	for {
 11139  		if v_0.Op != OpARMSLLconst {
 11140  			break
 11141  		}
 11142  		c := auxIntToInt32(v_0.AuxInt)
 11143  		y := v_0.Args[0]
 11144  		x := v_1
 11145  		v.reset(OpARMRSBSshiftLL)
 11146  		v.AuxInt = int32ToAuxInt(c)
 11147  		v.AddArg2(x, y)
 11148  		return true
 11149  	}
 11150  	// match: (SUBS x (SRLconst [c] y))
 11151  	// result: (SUBSshiftRL x y [c])
 11152  	for {
 11153  		x := v_0
 11154  		if v_1.Op != OpARMSRLconst {
 11155  			break
 11156  		}
 11157  		c := auxIntToInt32(v_1.AuxInt)
 11158  		y := v_1.Args[0]
 11159  		v.reset(OpARMSUBSshiftRL)
 11160  		v.AuxInt = int32ToAuxInt(c)
 11161  		v.AddArg2(x, y)
 11162  		return true
 11163  	}
 11164  	// match: (SUBS (SRLconst [c] y) x)
 11165  	// result: (RSBSshiftRL x y [c])
 11166  	for {
 11167  		if v_0.Op != OpARMSRLconst {
 11168  			break
 11169  		}
 11170  		c := auxIntToInt32(v_0.AuxInt)
 11171  		y := v_0.Args[0]
 11172  		x := v_1
 11173  		v.reset(OpARMRSBSshiftRL)
 11174  		v.AuxInt = int32ToAuxInt(c)
 11175  		v.AddArg2(x, y)
 11176  		return true
 11177  	}
 11178  	// match: (SUBS x (SRAconst [c] y))
 11179  	// result: (SUBSshiftRA x y [c])
 11180  	for {
 11181  		x := v_0
 11182  		if v_1.Op != OpARMSRAconst {
 11183  			break
 11184  		}
 11185  		c := auxIntToInt32(v_1.AuxInt)
 11186  		y := v_1.Args[0]
 11187  		v.reset(OpARMSUBSshiftRA)
 11188  		v.AuxInt = int32ToAuxInt(c)
 11189  		v.AddArg2(x, y)
 11190  		return true
 11191  	}
 11192  	// match: (SUBS (SRAconst [c] y) x)
 11193  	// result: (RSBSshiftRA x y [c])
 11194  	for {
 11195  		if v_0.Op != OpARMSRAconst {
 11196  			break
 11197  		}
 11198  		c := auxIntToInt32(v_0.AuxInt)
 11199  		y := v_0.Args[0]
 11200  		x := v_1
 11201  		v.reset(OpARMRSBSshiftRA)
 11202  		v.AuxInt = int32ToAuxInt(c)
 11203  		v.AddArg2(x, y)
 11204  		return true
 11205  	}
 11206  	// match: (SUBS x (SLL y z))
 11207  	// result: (SUBSshiftLLreg x y z)
 11208  	for {
 11209  		x := v_0
 11210  		if v_1.Op != OpARMSLL {
 11211  			break
 11212  		}
 11213  		z := v_1.Args[1]
 11214  		y := v_1.Args[0]
 11215  		v.reset(OpARMSUBSshiftLLreg)
 11216  		v.AddArg3(x, y, z)
 11217  		return true
 11218  	}
 11219  	// match: (SUBS (SLL y z) x)
 11220  	// result: (RSBSshiftLLreg x y z)
 11221  	for {
 11222  		if v_0.Op != OpARMSLL {
 11223  			break
 11224  		}
 11225  		z := v_0.Args[1]
 11226  		y := v_0.Args[0]
 11227  		x := v_1
 11228  		v.reset(OpARMRSBSshiftLLreg)
 11229  		v.AddArg3(x, y, z)
 11230  		return true
 11231  	}
 11232  	// match: (SUBS x (SRL y z))
 11233  	// result: (SUBSshiftRLreg x y z)
 11234  	for {
 11235  		x := v_0
 11236  		if v_1.Op != OpARMSRL {
 11237  			break
 11238  		}
 11239  		z := v_1.Args[1]
 11240  		y := v_1.Args[0]
 11241  		v.reset(OpARMSUBSshiftRLreg)
 11242  		v.AddArg3(x, y, z)
 11243  		return true
 11244  	}
 11245  	// match: (SUBS (SRL y z) x)
 11246  	// result: (RSBSshiftRLreg x y z)
 11247  	for {
 11248  		if v_0.Op != OpARMSRL {
 11249  			break
 11250  		}
 11251  		z := v_0.Args[1]
 11252  		y := v_0.Args[0]
 11253  		x := v_1
 11254  		v.reset(OpARMRSBSshiftRLreg)
 11255  		v.AddArg3(x, y, z)
 11256  		return true
 11257  	}
 11258  	// match: (SUBS x (SRA y z))
 11259  	// result: (SUBSshiftRAreg x y z)
 11260  	for {
 11261  		x := v_0
 11262  		if v_1.Op != OpARMSRA {
 11263  			break
 11264  		}
 11265  		z := v_1.Args[1]
 11266  		y := v_1.Args[0]
 11267  		v.reset(OpARMSUBSshiftRAreg)
 11268  		v.AddArg3(x, y, z)
 11269  		return true
 11270  	}
 11271  	// match: (SUBS (SRA y z) x)
 11272  	// result: (RSBSshiftRAreg x y z)
 11273  	for {
 11274  		if v_0.Op != OpARMSRA {
 11275  			break
 11276  		}
 11277  		z := v_0.Args[1]
 11278  		y := v_0.Args[0]
 11279  		x := v_1
 11280  		v.reset(OpARMRSBSshiftRAreg)
 11281  		v.AddArg3(x, y, z)
 11282  		return true
 11283  	}
 11284  	return false
 11285  }
 11286  func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool {
 11287  	v_1 := v.Args[1]
 11288  	v_0 := v.Args[0]
 11289  	b := v.Block
 11290  	// match: (SUBSshiftLL (MOVWconst [c]) x [d])
 11291  	// result: (RSBSconst [c] (SLLconst <x.Type> x [d]))
 11292  	for {
 11293  		d := auxIntToInt32(v.AuxInt)
 11294  		if v_0.Op != OpARMMOVWconst {
 11295  			break
 11296  		}
 11297  		c := auxIntToInt32(v_0.AuxInt)
 11298  		x := v_1
 11299  		v.reset(OpARMRSBSconst)
 11300  		v.AuxInt = int32ToAuxInt(c)
 11301  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
 11302  		v0.AuxInt = int32ToAuxInt(d)
 11303  		v0.AddArg(x)
 11304  		v.AddArg(v0)
 11305  		return true
 11306  	}
 11307  	// match: (SUBSshiftLL x (MOVWconst [c]) [d])
 11308  	// result: (SUBSconst x [c<<uint64(d)])
 11309  	for {
 11310  		d := auxIntToInt32(v.AuxInt)
 11311  		x := v_0
 11312  		if v_1.Op != OpARMMOVWconst {
 11313  			break
 11314  		}
 11315  		c := auxIntToInt32(v_1.AuxInt)
 11316  		v.reset(OpARMSUBSconst)
 11317  		v.AuxInt = int32ToAuxInt(c << uint64(d))
 11318  		v.AddArg(x)
 11319  		return true
 11320  	}
 11321  	return false
 11322  }
 11323  func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool {
 11324  	v_2 := v.Args[2]
 11325  	v_1 := v.Args[1]
 11326  	v_0 := v.Args[0]
 11327  	b := v.Block
 11328  	// match: (SUBSshiftLLreg (MOVWconst [c]) x y)
 11329  	// result: (RSBSconst [c] (SLL <x.Type> x y))
 11330  	for {
 11331  		if v_0.Op != OpARMMOVWconst {
 11332  			break
 11333  		}
 11334  		c := auxIntToInt32(v_0.AuxInt)
 11335  		x := v_1
 11336  		y := v_2
 11337  		v.reset(OpARMRSBSconst)
 11338  		v.AuxInt = int32ToAuxInt(c)
 11339  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 11340  		v0.AddArg2(x, y)
 11341  		v.AddArg(v0)
 11342  		return true
 11343  	}
 11344  	// match: (SUBSshiftLLreg x y (MOVWconst [c]))
 11345  	// cond: 0 <= c && c < 32
 11346  	// result: (SUBSshiftLL x y [c])
 11347  	for {
 11348  		x := v_0
 11349  		y := v_1
 11350  		if v_2.Op != OpARMMOVWconst {
 11351  			break
 11352  		}
 11353  		c := auxIntToInt32(v_2.AuxInt)
 11354  		if !(0 <= c && c < 32) {
 11355  			break
 11356  		}
 11357  		v.reset(OpARMSUBSshiftLL)
 11358  		v.AuxInt = int32ToAuxInt(c)
 11359  		v.AddArg2(x, y)
 11360  		return true
 11361  	}
 11362  	return false
 11363  }
 11364  func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool {
 11365  	v_1 := v.Args[1]
 11366  	v_0 := v.Args[0]
 11367  	b := v.Block
 11368  	// match: (SUBSshiftRA (MOVWconst [c]) x [d])
 11369  	// result: (RSBSconst [c] (SRAconst <x.Type> x [d]))
 11370  	for {
 11371  		d := auxIntToInt32(v.AuxInt)
 11372  		if v_0.Op != OpARMMOVWconst {
 11373  			break
 11374  		}
 11375  		c := auxIntToInt32(v_0.AuxInt)
 11376  		x := v_1
 11377  		v.reset(OpARMRSBSconst)
 11378  		v.AuxInt = int32ToAuxInt(c)
 11379  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
 11380  		v0.AuxInt = int32ToAuxInt(d)
 11381  		v0.AddArg(x)
 11382  		v.AddArg(v0)
 11383  		return true
 11384  	}
 11385  	// match: (SUBSshiftRA x (MOVWconst [c]) [d])
 11386  	// result: (SUBSconst x [c>>uint64(d)])
 11387  	for {
 11388  		d := auxIntToInt32(v.AuxInt)
 11389  		x := v_0
 11390  		if v_1.Op != OpARMMOVWconst {
 11391  			break
 11392  		}
 11393  		c := auxIntToInt32(v_1.AuxInt)
 11394  		v.reset(OpARMSUBSconst)
 11395  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
 11396  		v.AddArg(x)
 11397  		return true
 11398  	}
 11399  	return false
 11400  }
 11401  func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool {
 11402  	v_2 := v.Args[2]
 11403  	v_1 := v.Args[1]
 11404  	v_0 := v.Args[0]
 11405  	b := v.Block
 11406  	// match: (SUBSshiftRAreg (MOVWconst [c]) x y)
 11407  	// result: (RSBSconst [c] (SRA <x.Type> x y))
 11408  	for {
 11409  		if v_0.Op != OpARMMOVWconst {
 11410  			break
 11411  		}
 11412  		c := auxIntToInt32(v_0.AuxInt)
 11413  		x := v_1
 11414  		y := v_2
 11415  		v.reset(OpARMRSBSconst)
 11416  		v.AuxInt = int32ToAuxInt(c)
 11417  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
 11418  		v0.AddArg2(x, y)
 11419  		v.AddArg(v0)
 11420  		return true
 11421  	}
 11422  	// match: (SUBSshiftRAreg x y (MOVWconst [c]))
 11423  	// cond: 0 <= c && c < 32
 11424  	// result: (SUBSshiftRA x y [c])
 11425  	for {
 11426  		x := v_0
 11427  		y := v_1
 11428  		if v_2.Op != OpARMMOVWconst {
 11429  			break
 11430  		}
 11431  		c := auxIntToInt32(v_2.AuxInt)
 11432  		if !(0 <= c && c < 32) {
 11433  			break
 11434  		}
 11435  		v.reset(OpARMSUBSshiftRA)
 11436  		v.AuxInt = int32ToAuxInt(c)
 11437  		v.AddArg2(x, y)
 11438  		return true
 11439  	}
 11440  	return false
 11441  }
 11442  func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool {
 11443  	v_1 := v.Args[1]
 11444  	v_0 := v.Args[0]
 11445  	b := v.Block
 11446  	// match: (SUBSshiftRL (MOVWconst [c]) x [d])
 11447  	// result: (RSBSconst [c] (SRLconst <x.Type> x [d]))
 11448  	for {
 11449  		d := auxIntToInt32(v.AuxInt)
 11450  		if v_0.Op != OpARMMOVWconst {
 11451  			break
 11452  		}
 11453  		c := auxIntToInt32(v_0.AuxInt)
 11454  		x := v_1
 11455  		v.reset(OpARMRSBSconst)
 11456  		v.AuxInt = int32ToAuxInt(c)
 11457  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 11458  		v0.AuxInt = int32ToAuxInt(d)
 11459  		v0.AddArg(x)
 11460  		v.AddArg(v0)
 11461  		return true
 11462  	}
 11463  	// match: (SUBSshiftRL x (MOVWconst [c]) [d])
 11464  	// result: (SUBSconst x [int32(uint32(c)>>uint64(d))])
 11465  	for {
 11466  		d := auxIntToInt32(v.AuxInt)
 11467  		x := v_0
 11468  		if v_1.Op != OpARMMOVWconst {
 11469  			break
 11470  		}
 11471  		c := auxIntToInt32(v_1.AuxInt)
 11472  		v.reset(OpARMSUBSconst)
 11473  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 11474  		v.AddArg(x)
 11475  		return true
 11476  	}
 11477  	return false
 11478  }
 11479  func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool {
 11480  	v_2 := v.Args[2]
 11481  	v_1 := v.Args[1]
 11482  	v_0 := v.Args[0]
 11483  	b := v.Block
 11484  	// match: (SUBSshiftRLreg (MOVWconst [c]) x y)
 11485  	// result: (RSBSconst [c] (SRL <x.Type> x y))
 11486  	for {
 11487  		if v_0.Op != OpARMMOVWconst {
 11488  			break
 11489  		}
 11490  		c := auxIntToInt32(v_0.AuxInt)
 11491  		x := v_1
 11492  		y := v_2
 11493  		v.reset(OpARMRSBSconst)
 11494  		v.AuxInt = int32ToAuxInt(c)
 11495  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 11496  		v0.AddArg2(x, y)
 11497  		v.AddArg(v0)
 11498  		return true
 11499  	}
 11500  	// match: (SUBSshiftRLreg x y (MOVWconst [c]))
 11501  	// cond: 0 <= c && c < 32
 11502  	// result: (SUBSshiftRL x y [c])
 11503  	for {
 11504  		x := v_0
 11505  		y := v_1
 11506  		if v_2.Op != OpARMMOVWconst {
 11507  			break
 11508  		}
 11509  		c := auxIntToInt32(v_2.AuxInt)
 11510  		if !(0 <= c && c < 32) {
 11511  			break
 11512  		}
 11513  		v.reset(OpARMSUBSshiftRL)
 11514  		v.AuxInt = int32ToAuxInt(c)
 11515  		v.AddArg2(x, y)
 11516  		return true
 11517  	}
 11518  	return false
 11519  }
 11520  func rewriteValueARM_OpARMSUBconst(v *Value) bool {
 11521  	v_0 := v.Args[0]
 11522  	// match: (SUBconst [off1] (MOVWaddr [off2] {sym} ptr))
 11523  	// result: (MOVWaddr [off2-off1] {sym} ptr)
 11524  	for {
 11525  		off1 := auxIntToInt32(v.AuxInt)
 11526  		if v_0.Op != OpARMMOVWaddr {
 11527  			break
 11528  		}
 11529  		off2 := auxIntToInt32(v_0.AuxInt)
 11530  		sym := auxToSym(v_0.Aux)
 11531  		ptr := v_0.Args[0]
 11532  		v.reset(OpARMMOVWaddr)
 11533  		v.AuxInt = int32ToAuxInt(off2 - off1)
 11534  		v.Aux = symToAux(sym)
 11535  		v.AddArg(ptr)
 11536  		return true
 11537  	}
 11538  	// match: (SUBconst [0] x)
 11539  	// result: x
 11540  	for {
 11541  		if auxIntToInt32(v.AuxInt) != 0 {
 11542  			break
 11543  		}
 11544  		x := v_0
 11545  		v.copyOf(x)
 11546  		return true
 11547  	}
 11548  	// match: (SUBconst [c] x)
 11549  	// cond: !isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))
 11550  	// result: (ADDconst [-c] x)
 11551  	for {
 11552  		c := auxIntToInt32(v.AuxInt)
 11553  		x := v_0
 11554  		if !(!isARMImmRot(uint32(c)) && isARMImmRot(uint32(-c))) {
 11555  			break
 11556  		}
 11557  		v.reset(OpARMADDconst)
 11558  		v.AuxInt = int32ToAuxInt(-c)
 11559  		v.AddArg(x)
 11560  		return true
 11561  	}
 11562  	// match: (SUBconst [c] x)
 11563  	// cond: buildcfg.GOARM.Version==7 && !isARMImmRot(uint32(c)) && uint32(c)>0xffff && uint32(-c)<=0xffff
 11564  	// result: (ADDconst [-c] x)
 11565  	for {
 11566  		c := auxIntToInt32(v.AuxInt)
 11567  		x := v_0
 11568  		if !(buildcfg.GOARM.Version == 7 && !isARMImmRot(uint32(c)) && uint32(c) > 0xffff && uint32(-c) <= 0xffff) {
 11569  			break
 11570  		}
 11571  		v.reset(OpARMADDconst)
 11572  		v.AuxInt = int32ToAuxInt(-c)
 11573  		v.AddArg(x)
 11574  		return true
 11575  	}
 11576  	// match: (SUBconst [c] (MOVWconst [d]))
 11577  	// result: (MOVWconst [d-c])
 11578  	for {
 11579  		c := auxIntToInt32(v.AuxInt)
 11580  		if v_0.Op != OpARMMOVWconst {
 11581  			break
 11582  		}
 11583  		d := auxIntToInt32(v_0.AuxInt)
 11584  		v.reset(OpARMMOVWconst)
 11585  		v.AuxInt = int32ToAuxInt(d - c)
 11586  		return true
 11587  	}
 11588  	// match: (SUBconst [c] (SUBconst [d] x))
 11589  	// result: (ADDconst [-c-d] x)
 11590  	for {
 11591  		c := auxIntToInt32(v.AuxInt)
 11592  		if v_0.Op != OpARMSUBconst {
 11593  			break
 11594  		}
 11595  		d := auxIntToInt32(v_0.AuxInt)
 11596  		x := v_0.Args[0]
 11597  		v.reset(OpARMADDconst)
 11598  		v.AuxInt = int32ToAuxInt(-c - d)
 11599  		v.AddArg(x)
 11600  		return true
 11601  	}
 11602  	// match: (SUBconst [c] (ADDconst [d] x))
 11603  	// result: (ADDconst [-c+d] x)
 11604  	for {
 11605  		c := auxIntToInt32(v.AuxInt)
 11606  		if v_0.Op != OpARMADDconst {
 11607  			break
 11608  		}
 11609  		d := auxIntToInt32(v_0.AuxInt)
 11610  		x := v_0.Args[0]
 11611  		v.reset(OpARMADDconst)
 11612  		v.AuxInt = int32ToAuxInt(-c + d)
 11613  		v.AddArg(x)
 11614  		return true
 11615  	}
 11616  	// match: (SUBconst [c] (RSBconst [d] x))
 11617  	// result: (RSBconst [-c+d] x)
 11618  	for {
 11619  		c := auxIntToInt32(v.AuxInt)
 11620  		if v_0.Op != OpARMRSBconst {
 11621  			break
 11622  		}
 11623  		d := auxIntToInt32(v_0.AuxInt)
 11624  		x := v_0.Args[0]
 11625  		v.reset(OpARMRSBconst)
 11626  		v.AuxInt = int32ToAuxInt(-c + d)
 11627  		v.AddArg(x)
 11628  		return true
 11629  	}
 11630  	return false
 11631  }
 11632  func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool {
 11633  	v_1 := v.Args[1]
 11634  	v_0 := v.Args[0]
 11635  	b := v.Block
 11636  	// match: (SUBshiftLL (MOVWconst [c]) x [d])
 11637  	// result: (RSBconst [c] (SLLconst <x.Type> x [d]))
 11638  	for {
 11639  		d := auxIntToInt32(v.AuxInt)
 11640  		if v_0.Op != OpARMMOVWconst {
 11641  			break
 11642  		}
 11643  		c := auxIntToInt32(v_0.AuxInt)
 11644  		x := v_1
 11645  		v.reset(OpARMRSBconst)
 11646  		v.AuxInt = int32ToAuxInt(c)
 11647  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
 11648  		v0.AuxInt = int32ToAuxInt(d)
 11649  		v0.AddArg(x)
 11650  		v.AddArg(v0)
 11651  		return true
 11652  	}
 11653  	// match: (SUBshiftLL x (MOVWconst [c]) [d])
 11654  	// result: (SUBconst x [c<<uint64(d)])
 11655  	for {
 11656  		d := auxIntToInt32(v.AuxInt)
 11657  		x := v_0
 11658  		if v_1.Op != OpARMMOVWconst {
 11659  			break
 11660  		}
 11661  		c := auxIntToInt32(v_1.AuxInt)
 11662  		v.reset(OpARMSUBconst)
 11663  		v.AuxInt = int32ToAuxInt(c << uint64(d))
 11664  		v.AddArg(x)
 11665  		return true
 11666  	}
 11667  	// match: (SUBshiftLL (SLLconst x [c]) x [c])
 11668  	// result: (MOVWconst [0])
 11669  	for {
 11670  		c := auxIntToInt32(v.AuxInt)
 11671  		if v_0.Op != OpARMSLLconst || auxIntToInt32(v_0.AuxInt) != c {
 11672  			break
 11673  		}
 11674  		x := v_0.Args[0]
 11675  		if x != v_1 {
 11676  			break
 11677  		}
 11678  		v.reset(OpARMMOVWconst)
 11679  		v.AuxInt = int32ToAuxInt(0)
 11680  		return true
 11681  	}
 11682  	return false
 11683  }
 11684  func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool {
 11685  	v_2 := v.Args[2]
 11686  	v_1 := v.Args[1]
 11687  	v_0 := v.Args[0]
 11688  	b := v.Block
 11689  	// match: (SUBshiftLLreg (MOVWconst [c]) x y)
 11690  	// result: (RSBconst [c] (SLL <x.Type> x y))
 11691  	for {
 11692  		if v_0.Op != OpARMMOVWconst {
 11693  			break
 11694  		}
 11695  		c := auxIntToInt32(v_0.AuxInt)
 11696  		x := v_1
 11697  		y := v_2
 11698  		v.reset(OpARMRSBconst)
 11699  		v.AuxInt = int32ToAuxInt(c)
 11700  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 11701  		v0.AddArg2(x, y)
 11702  		v.AddArg(v0)
 11703  		return true
 11704  	}
 11705  	// match: (SUBshiftLLreg x y (MOVWconst [c]))
 11706  	// cond: 0 <= c && c < 32
 11707  	// result: (SUBshiftLL x y [c])
 11708  	for {
 11709  		x := v_0
 11710  		y := v_1
 11711  		if v_2.Op != OpARMMOVWconst {
 11712  			break
 11713  		}
 11714  		c := auxIntToInt32(v_2.AuxInt)
 11715  		if !(0 <= c && c < 32) {
 11716  			break
 11717  		}
 11718  		v.reset(OpARMSUBshiftLL)
 11719  		v.AuxInt = int32ToAuxInt(c)
 11720  		v.AddArg2(x, y)
 11721  		return true
 11722  	}
 11723  	return false
 11724  }
 11725  func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool {
 11726  	v_1 := v.Args[1]
 11727  	v_0 := v.Args[0]
 11728  	b := v.Block
 11729  	// match: (SUBshiftRA (MOVWconst [c]) x [d])
 11730  	// result: (RSBconst [c] (SRAconst <x.Type> x [d]))
 11731  	for {
 11732  		d := auxIntToInt32(v.AuxInt)
 11733  		if v_0.Op != OpARMMOVWconst {
 11734  			break
 11735  		}
 11736  		c := auxIntToInt32(v_0.AuxInt)
 11737  		x := v_1
 11738  		v.reset(OpARMRSBconst)
 11739  		v.AuxInt = int32ToAuxInt(c)
 11740  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
 11741  		v0.AuxInt = int32ToAuxInt(d)
 11742  		v0.AddArg(x)
 11743  		v.AddArg(v0)
 11744  		return true
 11745  	}
 11746  	// match: (SUBshiftRA x (MOVWconst [c]) [d])
 11747  	// result: (SUBconst x [c>>uint64(d)])
 11748  	for {
 11749  		d := auxIntToInt32(v.AuxInt)
 11750  		x := v_0
 11751  		if v_1.Op != OpARMMOVWconst {
 11752  			break
 11753  		}
 11754  		c := auxIntToInt32(v_1.AuxInt)
 11755  		v.reset(OpARMSUBconst)
 11756  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
 11757  		v.AddArg(x)
 11758  		return true
 11759  	}
 11760  	// match: (SUBshiftRA (SRAconst x [c]) x [c])
 11761  	// result: (MOVWconst [0])
 11762  	for {
 11763  		c := auxIntToInt32(v.AuxInt)
 11764  		if v_0.Op != OpARMSRAconst || auxIntToInt32(v_0.AuxInt) != c {
 11765  			break
 11766  		}
 11767  		x := v_0.Args[0]
 11768  		if x != v_1 {
 11769  			break
 11770  		}
 11771  		v.reset(OpARMMOVWconst)
 11772  		v.AuxInt = int32ToAuxInt(0)
 11773  		return true
 11774  	}
 11775  	return false
 11776  }
 11777  func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool {
 11778  	v_2 := v.Args[2]
 11779  	v_1 := v.Args[1]
 11780  	v_0 := v.Args[0]
 11781  	b := v.Block
 11782  	// match: (SUBshiftRAreg (MOVWconst [c]) x y)
 11783  	// result: (RSBconst [c] (SRA <x.Type> x y))
 11784  	for {
 11785  		if v_0.Op != OpARMMOVWconst {
 11786  			break
 11787  		}
 11788  		c := auxIntToInt32(v_0.AuxInt)
 11789  		x := v_1
 11790  		y := v_2
 11791  		v.reset(OpARMRSBconst)
 11792  		v.AuxInt = int32ToAuxInt(c)
 11793  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
 11794  		v0.AddArg2(x, y)
 11795  		v.AddArg(v0)
 11796  		return true
 11797  	}
 11798  	// match: (SUBshiftRAreg x y (MOVWconst [c]))
 11799  	// cond: 0 <= c && c < 32
 11800  	// result: (SUBshiftRA x y [c])
 11801  	for {
 11802  		x := v_0
 11803  		y := v_1
 11804  		if v_2.Op != OpARMMOVWconst {
 11805  			break
 11806  		}
 11807  		c := auxIntToInt32(v_2.AuxInt)
 11808  		if !(0 <= c && c < 32) {
 11809  			break
 11810  		}
 11811  		v.reset(OpARMSUBshiftRA)
 11812  		v.AuxInt = int32ToAuxInt(c)
 11813  		v.AddArg2(x, y)
 11814  		return true
 11815  	}
 11816  	return false
 11817  }
 11818  func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool {
 11819  	v_1 := v.Args[1]
 11820  	v_0 := v.Args[0]
 11821  	b := v.Block
 11822  	// match: (SUBshiftRL (MOVWconst [c]) x [d])
 11823  	// result: (RSBconst [c] (SRLconst <x.Type> x [d]))
 11824  	for {
 11825  		d := auxIntToInt32(v.AuxInt)
 11826  		if v_0.Op != OpARMMOVWconst {
 11827  			break
 11828  		}
 11829  		c := auxIntToInt32(v_0.AuxInt)
 11830  		x := v_1
 11831  		v.reset(OpARMRSBconst)
 11832  		v.AuxInt = int32ToAuxInt(c)
 11833  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 11834  		v0.AuxInt = int32ToAuxInt(d)
 11835  		v0.AddArg(x)
 11836  		v.AddArg(v0)
 11837  		return true
 11838  	}
 11839  	// match: (SUBshiftRL x (MOVWconst [c]) [d])
 11840  	// result: (SUBconst x [int32(uint32(c)>>uint64(d))])
 11841  	for {
 11842  		d := auxIntToInt32(v.AuxInt)
 11843  		x := v_0
 11844  		if v_1.Op != OpARMMOVWconst {
 11845  			break
 11846  		}
 11847  		c := auxIntToInt32(v_1.AuxInt)
 11848  		v.reset(OpARMSUBconst)
 11849  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 11850  		v.AddArg(x)
 11851  		return true
 11852  	}
 11853  	// match: (SUBshiftRL (SRLconst x [c]) x [c])
 11854  	// result: (MOVWconst [0])
 11855  	for {
 11856  		c := auxIntToInt32(v.AuxInt)
 11857  		if v_0.Op != OpARMSRLconst || auxIntToInt32(v_0.AuxInt) != c {
 11858  			break
 11859  		}
 11860  		x := v_0.Args[0]
 11861  		if x != v_1 {
 11862  			break
 11863  		}
 11864  		v.reset(OpARMMOVWconst)
 11865  		v.AuxInt = int32ToAuxInt(0)
 11866  		return true
 11867  	}
 11868  	return false
 11869  }
 11870  func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool {
 11871  	v_2 := v.Args[2]
 11872  	v_1 := v.Args[1]
 11873  	v_0 := v.Args[0]
 11874  	b := v.Block
 11875  	// match: (SUBshiftRLreg (MOVWconst [c]) x y)
 11876  	// result: (RSBconst [c] (SRL <x.Type> x y))
 11877  	for {
 11878  		if v_0.Op != OpARMMOVWconst {
 11879  			break
 11880  		}
 11881  		c := auxIntToInt32(v_0.AuxInt)
 11882  		x := v_1
 11883  		y := v_2
 11884  		v.reset(OpARMRSBconst)
 11885  		v.AuxInt = int32ToAuxInt(c)
 11886  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 11887  		v0.AddArg2(x, y)
 11888  		v.AddArg(v0)
 11889  		return true
 11890  	}
 11891  	// match: (SUBshiftRLreg x y (MOVWconst [c]))
 11892  	// cond: 0 <= c && c < 32
 11893  	// result: (SUBshiftRL x y [c])
 11894  	for {
 11895  		x := v_0
 11896  		y := v_1
 11897  		if v_2.Op != OpARMMOVWconst {
 11898  			break
 11899  		}
 11900  		c := auxIntToInt32(v_2.AuxInt)
 11901  		if !(0 <= c && c < 32) {
 11902  			break
 11903  		}
 11904  		v.reset(OpARMSUBshiftRL)
 11905  		v.AuxInt = int32ToAuxInt(c)
 11906  		v.AddArg2(x, y)
 11907  		return true
 11908  	}
 11909  	return false
 11910  }
 11911  func rewriteValueARM_OpARMTEQ(v *Value) bool {
 11912  	v_1 := v.Args[1]
 11913  	v_0 := v.Args[0]
 11914  	// match: (TEQ x (MOVWconst [c]))
 11915  	// result: (TEQconst [c] x)
 11916  	for {
 11917  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 11918  			x := v_0
 11919  			if v_1.Op != OpARMMOVWconst {
 11920  				continue
 11921  			}
 11922  			c := auxIntToInt32(v_1.AuxInt)
 11923  			v.reset(OpARMTEQconst)
 11924  			v.AuxInt = int32ToAuxInt(c)
 11925  			v.AddArg(x)
 11926  			return true
 11927  		}
 11928  		break
 11929  	}
 11930  	// match: (TEQ x (SLLconst [c] y))
 11931  	// result: (TEQshiftLL x y [c])
 11932  	for {
 11933  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 11934  			x := v_0
 11935  			if v_1.Op != OpARMSLLconst {
 11936  				continue
 11937  			}
 11938  			c := auxIntToInt32(v_1.AuxInt)
 11939  			y := v_1.Args[0]
 11940  			v.reset(OpARMTEQshiftLL)
 11941  			v.AuxInt = int32ToAuxInt(c)
 11942  			v.AddArg2(x, y)
 11943  			return true
 11944  		}
 11945  		break
 11946  	}
 11947  	// match: (TEQ x (SRLconst [c] y))
 11948  	// result: (TEQshiftRL x y [c])
 11949  	for {
 11950  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 11951  			x := v_0
 11952  			if v_1.Op != OpARMSRLconst {
 11953  				continue
 11954  			}
 11955  			c := auxIntToInt32(v_1.AuxInt)
 11956  			y := v_1.Args[0]
 11957  			v.reset(OpARMTEQshiftRL)
 11958  			v.AuxInt = int32ToAuxInt(c)
 11959  			v.AddArg2(x, y)
 11960  			return true
 11961  		}
 11962  		break
 11963  	}
 11964  	// match: (TEQ x (SRAconst [c] y))
 11965  	// result: (TEQshiftRA x y [c])
 11966  	for {
 11967  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 11968  			x := v_0
 11969  			if v_1.Op != OpARMSRAconst {
 11970  				continue
 11971  			}
 11972  			c := auxIntToInt32(v_1.AuxInt)
 11973  			y := v_1.Args[0]
 11974  			v.reset(OpARMTEQshiftRA)
 11975  			v.AuxInt = int32ToAuxInt(c)
 11976  			v.AddArg2(x, y)
 11977  			return true
 11978  		}
 11979  		break
 11980  	}
 11981  	// match: (TEQ x (SLL y z))
 11982  	// result: (TEQshiftLLreg x y z)
 11983  	for {
 11984  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 11985  			x := v_0
 11986  			if v_1.Op != OpARMSLL {
 11987  				continue
 11988  			}
 11989  			z := v_1.Args[1]
 11990  			y := v_1.Args[0]
 11991  			v.reset(OpARMTEQshiftLLreg)
 11992  			v.AddArg3(x, y, z)
 11993  			return true
 11994  		}
 11995  		break
 11996  	}
 11997  	// match: (TEQ x (SRL y z))
 11998  	// result: (TEQshiftRLreg x y z)
 11999  	for {
 12000  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12001  			x := v_0
 12002  			if v_1.Op != OpARMSRL {
 12003  				continue
 12004  			}
 12005  			z := v_1.Args[1]
 12006  			y := v_1.Args[0]
 12007  			v.reset(OpARMTEQshiftRLreg)
 12008  			v.AddArg3(x, y, z)
 12009  			return true
 12010  		}
 12011  		break
 12012  	}
 12013  	// match: (TEQ x (SRA y z))
 12014  	// result: (TEQshiftRAreg x y z)
 12015  	for {
 12016  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12017  			x := v_0
 12018  			if v_1.Op != OpARMSRA {
 12019  				continue
 12020  			}
 12021  			z := v_1.Args[1]
 12022  			y := v_1.Args[0]
 12023  			v.reset(OpARMTEQshiftRAreg)
 12024  			v.AddArg3(x, y, z)
 12025  			return true
 12026  		}
 12027  		break
 12028  	}
 12029  	return false
 12030  }
 12031  func rewriteValueARM_OpARMTEQconst(v *Value) bool {
 12032  	v_0 := v.Args[0]
 12033  	// match: (TEQconst (MOVWconst [x]) [y])
 12034  	// result: (FlagConstant [logicFlags32(x^y)])
 12035  	for {
 12036  		y := auxIntToInt32(v.AuxInt)
 12037  		if v_0.Op != OpARMMOVWconst {
 12038  			break
 12039  		}
 12040  		x := auxIntToInt32(v_0.AuxInt)
 12041  		v.reset(OpARMFlagConstant)
 12042  		v.AuxInt = flagConstantToAuxInt(logicFlags32(x ^ y))
 12043  		return true
 12044  	}
 12045  	return false
 12046  }
 12047  func rewriteValueARM_OpARMTEQshiftLL(v *Value) bool {
 12048  	v_1 := v.Args[1]
 12049  	v_0 := v.Args[0]
 12050  	b := v.Block
 12051  	// match: (TEQshiftLL (MOVWconst [c]) x [d])
 12052  	// result: (TEQconst [c] (SLLconst <x.Type> x [d]))
 12053  	for {
 12054  		d := auxIntToInt32(v.AuxInt)
 12055  		if v_0.Op != OpARMMOVWconst {
 12056  			break
 12057  		}
 12058  		c := auxIntToInt32(v_0.AuxInt)
 12059  		x := v_1
 12060  		v.reset(OpARMTEQconst)
 12061  		v.AuxInt = int32ToAuxInt(c)
 12062  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
 12063  		v0.AuxInt = int32ToAuxInt(d)
 12064  		v0.AddArg(x)
 12065  		v.AddArg(v0)
 12066  		return true
 12067  	}
 12068  	// match: (TEQshiftLL x (MOVWconst [c]) [d])
 12069  	// result: (TEQconst x [c<<uint64(d)])
 12070  	for {
 12071  		d := auxIntToInt32(v.AuxInt)
 12072  		x := v_0
 12073  		if v_1.Op != OpARMMOVWconst {
 12074  			break
 12075  		}
 12076  		c := auxIntToInt32(v_1.AuxInt)
 12077  		v.reset(OpARMTEQconst)
 12078  		v.AuxInt = int32ToAuxInt(c << uint64(d))
 12079  		v.AddArg(x)
 12080  		return true
 12081  	}
 12082  	return false
 12083  }
 12084  func rewriteValueARM_OpARMTEQshiftLLreg(v *Value) bool {
 12085  	v_2 := v.Args[2]
 12086  	v_1 := v.Args[1]
 12087  	v_0 := v.Args[0]
 12088  	b := v.Block
 12089  	// match: (TEQshiftLLreg (MOVWconst [c]) x y)
 12090  	// result: (TEQconst [c] (SLL <x.Type> x y))
 12091  	for {
 12092  		if v_0.Op != OpARMMOVWconst {
 12093  			break
 12094  		}
 12095  		c := auxIntToInt32(v_0.AuxInt)
 12096  		x := v_1
 12097  		y := v_2
 12098  		v.reset(OpARMTEQconst)
 12099  		v.AuxInt = int32ToAuxInt(c)
 12100  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 12101  		v0.AddArg2(x, y)
 12102  		v.AddArg(v0)
 12103  		return true
 12104  	}
 12105  	// match: (TEQshiftLLreg x y (MOVWconst [c]))
 12106  	// cond: 0 <= c && c < 32
 12107  	// result: (TEQshiftLL x y [c])
 12108  	for {
 12109  		x := v_0
 12110  		y := v_1
 12111  		if v_2.Op != OpARMMOVWconst {
 12112  			break
 12113  		}
 12114  		c := auxIntToInt32(v_2.AuxInt)
 12115  		if !(0 <= c && c < 32) {
 12116  			break
 12117  		}
 12118  		v.reset(OpARMTEQshiftLL)
 12119  		v.AuxInt = int32ToAuxInt(c)
 12120  		v.AddArg2(x, y)
 12121  		return true
 12122  	}
 12123  	return false
 12124  }
 12125  func rewriteValueARM_OpARMTEQshiftRA(v *Value) bool {
 12126  	v_1 := v.Args[1]
 12127  	v_0 := v.Args[0]
 12128  	b := v.Block
 12129  	// match: (TEQshiftRA (MOVWconst [c]) x [d])
 12130  	// result: (TEQconst [c] (SRAconst <x.Type> x [d]))
 12131  	for {
 12132  		d := auxIntToInt32(v.AuxInt)
 12133  		if v_0.Op != OpARMMOVWconst {
 12134  			break
 12135  		}
 12136  		c := auxIntToInt32(v_0.AuxInt)
 12137  		x := v_1
 12138  		v.reset(OpARMTEQconst)
 12139  		v.AuxInt = int32ToAuxInt(c)
 12140  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
 12141  		v0.AuxInt = int32ToAuxInt(d)
 12142  		v0.AddArg(x)
 12143  		v.AddArg(v0)
 12144  		return true
 12145  	}
 12146  	// match: (TEQshiftRA x (MOVWconst [c]) [d])
 12147  	// result: (TEQconst x [c>>uint64(d)])
 12148  	for {
 12149  		d := auxIntToInt32(v.AuxInt)
 12150  		x := v_0
 12151  		if v_1.Op != OpARMMOVWconst {
 12152  			break
 12153  		}
 12154  		c := auxIntToInt32(v_1.AuxInt)
 12155  		v.reset(OpARMTEQconst)
 12156  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
 12157  		v.AddArg(x)
 12158  		return true
 12159  	}
 12160  	return false
 12161  }
 12162  func rewriteValueARM_OpARMTEQshiftRAreg(v *Value) bool {
 12163  	v_2 := v.Args[2]
 12164  	v_1 := v.Args[1]
 12165  	v_0 := v.Args[0]
 12166  	b := v.Block
 12167  	// match: (TEQshiftRAreg (MOVWconst [c]) x y)
 12168  	// result: (TEQconst [c] (SRA <x.Type> x y))
 12169  	for {
 12170  		if v_0.Op != OpARMMOVWconst {
 12171  			break
 12172  		}
 12173  		c := auxIntToInt32(v_0.AuxInt)
 12174  		x := v_1
 12175  		y := v_2
 12176  		v.reset(OpARMTEQconst)
 12177  		v.AuxInt = int32ToAuxInt(c)
 12178  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
 12179  		v0.AddArg2(x, y)
 12180  		v.AddArg(v0)
 12181  		return true
 12182  	}
 12183  	// match: (TEQshiftRAreg x y (MOVWconst [c]))
 12184  	// cond: 0 <= c && c < 32
 12185  	// result: (TEQshiftRA x y [c])
 12186  	for {
 12187  		x := v_0
 12188  		y := v_1
 12189  		if v_2.Op != OpARMMOVWconst {
 12190  			break
 12191  		}
 12192  		c := auxIntToInt32(v_2.AuxInt)
 12193  		if !(0 <= c && c < 32) {
 12194  			break
 12195  		}
 12196  		v.reset(OpARMTEQshiftRA)
 12197  		v.AuxInt = int32ToAuxInt(c)
 12198  		v.AddArg2(x, y)
 12199  		return true
 12200  	}
 12201  	return false
 12202  }
 12203  func rewriteValueARM_OpARMTEQshiftRL(v *Value) bool {
 12204  	v_1 := v.Args[1]
 12205  	v_0 := v.Args[0]
 12206  	b := v.Block
 12207  	// match: (TEQshiftRL (MOVWconst [c]) x [d])
 12208  	// result: (TEQconst [c] (SRLconst <x.Type> x [d]))
 12209  	for {
 12210  		d := auxIntToInt32(v.AuxInt)
 12211  		if v_0.Op != OpARMMOVWconst {
 12212  			break
 12213  		}
 12214  		c := auxIntToInt32(v_0.AuxInt)
 12215  		x := v_1
 12216  		v.reset(OpARMTEQconst)
 12217  		v.AuxInt = int32ToAuxInt(c)
 12218  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 12219  		v0.AuxInt = int32ToAuxInt(d)
 12220  		v0.AddArg(x)
 12221  		v.AddArg(v0)
 12222  		return true
 12223  	}
 12224  	// match: (TEQshiftRL x (MOVWconst [c]) [d])
 12225  	// result: (TEQconst x [int32(uint32(c)>>uint64(d))])
 12226  	for {
 12227  		d := auxIntToInt32(v.AuxInt)
 12228  		x := v_0
 12229  		if v_1.Op != OpARMMOVWconst {
 12230  			break
 12231  		}
 12232  		c := auxIntToInt32(v_1.AuxInt)
 12233  		v.reset(OpARMTEQconst)
 12234  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 12235  		v.AddArg(x)
 12236  		return true
 12237  	}
 12238  	return false
 12239  }
 12240  func rewriteValueARM_OpARMTEQshiftRLreg(v *Value) bool {
 12241  	v_2 := v.Args[2]
 12242  	v_1 := v.Args[1]
 12243  	v_0 := v.Args[0]
 12244  	b := v.Block
 12245  	// match: (TEQshiftRLreg (MOVWconst [c]) x y)
 12246  	// result: (TEQconst [c] (SRL <x.Type> x y))
 12247  	for {
 12248  		if v_0.Op != OpARMMOVWconst {
 12249  			break
 12250  		}
 12251  		c := auxIntToInt32(v_0.AuxInt)
 12252  		x := v_1
 12253  		y := v_2
 12254  		v.reset(OpARMTEQconst)
 12255  		v.AuxInt = int32ToAuxInt(c)
 12256  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 12257  		v0.AddArg2(x, y)
 12258  		v.AddArg(v0)
 12259  		return true
 12260  	}
 12261  	// match: (TEQshiftRLreg x y (MOVWconst [c]))
 12262  	// cond: 0 <= c && c < 32
 12263  	// result: (TEQshiftRL x y [c])
 12264  	for {
 12265  		x := v_0
 12266  		y := v_1
 12267  		if v_2.Op != OpARMMOVWconst {
 12268  			break
 12269  		}
 12270  		c := auxIntToInt32(v_2.AuxInt)
 12271  		if !(0 <= c && c < 32) {
 12272  			break
 12273  		}
 12274  		v.reset(OpARMTEQshiftRL)
 12275  		v.AuxInt = int32ToAuxInt(c)
 12276  		v.AddArg2(x, y)
 12277  		return true
 12278  	}
 12279  	return false
 12280  }
 12281  func rewriteValueARM_OpARMTST(v *Value) bool {
 12282  	v_1 := v.Args[1]
 12283  	v_0 := v.Args[0]
 12284  	// match: (TST x (MOVWconst [c]))
 12285  	// result: (TSTconst [c] x)
 12286  	for {
 12287  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12288  			x := v_0
 12289  			if v_1.Op != OpARMMOVWconst {
 12290  				continue
 12291  			}
 12292  			c := auxIntToInt32(v_1.AuxInt)
 12293  			v.reset(OpARMTSTconst)
 12294  			v.AuxInt = int32ToAuxInt(c)
 12295  			v.AddArg(x)
 12296  			return true
 12297  		}
 12298  		break
 12299  	}
 12300  	// match: (TST x (SLLconst [c] y))
 12301  	// result: (TSTshiftLL x y [c])
 12302  	for {
 12303  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12304  			x := v_0
 12305  			if v_1.Op != OpARMSLLconst {
 12306  				continue
 12307  			}
 12308  			c := auxIntToInt32(v_1.AuxInt)
 12309  			y := v_1.Args[0]
 12310  			v.reset(OpARMTSTshiftLL)
 12311  			v.AuxInt = int32ToAuxInt(c)
 12312  			v.AddArg2(x, y)
 12313  			return true
 12314  		}
 12315  		break
 12316  	}
 12317  	// match: (TST x (SRLconst [c] y))
 12318  	// result: (TSTshiftRL x y [c])
 12319  	for {
 12320  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12321  			x := v_0
 12322  			if v_1.Op != OpARMSRLconst {
 12323  				continue
 12324  			}
 12325  			c := auxIntToInt32(v_1.AuxInt)
 12326  			y := v_1.Args[0]
 12327  			v.reset(OpARMTSTshiftRL)
 12328  			v.AuxInt = int32ToAuxInt(c)
 12329  			v.AddArg2(x, y)
 12330  			return true
 12331  		}
 12332  		break
 12333  	}
 12334  	// match: (TST x (SRAconst [c] y))
 12335  	// result: (TSTshiftRA x y [c])
 12336  	for {
 12337  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12338  			x := v_0
 12339  			if v_1.Op != OpARMSRAconst {
 12340  				continue
 12341  			}
 12342  			c := auxIntToInt32(v_1.AuxInt)
 12343  			y := v_1.Args[0]
 12344  			v.reset(OpARMTSTshiftRA)
 12345  			v.AuxInt = int32ToAuxInt(c)
 12346  			v.AddArg2(x, y)
 12347  			return true
 12348  		}
 12349  		break
 12350  	}
 12351  	// match: (TST x (SLL y z))
 12352  	// result: (TSTshiftLLreg x y z)
 12353  	for {
 12354  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12355  			x := v_0
 12356  			if v_1.Op != OpARMSLL {
 12357  				continue
 12358  			}
 12359  			z := v_1.Args[1]
 12360  			y := v_1.Args[0]
 12361  			v.reset(OpARMTSTshiftLLreg)
 12362  			v.AddArg3(x, y, z)
 12363  			return true
 12364  		}
 12365  		break
 12366  	}
 12367  	// match: (TST x (SRL y z))
 12368  	// result: (TSTshiftRLreg x y z)
 12369  	for {
 12370  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12371  			x := v_0
 12372  			if v_1.Op != OpARMSRL {
 12373  				continue
 12374  			}
 12375  			z := v_1.Args[1]
 12376  			y := v_1.Args[0]
 12377  			v.reset(OpARMTSTshiftRLreg)
 12378  			v.AddArg3(x, y, z)
 12379  			return true
 12380  		}
 12381  		break
 12382  	}
 12383  	// match: (TST x (SRA y z))
 12384  	// result: (TSTshiftRAreg x y z)
 12385  	for {
 12386  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12387  			x := v_0
 12388  			if v_1.Op != OpARMSRA {
 12389  				continue
 12390  			}
 12391  			z := v_1.Args[1]
 12392  			y := v_1.Args[0]
 12393  			v.reset(OpARMTSTshiftRAreg)
 12394  			v.AddArg3(x, y, z)
 12395  			return true
 12396  		}
 12397  		break
 12398  	}
 12399  	return false
 12400  }
 12401  func rewriteValueARM_OpARMTSTconst(v *Value) bool {
 12402  	v_0 := v.Args[0]
 12403  	// match: (TSTconst (MOVWconst [x]) [y])
 12404  	// result: (FlagConstant [logicFlags32(x&y)])
 12405  	for {
 12406  		y := auxIntToInt32(v.AuxInt)
 12407  		if v_0.Op != OpARMMOVWconst {
 12408  			break
 12409  		}
 12410  		x := auxIntToInt32(v_0.AuxInt)
 12411  		v.reset(OpARMFlagConstant)
 12412  		v.AuxInt = flagConstantToAuxInt(logicFlags32(x & y))
 12413  		return true
 12414  	}
 12415  	return false
 12416  }
 12417  func rewriteValueARM_OpARMTSTshiftLL(v *Value) bool {
 12418  	v_1 := v.Args[1]
 12419  	v_0 := v.Args[0]
 12420  	b := v.Block
 12421  	// match: (TSTshiftLL (MOVWconst [c]) x [d])
 12422  	// result: (TSTconst [c] (SLLconst <x.Type> x [d]))
 12423  	for {
 12424  		d := auxIntToInt32(v.AuxInt)
 12425  		if v_0.Op != OpARMMOVWconst {
 12426  			break
 12427  		}
 12428  		c := auxIntToInt32(v_0.AuxInt)
 12429  		x := v_1
 12430  		v.reset(OpARMTSTconst)
 12431  		v.AuxInt = int32ToAuxInt(c)
 12432  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
 12433  		v0.AuxInt = int32ToAuxInt(d)
 12434  		v0.AddArg(x)
 12435  		v.AddArg(v0)
 12436  		return true
 12437  	}
 12438  	// match: (TSTshiftLL x (MOVWconst [c]) [d])
 12439  	// result: (TSTconst x [c<<uint64(d)])
 12440  	for {
 12441  		d := auxIntToInt32(v.AuxInt)
 12442  		x := v_0
 12443  		if v_1.Op != OpARMMOVWconst {
 12444  			break
 12445  		}
 12446  		c := auxIntToInt32(v_1.AuxInt)
 12447  		v.reset(OpARMTSTconst)
 12448  		v.AuxInt = int32ToAuxInt(c << uint64(d))
 12449  		v.AddArg(x)
 12450  		return true
 12451  	}
 12452  	return false
 12453  }
 12454  func rewriteValueARM_OpARMTSTshiftLLreg(v *Value) bool {
 12455  	v_2 := v.Args[2]
 12456  	v_1 := v.Args[1]
 12457  	v_0 := v.Args[0]
 12458  	b := v.Block
 12459  	// match: (TSTshiftLLreg (MOVWconst [c]) x y)
 12460  	// result: (TSTconst [c] (SLL <x.Type> x y))
 12461  	for {
 12462  		if v_0.Op != OpARMMOVWconst {
 12463  			break
 12464  		}
 12465  		c := auxIntToInt32(v_0.AuxInt)
 12466  		x := v_1
 12467  		y := v_2
 12468  		v.reset(OpARMTSTconst)
 12469  		v.AuxInt = int32ToAuxInt(c)
 12470  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 12471  		v0.AddArg2(x, y)
 12472  		v.AddArg(v0)
 12473  		return true
 12474  	}
 12475  	// match: (TSTshiftLLreg x y (MOVWconst [c]))
 12476  	// cond: 0 <= c && c < 32
 12477  	// result: (TSTshiftLL x y [c])
 12478  	for {
 12479  		x := v_0
 12480  		y := v_1
 12481  		if v_2.Op != OpARMMOVWconst {
 12482  			break
 12483  		}
 12484  		c := auxIntToInt32(v_2.AuxInt)
 12485  		if !(0 <= c && c < 32) {
 12486  			break
 12487  		}
 12488  		v.reset(OpARMTSTshiftLL)
 12489  		v.AuxInt = int32ToAuxInt(c)
 12490  		v.AddArg2(x, y)
 12491  		return true
 12492  	}
 12493  	return false
 12494  }
 12495  func rewriteValueARM_OpARMTSTshiftRA(v *Value) bool {
 12496  	v_1 := v.Args[1]
 12497  	v_0 := v.Args[0]
 12498  	b := v.Block
 12499  	// match: (TSTshiftRA (MOVWconst [c]) x [d])
 12500  	// result: (TSTconst [c] (SRAconst <x.Type> x [d]))
 12501  	for {
 12502  		d := auxIntToInt32(v.AuxInt)
 12503  		if v_0.Op != OpARMMOVWconst {
 12504  			break
 12505  		}
 12506  		c := auxIntToInt32(v_0.AuxInt)
 12507  		x := v_1
 12508  		v.reset(OpARMTSTconst)
 12509  		v.AuxInt = int32ToAuxInt(c)
 12510  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
 12511  		v0.AuxInt = int32ToAuxInt(d)
 12512  		v0.AddArg(x)
 12513  		v.AddArg(v0)
 12514  		return true
 12515  	}
 12516  	// match: (TSTshiftRA x (MOVWconst [c]) [d])
 12517  	// result: (TSTconst x [c>>uint64(d)])
 12518  	for {
 12519  		d := auxIntToInt32(v.AuxInt)
 12520  		x := v_0
 12521  		if v_1.Op != OpARMMOVWconst {
 12522  			break
 12523  		}
 12524  		c := auxIntToInt32(v_1.AuxInt)
 12525  		v.reset(OpARMTSTconst)
 12526  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
 12527  		v.AddArg(x)
 12528  		return true
 12529  	}
 12530  	return false
 12531  }
 12532  func rewriteValueARM_OpARMTSTshiftRAreg(v *Value) bool {
 12533  	v_2 := v.Args[2]
 12534  	v_1 := v.Args[1]
 12535  	v_0 := v.Args[0]
 12536  	b := v.Block
 12537  	// match: (TSTshiftRAreg (MOVWconst [c]) x y)
 12538  	// result: (TSTconst [c] (SRA <x.Type> x y))
 12539  	for {
 12540  		if v_0.Op != OpARMMOVWconst {
 12541  			break
 12542  		}
 12543  		c := auxIntToInt32(v_0.AuxInt)
 12544  		x := v_1
 12545  		y := v_2
 12546  		v.reset(OpARMTSTconst)
 12547  		v.AuxInt = int32ToAuxInt(c)
 12548  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
 12549  		v0.AddArg2(x, y)
 12550  		v.AddArg(v0)
 12551  		return true
 12552  	}
 12553  	// match: (TSTshiftRAreg x y (MOVWconst [c]))
 12554  	// cond: 0 <= c && c < 32
 12555  	// result: (TSTshiftRA x y [c])
 12556  	for {
 12557  		x := v_0
 12558  		y := v_1
 12559  		if v_2.Op != OpARMMOVWconst {
 12560  			break
 12561  		}
 12562  		c := auxIntToInt32(v_2.AuxInt)
 12563  		if !(0 <= c && c < 32) {
 12564  			break
 12565  		}
 12566  		v.reset(OpARMTSTshiftRA)
 12567  		v.AuxInt = int32ToAuxInt(c)
 12568  		v.AddArg2(x, y)
 12569  		return true
 12570  	}
 12571  	return false
 12572  }
 12573  func rewriteValueARM_OpARMTSTshiftRL(v *Value) bool {
 12574  	v_1 := v.Args[1]
 12575  	v_0 := v.Args[0]
 12576  	b := v.Block
 12577  	// match: (TSTshiftRL (MOVWconst [c]) x [d])
 12578  	// result: (TSTconst [c] (SRLconst <x.Type> x [d]))
 12579  	for {
 12580  		d := auxIntToInt32(v.AuxInt)
 12581  		if v_0.Op != OpARMMOVWconst {
 12582  			break
 12583  		}
 12584  		c := auxIntToInt32(v_0.AuxInt)
 12585  		x := v_1
 12586  		v.reset(OpARMTSTconst)
 12587  		v.AuxInt = int32ToAuxInt(c)
 12588  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 12589  		v0.AuxInt = int32ToAuxInt(d)
 12590  		v0.AddArg(x)
 12591  		v.AddArg(v0)
 12592  		return true
 12593  	}
 12594  	// match: (TSTshiftRL x (MOVWconst [c]) [d])
 12595  	// result: (TSTconst x [int32(uint32(c)>>uint64(d))])
 12596  	for {
 12597  		d := auxIntToInt32(v.AuxInt)
 12598  		x := v_0
 12599  		if v_1.Op != OpARMMOVWconst {
 12600  			break
 12601  		}
 12602  		c := auxIntToInt32(v_1.AuxInt)
 12603  		v.reset(OpARMTSTconst)
 12604  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 12605  		v.AddArg(x)
 12606  		return true
 12607  	}
 12608  	return false
 12609  }
 12610  func rewriteValueARM_OpARMTSTshiftRLreg(v *Value) bool {
 12611  	v_2 := v.Args[2]
 12612  	v_1 := v.Args[1]
 12613  	v_0 := v.Args[0]
 12614  	b := v.Block
 12615  	// match: (TSTshiftRLreg (MOVWconst [c]) x y)
 12616  	// result: (TSTconst [c] (SRL <x.Type> x y))
 12617  	for {
 12618  		if v_0.Op != OpARMMOVWconst {
 12619  			break
 12620  		}
 12621  		c := auxIntToInt32(v_0.AuxInt)
 12622  		x := v_1
 12623  		y := v_2
 12624  		v.reset(OpARMTSTconst)
 12625  		v.AuxInt = int32ToAuxInt(c)
 12626  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 12627  		v0.AddArg2(x, y)
 12628  		v.AddArg(v0)
 12629  		return true
 12630  	}
 12631  	// match: (TSTshiftRLreg x y (MOVWconst [c]))
 12632  	// cond: 0 <= c && c < 32
 12633  	// result: (TSTshiftRL x y [c])
 12634  	for {
 12635  		x := v_0
 12636  		y := v_1
 12637  		if v_2.Op != OpARMMOVWconst {
 12638  			break
 12639  		}
 12640  		c := auxIntToInt32(v_2.AuxInt)
 12641  		if !(0 <= c && c < 32) {
 12642  			break
 12643  		}
 12644  		v.reset(OpARMTSTshiftRL)
 12645  		v.AuxInt = int32ToAuxInt(c)
 12646  		v.AddArg2(x, y)
 12647  		return true
 12648  	}
 12649  	return false
 12650  }
 12651  func rewriteValueARM_OpARMXOR(v *Value) bool {
 12652  	v_1 := v.Args[1]
 12653  	v_0 := v.Args[0]
 12654  	// match: (XOR x (MOVWconst [c]))
 12655  	// result: (XORconst [c] x)
 12656  	for {
 12657  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12658  			x := v_0
 12659  			if v_1.Op != OpARMMOVWconst {
 12660  				continue
 12661  			}
 12662  			c := auxIntToInt32(v_1.AuxInt)
 12663  			v.reset(OpARMXORconst)
 12664  			v.AuxInt = int32ToAuxInt(c)
 12665  			v.AddArg(x)
 12666  			return true
 12667  		}
 12668  		break
 12669  	}
 12670  	// match: (XOR x (SLLconst [c] y))
 12671  	// result: (XORshiftLL x y [c])
 12672  	for {
 12673  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12674  			x := v_0
 12675  			if v_1.Op != OpARMSLLconst {
 12676  				continue
 12677  			}
 12678  			c := auxIntToInt32(v_1.AuxInt)
 12679  			y := v_1.Args[0]
 12680  			v.reset(OpARMXORshiftLL)
 12681  			v.AuxInt = int32ToAuxInt(c)
 12682  			v.AddArg2(x, y)
 12683  			return true
 12684  		}
 12685  		break
 12686  	}
 12687  	// match: (XOR x (SRLconst [c] y))
 12688  	// result: (XORshiftRL x y [c])
 12689  	for {
 12690  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12691  			x := v_0
 12692  			if v_1.Op != OpARMSRLconst {
 12693  				continue
 12694  			}
 12695  			c := auxIntToInt32(v_1.AuxInt)
 12696  			y := v_1.Args[0]
 12697  			v.reset(OpARMXORshiftRL)
 12698  			v.AuxInt = int32ToAuxInt(c)
 12699  			v.AddArg2(x, y)
 12700  			return true
 12701  		}
 12702  		break
 12703  	}
 12704  	// match: (XOR x (SRAconst [c] y))
 12705  	// result: (XORshiftRA x y [c])
 12706  	for {
 12707  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12708  			x := v_0
 12709  			if v_1.Op != OpARMSRAconst {
 12710  				continue
 12711  			}
 12712  			c := auxIntToInt32(v_1.AuxInt)
 12713  			y := v_1.Args[0]
 12714  			v.reset(OpARMXORshiftRA)
 12715  			v.AuxInt = int32ToAuxInt(c)
 12716  			v.AddArg2(x, y)
 12717  			return true
 12718  		}
 12719  		break
 12720  	}
 12721  	// match: (XOR x (SRRconst [c] y))
 12722  	// result: (XORshiftRR x y [c])
 12723  	for {
 12724  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12725  			x := v_0
 12726  			if v_1.Op != OpARMSRRconst {
 12727  				continue
 12728  			}
 12729  			c := auxIntToInt32(v_1.AuxInt)
 12730  			y := v_1.Args[0]
 12731  			v.reset(OpARMXORshiftRR)
 12732  			v.AuxInt = int32ToAuxInt(c)
 12733  			v.AddArg2(x, y)
 12734  			return true
 12735  		}
 12736  		break
 12737  	}
 12738  	// match: (XOR x (SLL y z))
 12739  	// result: (XORshiftLLreg x y z)
 12740  	for {
 12741  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12742  			x := v_0
 12743  			if v_1.Op != OpARMSLL {
 12744  				continue
 12745  			}
 12746  			z := v_1.Args[1]
 12747  			y := v_1.Args[0]
 12748  			v.reset(OpARMXORshiftLLreg)
 12749  			v.AddArg3(x, y, z)
 12750  			return true
 12751  		}
 12752  		break
 12753  	}
 12754  	// match: (XOR x (SRL y z))
 12755  	// result: (XORshiftRLreg x y z)
 12756  	for {
 12757  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12758  			x := v_0
 12759  			if v_1.Op != OpARMSRL {
 12760  				continue
 12761  			}
 12762  			z := v_1.Args[1]
 12763  			y := v_1.Args[0]
 12764  			v.reset(OpARMXORshiftRLreg)
 12765  			v.AddArg3(x, y, z)
 12766  			return true
 12767  		}
 12768  		break
 12769  	}
 12770  	// match: (XOR x (SRA y z))
 12771  	// result: (XORshiftRAreg x y z)
 12772  	for {
 12773  		for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 {
 12774  			x := v_0
 12775  			if v_1.Op != OpARMSRA {
 12776  				continue
 12777  			}
 12778  			z := v_1.Args[1]
 12779  			y := v_1.Args[0]
 12780  			v.reset(OpARMXORshiftRAreg)
 12781  			v.AddArg3(x, y, z)
 12782  			return true
 12783  		}
 12784  		break
 12785  	}
 12786  	// match: (XOR x x)
 12787  	// result: (MOVWconst [0])
 12788  	for {
 12789  		x := v_0
 12790  		if x != v_1 {
 12791  			break
 12792  		}
 12793  		v.reset(OpARMMOVWconst)
 12794  		v.AuxInt = int32ToAuxInt(0)
 12795  		return true
 12796  	}
 12797  	return false
 12798  }
 12799  func rewriteValueARM_OpARMXORconst(v *Value) bool {
 12800  	v_0 := v.Args[0]
 12801  	// match: (XORconst [0] x)
 12802  	// result: x
 12803  	for {
 12804  		if auxIntToInt32(v.AuxInt) != 0 {
 12805  			break
 12806  		}
 12807  		x := v_0
 12808  		v.copyOf(x)
 12809  		return true
 12810  	}
 12811  	// match: (XORconst [c] (MOVWconst [d]))
 12812  	// result: (MOVWconst [c^d])
 12813  	for {
 12814  		c := auxIntToInt32(v.AuxInt)
 12815  		if v_0.Op != OpARMMOVWconst {
 12816  			break
 12817  		}
 12818  		d := auxIntToInt32(v_0.AuxInt)
 12819  		v.reset(OpARMMOVWconst)
 12820  		v.AuxInt = int32ToAuxInt(c ^ d)
 12821  		return true
 12822  	}
 12823  	// match: (XORconst [c] (XORconst [d] x))
 12824  	// result: (XORconst [c^d] x)
 12825  	for {
 12826  		c := auxIntToInt32(v.AuxInt)
 12827  		if v_0.Op != OpARMXORconst {
 12828  			break
 12829  		}
 12830  		d := auxIntToInt32(v_0.AuxInt)
 12831  		x := v_0.Args[0]
 12832  		v.reset(OpARMXORconst)
 12833  		v.AuxInt = int32ToAuxInt(c ^ d)
 12834  		v.AddArg(x)
 12835  		return true
 12836  	}
 12837  	return false
 12838  }
 12839  func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
 12840  	v_1 := v.Args[1]
 12841  	v_0 := v.Args[0]
 12842  	b := v.Block
 12843  	typ := &b.Func.Config.Types
 12844  	// match: (XORshiftLL (MOVWconst [c]) x [d])
 12845  	// result: (XORconst [c] (SLLconst <x.Type> x [d]))
 12846  	for {
 12847  		d := auxIntToInt32(v.AuxInt)
 12848  		if v_0.Op != OpARMMOVWconst {
 12849  			break
 12850  		}
 12851  		c := auxIntToInt32(v_0.AuxInt)
 12852  		x := v_1
 12853  		v.reset(OpARMXORconst)
 12854  		v.AuxInt = int32ToAuxInt(c)
 12855  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, x.Type)
 12856  		v0.AuxInt = int32ToAuxInt(d)
 12857  		v0.AddArg(x)
 12858  		v.AddArg(v0)
 12859  		return true
 12860  	}
 12861  	// match: (XORshiftLL x (MOVWconst [c]) [d])
 12862  	// result: (XORconst x [c<<uint64(d)])
 12863  	for {
 12864  		d := auxIntToInt32(v.AuxInt)
 12865  		x := v_0
 12866  		if v_1.Op != OpARMMOVWconst {
 12867  			break
 12868  		}
 12869  		c := auxIntToInt32(v_1.AuxInt)
 12870  		v.reset(OpARMXORconst)
 12871  		v.AuxInt = int32ToAuxInt(c << uint64(d))
 12872  		v.AddArg(x)
 12873  		return true
 12874  	}
 12875  	// match: (XORshiftLL <typ.UInt16> [8] (BFXU <typ.UInt16> [int32(armBFAuxInt(8, 8))] x) x)
 12876  	// result: (REV16 x)
 12877  	for {
 12878  		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMBFXU || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != int32(armBFAuxInt(8, 8)) {
 12879  			break
 12880  		}
 12881  		x := v_0.Args[0]
 12882  		if x != v_1 {
 12883  			break
 12884  		}
 12885  		v.reset(OpARMREV16)
 12886  		v.AddArg(x)
 12887  		return true
 12888  	}
 12889  	// match: (XORshiftLL <typ.UInt16> [8] (SRLconst <typ.UInt16> [24] (SLLconst [16] x)) x)
 12890  	// cond: buildcfg.GOARM.Version>=6
 12891  	// result: (REV16 x)
 12892  	for {
 12893  		if v.Type != typ.UInt16 || auxIntToInt32(v.AuxInt) != 8 || v_0.Op != OpARMSRLconst || v_0.Type != typ.UInt16 || auxIntToInt32(v_0.AuxInt) != 24 {
 12894  			break
 12895  		}
 12896  		v_0_0 := v_0.Args[0]
 12897  		if v_0_0.Op != OpARMSLLconst || auxIntToInt32(v_0_0.AuxInt) != 16 {
 12898  			break
 12899  		}
 12900  		x := v_0_0.Args[0]
 12901  		if x != v_1 || !(buildcfg.GOARM.Version >= 6) {
 12902  			break
 12903  		}
 12904  		v.reset(OpARMREV16)
 12905  		v.AddArg(x)
 12906  		return true
 12907  	}
 12908  	// match: (XORshiftLL (SLLconst x [c]) x [c])
 12909  	// result: (MOVWconst [0])
 12910  	for {
 12911  		c := auxIntToInt32(v.AuxInt)
 12912  		if v_0.Op != OpARMSLLconst || auxIntToInt32(v_0.AuxInt) != c {
 12913  			break
 12914  		}
 12915  		x := v_0.Args[0]
 12916  		if x != v_1 {
 12917  			break
 12918  		}
 12919  		v.reset(OpARMMOVWconst)
 12920  		v.AuxInt = int32ToAuxInt(0)
 12921  		return true
 12922  	}
 12923  	return false
 12924  }
 12925  func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool {
 12926  	v_2 := v.Args[2]
 12927  	v_1 := v.Args[1]
 12928  	v_0 := v.Args[0]
 12929  	b := v.Block
 12930  	// match: (XORshiftLLreg (MOVWconst [c]) x y)
 12931  	// result: (XORconst [c] (SLL <x.Type> x y))
 12932  	for {
 12933  		if v_0.Op != OpARMMOVWconst {
 12934  			break
 12935  		}
 12936  		c := auxIntToInt32(v_0.AuxInt)
 12937  		x := v_1
 12938  		y := v_2
 12939  		v.reset(OpARMXORconst)
 12940  		v.AuxInt = int32ToAuxInt(c)
 12941  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 12942  		v0.AddArg2(x, y)
 12943  		v.AddArg(v0)
 12944  		return true
 12945  	}
 12946  	// match: (XORshiftLLreg x y (MOVWconst [c]))
 12947  	// cond: 0 <= c && c < 32
 12948  	// result: (XORshiftLL x y [c])
 12949  	for {
 12950  		x := v_0
 12951  		y := v_1
 12952  		if v_2.Op != OpARMMOVWconst {
 12953  			break
 12954  		}
 12955  		c := auxIntToInt32(v_2.AuxInt)
 12956  		if !(0 <= c && c < 32) {
 12957  			break
 12958  		}
 12959  		v.reset(OpARMXORshiftLL)
 12960  		v.AuxInt = int32ToAuxInt(c)
 12961  		v.AddArg2(x, y)
 12962  		return true
 12963  	}
 12964  	return false
 12965  }
 12966  func rewriteValueARM_OpARMXORshiftRA(v *Value) bool {
 12967  	v_1 := v.Args[1]
 12968  	v_0 := v.Args[0]
 12969  	b := v.Block
 12970  	// match: (XORshiftRA (MOVWconst [c]) x [d])
 12971  	// result: (XORconst [c] (SRAconst <x.Type> x [d]))
 12972  	for {
 12973  		d := auxIntToInt32(v.AuxInt)
 12974  		if v_0.Op != OpARMMOVWconst {
 12975  			break
 12976  		}
 12977  		c := auxIntToInt32(v_0.AuxInt)
 12978  		x := v_1
 12979  		v.reset(OpARMXORconst)
 12980  		v.AuxInt = int32ToAuxInt(c)
 12981  		v0 := b.NewValue0(v.Pos, OpARMSRAconst, x.Type)
 12982  		v0.AuxInt = int32ToAuxInt(d)
 12983  		v0.AddArg(x)
 12984  		v.AddArg(v0)
 12985  		return true
 12986  	}
 12987  	// match: (XORshiftRA x (MOVWconst [c]) [d])
 12988  	// result: (XORconst x [c>>uint64(d)])
 12989  	for {
 12990  		d := auxIntToInt32(v.AuxInt)
 12991  		x := v_0
 12992  		if v_1.Op != OpARMMOVWconst {
 12993  			break
 12994  		}
 12995  		c := auxIntToInt32(v_1.AuxInt)
 12996  		v.reset(OpARMXORconst)
 12997  		v.AuxInt = int32ToAuxInt(c >> uint64(d))
 12998  		v.AddArg(x)
 12999  		return true
 13000  	}
 13001  	// match: (XORshiftRA (SRAconst x [c]) x [c])
 13002  	// result: (MOVWconst [0])
 13003  	for {
 13004  		c := auxIntToInt32(v.AuxInt)
 13005  		if v_0.Op != OpARMSRAconst || auxIntToInt32(v_0.AuxInt) != c {
 13006  			break
 13007  		}
 13008  		x := v_0.Args[0]
 13009  		if x != v_1 {
 13010  			break
 13011  		}
 13012  		v.reset(OpARMMOVWconst)
 13013  		v.AuxInt = int32ToAuxInt(0)
 13014  		return true
 13015  	}
 13016  	return false
 13017  }
 13018  func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool {
 13019  	v_2 := v.Args[2]
 13020  	v_1 := v.Args[1]
 13021  	v_0 := v.Args[0]
 13022  	b := v.Block
 13023  	// match: (XORshiftRAreg (MOVWconst [c]) x y)
 13024  	// result: (XORconst [c] (SRA <x.Type> x y))
 13025  	for {
 13026  		if v_0.Op != OpARMMOVWconst {
 13027  			break
 13028  		}
 13029  		c := auxIntToInt32(v_0.AuxInt)
 13030  		x := v_1
 13031  		y := v_2
 13032  		v.reset(OpARMXORconst)
 13033  		v.AuxInt = int32ToAuxInt(c)
 13034  		v0 := b.NewValue0(v.Pos, OpARMSRA, x.Type)
 13035  		v0.AddArg2(x, y)
 13036  		v.AddArg(v0)
 13037  		return true
 13038  	}
 13039  	// match: (XORshiftRAreg x y (MOVWconst [c]))
 13040  	// cond: 0 <= c && c < 32
 13041  	// result: (XORshiftRA x y [c])
 13042  	for {
 13043  		x := v_0
 13044  		y := v_1
 13045  		if v_2.Op != OpARMMOVWconst {
 13046  			break
 13047  		}
 13048  		c := auxIntToInt32(v_2.AuxInt)
 13049  		if !(0 <= c && c < 32) {
 13050  			break
 13051  		}
 13052  		v.reset(OpARMXORshiftRA)
 13053  		v.AuxInt = int32ToAuxInt(c)
 13054  		v.AddArg2(x, y)
 13055  		return true
 13056  	}
 13057  	return false
 13058  }
 13059  func rewriteValueARM_OpARMXORshiftRL(v *Value) bool {
 13060  	v_1 := v.Args[1]
 13061  	v_0 := v.Args[0]
 13062  	b := v.Block
 13063  	// match: (XORshiftRL (MOVWconst [c]) x [d])
 13064  	// result: (XORconst [c] (SRLconst <x.Type> x [d]))
 13065  	for {
 13066  		d := auxIntToInt32(v.AuxInt)
 13067  		if v_0.Op != OpARMMOVWconst {
 13068  			break
 13069  		}
 13070  		c := auxIntToInt32(v_0.AuxInt)
 13071  		x := v_1
 13072  		v.reset(OpARMXORconst)
 13073  		v.AuxInt = int32ToAuxInt(c)
 13074  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, x.Type)
 13075  		v0.AuxInt = int32ToAuxInt(d)
 13076  		v0.AddArg(x)
 13077  		v.AddArg(v0)
 13078  		return true
 13079  	}
 13080  	// match: (XORshiftRL x (MOVWconst [c]) [d])
 13081  	// result: (XORconst x [int32(uint32(c)>>uint64(d))])
 13082  	for {
 13083  		d := auxIntToInt32(v.AuxInt)
 13084  		x := v_0
 13085  		if v_1.Op != OpARMMOVWconst {
 13086  			break
 13087  		}
 13088  		c := auxIntToInt32(v_1.AuxInt)
 13089  		v.reset(OpARMXORconst)
 13090  		v.AuxInt = int32ToAuxInt(int32(uint32(c) >> uint64(d)))
 13091  		v.AddArg(x)
 13092  		return true
 13093  	}
 13094  	// match: (XORshiftRL (SRLconst x [c]) x [c])
 13095  	// result: (MOVWconst [0])
 13096  	for {
 13097  		c := auxIntToInt32(v.AuxInt)
 13098  		if v_0.Op != OpARMSRLconst || auxIntToInt32(v_0.AuxInt) != c {
 13099  			break
 13100  		}
 13101  		x := v_0.Args[0]
 13102  		if x != v_1 {
 13103  			break
 13104  		}
 13105  		v.reset(OpARMMOVWconst)
 13106  		v.AuxInt = int32ToAuxInt(0)
 13107  		return true
 13108  	}
 13109  	return false
 13110  }
 13111  func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool {
 13112  	v_2 := v.Args[2]
 13113  	v_1 := v.Args[1]
 13114  	v_0 := v.Args[0]
 13115  	b := v.Block
 13116  	// match: (XORshiftRLreg (MOVWconst [c]) x y)
 13117  	// result: (XORconst [c] (SRL <x.Type> x y))
 13118  	for {
 13119  		if v_0.Op != OpARMMOVWconst {
 13120  			break
 13121  		}
 13122  		c := auxIntToInt32(v_0.AuxInt)
 13123  		x := v_1
 13124  		y := v_2
 13125  		v.reset(OpARMXORconst)
 13126  		v.AuxInt = int32ToAuxInt(c)
 13127  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 13128  		v0.AddArg2(x, y)
 13129  		v.AddArg(v0)
 13130  		return true
 13131  	}
 13132  	// match: (XORshiftRLreg x y (MOVWconst [c]))
 13133  	// cond: 0 <= c && c < 32
 13134  	// result: (XORshiftRL x y [c])
 13135  	for {
 13136  		x := v_0
 13137  		y := v_1
 13138  		if v_2.Op != OpARMMOVWconst {
 13139  			break
 13140  		}
 13141  		c := auxIntToInt32(v_2.AuxInt)
 13142  		if !(0 <= c && c < 32) {
 13143  			break
 13144  		}
 13145  		v.reset(OpARMXORshiftRL)
 13146  		v.AuxInt = int32ToAuxInt(c)
 13147  		v.AddArg2(x, y)
 13148  		return true
 13149  	}
 13150  	return false
 13151  }
 13152  func rewriteValueARM_OpARMXORshiftRR(v *Value) bool {
 13153  	v_1 := v.Args[1]
 13154  	v_0 := v.Args[0]
 13155  	b := v.Block
 13156  	// match: (XORshiftRR (MOVWconst [c]) x [d])
 13157  	// result: (XORconst [c] (SRRconst <x.Type> x [d]))
 13158  	for {
 13159  		d := auxIntToInt32(v.AuxInt)
 13160  		if v_0.Op != OpARMMOVWconst {
 13161  			break
 13162  		}
 13163  		c := auxIntToInt32(v_0.AuxInt)
 13164  		x := v_1
 13165  		v.reset(OpARMXORconst)
 13166  		v.AuxInt = int32ToAuxInt(c)
 13167  		v0 := b.NewValue0(v.Pos, OpARMSRRconst, x.Type)
 13168  		v0.AuxInt = int32ToAuxInt(d)
 13169  		v0.AddArg(x)
 13170  		v.AddArg(v0)
 13171  		return true
 13172  	}
 13173  	// match: (XORshiftRR x (MOVWconst [c]) [d])
 13174  	// result: (XORconst x [int32(uint32(c)>>uint64(d)|uint32(c)<<uint64(32-d))])
 13175  	for {
 13176  		d := auxIntToInt32(v.AuxInt)
 13177  		x := v_0
 13178  		if v_1.Op != OpARMMOVWconst {
 13179  			break
 13180  		}
 13181  		c := auxIntToInt32(v_1.AuxInt)
 13182  		v.reset(OpARMXORconst)
 13183  		v.AuxInt = int32ToAuxInt(int32(uint32(c)>>uint64(d) | uint32(c)<<uint64(32-d)))
 13184  		v.AddArg(x)
 13185  		return true
 13186  	}
 13187  	return false
 13188  }
 13189  func rewriteValueARM_OpAddr(v *Value) bool {
 13190  	v_0 := v.Args[0]
 13191  	// match: (Addr {sym} base)
 13192  	// result: (MOVWaddr {sym} base)
 13193  	for {
 13194  		sym := auxToSym(v.Aux)
 13195  		base := v_0
 13196  		v.reset(OpARMMOVWaddr)
 13197  		v.Aux = symToAux(sym)
 13198  		v.AddArg(base)
 13199  		return true
 13200  	}
 13201  }
 13202  func rewriteValueARM_OpAvg32u(v *Value) bool {
 13203  	v_1 := v.Args[1]
 13204  	v_0 := v.Args[0]
 13205  	b := v.Block
 13206  	// match: (Avg32u <t> x y)
 13207  	// result: (ADD (SRLconst <t> (SUB <t> x y) [1]) y)
 13208  	for {
 13209  		t := v.Type
 13210  		x := v_0
 13211  		y := v_1
 13212  		v.reset(OpARMADD)
 13213  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, t)
 13214  		v0.AuxInt = int32ToAuxInt(1)
 13215  		v1 := b.NewValue0(v.Pos, OpARMSUB, t)
 13216  		v1.AddArg2(x, y)
 13217  		v0.AddArg(v1)
 13218  		v.AddArg2(v0, y)
 13219  		return true
 13220  	}
 13221  }
 13222  func rewriteValueARM_OpBitLen16(v *Value) bool {
 13223  	v_0 := v.Args[0]
 13224  	b := v.Block
 13225  	typ := &b.Func.Config.Types
 13226  	// match: (BitLen16 x)
 13227  	// result: (BitLen32 (ZeroExt16to32 x))
 13228  	for {
 13229  		x := v_0
 13230  		v.reset(OpBitLen32)
 13231  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13232  		v0.AddArg(x)
 13233  		v.AddArg(v0)
 13234  		return true
 13235  	}
 13236  }
 13237  func rewriteValueARM_OpBitLen32(v *Value) bool {
 13238  	v_0 := v.Args[0]
 13239  	b := v.Block
 13240  	// match: (BitLen32 <t> x)
 13241  	// result: (RSBconst [32] (CLZ <t> x))
 13242  	for {
 13243  		t := v.Type
 13244  		x := v_0
 13245  		v.reset(OpARMRSBconst)
 13246  		v.AuxInt = int32ToAuxInt(32)
 13247  		v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
 13248  		v0.AddArg(x)
 13249  		v.AddArg(v0)
 13250  		return true
 13251  	}
 13252  }
 13253  func rewriteValueARM_OpBitLen8(v *Value) bool {
 13254  	v_0 := v.Args[0]
 13255  	b := v.Block
 13256  	typ := &b.Func.Config.Types
 13257  	// match: (BitLen8 x)
 13258  	// result: (BitLen32 (ZeroExt8to32 x))
 13259  	for {
 13260  		x := v_0
 13261  		v.reset(OpBitLen32)
 13262  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13263  		v0.AddArg(x)
 13264  		v.AddArg(v0)
 13265  		return true
 13266  	}
 13267  }
 13268  func rewriteValueARM_OpBswap32(v *Value) bool {
 13269  	v_0 := v.Args[0]
 13270  	b := v.Block
 13271  	// match: (Bswap32 <t> x)
 13272  	// cond: buildcfg.GOARM.Version==5
 13273  	// result: (XOR <t> (SRLconst <t> (BICconst <t> (XOR <t> x (SRRconst <t> [16] x)) [0xff0000]) [8]) (SRRconst <t> x [8]))
 13274  	for {
 13275  		t := v.Type
 13276  		x := v_0
 13277  		if !(buildcfg.GOARM.Version == 5) {
 13278  			break
 13279  		}
 13280  		v.reset(OpARMXOR)
 13281  		v.Type = t
 13282  		v0 := b.NewValue0(v.Pos, OpARMSRLconst, t)
 13283  		v0.AuxInt = int32ToAuxInt(8)
 13284  		v1 := b.NewValue0(v.Pos, OpARMBICconst, t)
 13285  		v1.AuxInt = int32ToAuxInt(0xff0000)
 13286  		v2 := b.NewValue0(v.Pos, OpARMXOR, t)
 13287  		v3 := b.NewValue0(v.Pos, OpARMSRRconst, t)
 13288  		v3.AuxInt = int32ToAuxInt(16)
 13289  		v3.AddArg(x)
 13290  		v2.AddArg2(x, v3)
 13291  		v1.AddArg(v2)
 13292  		v0.AddArg(v1)
 13293  		v4 := b.NewValue0(v.Pos, OpARMSRRconst, t)
 13294  		v4.AuxInt = int32ToAuxInt(8)
 13295  		v4.AddArg(x)
 13296  		v.AddArg2(v0, v4)
 13297  		return true
 13298  	}
 13299  	// match: (Bswap32 x)
 13300  	// cond: buildcfg.GOARM.Version>=6
 13301  	// result: (REV x)
 13302  	for {
 13303  		x := v_0
 13304  		if !(buildcfg.GOARM.Version >= 6) {
 13305  			break
 13306  		}
 13307  		v.reset(OpARMREV)
 13308  		v.AddArg(x)
 13309  		return true
 13310  	}
 13311  	return false
 13312  }
 13313  func rewriteValueARM_OpConst16(v *Value) bool {
 13314  	// match: (Const16 [val])
 13315  	// result: (MOVWconst [int32(val)])
 13316  	for {
 13317  		val := auxIntToInt16(v.AuxInt)
 13318  		v.reset(OpARMMOVWconst)
 13319  		v.AuxInt = int32ToAuxInt(int32(val))
 13320  		return true
 13321  	}
 13322  }
 13323  func rewriteValueARM_OpConst32(v *Value) bool {
 13324  	// match: (Const32 [val])
 13325  	// result: (MOVWconst [int32(val)])
 13326  	for {
 13327  		val := auxIntToInt32(v.AuxInt)
 13328  		v.reset(OpARMMOVWconst)
 13329  		v.AuxInt = int32ToAuxInt(int32(val))
 13330  		return true
 13331  	}
 13332  }
 13333  func rewriteValueARM_OpConst32F(v *Value) bool {
 13334  	// match: (Const32F [val])
 13335  	// result: (MOVFconst [float64(val)])
 13336  	for {
 13337  		val := auxIntToFloat32(v.AuxInt)
 13338  		v.reset(OpARMMOVFconst)
 13339  		v.AuxInt = float64ToAuxInt(float64(val))
 13340  		return true
 13341  	}
 13342  }
 13343  func rewriteValueARM_OpConst64F(v *Value) bool {
 13344  	// match: (Const64F [val])
 13345  	// result: (MOVDconst [float64(val)])
 13346  	for {
 13347  		val := auxIntToFloat64(v.AuxInt)
 13348  		v.reset(OpARMMOVDconst)
 13349  		v.AuxInt = float64ToAuxInt(float64(val))
 13350  		return true
 13351  	}
 13352  }
 13353  func rewriteValueARM_OpConst8(v *Value) bool {
 13354  	// match: (Const8 [val])
 13355  	// result: (MOVWconst [int32(val)])
 13356  	for {
 13357  		val := auxIntToInt8(v.AuxInt)
 13358  		v.reset(OpARMMOVWconst)
 13359  		v.AuxInt = int32ToAuxInt(int32(val))
 13360  		return true
 13361  	}
 13362  }
 13363  func rewriteValueARM_OpConstBool(v *Value) bool {
 13364  	// match: (ConstBool [t])
 13365  	// result: (MOVWconst [b2i32(t)])
 13366  	for {
 13367  		t := auxIntToBool(v.AuxInt)
 13368  		v.reset(OpARMMOVWconst)
 13369  		v.AuxInt = int32ToAuxInt(b2i32(t))
 13370  		return true
 13371  	}
 13372  }
 13373  func rewriteValueARM_OpConstNil(v *Value) bool {
 13374  	// match: (ConstNil)
 13375  	// result: (MOVWconst [0])
 13376  	for {
 13377  		v.reset(OpARMMOVWconst)
 13378  		v.AuxInt = int32ToAuxInt(0)
 13379  		return true
 13380  	}
 13381  }
 13382  func rewriteValueARM_OpCtz16(v *Value) bool {
 13383  	v_0 := v.Args[0]
 13384  	b := v.Block
 13385  	typ := &b.Func.Config.Types
 13386  	// match: (Ctz16 <t> x)
 13387  	// cond: buildcfg.GOARM.Version<=6
 13388  	// result: (RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x10000] x))) [1])))
 13389  	for {
 13390  		t := v.Type
 13391  		x := v_0
 13392  		if !(buildcfg.GOARM.Version <= 6) {
 13393  			break
 13394  		}
 13395  		v.reset(OpARMRSBconst)
 13396  		v.AuxInt = int32ToAuxInt(32)
 13397  		v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
 13398  		v1 := b.NewValue0(v.Pos, OpARMSUBconst, typ.UInt32)
 13399  		v1.AuxInt = int32ToAuxInt(1)
 13400  		v2 := b.NewValue0(v.Pos, OpARMAND, typ.UInt32)
 13401  		v3 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
 13402  		v3.AuxInt = int32ToAuxInt(0x10000)
 13403  		v3.AddArg(x)
 13404  		v4 := b.NewValue0(v.Pos, OpARMRSBconst, typ.UInt32)
 13405  		v4.AuxInt = int32ToAuxInt(0)
 13406  		v4.AddArg(v3)
 13407  		v2.AddArg2(v3, v4)
 13408  		v1.AddArg(v2)
 13409  		v0.AddArg(v1)
 13410  		v.AddArg(v0)
 13411  		return true
 13412  	}
 13413  	// match: (Ctz16 <t> x)
 13414  	// cond: buildcfg.GOARM.Version==7
 13415  	// result: (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x10000] x)))
 13416  	for {
 13417  		t := v.Type
 13418  		x := v_0
 13419  		if !(buildcfg.GOARM.Version == 7) {
 13420  			break
 13421  		}
 13422  		v.reset(OpARMCLZ)
 13423  		v.Type = t
 13424  		v0 := b.NewValue0(v.Pos, OpARMRBIT, typ.UInt32)
 13425  		v1 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
 13426  		v1.AuxInt = int32ToAuxInt(0x10000)
 13427  		v1.AddArg(x)
 13428  		v0.AddArg(v1)
 13429  		v.AddArg(v0)
 13430  		return true
 13431  	}
 13432  	return false
 13433  }
 13434  func rewriteValueARM_OpCtz32(v *Value) bool {
 13435  	v_0 := v.Args[0]
 13436  	b := v.Block
 13437  	// match: (Ctz32 <t> x)
 13438  	// cond: buildcfg.GOARM.Version<=6
 13439  	// result: (RSBconst [32] (CLZ <t> (SUBconst <t> (AND <t> x (RSBconst <t> [0] x)) [1])))
 13440  	for {
 13441  		t := v.Type
 13442  		x := v_0
 13443  		if !(buildcfg.GOARM.Version <= 6) {
 13444  			break
 13445  		}
 13446  		v.reset(OpARMRSBconst)
 13447  		v.AuxInt = int32ToAuxInt(32)
 13448  		v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
 13449  		v1 := b.NewValue0(v.Pos, OpARMSUBconst, t)
 13450  		v1.AuxInt = int32ToAuxInt(1)
 13451  		v2 := b.NewValue0(v.Pos, OpARMAND, t)
 13452  		v3 := b.NewValue0(v.Pos, OpARMRSBconst, t)
 13453  		v3.AuxInt = int32ToAuxInt(0)
 13454  		v3.AddArg(x)
 13455  		v2.AddArg2(x, v3)
 13456  		v1.AddArg(v2)
 13457  		v0.AddArg(v1)
 13458  		v.AddArg(v0)
 13459  		return true
 13460  	}
 13461  	// match: (Ctz32 <t> x)
 13462  	// cond: buildcfg.GOARM.Version==7
 13463  	// result: (CLZ <t> (RBIT <t> x))
 13464  	for {
 13465  		t := v.Type
 13466  		x := v_0
 13467  		if !(buildcfg.GOARM.Version == 7) {
 13468  			break
 13469  		}
 13470  		v.reset(OpARMCLZ)
 13471  		v.Type = t
 13472  		v0 := b.NewValue0(v.Pos, OpARMRBIT, t)
 13473  		v0.AddArg(x)
 13474  		v.AddArg(v0)
 13475  		return true
 13476  	}
 13477  	return false
 13478  }
 13479  func rewriteValueARM_OpCtz8(v *Value) bool {
 13480  	v_0 := v.Args[0]
 13481  	b := v.Block
 13482  	typ := &b.Func.Config.Types
 13483  	// match: (Ctz8 <t> x)
 13484  	// cond: buildcfg.GOARM.Version<=6
 13485  	// result: (RSBconst [32] (CLZ <t> (SUBconst <typ.UInt32> (AND <typ.UInt32> (ORconst <typ.UInt32> [0x100] x) (RSBconst <typ.UInt32> [0] (ORconst <typ.UInt32> [0x100] x))) [1])))
 13486  	for {
 13487  		t := v.Type
 13488  		x := v_0
 13489  		if !(buildcfg.GOARM.Version <= 6) {
 13490  			break
 13491  		}
 13492  		v.reset(OpARMRSBconst)
 13493  		v.AuxInt = int32ToAuxInt(32)
 13494  		v0 := b.NewValue0(v.Pos, OpARMCLZ, t)
 13495  		v1 := b.NewValue0(v.Pos, OpARMSUBconst, typ.UInt32)
 13496  		v1.AuxInt = int32ToAuxInt(1)
 13497  		v2 := b.NewValue0(v.Pos, OpARMAND, typ.UInt32)
 13498  		v3 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
 13499  		v3.AuxInt = int32ToAuxInt(0x100)
 13500  		v3.AddArg(x)
 13501  		v4 := b.NewValue0(v.Pos, OpARMRSBconst, typ.UInt32)
 13502  		v4.AuxInt = int32ToAuxInt(0)
 13503  		v4.AddArg(v3)
 13504  		v2.AddArg2(v3, v4)
 13505  		v1.AddArg(v2)
 13506  		v0.AddArg(v1)
 13507  		v.AddArg(v0)
 13508  		return true
 13509  	}
 13510  	// match: (Ctz8 <t> x)
 13511  	// cond: buildcfg.GOARM.Version==7
 13512  	// result: (CLZ <t> (RBIT <typ.UInt32> (ORconst <typ.UInt32> [0x100] x)))
 13513  	for {
 13514  		t := v.Type
 13515  		x := v_0
 13516  		if !(buildcfg.GOARM.Version == 7) {
 13517  			break
 13518  		}
 13519  		v.reset(OpARMCLZ)
 13520  		v.Type = t
 13521  		v0 := b.NewValue0(v.Pos, OpARMRBIT, typ.UInt32)
 13522  		v1 := b.NewValue0(v.Pos, OpARMORconst, typ.UInt32)
 13523  		v1.AuxInt = int32ToAuxInt(0x100)
 13524  		v1.AddArg(x)
 13525  		v0.AddArg(v1)
 13526  		v.AddArg(v0)
 13527  		return true
 13528  	}
 13529  	return false
 13530  }
 13531  func rewriteValueARM_OpDiv16(v *Value) bool {
 13532  	v_1 := v.Args[1]
 13533  	v_0 := v.Args[0]
 13534  	b := v.Block
 13535  	typ := &b.Func.Config.Types
 13536  	// match: (Div16 x y)
 13537  	// result: (Div32 (SignExt16to32 x) (SignExt16to32 y))
 13538  	for {
 13539  		x := v_0
 13540  		y := v_1
 13541  		v.reset(OpDiv32)
 13542  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 13543  		v0.AddArg(x)
 13544  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 13545  		v1.AddArg(y)
 13546  		v.AddArg2(v0, v1)
 13547  		return true
 13548  	}
 13549  }
 13550  func rewriteValueARM_OpDiv16u(v *Value) bool {
 13551  	v_1 := v.Args[1]
 13552  	v_0 := v.Args[0]
 13553  	b := v.Block
 13554  	typ := &b.Func.Config.Types
 13555  	// match: (Div16u x y)
 13556  	// result: (Div32u (ZeroExt16to32 x) (ZeroExt16to32 y))
 13557  	for {
 13558  		x := v_0
 13559  		y := v_1
 13560  		v.reset(OpDiv32u)
 13561  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13562  		v0.AddArg(x)
 13563  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13564  		v1.AddArg(y)
 13565  		v.AddArg2(v0, v1)
 13566  		return true
 13567  	}
 13568  }
 13569  func rewriteValueARM_OpDiv32(v *Value) bool {
 13570  	v_1 := v.Args[1]
 13571  	v_0 := v.Args[0]
 13572  	b := v.Block
 13573  	typ := &b.Func.Config.Types
 13574  	// match: (Div32 x y)
 13575  	// result: (SUB (XOR <typ.UInt32> (Select0 <typ.UInt32> (CALLudiv (SUB <typ.UInt32> (XOR x <typ.UInt32> (Signmask x)) (Signmask x)) (SUB <typ.UInt32> (XOR y <typ.UInt32> (Signmask y)) (Signmask y)))) (Signmask (XOR <typ.UInt32> x y))) (Signmask (XOR <typ.UInt32> x y)))
 13576  	for {
 13577  		x := v_0
 13578  		y := v_1
 13579  		v.reset(OpARMSUB)
 13580  		v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 13581  		v1 := b.NewValue0(v.Pos, OpSelect0, typ.UInt32)
 13582  		v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
 13583  		v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
 13584  		v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 13585  		v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
 13586  		v5.AddArg(x)
 13587  		v4.AddArg2(x, v5)
 13588  		v3.AddArg2(v4, v5)
 13589  		v6 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
 13590  		v7 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 13591  		v8 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
 13592  		v8.AddArg(y)
 13593  		v7.AddArg2(y, v8)
 13594  		v6.AddArg2(v7, v8)
 13595  		v2.AddArg2(v3, v6)
 13596  		v1.AddArg(v2)
 13597  		v9 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
 13598  		v10 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 13599  		v10.AddArg2(x, y)
 13600  		v9.AddArg(v10)
 13601  		v0.AddArg2(v1, v9)
 13602  		v.AddArg2(v0, v9)
 13603  		return true
 13604  	}
 13605  }
 13606  func rewriteValueARM_OpDiv32u(v *Value) bool {
 13607  	v_1 := v.Args[1]
 13608  	v_0 := v.Args[0]
 13609  	b := v.Block
 13610  	typ := &b.Func.Config.Types
 13611  	// match: (Div32u x y)
 13612  	// result: (Select0 <typ.UInt32> (CALLudiv x y))
 13613  	for {
 13614  		x := v_0
 13615  		y := v_1
 13616  		v.reset(OpSelect0)
 13617  		v.Type = typ.UInt32
 13618  		v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
 13619  		v0.AddArg2(x, y)
 13620  		v.AddArg(v0)
 13621  		return true
 13622  	}
 13623  }
 13624  func rewriteValueARM_OpDiv8(v *Value) bool {
 13625  	v_1 := v.Args[1]
 13626  	v_0 := v.Args[0]
 13627  	b := v.Block
 13628  	typ := &b.Func.Config.Types
 13629  	// match: (Div8 x y)
 13630  	// result: (Div32 (SignExt8to32 x) (SignExt8to32 y))
 13631  	for {
 13632  		x := v_0
 13633  		y := v_1
 13634  		v.reset(OpDiv32)
 13635  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 13636  		v0.AddArg(x)
 13637  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 13638  		v1.AddArg(y)
 13639  		v.AddArg2(v0, v1)
 13640  		return true
 13641  	}
 13642  }
 13643  func rewriteValueARM_OpDiv8u(v *Value) bool {
 13644  	v_1 := v.Args[1]
 13645  	v_0 := v.Args[0]
 13646  	b := v.Block
 13647  	typ := &b.Func.Config.Types
 13648  	// match: (Div8u x y)
 13649  	// result: (Div32u (ZeroExt8to32 x) (ZeroExt8to32 y))
 13650  	for {
 13651  		x := v_0
 13652  		y := v_1
 13653  		v.reset(OpDiv32u)
 13654  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13655  		v0.AddArg(x)
 13656  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13657  		v1.AddArg(y)
 13658  		v.AddArg2(v0, v1)
 13659  		return true
 13660  	}
 13661  }
 13662  func rewriteValueARM_OpEq16(v *Value) bool {
 13663  	v_1 := v.Args[1]
 13664  	v_0 := v.Args[0]
 13665  	b := v.Block
 13666  	typ := &b.Func.Config.Types
 13667  	// match: (Eq16 x y)
 13668  	// result: (Equal (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
 13669  	for {
 13670  		x := v_0
 13671  		y := v_1
 13672  		v.reset(OpARMEqual)
 13673  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13674  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13675  		v1.AddArg(x)
 13676  		v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13677  		v2.AddArg(y)
 13678  		v0.AddArg2(v1, v2)
 13679  		v.AddArg(v0)
 13680  		return true
 13681  	}
 13682  }
 13683  func rewriteValueARM_OpEq32(v *Value) bool {
 13684  	v_1 := v.Args[1]
 13685  	v_0 := v.Args[0]
 13686  	b := v.Block
 13687  	// match: (Eq32 x y)
 13688  	// result: (Equal (CMP x y))
 13689  	for {
 13690  		x := v_0
 13691  		y := v_1
 13692  		v.reset(OpARMEqual)
 13693  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13694  		v0.AddArg2(x, y)
 13695  		v.AddArg(v0)
 13696  		return true
 13697  	}
 13698  }
 13699  func rewriteValueARM_OpEq32F(v *Value) bool {
 13700  	v_1 := v.Args[1]
 13701  	v_0 := v.Args[0]
 13702  	b := v.Block
 13703  	// match: (Eq32F x y)
 13704  	// result: (Equal (CMPF x y))
 13705  	for {
 13706  		x := v_0
 13707  		y := v_1
 13708  		v.reset(OpARMEqual)
 13709  		v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
 13710  		v0.AddArg2(x, y)
 13711  		v.AddArg(v0)
 13712  		return true
 13713  	}
 13714  }
 13715  func rewriteValueARM_OpEq64F(v *Value) bool {
 13716  	v_1 := v.Args[1]
 13717  	v_0 := v.Args[0]
 13718  	b := v.Block
 13719  	// match: (Eq64F x y)
 13720  	// result: (Equal (CMPD x y))
 13721  	for {
 13722  		x := v_0
 13723  		y := v_1
 13724  		v.reset(OpARMEqual)
 13725  		v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
 13726  		v0.AddArg2(x, y)
 13727  		v.AddArg(v0)
 13728  		return true
 13729  	}
 13730  }
 13731  func rewriteValueARM_OpEq8(v *Value) bool {
 13732  	v_1 := v.Args[1]
 13733  	v_0 := v.Args[0]
 13734  	b := v.Block
 13735  	typ := &b.Func.Config.Types
 13736  	// match: (Eq8 x y)
 13737  	// result: (Equal (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
 13738  	for {
 13739  		x := v_0
 13740  		y := v_1
 13741  		v.reset(OpARMEqual)
 13742  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13743  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13744  		v1.AddArg(x)
 13745  		v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13746  		v2.AddArg(y)
 13747  		v0.AddArg2(v1, v2)
 13748  		v.AddArg(v0)
 13749  		return true
 13750  	}
 13751  }
 13752  func rewriteValueARM_OpEqB(v *Value) bool {
 13753  	v_1 := v.Args[1]
 13754  	v_0 := v.Args[0]
 13755  	b := v.Block
 13756  	typ := &b.Func.Config.Types
 13757  	// match: (EqB x y)
 13758  	// result: (XORconst [1] (XOR <typ.Bool> x y))
 13759  	for {
 13760  		x := v_0
 13761  		y := v_1
 13762  		v.reset(OpARMXORconst)
 13763  		v.AuxInt = int32ToAuxInt(1)
 13764  		v0 := b.NewValue0(v.Pos, OpARMXOR, typ.Bool)
 13765  		v0.AddArg2(x, y)
 13766  		v.AddArg(v0)
 13767  		return true
 13768  	}
 13769  }
 13770  func rewriteValueARM_OpEqPtr(v *Value) bool {
 13771  	v_1 := v.Args[1]
 13772  	v_0 := v.Args[0]
 13773  	b := v.Block
 13774  	// match: (EqPtr x y)
 13775  	// result: (Equal (CMP x y))
 13776  	for {
 13777  		x := v_0
 13778  		y := v_1
 13779  		v.reset(OpARMEqual)
 13780  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13781  		v0.AddArg2(x, y)
 13782  		v.AddArg(v0)
 13783  		return true
 13784  	}
 13785  }
 13786  func rewriteValueARM_OpFMA(v *Value) bool {
 13787  	v_2 := v.Args[2]
 13788  	v_1 := v.Args[1]
 13789  	v_0 := v.Args[0]
 13790  	// match: (FMA x y z)
 13791  	// result: (FMULAD z x y)
 13792  	for {
 13793  		x := v_0
 13794  		y := v_1
 13795  		z := v_2
 13796  		v.reset(OpARMFMULAD)
 13797  		v.AddArg3(z, x, y)
 13798  		return true
 13799  	}
 13800  }
 13801  func rewriteValueARM_OpIsInBounds(v *Value) bool {
 13802  	v_1 := v.Args[1]
 13803  	v_0 := v.Args[0]
 13804  	b := v.Block
 13805  	// match: (IsInBounds idx len)
 13806  	// result: (LessThanU (CMP idx len))
 13807  	for {
 13808  		idx := v_0
 13809  		len := v_1
 13810  		v.reset(OpARMLessThanU)
 13811  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13812  		v0.AddArg2(idx, len)
 13813  		v.AddArg(v0)
 13814  		return true
 13815  	}
 13816  }
 13817  func rewriteValueARM_OpIsNonNil(v *Value) bool {
 13818  	v_0 := v.Args[0]
 13819  	b := v.Block
 13820  	// match: (IsNonNil ptr)
 13821  	// result: (NotEqual (CMPconst [0] ptr))
 13822  	for {
 13823  		ptr := v_0
 13824  		v.reset(OpARMNotEqual)
 13825  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 13826  		v0.AuxInt = int32ToAuxInt(0)
 13827  		v0.AddArg(ptr)
 13828  		v.AddArg(v0)
 13829  		return true
 13830  	}
 13831  }
 13832  func rewriteValueARM_OpIsSliceInBounds(v *Value) bool {
 13833  	v_1 := v.Args[1]
 13834  	v_0 := v.Args[0]
 13835  	b := v.Block
 13836  	// match: (IsSliceInBounds idx len)
 13837  	// result: (LessEqualU (CMP idx len))
 13838  	for {
 13839  		idx := v_0
 13840  		len := v_1
 13841  		v.reset(OpARMLessEqualU)
 13842  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13843  		v0.AddArg2(idx, len)
 13844  		v.AddArg(v0)
 13845  		return true
 13846  	}
 13847  }
 13848  func rewriteValueARM_OpLeq16(v *Value) bool {
 13849  	v_1 := v.Args[1]
 13850  	v_0 := v.Args[0]
 13851  	b := v.Block
 13852  	typ := &b.Func.Config.Types
 13853  	// match: (Leq16 x y)
 13854  	// result: (LessEqual (CMP (SignExt16to32 x) (SignExt16to32 y)))
 13855  	for {
 13856  		x := v_0
 13857  		y := v_1
 13858  		v.reset(OpARMLessEqual)
 13859  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13860  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 13861  		v1.AddArg(x)
 13862  		v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 13863  		v2.AddArg(y)
 13864  		v0.AddArg2(v1, v2)
 13865  		v.AddArg(v0)
 13866  		return true
 13867  	}
 13868  }
 13869  func rewriteValueARM_OpLeq16U(v *Value) bool {
 13870  	v_1 := v.Args[1]
 13871  	v_0 := v.Args[0]
 13872  	b := v.Block
 13873  	typ := &b.Func.Config.Types
 13874  	// match: (Leq16U x y)
 13875  	// result: (LessEqualU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
 13876  	for {
 13877  		x := v_0
 13878  		y := v_1
 13879  		v.reset(OpARMLessEqualU)
 13880  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13881  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13882  		v1.AddArg(x)
 13883  		v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 13884  		v2.AddArg(y)
 13885  		v0.AddArg2(v1, v2)
 13886  		v.AddArg(v0)
 13887  		return true
 13888  	}
 13889  }
 13890  func rewriteValueARM_OpLeq32(v *Value) bool {
 13891  	v_1 := v.Args[1]
 13892  	v_0 := v.Args[0]
 13893  	b := v.Block
 13894  	// match: (Leq32 x y)
 13895  	// result: (LessEqual (CMP x y))
 13896  	for {
 13897  		x := v_0
 13898  		y := v_1
 13899  		v.reset(OpARMLessEqual)
 13900  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13901  		v0.AddArg2(x, y)
 13902  		v.AddArg(v0)
 13903  		return true
 13904  	}
 13905  }
 13906  func rewriteValueARM_OpLeq32F(v *Value) bool {
 13907  	v_1 := v.Args[1]
 13908  	v_0 := v.Args[0]
 13909  	b := v.Block
 13910  	// match: (Leq32F x y)
 13911  	// result: (GreaterEqual (CMPF y x))
 13912  	for {
 13913  		x := v_0
 13914  		y := v_1
 13915  		v.reset(OpARMGreaterEqual)
 13916  		v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
 13917  		v0.AddArg2(y, x)
 13918  		v.AddArg(v0)
 13919  		return true
 13920  	}
 13921  }
 13922  func rewriteValueARM_OpLeq32U(v *Value) bool {
 13923  	v_1 := v.Args[1]
 13924  	v_0 := v.Args[0]
 13925  	b := v.Block
 13926  	// match: (Leq32U x y)
 13927  	// result: (LessEqualU (CMP x y))
 13928  	for {
 13929  		x := v_0
 13930  		y := v_1
 13931  		v.reset(OpARMLessEqualU)
 13932  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13933  		v0.AddArg2(x, y)
 13934  		v.AddArg(v0)
 13935  		return true
 13936  	}
 13937  }
 13938  func rewriteValueARM_OpLeq64F(v *Value) bool {
 13939  	v_1 := v.Args[1]
 13940  	v_0 := v.Args[0]
 13941  	b := v.Block
 13942  	// match: (Leq64F x y)
 13943  	// result: (GreaterEqual (CMPD y x))
 13944  	for {
 13945  		x := v_0
 13946  		y := v_1
 13947  		v.reset(OpARMGreaterEqual)
 13948  		v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
 13949  		v0.AddArg2(y, x)
 13950  		v.AddArg(v0)
 13951  		return true
 13952  	}
 13953  }
 13954  func rewriteValueARM_OpLeq8(v *Value) bool {
 13955  	v_1 := v.Args[1]
 13956  	v_0 := v.Args[0]
 13957  	b := v.Block
 13958  	typ := &b.Func.Config.Types
 13959  	// match: (Leq8 x y)
 13960  	// result: (LessEqual (CMP (SignExt8to32 x) (SignExt8to32 y)))
 13961  	for {
 13962  		x := v_0
 13963  		y := v_1
 13964  		v.reset(OpARMLessEqual)
 13965  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13966  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 13967  		v1.AddArg(x)
 13968  		v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 13969  		v2.AddArg(y)
 13970  		v0.AddArg2(v1, v2)
 13971  		v.AddArg(v0)
 13972  		return true
 13973  	}
 13974  }
 13975  func rewriteValueARM_OpLeq8U(v *Value) bool {
 13976  	v_1 := v.Args[1]
 13977  	v_0 := v.Args[0]
 13978  	b := v.Block
 13979  	typ := &b.Func.Config.Types
 13980  	// match: (Leq8U x y)
 13981  	// result: (LessEqualU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
 13982  	for {
 13983  		x := v_0
 13984  		y := v_1
 13985  		v.reset(OpARMLessEqualU)
 13986  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 13987  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13988  		v1.AddArg(x)
 13989  		v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 13990  		v2.AddArg(y)
 13991  		v0.AddArg2(v1, v2)
 13992  		v.AddArg(v0)
 13993  		return true
 13994  	}
 13995  }
 13996  func rewriteValueARM_OpLess16(v *Value) bool {
 13997  	v_1 := v.Args[1]
 13998  	v_0 := v.Args[0]
 13999  	b := v.Block
 14000  	typ := &b.Func.Config.Types
 14001  	// match: (Less16 x y)
 14002  	// result: (LessThan (CMP (SignExt16to32 x) (SignExt16to32 y)))
 14003  	for {
 14004  		x := v_0
 14005  		y := v_1
 14006  		v.reset(OpARMLessThan)
 14007  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14008  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 14009  		v1.AddArg(x)
 14010  		v2 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 14011  		v2.AddArg(y)
 14012  		v0.AddArg2(v1, v2)
 14013  		v.AddArg(v0)
 14014  		return true
 14015  	}
 14016  }
 14017  func rewriteValueARM_OpLess16U(v *Value) bool {
 14018  	v_1 := v.Args[1]
 14019  	v_0 := v.Args[0]
 14020  	b := v.Block
 14021  	typ := &b.Func.Config.Types
 14022  	// match: (Less16U x y)
 14023  	// result: (LessThanU (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
 14024  	for {
 14025  		x := v_0
 14026  		y := v_1
 14027  		v.reset(OpARMLessThanU)
 14028  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14029  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14030  		v1.AddArg(x)
 14031  		v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14032  		v2.AddArg(y)
 14033  		v0.AddArg2(v1, v2)
 14034  		v.AddArg(v0)
 14035  		return true
 14036  	}
 14037  }
 14038  func rewriteValueARM_OpLess32(v *Value) bool {
 14039  	v_1 := v.Args[1]
 14040  	v_0 := v.Args[0]
 14041  	b := v.Block
 14042  	// match: (Less32 x y)
 14043  	// result: (LessThan (CMP x y))
 14044  	for {
 14045  		x := v_0
 14046  		y := v_1
 14047  		v.reset(OpARMLessThan)
 14048  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14049  		v0.AddArg2(x, y)
 14050  		v.AddArg(v0)
 14051  		return true
 14052  	}
 14053  }
 14054  func rewriteValueARM_OpLess32F(v *Value) bool {
 14055  	v_1 := v.Args[1]
 14056  	v_0 := v.Args[0]
 14057  	b := v.Block
 14058  	// match: (Less32F x y)
 14059  	// result: (GreaterThan (CMPF y x))
 14060  	for {
 14061  		x := v_0
 14062  		y := v_1
 14063  		v.reset(OpARMGreaterThan)
 14064  		v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
 14065  		v0.AddArg2(y, x)
 14066  		v.AddArg(v0)
 14067  		return true
 14068  	}
 14069  }
 14070  func rewriteValueARM_OpLess32U(v *Value) bool {
 14071  	v_1 := v.Args[1]
 14072  	v_0 := v.Args[0]
 14073  	b := v.Block
 14074  	// match: (Less32U x y)
 14075  	// result: (LessThanU (CMP x y))
 14076  	for {
 14077  		x := v_0
 14078  		y := v_1
 14079  		v.reset(OpARMLessThanU)
 14080  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14081  		v0.AddArg2(x, y)
 14082  		v.AddArg(v0)
 14083  		return true
 14084  	}
 14085  }
 14086  func rewriteValueARM_OpLess64F(v *Value) bool {
 14087  	v_1 := v.Args[1]
 14088  	v_0 := v.Args[0]
 14089  	b := v.Block
 14090  	// match: (Less64F x y)
 14091  	// result: (GreaterThan (CMPD y x))
 14092  	for {
 14093  		x := v_0
 14094  		y := v_1
 14095  		v.reset(OpARMGreaterThan)
 14096  		v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
 14097  		v0.AddArg2(y, x)
 14098  		v.AddArg(v0)
 14099  		return true
 14100  	}
 14101  }
 14102  func rewriteValueARM_OpLess8(v *Value) bool {
 14103  	v_1 := v.Args[1]
 14104  	v_0 := v.Args[0]
 14105  	b := v.Block
 14106  	typ := &b.Func.Config.Types
 14107  	// match: (Less8 x y)
 14108  	// result: (LessThan (CMP (SignExt8to32 x) (SignExt8to32 y)))
 14109  	for {
 14110  		x := v_0
 14111  		y := v_1
 14112  		v.reset(OpARMLessThan)
 14113  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14114  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 14115  		v1.AddArg(x)
 14116  		v2 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 14117  		v2.AddArg(y)
 14118  		v0.AddArg2(v1, v2)
 14119  		v.AddArg(v0)
 14120  		return true
 14121  	}
 14122  }
 14123  func rewriteValueARM_OpLess8U(v *Value) bool {
 14124  	v_1 := v.Args[1]
 14125  	v_0 := v.Args[0]
 14126  	b := v.Block
 14127  	typ := &b.Func.Config.Types
 14128  	// match: (Less8U x y)
 14129  	// result: (LessThanU (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
 14130  	for {
 14131  		x := v_0
 14132  		y := v_1
 14133  		v.reset(OpARMLessThanU)
 14134  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14135  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14136  		v1.AddArg(x)
 14137  		v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14138  		v2.AddArg(y)
 14139  		v0.AddArg2(v1, v2)
 14140  		v.AddArg(v0)
 14141  		return true
 14142  	}
 14143  }
 14144  func rewriteValueARM_OpLoad(v *Value) bool {
 14145  	v_1 := v.Args[1]
 14146  	v_0 := v.Args[0]
 14147  	// match: (Load <t> ptr mem)
 14148  	// cond: t.IsBoolean()
 14149  	// result: (MOVBUload ptr mem)
 14150  	for {
 14151  		t := v.Type
 14152  		ptr := v_0
 14153  		mem := v_1
 14154  		if !(t.IsBoolean()) {
 14155  			break
 14156  		}
 14157  		v.reset(OpARMMOVBUload)
 14158  		v.AddArg2(ptr, mem)
 14159  		return true
 14160  	}
 14161  	// match: (Load <t> ptr mem)
 14162  	// cond: (is8BitInt(t) && t.IsSigned())
 14163  	// result: (MOVBload ptr mem)
 14164  	for {
 14165  		t := v.Type
 14166  		ptr := v_0
 14167  		mem := v_1
 14168  		if !(is8BitInt(t) && t.IsSigned()) {
 14169  			break
 14170  		}
 14171  		v.reset(OpARMMOVBload)
 14172  		v.AddArg2(ptr, mem)
 14173  		return true
 14174  	}
 14175  	// match: (Load <t> ptr mem)
 14176  	// cond: (is8BitInt(t) && !t.IsSigned())
 14177  	// result: (MOVBUload ptr mem)
 14178  	for {
 14179  		t := v.Type
 14180  		ptr := v_0
 14181  		mem := v_1
 14182  		if !(is8BitInt(t) && !t.IsSigned()) {
 14183  			break
 14184  		}
 14185  		v.reset(OpARMMOVBUload)
 14186  		v.AddArg2(ptr, mem)
 14187  		return true
 14188  	}
 14189  	// match: (Load <t> ptr mem)
 14190  	// cond: (is16BitInt(t) && t.IsSigned())
 14191  	// result: (MOVHload ptr mem)
 14192  	for {
 14193  		t := v.Type
 14194  		ptr := v_0
 14195  		mem := v_1
 14196  		if !(is16BitInt(t) && t.IsSigned()) {
 14197  			break
 14198  		}
 14199  		v.reset(OpARMMOVHload)
 14200  		v.AddArg2(ptr, mem)
 14201  		return true
 14202  	}
 14203  	// match: (Load <t> ptr mem)
 14204  	// cond: (is16BitInt(t) && !t.IsSigned())
 14205  	// result: (MOVHUload ptr mem)
 14206  	for {
 14207  		t := v.Type
 14208  		ptr := v_0
 14209  		mem := v_1
 14210  		if !(is16BitInt(t) && !t.IsSigned()) {
 14211  			break
 14212  		}
 14213  		v.reset(OpARMMOVHUload)
 14214  		v.AddArg2(ptr, mem)
 14215  		return true
 14216  	}
 14217  	// match: (Load <t> ptr mem)
 14218  	// cond: (is32BitInt(t) || isPtr(t))
 14219  	// result: (MOVWload ptr mem)
 14220  	for {
 14221  		t := v.Type
 14222  		ptr := v_0
 14223  		mem := v_1
 14224  		if !(is32BitInt(t) || isPtr(t)) {
 14225  			break
 14226  		}
 14227  		v.reset(OpARMMOVWload)
 14228  		v.AddArg2(ptr, mem)
 14229  		return true
 14230  	}
 14231  	// match: (Load <t> ptr mem)
 14232  	// cond: is32BitFloat(t)
 14233  	// result: (MOVFload ptr mem)
 14234  	for {
 14235  		t := v.Type
 14236  		ptr := v_0
 14237  		mem := v_1
 14238  		if !(is32BitFloat(t)) {
 14239  			break
 14240  		}
 14241  		v.reset(OpARMMOVFload)
 14242  		v.AddArg2(ptr, mem)
 14243  		return true
 14244  	}
 14245  	// match: (Load <t> ptr mem)
 14246  	// cond: is64BitFloat(t)
 14247  	// result: (MOVDload ptr mem)
 14248  	for {
 14249  		t := v.Type
 14250  		ptr := v_0
 14251  		mem := v_1
 14252  		if !(is64BitFloat(t)) {
 14253  			break
 14254  		}
 14255  		v.reset(OpARMMOVDload)
 14256  		v.AddArg2(ptr, mem)
 14257  		return true
 14258  	}
 14259  	return false
 14260  }
 14261  func rewriteValueARM_OpLocalAddr(v *Value) bool {
 14262  	v_1 := v.Args[1]
 14263  	v_0 := v.Args[0]
 14264  	b := v.Block
 14265  	typ := &b.Func.Config.Types
 14266  	// match: (LocalAddr <t> {sym} base mem)
 14267  	// cond: t.Elem().HasPointers()
 14268  	// result: (MOVWaddr {sym} (SPanchored base mem))
 14269  	for {
 14270  		t := v.Type
 14271  		sym := auxToSym(v.Aux)
 14272  		base := v_0
 14273  		mem := v_1
 14274  		if !(t.Elem().HasPointers()) {
 14275  			break
 14276  		}
 14277  		v.reset(OpARMMOVWaddr)
 14278  		v.Aux = symToAux(sym)
 14279  		v0 := b.NewValue0(v.Pos, OpSPanchored, typ.Uintptr)
 14280  		v0.AddArg2(base, mem)
 14281  		v.AddArg(v0)
 14282  		return true
 14283  	}
 14284  	// match: (LocalAddr <t> {sym} base _)
 14285  	// cond: !t.Elem().HasPointers()
 14286  	// result: (MOVWaddr {sym} base)
 14287  	for {
 14288  		t := v.Type
 14289  		sym := auxToSym(v.Aux)
 14290  		base := v_0
 14291  		if !(!t.Elem().HasPointers()) {
 14292  			break
 14293  		}
 14294  		v.reset(OpARMMOVWaddr)
 14295  		v.Aux = symToAux(sym)
 14296  		v.AddArg(base)
 14297  		return true
 14298  	}
 14299  	return false
 14300  }
 14301  func rewriteValueARM_OpLsh16x16(v *Value) bool {
 14302  	v_1 := v.Args[1]
 14303  	v_0 := v.Args[0]
 14304  	b := v.Block
 14305  	typ := &b.Func.Config.Types
 14306  	// match: (Lsh16x16 x y)
 14307  	// result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
 14308  	for {
 14309  		x := v_0
 14310  		y := v_1
 14311  		v.reset(OpARMCMOVWHSconst)
 14312  		v.AuxInt = int32ToAuxInt(0)
 14313  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 14314  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14315  		v1.AddArg(y)
 14316  		v0.AddArg2(x, v1)
 14317  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 14318  		v2.AuxInt = int32ToAuxInt(256)
 14319  		v2.AddArg(v1)
 14320  		v.AddArg2(v0, v2)
 14321  		return true
 14322  	}
 14323  }
 14324  func rewriteValueARM_OpLsh16x32(v *Value) bool {
 14325  	v_1 := v.Args[1]
 14326  	v_0 := v.Args[0]
 14327  	b := v.Block
 14328  	// match: (Lsh16x32 x y)
 14329  	// result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0])
 14330  	for {
 14331  		x := v_0
 14332  		y := v_1
 14333  		v.reset(OpARMCMOVWHSconst)
 14334  		v.AuxInt = int32ToAuxInt(0)
 14335  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 14336  		v0.AddArg2(x, y)
 14337  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 14338  		v1.AuxInt = int32ToAuxInt(256)
 14339  		v1.AddArg(y)
 14340  		v.AddArg2(v0, v1)
 14341  		return true
 14342  	}
 14343  }
 14344  func rewriteValueARM_OpLsh16x64(v *Value) bool {
 14345  	v_1 := v.Args[1]
 14346  	v_0 := v.Args[0]
 14347  	// match: (Lsh16x64 x (Const64 [c]))
 14348  	// cond: uint64(c) < 16
 14349  	// result: (SLLconst x [int32(c)])
 14350  	for {
 14351  		x := v_0
 14352  		if v_1.Op != OpConst64 {
 14353  			break
 14354  		}
 14355  		c := auxIntToInt64(v_1.AuxInt)
 14356  		if !(uint64(c) < 16) {
 14357  			break
 14358  		}
 14359  		v.reset(OpARMSLLconst)
 14360  		v.AuxInt = int32ToAuxInt(int32(c))
 14361  		v.AddArg(x)
 14362  		return true
 14363  	}
 14364  	// match: (Lsh16x64 _ (Const64 [c]))
 14365  	// cond: uint64(c) >= 16
 14366  	// result: (Const16 [0])
 14367  	for {
 14368  		if v_1.Op != OpConst64 {
 14369  			break
 14370  		}
 14371  		c := auxIntToInt64(v_1.AuxInt)
 14372  		if !(uint64(c) >= 16) {
 14373  			break
 14374  		}
 14375  		v.reset(OpConst16)
 14376  		v.AuxInt = int16ToAuxInt(0)
 14377  		return true
 14378  	}
 14379  	return false
 14380  }
 14381  func rewriteValueARM_OpLsh16x8(v *Value) bool {
 14382  	v_1 := v.Args[1]
 14383  	v_0 := v.Args[0]
 14384  	b := v.Block
 14385  	typ := &b.Func.Config.Types
 14386  	// match: (Lsh16x8 x y)
 14387  	// result: (SLL x (ZeroExt8to32 y))
 14388  	for {
 14389  		x := v_0
 14390  		y := v_1
 14391  		v.reset(OpARMSLL)
 14392  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14393  		v0.AddArg(y)
 14394  		v.AddArg2(x, v0)
 14395  		return true
 14396  	}
 14397  }
 14398  func rewriteValueARM_OpLsh32x16(v *Value) bool {
 14399  	v_1 := v.Args[1]
 14400  	v_0 := v.Args[0]
 14401  	b := v.Block
 14402  	typ := &b.Func.Config.Types
 14403  	// match: (Lsh32x16 x y)
 14404  	// result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
 14405  	for {
 14406  		x := v_0
 14407  		y := v_1
 14408  		v.reset(OpARMCMOVWHSconst)
 14409  		v.AuxInt = int32ToAuxInt(0)
 14410  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 14411  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14412  		v1.AddArg(y)
 14413  		v0.AddArg2(x, v1)
 14414  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 14415  		v2.AuxInt = int32ToAuxInt(256)
 14416  		v2.AddArg(v1)
 14417  		v.AddArg2(v0, v2)
 14418  		return true
 14419  	}
 14420  }
 14421  func rewriteValueARM_OpLsh32x32(v *Value) bool {
 14422  	v_1 := v.Args[1]
 14423  	v_0 := v.Args[0]
 14424  	b := v.Block
 14425  	// match: (Lsh32x32 x y)
 14426  	// result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0])
 14427  	for {
 14428  		x := v_0
 14429  		y := v_1
 14430  		v.reset(OpARMCMOVWHSconst)
 14431  		v.AuxInt = int32ToAuxInt(0)
 14432  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 14433  		v0.AddArg2(x, y)
 14434  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 14435  		v1.AuxInt = int32ToAuxInt(256)
 14436  		v1.AddArg(y)
 14437  		v.AddArg2(v0, v1)
 14438  		return true
 14439  	}
 14440  }
 14441  func rewriteValueARM_OpLsh32x64(v *Value) bool {
 14442  	v_1 := v.Args[1]
 14443  	v_0 := v.Args[0]
 14444  	// match: (Lsh32x64 x (Const64 [c]))
 14445  	// cond: uint64(c) < 32
 14446  	// result: (SLLconst x [int32(c)])
 14447  	for {
 14448  		x := v_0
 14449  		if v_1.Op != OpConst64 {
 14450  			break
 14451  		}
 14452  		c := auxIntToInt64(v_1.AuxInt)
 14453  		if !(uint64(c) < 32) {
 14454  			break
 14455  		}
 14456  		v.reset(OpARMSLLconst)
 14457  		v.AuxInt = int32ToAuxInt(int32(c))
 14458  		v.AddArg(x)
 14459  		return true
 14460  	}
 14461  	// match: (Lsh32x64 _ (Const64 [c]))
 14462  	// cond: uint64(c) >= 32
 14463  	// result: (Const32 [0])
 14464  	for {
 14465  		if v_1.Op != OpConst64 {
 14466  			break
 14467  		}
 14468  		c := auxIntToInt64(v_1.AuxInt)
 14469  		if !(uint64(c) >= 32) {
 14470  			break
 14471  		}
 14472  		v.reset(OpConst32)
 14473  		v.AuxInt = int32ToAuxInt(0)
 14474  		return true
 14475  	}
 14476  	return false
 14477  }
 14478  func rewriteValueARM_OpLsh32x8(v *Value) bool {
 14479  	v_1 := v.Args[1]
 14480  	v_0 := v.Args[0]
 14481  	b := v.Block
 14482  	typ := &b.Func.Config.Types
 14483  	// match: (Lsh32x8 x y)
 14484  	// result: (SLL x (ZeroExt8to32 y))
 14485  	for {
 14486  		x := v_0
 14487  		y := v_1
 14488  		v.reset(OpARMSLL)
 14489  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14490  		v0.AddArg(y)
 14491  		v.AddArg2(x, v0)
 14492  		return true
 14493  	}
 14494  }
 14495  func rewriteValueARM_OpLsh8x16(v *Value) bool {
 14496  	v_1 := v.Args[1]
 14497  	v_0 := v.Args[0]
 14498  	b := v.Block
 14499  	typ := &b.Func.Config.Types
 14500  	// match: (Lsh8x16 x y)
 14501  	// result: (CMOVWHSconst (SLL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
 14502  	for {
 14503  		x := v_0
 14504  		y := v_1
 14505  		v.reset(OpARMCMOVWHSconst)
 14506  		v.AuxInt = int32ToAuxInt(0)
 14507  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 14508  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14509  		v1.AddArg(y)
 14510  		v0.AddArg2(x, v1)
 14511  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 14512  		v2.AuxInt = int32ToAuxInt(256)
 14513  		v2.AddArg(v1)
 14514  		v.AddArg2(v0, v2)
 14515  		return true
 14516  	}
 14517  }
 14518  func rewriteValueARM_OpLsh8x32(v *Value) bool {
 14519  	v_1 := v.Args[1]
 14520  	v_0 := v.Args[0]
 14521  	b := v.Block
 14522  	// match: (Lsh8x32 x y)
 14523  	// result: (CMOVWHSconst (SLL <x.Type> x y) (CMPconst [256] y) [0])
 14524  	for {
 14525  		x := v_0
 14526  		y := v_1
 14527  		v.reset(OpARMCMOVWHSconst)
 14528  		v.AuxInt = int32ToAuxInt(0)
 14529  		v0 := b.NewValue0(v.Pos, OpARMSLL, x.Type)
 14530  		v0.AddArg2(x, y)
 14531  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 14532  		v1.AuxInt = int32ToAuxInt(256)
 14533  		v1.AddArg(y)
 14534  		v.AddArg2(v0, v1)
 14535  		return true
 14536  	}
 14537  }
 14538  func rewriteValueARM_OpLsh8x64(v *Value) bool {
 14539  	v_1 := v.Args[1]
 14540  	v_0 := v.Args[0]
 14541  	// match: (Lsh8x64 x (Const64 [c]))
 14542  	// cond: uint64(c) < 8
 14543  	// result: (SLLconst x [int32(c)])
 14544  	for {
 14545  		x := v_0
 14546  		if v_1.Op != OpConst64 {
 14547  			break
 14548  		}
 14549  		c := auxIntToInt64(v_1.AuxInt)
 14550  		if !(uint64(c) < 8) {
 14551  			break
 14552  		}
 14553  		v.reset(OpARMSLLconst)
 14554  		v.AuxInt = int32ToAuxInt(int32(c))
 14555  		v.AddArg(x)
 14556  		return true
 14557  	}
 14558  	// match: (Lsh8x64 _ (Const64 [c]))
 14559  	// cond: uint64(c) >= 8
 14560  	// result: (Const8 [0])
 14561  	for {
 14562  		if v_1.Op != OpConst64 {
 14563  			break
 14564  		}
 14565  		c := auxIntToInt64(v_1.AuxInt)
 14566  		if !(uint64(c) >= 8) {
 14567  			break
 14568  		}
 14569  		v.reset(OpConst8)
 14570  		v.AuxInt = int8ToAuxInt(0)
 14571  		return true
 14572  	}
 14573  	return false
 14574  }
 14575  func rewriteValueARM_OpLsh8x8(v *Value) bool {
 14576  	v_1 := v.Args[1]
 14577  	v_0 := v.Args[0]
 14578  	b := v.Block
 14579  	typ := &b.Func.Config.Types
 14580  	// match: (Lsh8x8 x y)
 14581  	// result: (SLL x (ZeroExt8to32 y))
 14582  	for {
 14583  		x := v_0
 14584  		y := v_1
 14585  		v.reset(OpARMSLL)
 14586  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14587  		v0.AddArg(y)
 14588  		v.AddArg2(x, v0)
 14589  		return true
 14590  	}
 14591  }
 14592  func rewriteValueARM_OpMod16(v *Value) bool {
 14593  	v_1 := v.Args[1]
 14594  	v_0 := v.Args[0]
 14595  	b := v.Block
 14596  	typ := &b.Func.Config.Types
 14597  	// match: (Mod16 x y)
 14598  	// result: (Mod32 (SignExt16to32 x) (SignExt16to32 y))
 14599  	for {
 14600  		x := v_0
 14601  		y := v_1
 14602  		v.reset(OpMod32)
 14603  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 14604  		v0.AddArg(x)
 14605  		v1 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 14606  		v1.AddArg(y)
 14607  		v.AddArg2(v0, v1)
 14608  		return true
 14609  	}
 14610  }
 14611  func rewriteValueARM_OpMod16u(v *Value) bool {
 14612  	v_1 := v.Args[1]
 14613  	v_0 := v.Args[0]
 14614  	b := v.Block
 14615  	typ := &b.Func.Config.Types
 14616  	// match: (Mod16u x y)
 14617  	// result: (Mod32u (ZeroExt16to32 x) (ZeroExt16to32 y))
 14618  	for {
 14619  		x := v_0
 14620  		y := v_1
 14621  		v.reset(OpMod32u)
 14622  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14623  		v0.AddArg(x)
 14624  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14625  		v1.AddArg(y)
 14626  		v.AddArg2(v0, v1)
 14627  		return true
 14628  	}
 14629  }
 14630  func rewriteValueARM_OpMod32(v *Value) bool {
 14631  	v_1 := v.Args[1]
 14632  	v_0 := v.Args[0]
 14633  	b := v.Block
 14634  	typ := &b.Func.Config.Types
 14635  	// match: (Mod32 x y)
 14636  	// result: (SUB (XOR <typ.UInt32> (Select1 <typ.UInt32> (CALLudiv (SUB <typ.UInt32> (XOR <typ.UInt32> x (Signmask x)) (Signmask x)) (SUB <typ.UInt32> (XOR <typ.UInt32> y (Signmask y)) (Signmask y)))) (Signmask x)) (Signmask x))
 14637  	for {
 14638  		x := v_0
 14639  		y := v_1
 14640  		v.reset(OpARMSUB)
 14641  		v0 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 14642  		v1 := b.NewValue0(v.Pos, OpSelect1, typ.UInt32)
 14643  		v2 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
 14644  		v3 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
 14645  		v4 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 14646  		v5 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
 14647  		v5.AddArg(x)
 14648  		v4.AddArg2(x, v5)
 14649  		v3.AddArg2(v4, v5)
 14650  		v6 := b.NewValue0(v.Pos, OpARMSUB, typ.UInt32)
 14651  		v7 := b.NewValue0(v.Pos, OpARMXOR, typ.UInt32)
 14652  		v8 := b.NewValue0(v.Pos, OpSignmask, typ.Int32)
 14653  		v8.AddArg(y)
 14654  		v7.AddArg2(y, v8)
 14655  		v6.AddArg2(v7, v8)
 14656  		v2.AddArg2(v3, v6)
 14657  		v1.AddArg(v2)
 14658  		v0.AddArg2(v1, v5)
 14659  		v.AddArg2(v0, v5)
 14660  		return true
 14661  	}
 14662  }
 14663  func rewriteValueARM_OpMod32u(v *Value) bool {
 14664  	v_1 := v.Args[1]
 14665  	v_0 := v.Args[0]
 14666  	b := v.Block
 14667  	typ := &b.Func.Config.Types
 14668  	// match: (Mod32u x y)
 14669  	// result: (Select1 <typ.UInt32> (CALLudiv x y))
 14670  	for {
 14671  		x := v_0
 14672  		y := v_1
 14673  		v.reset(OpSelect1)
 14674  		v.Type = typ.UInt32
 14675  		v0 := b.NewValue0(v.Pos, OpARMCALLudiv, types.NewTuple(typ.UInt32, typ.UInt32))
 14676  		v0.AddArg2(x, y)
 14677  		v.AddArg(v0)
 14678  		return true
 14679  	}
 14680  }
 14681  func rewriteValueARM_OpMod8(v *Value) bool {
 14682  	v_1 := v.Args[1]
 14683  	v_0 := v.Args[0]
 14684  	b := v.Block
 14685  	typ := &b.Func.Config.Types
 14686  	// match: (Mod8 x y)
 14687  	// result: (Mod32 (SignExt8to32 x) (SignExt8to32 y))
 14688  	for {
 14689  		x := v_0
 14690  		y := v_1
 14691  		v.reset(OpMod32)
 14692  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 14693  		v0.AddArg(x)
 14694  		v1 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 14695  		v1.AddArg(y)
 14696  		v.AddArg2(v0, v1)
 14697  		return true
 14698  	}
 14699  }
 14700  func rewriteValueARM_OpMod8u(v *Value) bool {
 14701  	v_1 := v.Args[1]
 14702  	v_0 := v.Args[0]
 14703  	b := v.Block
 14704  	typ := &b.Func.Config.Types
 14705  	// match: (Mod8u x y)
 14706  	// result: (Mod32u (ZeroExt8to32 x) (ZeroExt8to32 y))
 14707  	for {
 14708  		x := v_0
 14709  		y := v_1
 14710  		v.reset(OpMod32u)
 14711  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14712  		v0.AddArg(x)
 14713  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 14714  		v1.AddArg(y)
 14715  		v.AddArg2(v0, v1)
 14716  		return true
 14717  	}
 14718  }
 14719  func rewriteValueARM_OpMove(v *Value) bool {
 14720  	v_2 := v.Args[2]
 14721  	v_1 := v.Args[1]
 14722  	v_0 := v.Args[0]
 14723  	b := v.Block
 14724  	config := b.Func.Config
 14725  	typ := &b.Func.Config.Types
 14726  	// match: (Move [0] _ _ mem)
 14727  	// result: mem
 14728  	for {
 14729  		if auxIntToInt64(v.AuxInt) != 0 {
 14730  			break
 14731  		}
 14732  		mem := v_2
 14733  		v.copyOf(mem)
 14734  		return true
 14735  	}
 14736  	// match: (Move [1] dst src mem)
 14737  	// result: (MOVBstore dst (MOVBUload src mem) mem)
 14738  	for {
 14739  		if auxIntToInt64(v.AuxInt) != 1 {
 14740  			break
 14741  		}
 14742  		dst := v_0
 14743  		src := v_1
 14744  		mem := v_2
 14745  		v.reset(OpARMMOVBstore)
 14746  		v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14747  		v0.AddArg2(src, mem)
 14748  		v.AddArg3(dst, v0, mem)
 14749  		return true
 14750  	}
 14751  	// match: (Move [2] {t} dst src mem)
 14752  	// cond: t.Alignment()%2 == 0
 14753  	// result: (MOVHstore dst (MOVHUload src mem) mem)
 14754  	for {
 14755  		if auxIntToInt64(v.AuxInt) != 2 {
 14756  			break
 14757  		}
 14758  		t := auxToType(v.Aux)
 14759  		dst := v_0
 14760  		src := v_1
 14761  		mem := v_2
 14762  		if !(t.Alignment()%2 == 0) {
 14763  			break
 14764  		}
 14765  		v.reset(OpARMMOVHstore)
 14766  		v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16)
 14767  		v0.AddArg2(src, mem)
 14768  		v.AddArg3(dst, v0, mem)
 14769  		return true
 14770  	}
 14771  	// match: (Move [2] dst src mem)
 14772  	// result: (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))
 14773  	for {
 14774  		if auxIntToInt64(v.AuxInt) != 2 {
 14775  			break
 14776  		}
 14777  		dst := v_0
 14778  		src := v_1
 14779  		mem := v_2
 14780  		v.reset(OpARMMOVBstore)
 14781  		v.AuxInt = int32ToAuxInt(1)
 14782  		v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14783  		v0.AuxInt = int32ToAuxInt(1)
 14784  		v0.AddArg2(src, mem)
 14785  		v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 14786  		v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14787  		v2.AddArg2(src, mem)
 14788  		v1.AddArg3(dst, v2, mem)
 14789  		v.AddArg3(dst, v0, v1)
 14790  		return true
 14791  	}
 14792  	// match: (Move [4] {t} dst src mem)
 14793  	// cond: t.Alignment()%4 == 0
 14794  	// result: (MOVWstore dst (MOVWload src mem) mem)
 14795  	for {
 14796  		if auxIntToInt64(v.AuxInt) != 4 {
 14797  			break
 14798  		}
 14799  		t := auxToType(v.Aux)
 14800  		dst := v_0
 14801  		src := v_1
 14802  		mem := v_2
 14803  		if !(t.Alignment()%4 == 0) {
 14804  			break
 14805  		}
 14806  		v.reset(OpARMMOVWstore)
 14807  		v0 := b.NewValue0(v.Pos, OpARMMOVWload, typ.UInt32)
 14808  		v0.AddArg2(src, mem)
 14809  		v.AddArg3(dst, v0, mem)
 14810  		return true
 14811  	}
 14812  	// match: (Move [4] {t} dst src mem)
 14813  	// cond: t.Alignment()%2 == 0
 14814  	// result: (MOVHstore [2] dst (MOVHUload [2] src mem) (MOVHstore dst (MOVHUload src mem) mem))
 14815  	for {
 14816  		if auxIntToInt64(v.AuxInt) != 4 {
 14817  			break
 14818  		}
 14819  		t := auxToType(v.Aux)
 14820  		dst := v_0
 14821  		src := v_1
 14822  		mem := v_2
 14823  		if !(t.Alignment()%2 == 0) {
 14824  			break
 14825  		}
 14826  		v.reset(OpARMMOVHstore)
 14827  		v.AuxInt = int32ToAuxInt(2)
 14828  		v0 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16)
 14829  		v0.AuxInt = int32ToAuxInt(2)
 14830  		v0.AddArg2(src, mem)
 14831  		v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem)
 14832  		v2 := b.NewValue0(v.Pos, OpARMMOVHUload, typ.UInt16)
 14833  		v2.AddArg2(src, mem)
 14834  		v1.AddArg3(dst, v2, mem)
 14835  		v.AddArg3(dst, v0, v1)
 14836  		return true
 14837  	}
 14838  	// match: (Move [4] dst src mem)
 14839  	// result: (MOVBstore [3] dst (MOVBUload [3] src mem) (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem))))
 14840  	for {
 14841  		if auxIntToInt64(v.AuxInt) != 4 {
 14842  			break
 14843  		}
 14844  		dst := v_0
 14845  		src := v_1
 14846  		mem := v_2
 14847  		v.reset(OpARMMOVBstore)
 14848  		v.AuxInt = int32ToAuxInt(3)
 14849  		v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14850  		v0.AuxInt = int32ToAuxInt(3)
 14851  		v0.AddArg2(src, mem)
 14852  		v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 14853  		v1.AuxInt = int32ToAuxInt(2)
 14854  		v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14855  		v2.AuxInt = int32ToAuxInt(2)
 14856  		v2.AddArg2(src, mem)
 14857  		v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 14858  		v3.AuxInt = int32ToAuxInt(1)
 14859  		v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14860  		v4.AuxInt = int32ToAuxInt(1)
 14861  		v4.AddArg2(src, mem)
 14862  		v5 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 14863  		v6 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14864  		v6.AddArg2(src, mem)
 14865  		v5.AddArg3(dst, v6, mem)
 14866  		v3.AddArg3(dst, v4, v5)
 14867  		v1.AddArg3(dst, v2, v3)
 14868  		v.AddArg3(dst, v0, v1)
 14869  		return true
 14870  	}
 14871  	// match: (Move [3] dst src mem)
 14872  	// result: (MOVBstore [2] dst (MOVBUload [2] src mem) (MOVBstore [1] dst (MOVBUload [1] src mem) (MOVBstore dst (MOVBUload src mem) mem)))
 14873  	for {
 14874  		if auxIntToInt64(v.AuxInt) != 3 {
 14875  			break
 14876  		}
 14877  		dst := v_0
 14878  		src := v_1
 14879  		mem := v_2
 14880  		v.reset(OpARMMOVBstore)
 14881  		v.AuxInt = int32ToAuxInt(2)
 14882  		v0 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14883  		v0.AuxInt = int32ToAuxInt(2)
 14884  		v0.AddArg2(src, mem)
 14885  		v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 14886  		v1.AuxInt = int32ToAuxInt(1)
 14887  		v2 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14888  		v2.AuxInt = int32ToAuxInt(1)
 14889  		v2.AddArg2(src, mem)
 14890  		v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 14891  		v4 := b.NewValue0(v.Pos, OpARMMOVBUload, typ.UInt8)
 14892  		v4.AddArg2(src, mem)
 14893  		v3.AddArg3(dst, v4, mem)
 14894  		v1.AddArg3(dst, v2, v3)
 14895  		v.AddArg3(dst, v0, v1)
 14896  		return true
 14897  	}
 14898  	// match: (Move [s] {t} dst src mem)
 14899  	// cond: s%4 == 0 && s > 4 && s <= 512 && t.Alignment()%4 == 0 && logLargeCopy(v, s)
 14900  	// result: (DUFFCOPY [8 * (128 - s/4)] dst src mem)
 14901  	for {
 14902  		s := auxIntToInt64(v.AuxInt)
 14903  		t := auxToType(v.Aux)
 14904  		dst := v_0
 14905  		src := v_1
 14906  		mem := v_2
 14907  		if !(s%4 == 0 && s > 4 && s <= 512 && t.Alignment()%4 == 0 && logLargeCopy(v, s)) {
 14908  			break
 14909  		}
 14910  		v.reset(OpARMDUFFCOPY)
 14911  		v.AuxInt = int64ToAuxInt(8 * (128 - s/4))
 14912  		v.AddArg3(dst, src, mem)
 14913  		return true
 14914  	}
 14915  	// match: (Move [s] {t} dst src mem)
 14916  	// cond: (s > 512 || t.Alignment()%4 != 0) && logLargeCopy(v, s)
 14917  	// result: (LoweredMove [t.Alignment()] dst src (ADDconst <src.Type> src [int32(s-moveSize(t.Alignment(), config))]) mem)
 14918  	for {
 14919  		s := auxIntToInt64(v.AuxInt)
 14920  		t := auxToType(v.Aux)
 14921  		dst := v_0
 14922  		src := v_1
 14923  		mem := v_2
 14924  		if !((s > 512 || t.Alignment()%4 != 0) && logLargeCopy(v, s)) {
 14925  			break
 14926  		}
 14927  		v.reset(OpARMLoweredMove)
 14928  		v.AuxInt = int64ToAuxInt(t.Alignment())
 14929  		v0 := b.NewValue0(v.Pos, OpARMADDconst, src.Type)
 14930  		v0.AuxInt = int32ToAuxInt(int32(s - moveSize(t.Alignment(), config)))
 14931  		v0.AddArg(src)
 14932  		v.AddArg4(dst, src, v0, mem)
 14933  		return true
 14934  	}
 14935  	return false
 14936  }
 14937  func rewriteValueARM_OpNeg16(v *Value) bool {
 14938  	v_0 := v.Args[0]
 14939  	// match: (Neg16 x)
 14940  	// result: (RSBconst [0] x)
 14941  	for {
 14942  		x := v_0
 14943  		v.reset(OpARMRSBconst)
 14944  		v.AuxInt = int32ToAuxInt(0)
 14945  		v.AddArg(x)
 14946  		return true
 14947  	}
 14948  }
 14949  func rewriteValueARM_OpNeg32(v *Value) bool {
 14950  	v_0 := v.Args[0]
 14951  	// match: (Neg32 x)
 14952  	// result: (RSBconst [0] x)
 14953  	for {
 14954  		x := v_0
 14955  		v.reset(OpARMRSBconst)
 14956  		v.AuxInt = int32ToAuxInt(0)
 14957  		v.AddArg(x)
 14958  		return true
 14959  	}
 14960  }
 14961  func rewriteValueARM_OpNeg8(v *Value) bool {
 14962  	v_0 := v.Args[0]
 14963  	// match: (Neg8 x)
 14964  	// result: (RSBconst [0] x)
 14965  	for {
 14966  		x := v_0
 14967  		v.reset(OpARMRSBconst)
 14968  		v.AuxInt = int32ToAuxInt(0)
 14969  		v.AddArg(x)
 14970  		return true
 14971  	}
 14972  }
 14973  func rewriteValueARM_OpNeq16(v *Value) bool {
 14974  	v_1 := v.Args[1]
 14975  	v_0 := v.Args[0]
 14976  	b := v.Block
 14977  	typ := &b.Func.Config.Types
 14978  	// match: (Neq16 x y)
 14979  	// result: (NotEqual (CMP (ZeroExt16to32 x) (ZeroExt16to32 y)))
 14980  	for {
 14981  		x := v_0
 14982  		y := v_1
 14983  		v.reset(OpARMNotEqual)
 14984  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 14985  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14986  		v1.AddArg(x)
 14987  		v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 14988  		v2.AddArg(y)
 14989  		v0.AddArg2(v1, v2)
 14990  		v.AddArg(v0)
 14991  		return true
 14992  	}
 14993  }
 14994  func rewriteValueARM_OpNeq32(v *Value) bool {
 14995  	v_1 := v.Args[1]
 14996  	v_0 := v.Args[0]
 14997  	b := v.Block
 14998  	// match: (Neq32 x y)
 14999  	// result: (NotEqual (CMP x y))
 15000  	for {
 15001  		x := v_0
 15002  		y := v_1
 15003  		v.reset(OpARMNotEqual)
 15004  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 15005  		v0.AddArg2(x, y)
 15006  		v.AddArg(v0)
 15007  		return true
 15008  	}
 15009  }
 15010  func rewriteValueARM_OpNeq32F(v *Value) bool {
 15011  	v_1 := v.Args[1]
 15012  	v_0 := v.Args[0]
 15013  	b := v.Block
 15014  	// match: (Neq32F x y)
 15015  	// result: (NotEqual (CMPF x y))
 15016  	for {
 15017  		x := v_0
 15018  		y := v_1
 15019  		v.reset(OpARMNotEqual)
 15020  		v0 := b.NewValue0(v.Pos, OpARMCMPF, types.TypeFlags)
 15021  		v0.AddArg2(x, y)
 15022  		v.AddArg(v0)
 15023  		return true
 15024  	}
 15025  }
 15026  func rewriteValueARM_OpNeq64F(v *Value) bool {
 15027  	v_1 := v.Args[1]
 15028  	v_0 := v.Args[0]
 15029  	b := v.Block
 15030  	// match: (Neq64F x y)
 15031  	// result: (NotEqual (CMPD x y))
 15032  	for {
 15033  		x := v_0
 15034  		y := v_1
 15035  		v.reset(OpARMNotEqual)
 15036  		v0 := b.NewValue0(v.Pos, OpARMCMPD, types.TypeFlags)
 15037  		v0.AddArg2(x, y)
 15038  		v.AddArg(v0)
 15039  		return true
 15040  	}
 15041  }
 15042  func rewriteValueARM_OpNeq8(v *Value) bool {
 15043  	v_1 := v.Args[1]
 15044  	v_0 := v.Args[0]
 15045  	b := v.Block
 15046  	typ := &b.Func.Config.Types
 15047  	// match: (Neq8 x y)
 15048  	// result: (NotEqual (CMP (ZeroExt8to32 x) (ZeroExt8to32 y)))
 15049  	for {
 15050  		x := v_0
 15051  		y := v_1
 15052  		v.reset(OpARMNotEqual)
 15053  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 15054  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15055  		v1.AddArg(x)
 15056  		v2 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15057  		v2.AddArg(y)
 15058  		v0.AddArg2(v1, v2)
 15059  		v.AddArg(v0)
 15060  		return true
 15061  	}
 15062  }
 15063  func rewriteValueARM_OpNeqPtr(v *Value) bool {
 15064  	v_1 := v.Args[1]
 15065  	v_0 := v.Args[0]
 15066  	b := v.Block
 15067  	// match: (NeqPtr x y)
 15068  	// result: (NotEqual (CMP x y))
 15069  	for {
 15070  		x := v_0
 15071  		y := v_1
 15072  		v.reset(OpARMNotEqual)
 15073  		v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
 15074  		v0.AddArg2(x, y)
 15075  		v.AddArg(v0)
 15076  		return true
 15077  	}
 15078  }
 15079  func rewriteValueARM_OpNot(v *Value) bool {
 15080  	v_0 := v.Args[0]
 15081  	// match: (Not x)
 15082  	// result: (XORconst [1] x)
 15083  	for {
 15084  		x := v_0
 15085  		v.reset(OpARMXORconst)
 15086  		v.AuxInt = int32ToAuxInt(1)
 15087  		v.AddArg(x)
 15088  		return true
 15089  	}
 15090  }
 15091  func rewriteValueARM_OpOffPtr(v *Value) bool {
 15092  	v_0 := v.Args[0]
 15093  	// match: (OffPtr [off] ptr:(SP))
 15094  	// result: (MOVWaddr [int32(off)] ptr)
 15095  	for {
 15096  		off := auxIntToInt64(v.AuxInt)
 15097  		ptr := v_0
 15098  		if ptr.Op != OpSP {
 15099  			break
 15100  		}
 15101  		v.reset(OpARMMOVWaddr)
 15102  		v.AuxInt = int32ToAuxInt(int32(off))
 15103  		v.AddArg(ptr)
 15104  		return true
 15105  	}
 15106  	// match: (OffPtr [off] ptr)
 15107  	// result: (ADDconst [int32(off)] ptr)
 15108  	for {
 15109  		off := auxIntToInt64(v.AuxInt)
 15110  		ptr := v_0
 15111  		v.reset(OpARMADDconst)
 15112  		v.AuxInt = int32ToAuxInt(int32(off))
 15113  		v.AddArg(ptr)
 15114  		return true
 15115  	}
 15116  }
 15117  func rewriteValueARM_OpRotateLeft16(v *Value) bool {
 15118  	v_1 := v.Args[1]
 15119  	v_0 := v.Args[0]
 15120  	b := v.Block
 15121  	typ := &b.Func.Config.Types
 15122  	// match: (RotateLeft16 <t> x (MOVWconst [c]))
 15123  	// result: (Or16 (Lsh16x32 <t> x (MOVWconst [c&15])) (Rsh16Ux32 <t> x (MOVWconst [-c&15])))
 15124  	for {
 15125  		t := v.Type
 15126  		x := v_0
 15127  		if v_1.Op != OpARMMOVWconst {
 15128  			break
 15129  		}
 15130  		c := auxIntToInt32(v_1.AuxInt)
 15131  		v.reset(OpOr16)
 15132  		v0 := b.NewValue0(v.Pos, OpLsh16x32, t)
 15133  		v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 15134  		v1.AuxInt = int32ToAuxInt(c & 15)
 15135  		v0.AddArg2(x, v1)
 15136  		v2 := b.NewValue0(v.Pos, OpRsh16Ux32, t)
 15137  		v3 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 15138  		v3.AuxInt = int32ToAuxInt(-c & 15)
 15139  		v2.AddArg2(x, v3)
 15140  		v.AddArg2(v0, v2)
 15141  		return true
 15142  	}
 15143  	return false
 15144  }
 15145  func rewriteValueARM_OpRotateLeft32(v *Value) bool {
 15146  	v_1 := v.Args[1]
 15147  	v_0 := v.Args[0]
 15148  	b := v.Block
 15149  	// match: (RotateLeft32 x y)
 15150  	// result: (SRR x (RSBconst [0] <y.Type> y))
 15151  	for {
 15152  		x := v_0
 15153  		y := v_1
 15154  		v.reset(OpARMSRR)
 15155  		v0 := b.NewValue0(v.Pos, OpARMRSBconst, y.Type)
 15156  		v0.AuxInt = int32ToAuxInt(0)
 15157  		v0.AddArg(y)
 15158  		v.AddArg2(x, v0)
 15159  		return true
 15160  	}
 15161  }
 15162  func rewriteValueARM_OpRotateLeft8(v *Value) bool {
 15163  	v_1 := v.Args[1]
 15164  	v_0 := v.Args[0]
 15165  	b := v.Block
 15166  	typ := &b.Func.Config.Types
 15167  	// match: (RotateLeft8 <t> x (MOVWconst [c]))
 15168  	// result: (Or8 (Lsh8x32 <t> x (MOVWconst [c&7])) (Rsh8Ux32 <t> x (MOVWconst [-c&7])))
 15169  	for {
 15170  		t := v.Type
 15171  		x := v_0
 15172  		if v_1.Op != OpARMMOVWconst {
 15173  			break
 15174  		}
 15175  		c := auxIntToInt32(v_1.AuxInt)
 15176  		v.reset(OpOr8)
 15177  		v0 := b.NewValue0(v.Pos, OpLsh8x32, t)
 15178  		v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 15179  		v1.AuxInt = int32ToAuxInt(c & 7)
 15180  		v0.AddArg2(x, v1)
 15181  		v2 := b.NewValue0(v.Pos, OpRsh8Ux32, t)
 15182  		v3 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 15183  		v3.AuxInt = int32ToAuxInt(-c & 7)
 15184  		v2.AddArg2(x, v3)
 15185  		v.AddArg2(v0, v2)
 15186  		return true
 15187  	}
 15188  	return false
 15189  }
 15190  func rewriteValueARM_OpRsh16Ux16(v *Value) bool {
 15191  	v_1 := v.Args[1]
 15192  	v_0 := v.Args[0]
 15193  	b := v.Block
 15194  	typ := &b.Func.Config.Types
 15195  	// match: (Rsh16Ux16 x y)
 15196  	// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
 15197  	for {
 15198  		x := v_0
 15199  		y := v_1
 15200  		v.reset(OpARMCMOVWHSconst)
 15201  		v.AuxInt = int32ToAuxInt(0)
 15202  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 15203  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15204  		v1.AddArg(x)
 15205  		v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15206  		v2.AddArg(y)
 15207  		v0.AddArg2(v1, v2)
 15208  		v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15209  		v3.AuxInt = int32ToAuxInt(256)
 15210  		v3.AddArg(v2)
 15211  		v.AddArg2(v0, v3)
 15212  		return true
 15213  	}
 15214  }
 15215  func rewriteValueARM_OpRsh16Ux32(v *Value) bool {
 15216  	v_1 := v.Args[1]
 15217  	v_0 := v.Args[0]
 15218  	b := v.Block
 15219  	typ := &b.Func.Config.Types
 15220  	// match: (Rsh16Ux32 x y)
 15221  	// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt16to32 x) y) (CMPconst [256] y) [0])
 15222  	for {
 15223  		x := v_0
 15224  		y := v_1
 15225  		v.reset(OpARMCMOVWHSconst)
 15226  		v.AuxInt = int32ToAuxInt(0)
 15227  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 15228  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15229  		v1.AddArg(x)
 15230  		v0.AddArg2(v1, y)
 15231  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15232  		v2.AuxInt = int32ToAuxInt(256)
 15233  		v2.AddArg(y)
 15234  		v.AddArg2(v0, v2)
 15235  		return true
 15236  	}
 15237  }
 15238  func rewriteValueARM_OpRsh16Ux64(v *Value) bool {
 15239  	v_1 := v.Args[1]
 15240  	v_0 := v.Args[0]
 15241  	b := v.Block
 15242  	typ := &b.Func.Config.Types
 15243  	// match: (Rsh16Ux64 x (Const64 [c]))
 15244  	// cond: uint64(c) < 16
 15245  	// result: (SRLconst (SLLconst <typ.UInt32> x [16]) [int32(c+16)])
 15246  	for {
 15247  		x := v_0
 15248  		if v_1.Op != OpConst64 {
 15249  			break
 15250  		}
 15251  		c := auxIntToInt64(v_1.AuxInt)
 15252  		if !(uint64(c) < 16) {
 15253  			break
 15254  		}
 15255  		v.reset(OpARMSRLconst)
 15256  		v.AuxInt = int32ToAuxInt(int32(c + 16))
 15257  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
 15258  		v0.AuxInt = int32ToAuxInt(16)
 15259  		v0.AddArg(x)
 15260  		v.AddArg(v0)
 15261  		return true
 15262  	}
 15263  	// match: (Rsh16Ux64 _ (Const64 [c]))
 15264  	// cond: uint64(c) >= 16
 15265  	// result: (Const16 [0])
 15266  	for {
 15267  		if v_1.Op != OpConst64 {
 15268  			break
 15269  		}
 15270  		c := auxIntToInt64(v_1.AuxInt)
 15271  		if !(uint64(c) >= 16) {
 15272  			break
 15273  		}
 15274  		v.reset(OpConst16)
 15275  		v.AuxInt = int16ToAuxInt(0)
 15276  		return true
 15277  	}
 15278  	return false
 15279  }
 15280  func rewriteValueARM_OpRsh16Ux8(v *Value) bool {
 15281  	v_1 := v.Args[1]
 15282  	v_0 := v.Args[0]
 15283  	b := v.Block
 15284  	typ := &b.Func.Config.Types
 15285  	// match: (Rsh16Ux8 x y)
 15286  	// result: (SRL (ZeroExt16to32 x) (ZeroExt8to32 y))
 15287  	for {
 15288  		x := v_0
 15289  		y := v_1
 15290  		v.reset(OpARMSRL)
 15291  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15292  		v0.AddArg(x)
 15293  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15294  		v1.AddArg(y)
 15295  		v.AddArg2(v0, v1)
 15296  		return true
 15297  	}
 15298  }
 15299  func rewriteValueARM_OpRsh16x16(v *Value) bool {
 15300  	v_1 := v.Args[1]
 15301  	v_0 := v.Args[0]
 15302  	b := v.Block
 15303  	typ := &b.Func.Config.Types
 15304  	// match: (Rsh16x16 x y)
 15305  	// result: (SRAcond (SignExt16to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y)))
 15306  	for {
 15307  		x := v_0
 15308  		y := v_1
 15309  		v.reset(OpARMSRAcond)
 15310  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 15311  		v0.AddArg(x)
 15312  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15313  		v1.AddArg(y)
 15314  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15315  		v2.AuxInt = int32ToAuxInt(256)
 15316  		v2.AddArg(v1)
 15317  		v.AddArg3(v0, v1, v2)
 15318  		return true
 15319  	}
 15320  }
 15321  func rewriteValueARM_OpRsh16x32(v *Value) bool {
 15322  	v_1 := v.Args[1]
 15323  	v_0 := v.Args[0]
 15324  	b := v.Block
 15325  	typ := &b.Func.Config.Types
 15326  	// match: (Rsh16x32 x y)
 15327  	// result: (SRAcond (SignExt16to32 x) y (CMPconst [256] y))
 15328  	for {
 15329  		x := v_0
 15330  		y := v_1
 15331  		v.reset(OpARMSRAcond)
 15332  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 15333  		v0.AddArg(x)
 15334  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15335  		v1.AuxInt = int32ToAuxInt(256)
 15336  		v1.AddArg(y)
 15337  		v.AddArg3(v0, y, v1)
 15338  		return true
 15339  	}
 15340  }
 15341  func rewriteValueARM_OpRsh16x64(v *Value) bool {
 15342  	v_1 := v.Args[1]
 15343  	v_0 := v.Args[0]
 15344  	b := v.Block
 15345  	typ := &b.Func.Config.Types
 15346  	// match: (Rsh16x64 x (Const64 [c]))
 15347  	// cond: uint64(c) < 16
 15348  	// result: (SRAconst (SLLconst <typ.UInt32> x [16]) [int32(c+16)])
 15349  	for {
 15350  		x := v_0
 15351  		if v_1.Op != OpConst64 {
 15352  			break
 15353  		}
 15354  		c := auxIntToInt64(v_1.AuxInt)
 15355  		if !(uint64(c) < 16) {
 15356  			break
 15357  		}
 15358  		v.reset(OpARMSRAconst)
 15359  		v.AuxInt = int32ToAuxInt(int32(c + 16))
 15360  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
 15361  		v0.AuxInt = int32ToAuxInt(16)
 15362  		v0.AddArg(x)
 15363  		v.AddArg(v0)
 15364  		return true
 15365  	}
 15366  	// match: (Rsh16x64 x (Const64 [c]))
 15367  	// cond: uint64(c) >= 16
 15368  	// result: (SRAconst (SLLconst <typ.UInt32> x [16]) [31])
 15369  	for {
 15370  		x := v_0
 15371  		if v_1.Op != OpConst64 {
 15372  			break
 15373  		}
 15374  		c := auxIntToInt64(v_1.AuxInt)
 15375  		if !(uint64(c) >= 16) {
 15376  			break
 15377  		}
 15378  		v.reset(OpARMSRAconst)
 15379  		v.AuxInt = int32ToAuxInt(31)
 15380  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
 15381  		v0.AuxInt = int32ToAuxInt(16)
 15382  		v0.AddArg(x)
 15383  		v.AddArg(v0)
 15384  		return true
 15385  	}
 15386  	return false
 15387  }
 15388  func rewriteValueARM_OpRsh16x8(v *Value) bool {
 15389  	v_1 := v.Args[1]
 15390  	v_0 := v.Args[0]
 15391  	b := v.Block
 15392  	typ := &b.Func.Config.Types
 15393  	// match: (Rsh16x8 x y)
 15394  	// result: (SRA (SignExt16to32 x) (ZeroExt8to32 y))
 15395  	for {
 15396  		x := v_0
 15397  		y := v_1
 15398  		v.reset(OpARMSRA)
 15399  		v0 := b.NewValue0(v.Pos, OpSignExt16to32, typ.Int32)
 15400  		v0.AddArg(x)
 15401  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15402  		v1.AddArg(y)
 15403  		v.AddArg2(v0, v1)
 15404  		return true
 15405  	}
 15406  }
 15407  func rewriteValueARM_OpRsh32Ux16(v *Value) bool {
 15408  	v_1 := v.Args[1]
 15409  	v_0 := v.Args[0]
 15410  	b := v.Block
 15411  	typ := &b.Func.Config.Types
 15412  	// match: (Rsh32Ux16 x y)
 15413  	// result: (CMOVWHSconst (SRL <x.Type> x (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
 15414  	for {
 15415  		x := v_0
 15416  		y := v_1
 15417  		v.reset(OpARMCMOVWHSconst)
 15418  		v.AuxInt = int32ToAuxInt(0)
 15419  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 15420  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15421  		v1.AddArg(y)
 15422  		v0.AddArg2(x, v1)
 15423  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15424  		v2.AuxInt = int32ToAuxInt(256)
 15425  		v2.AddArg(v1)
 15426  		v.AddArg2(v0, v2)
 15427  		return true
 15428  	}
 15429  }
 15430  func rewriteValueARM_OpRsh32Ux32(v *Value) bool {
 15431  	v_1 := v.Args[1]
 15432  	v_0 := v.Args[0]
 15433  	b := v.Block
 15434  	// match: (Rsh32Ux32 x y)
 15435  	// result: (CMOVWHSconst (SRL <x.Type> x y) (CMPconst [256] y) [0])
 15436  	for {
 15437  		x := v_0
 15438  		y := v_1
 15439  		v.reset(OpARMCMOVWHSconst)
 15440  		v.AuxInt = int32ToAuxInt(0)
 15441  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 15442  		v0.AddArg2(x, y)
 15443  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15444  		v1.AuxInt = int32ToAuxInt(256)
 15445  		v1.AddArg(y)
 15446  		v.AddArg2(v0, v1)
 15447  		return true
 15448  	}
 15449  }
 15450  func rewriteValueARM_OpRsh32Ux64(v *Value) bool {
 15451  	v_1 := v.Args[1]
 15452  	v_0 := v.Args[0]
 15453  	// match: (Rsh32Ux64 x (Const64 [c]))
 15454  	// cond: uint64(c) < 32
 15455  	// result: (SRLconst x [int32(c)])
 15456  	for {
 15457  		x := v_0
 15458  		if v_1.Op != OpConst64 {
 15459  			break
 15460  		}
 15461  		c := auxIntToInt64(v_1.AuxInt)
 15462  		if !(uint64(c) < 32) {
 15463  			break
 15464  		}
 15465  		v.reset(OpARMSRLconst)
 15466  		v.AuxInt = int32ToAuxInt(int32(c))
 15467  		v.AddArg(x)
 15468  		return true
 15469  	}
 15470  	// match: (Rsh32Ux64 _ (Const64 [c]))
 15471  	// cond: uint64(c) >= 32
 15472  	// result: (Const32 [0])
 15473  	for {
 15474  		if v_1.Op != OpConst64 {
 15475  			break
 15476  		}
 15477  		c := auxIntToInt64(v_1.AuxInt)
 15478  		if !(uint64(c) >= 32) {
 15479  			break
 15480  		}
 15481  		v.reset(OpConst32)
 15482  		v.AuxInt = int32ToAuxInt(0)
 15483  		return true
 15484  	}
 15485  	return false
 15486  }
 15487  func rewriteValueARM_OpRsh32Ux8(v *Value) bool {
 15488  	v_1 := v.Args[1]
 15489  	v_0 := v.Args[0]
 15490  	b := v.Block
 15491  	typ := &b.Func.Config.Types
 15492  	// match: (Rsh32Ux8 x y)
 15493  	// result: (SRL x (ZeroExt8to32 y))
 15494  	for {
 15495  		x := v_0
 15496  		y := v_1
 15497  		v.reset(OpARMSRL)
 15498  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15499  		v0.AddArg(y)
 15500  		v.AddArg2(x, v0)
 15501  		return true
 15502  	}
 15503  }
 15504  func rewriteValueARM_OpRsh32x16(v *Value) bool {
 15505  	v_1 := v.Args[1]
 15506  	v_0 := v.Args[0]
 15507  	b := v.Block
 15508  	typ := &b.Func.Config.Types
 15509  	// match: (Rsh32x16 x y)
 15510  	// result: (SRAcond x (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y)))
 15511  	for {
 15512  		x := v_0
 15513  		y := v_1
 15514  		v.reset(OpARMSRAcond)
 15515  		v0 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15516  		v0.AddArg(y)
 15517  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15518  		v1.AuxInt = int32ToAuxInt(256)
 15519  		v1.AddArg(v0)
 15520  		v.AddArg3(x, v0, v1)
 15521  		return true
 15522  	}
 15523  }
 15524  func rewriteValueARM_OpRsh32x32(v *Value) bool {
 15525  	v_1 := v.Args[1]
 15526  	v_0 := v.Args[0]
 15527  	b := v.Block
 15528  	// match: (Rsh32x32 x y)
 15529  	// result: (SRAcond x y (CMPconst [256] y))
 15530  	for {
 15531  		x := v_0
 15532  		y := v_1
 15533  		v.reset(OpARMSRAcond)
 15534  		v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15535  		v0.AuxInt = int32ToAuxInt(256)
 15536  		v0.AddArg(y)
 15537  		v.AddArg3(x, y, v0)
 15538  		return true
 15539  	}
 15540  }
 15541  func rewriteValueARM_OpRsh32x64(v *Value) bool {
 15542  	v_1 := v.Args[1]
 15543  	v_0 := v.Args[0]
 15544  	// match: (Rsh32x64 x (Const64 [c]))
 15545  	// cond: uint64(c) < 32
 15546  	// result: (SRAconst x [int32(c)])
 15547  	for {
 15548  		x := v_0
 15549  		if v_1.Op != OpConst64 {
 15550  			break
 15551  		}
 15552  		c := auxIntToInt64(v_1.AuxInt)
 15553  		if !(uint64(c) < 32) {
 15554  			break
 15555  		}
 15556  		v.reset(OpARMSRAconst)
 15557  		v.AuxInt = int32ToAuxInt(int32(c))
 15558  		v.AddArg(x)
 15559  		return true
 15560  	}
 15561  	// match: (Rsh32x64 x (Const64 [c]))
 15562  	// cond: uint64(c) >= 32
 15563  	// result: (SRAconst x [31])
 15564  	for {
 15565  		x := v_0
 15566  		if v_1.Op != OpConst64 {
 15567  			break
 15568  		}
 15569  		c := auxIntToInt64(v_1.AuxInt)
 15570  		if !(uint64(c) >= 32) {
 15571  			break
 15572  		}
 15573  		v.reset(OpARMSRAconst)
 15574  		v.AuxInt = int32ToAuxInt(31)
 15575  		v.AddArg(x)
 15576  		return true
 15577  	}
 15578  	return false
 15579  }
 15580  func rewriteValueARM_OpRsh32x8(v *Value) bool {
 15581  	v_1 := v.Args[1]
 15582  	v_0 := v.Args[0]
 15583  	b := v.Block
 15584  	typ := &b.Func.Config.Types
 15585  	// match: (Rsh32x8 x y)
 15586  	// result: (SRA x (ZeroExt8to32 y))
 15587  	for {
 15588  		x := v_0
 15589  		y := v_1
 15590  		v.reset(OpARMSRA)
 15591  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15592  		v0.AddArg(y)
 15593  		v.AddArg2(x, v0)
 15594  		return true
 15595  	}
 15596  }
 15597  func rewriteValueARM_OpRsh8Ux16(v *Value) bool {
 15598  	v_1 := v.Args[1]
 15599  	v_0 := v.Args[0]
 15600  	b := v.Block
 15601  	typ := &b.Func.Config.Types
 15602  	// match: (Rsh8Ux16 x y)
 15603  	// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) (ZeroExt16to32 y)) (CMPconst [256] (ZeroExt16to32 y)) [0])
 15604  	for {
 15605  		x := v_0
 15606  		y := v_1
 15607  		v.reset(OpARMCMOVWHSconst)
 15608  		v.AuxInt = int32ToAuxInt(0)
 15609  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 15610  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15611  		v1.AddArg(x)
 15612  		v2 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15613  		v2.AddArg(y)
 15614  		v0.AddArg2(v1, v2)
 15615  		v3 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15616  		v3.AuxInt = int32ToAuxInt(256)
 15617  		v3.AddArg(v2)
 15618  		v.AddArg2(v0, v3)
 15619  		return true
 15620  	}
 15621  }
 15622  func rewriteValueARM_OpRsh8Ux32(v *Value) bool {
 15623  	v_1 := v.Args[1]
 15624  	v_0 := v.Args[0]
 15625  	b := v.Block
 15626  	typ := &b.Func.Config.Types
 15627  	// match: (Rsh8Ux32 x y)
 15628  	// result: (CMOVWHSconst (SRL <x.Type> (ZeroExt8to32 x) y) (CMPconst [256] y) [0])
 15629  	for {
 15630  		x := v_0
 15631  		y := v_1
 15632  		v.reset(OpARMCMOVWHSconst)
 15633  		v.AuxInt = int32ToAuxInt(0)
 15634  		v0 := b.NewValue0(v.Pos, OpARMSRL, x.Type)
 15635  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15636  		v1.AddArg(x)
 15637  		v0.AddArg2(v1, y)
 15638  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15639  		v2.AuxInt = int32ToAuxInt(256)
 15640  		v2.AddArg(y)
 15641  		v.AddArg2(v0, v2)
 15642  		return true
 15643  	}
 15644  }
 15645  func rewriteValueARM_OpRsh8Ux64(v *Value) bool {
 15646  	v_1 := v.Args[1]
 15647  	v_0 := v.Args[0]
 15648  	b := v.Block
 15649  	typ := &b.Func.Config.Types
 15650  	// match: (Rsh8Ux64 x (Const64 [c]))
 15651  	// cond: uint64(c) < 8
 15652  	// result: (SRLconst (SLLconst <typ.UInt32> x [24]) [int32(c+24)])
 15653  	for {
 15654  		x := v_0
 15655  		if v_1.Op != OpConst64 {
 15656  			break
 15657  		}
 15658  		c := auxIntToInt64(v_1.AuxInt)
 15659  		if !(uint64(c) < 8) {
 15660  			break
 15661  		}
 15662  		v.reset(OpARMSRLconst)
 15663  		v.AuxInt = int32ToAuxInt(int32(c + 24))
 15664  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
 15665  		v0.AuxInt = int32ToAuxInt(24)
 15666  		v0.AddArg(x)
 15667  		v.AddArg(v0)
 15668  		return true
 15669  	}
 15670  	// match: (Rsh8Ux64 _ (Const64 [c]))
 15671  	// cond: uint64(c) >= 8
 15672  	// result: (Const8 [0])
 15673  	for {
 15674  		if v_1.Op != OpConst64 {
 15675  			break
 15676  		}
 15677  		c := auxIntToInt64(v_1.AuxInt)
 15678  		if !(uint64(c) >= 8) {
 15679  			break
 15680  		}
 15681  		v.reset(OpConst8)
 15682  		v.AuxInt = int8ToAuxInt(0)
 15683  		return true
 15684  	}
 15685  	return false
 15686  }
 15687  func rewriteValueARM_OpRsh8Ux8(v *Value) bool {
 15688  	v_1 := v.Args[1]
 15689  	v_0 := v.Args[0]
 15690  	b := v.Block
 15691  	typ := &b.Func.Config.Types
 15692  	// match: (Rsh8Ux8 x y)
 15693  	// result: (SRL (ZeroExt8to32 x) (ZeroExt8to32 y))
 15694  	for {
 15695  		x := v_0
 15696  		y := v_1
 15697  		v.reset(OpARMSRL)
 15698  		v0 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15699  		v0.AddArg(x)
 15700  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15701  		v1.AddArg(y)
 15702  		v.AddArg2(v0, v1)
 15703  		return true
 15704  	}
 15705  }
 15706  func rewriteValueARM_OpRsh8x16(v *Value) bool {
 15707  	v_1 := v.Args[1]
 15708  	v_0 := v.Args[0]
 15709  	b := v.Block
 15710  	typ := &b.Func.Config.Types
 15711  	// match: (Rsh8x16 x y)
 15712  	// result: (SRAcond (SignExt8to32 x) (ZeroExt16to32 y) (CMPconst [256] (ZeroExt16to32 y)))
 15713  	for {
 15714  		x := v_0
 15715  		y := v_1
 15716  		v.reset(OpARMSRAcond)
 15717  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 15718  		v0.AddArg(x)
 15719  		v1 := b.NewValue0(v.Pos, OpZeroExt16to32, typ.UInt32)
 15720  		v1.AddArg(y)
 15721  		v2 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15722  		v2.AuxInt = int32ToAuxInt(256)
 15723  		v2.AddArg(v1)
 15724  		v.AddArg3(v0, v1, v2)
 15725  		return true
 15726  	}
 15727  }
 15728  func rewriteValueARM_OpRsh8x32(v *Value) bool {
 15729  	v_1 := v.Args[1]
 15730  	v_0 := v.Args[0]
 15731  	b := v.Block
 15732  	typ := &b.Func.Config.Types
 15733  	// match: (Rsh8x32 x y)
 15734  	// result: (SRAcond (SignExt8to32 x) y (CMPconst [256] y))
 15735  	for {
 15736  		x := v_0
 15737  		y := v_1
 15738  		v.reset(OpARMSRAcond)
 15739  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 15740  		v0.AddArg(x)
 15741  		v1 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
 15742  		v1.AuxInt = int32ToAuxInt(256)
 15743  		v1.AddArg(y)
 15744  		v.AddArg3(v0, y, v1)
 15745  		return true
 15746  	}
 15747  }
 15748  func rewriteValueARM_OpRsh8x64(v *Value) bool {
 15749  	v_1 := v.Args[1]
 15750  	v_0 := v.Args[0]
 15751  	b := v.Block
 15752  	typ := &b.Func.Config.Types
 15753  	// match: (Rsh8x64 x (Const64 [c]))
 15754  	// cond: uint64(c) < 8
 15755  	// result: (SRAconst (SLLconst <typ.UInt32> x [24]) [int32(c+24)])
 15756  	for {
 15757  		x := v_0
 15758  		if v_1.Op != OpConst64 {
 15759  			break
 15760  		}
 15761  		c := auxIntToInt64(v_1.AuxInt)
 15762  		if !(uint64(c) < 8) {
 15763  			break
 15764  		}
 15765  		v.reset(OpARMSRAconst)
 15766  		v.AuxInt = int32ToAuxInt(int32(c + 24))
 15767  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
 15768  		v0.AuxInt = int32ToAuxInt(24)
 15769  		v0.AddArg(x)
 15770  		v.AddArg(v0)
 15771  		return true
 15772  	}
 15773  	// match: (Rsh8x64 x (Const64 [c]))
 15774  	// cond: uint64(c) >= 8
 15775  	// result: (SRAconst (SLLconst <typ.UInt32> x [24]) [31])
 15776  	for {
 15777  		x := v_0
 15778  		if v_1.Op != OpConst64 {
 15779  			break
 15780  		}
 15781  		c := auxIntToInt64(v_1.AuxInt)
 15782  		if !(uint64(c) >= 8) {
 15783  			break
 15784  		}
 15785  		v.reset(OpARMSRAconst)
 15786  		v.AuxInt = int32ToAuxInt(31)
 15787  		v0 := b.NewValue0(v.Pos, OpARMSLLconst, typ.UInt32)
 15788  		v0.AuxInt = int32ToAuxInt(24)
 15789  		v0.AddArg(x)
 15790  		v.AddArg(v0)
 15791  		return true
 15792  	}
 15793  	return false
 15794  }
 15795  func rewriteValueARM_OpRsh8x8(v *Value) bool {
 15796  	v_1 := v.Args[1]
 15797  	v_0 := v.Args[0]
 15798  	b := v.Block
 15799  	typ := &b.Func.Config.Types
 15800  	// match: (Rsh8x8 x y)
 15801  	// result: (SRA (SignExt8to32 x) (ZeroExt8to32 y))
 15802  	for {
 15803  		x := v_0
 15804  		y := v_1
 15805  		v.reset(OpARMSRA)
 15806  		v0 := b.NewValue0(v.Pos, OpSignExt8to32, typ.Int32)
 15807  		v0.AddArg(x)
 15808  		v1 := b.NewValue0(v.Pos, OpZeroExt8to32, typ.UInt32)
 15809  		v1.AddArg(y)
 15810  		v.AddArg2(v0, v1)
 15811  		return true
 15812  	}
 15813  }
 15814  func rewriteValueARM_OpSelect0(v *Value) bool {
 15815  	v_0 := v.Args[0]
 15816  	// match: (Select0 (CALLudiv x (MOVWconst [1])))
 15817  	// result: x
 15818  	for {
 15819  		if v_0.Op != OpARMCALLudiv {
 15820  			break
 15821  		}
 15822  		_ = v_0.Args[1]
 15823  		x := v_0.Args[0]
 15824  		v_0_1 := v_0.Args[1]
 15825  		if v_0_1.Op != OpARMMOVWconst || auxIntToInt32(v_0_1.AuxInt) != 1 {
 15826  			break
 15827  		}
 15828  		v.copyOf(x)
 15829  		return true
 15830  	}
 15831  	// match: (Select0 (CALLudiv x (MOVWconst [c])))
 15832  	// cond: isPowerOfTwo(c)
 15833  	// result: (SRLconst [int32(log32(c))] x)
 15834  	for {
 15835  		if v_0.Op != OpARMCALLudiv {
 15836  			break
 15837  		}
 15838  		_ = v_0.Args[1]
 15839  		x := v_0.Args[0]
 15840  		v_0_1 := v_0.Args[1]
 15841  		if v_0_1.Op != OpARMMOVWconst {
 15842  			break
 15843  		}
 15844  		c := auxIntToInt32(v_0_1.AuxInt)
 15845  		if !(isPowerOfTwo(c)) {
 15846  			break
 15847  		}
 15848  		v.reset(OpARMSRLconst)
 15849  		v.AuxInt = int32ToAuxInt(int32(log32(c)))
 15850  		v.AddArg(x)
 15851  		return true
 15852  	}
 15853  	// match: (Select0 (CALLudiv (MOVWconst [c]) (MOVWconst [d])))
 15854  	// cond: d != 0
 15855  	// result: (MOVWconst [int32(uint32(c)/uint32(d))])
 15856  	for {
 15857  		if v_0.Op != OpARMCALLudiv {
 15858  			break
 15859  		}
 15860  		_ = v_0.Args[1]
 15861  		v_0_0 := v_0.Args[0]
 15862  		if v_0_0.Op != OpARMMOVWconst {
 15863  			break
 15864  		}
 15865  		c := auxIntToInt32(v_0_0.AuxInt)
 15866  		v_0_1 := v_0.Args[1]
 15867  		if v_0_1.Op != OpARMMOVWconst {
 15868  			break
 15869  		}
 15870  		d := auxIntToInt32(v_0_1.AuxInt)
 15871  		if !(d != 0) {
 15872  			break
 15873  		}
 15874  		v.reset(OpARMMOVWconst)
 15875  		v.AuxInt = int32ToAuxInt(int32(uint32(c) / uint32(d)))
 15876  		return true
 15877  	}
 15878  	return false
 15879  }
 15880  func rewriteValueARM_OpSelect1(v *Value) bool {
 15881  	v_0 := v.Args[0]
 15882  	// match: (Select1 (CALLudiv _ (MOVWconst [1])))
 15883  	// result: (MOVWconst [0])
 15884  	for {
 15885  		if v_0.Op != OpARMCALLudiv {
 15886  			break
 15887  		}
 15888  		_ = v_0.Args[1]
 15889  		v_0_1 := v_0.Args[1]
 15890  		if v_0_1.Op != OpARMMOVWconst || auxIntToInt32(v_0_1.AuxInt) != 1 {
 15891  			break
 15892  		}
 15893  		v.reset(OpARMMOVWconst)
 15894  		v.AuxInt = int32ToAuxInt(0)
 15895  		return true
 15896  	}
 15897  	// match: (Select1 (CALLudiv x (MOVWconst [c])))
 15898  	// cond: isPowerOfTwo(c)
 15899  	// result: (ANDconst [c-1] x)
 15900  	for {
 15901  		if v_0.Op != OpARMCALLudiv {
 15902  			break
 15903  		}
 15904  		_ = v_0.Args[1]
 15905  		x := v_0.Args[0]
 15906  		v_0_1 := v_0.Args[1]
 15907  		if v_0_1.Op != OpARMMOVWconst {
 15908  			break
 15909  		}
 15910  		c := auxIntToInt32(v_0_1.AuxInt)
 15911  		if !(isPowerOfTwo(c)) {
 15912  			break
 15913  		}
 15914  		v.reset(OpARMANDconst)
 15915  		v.AuxInt = int32ToAuxInt(c - 1)
 15916  		v.AddArg(x)
 15917  		return true
 15918  	}
 15919  	// match: (Select1 (CALLudiv (MOVWconst [c]) (MOVWconst [d])))
 15920  	// cond: d != 0
 15921  	// result: (MOVWconst [int32(uint32(c)%uint32(d))])
 15922  	for {
 15923  		if v_0.Op != OpARMCALLudiv {
 15924  			break
 15925  		}
 15926  		_ = v_0.Args[1]
 15927  		v_0_0 := v_0.Args[0]
 15928  		if v_0_0.Op != OpARMMOVWconst {
 15929  			break
 15930  		}
 15931  		c := auxIntToInt32(v_0_0.AuxInt)
 15932  		v_0_1 := v_0.Args[1]
 15933  		if v_0_1.Op != OpARMMOVWconst {
 15934  			break
 15935  		}
 15936  		d := auxIntToInt32(v_0_1.AuxInt)
 15937  		if !(d != 0) {
 15938  			break
 15939  		}
 15940  		v.reset(OpARMMOVWconst)
 15941  		v.AuxInt = int32ToAuxInt(int32(uint32(c) % uint32(d)))
 15942  		return true
 15943  	}
 15944  	return false
 15945  }
 15946  func rewriteValueARM_OpSignmask(v *Value) bool {
 15947  	v_0 := v.Args[0]
 15948  	// match: (Signmask x)
 15949  	// result: (SRAconst x [31])
 15950  	for {
 15951  		x := v_0
 15952  		v.reset(OpARMSRAconst)
 15953  		v.AuxInt = int32ToAuxInt(31)
 15954  		v.AddArg(x)
 15955  		return true
 15956  	}
 15957  }
 15958  func rewriteValueARM_OpSlicemask(v *Value) bool {
 15959  	v_0 := v.Args[0]
 15960  	b := v.Block
 15961  	// match: (Slicemask <t> x)
 15962  	// result: (SRAconst (RSBconst <t> [0] x) [31])
 15963  	for {
 15964  		t := v.Type
 15965  		x := v_0
 15966  		v.reset(OpARMSRAconst)
 15967  		v.AuxInt = int32ToAuxInt(31)
 15968  		v0 := b.NewValue0(v.Pos, OpARMRSBconst, t)
 15969  		v0.AuxInt = int32ToAuxInt(0)
 15970  		v0.AddArg(x)
 15971  		v.AddArg(v0)
 15972  		return true
 15973  	}
 15974  }
 15975  func rewriteValueARM_OpStore(v *Value) bool {
 15976  	v_2 := v.Args[2]
 15977  	v_1 := v.Args[1]
 15978  	v_0 := v.Args[0]
 15979  	// match: (Store {t} ptr val mem)
 15980  	// cond: t.Size() == 1
 15981  	// result: (MOVBstore ptr val mem)
 15982  	for {
 15983  		t := auxToType(v.Aux)
 15984  		ptr := v_0
 15985  		val := v_1
 15986  		mem := v_2
 15987  		if !(t.Size() == 1) {
 15988  			break
 15989  		}
 15990  		v.reset(OpARMMOVBstore)
 15991  		v.AddArg3(ptr, val, mem)
 15992  		return true
 15993  	}
 15994  	// match: (Store {t} ptr val mem)
 15995  	// cond: t.Size() == 2
 15996  	// result: (MOVHstore ptr val mem)
 15997  	for {
 15998  		t := auxToType(v.Aux)
 15999  		ptr := v_0
 16000  		val := v_1
 16001  		mem := v_2
 16002  		if !(t.Size() == 2) {
 16003  			break
 16004  		}
 16005  		v.reset(OpARMMOVHstore)
 16006  		v.AddArg3(ptr, val, mem)
 16007  		return true
 16008  	}
 16009  	// match: (Store {t} ptr val mem)
 16010  	// cond: t.Size() == 4 && !t.IsFloat()
 16011  	// result: (MOVWstore ptr val mem)
 16012  	for {
 16013  		t := auxToType(v.Aux)
 16014  		ptr := v_0
 16015  		val := v_1
 16016  		mem := v_2
 16017  		if !(t.Size() == 4 && !t.IsFloat()) {
 16018  			break
 16019  		}
 16020  		v.reset(OpARMMOVWstore)
 16021  		v.AddArg3(ptr, val, mem)
 16022  		return true
 16023  	}
 16024  	// match: (Store {t} ptr val mem)
 16025  	// cond: t.Size() == 4 && t.IsFloat()
 16026  	// result: (MOVFstore ptr val mem)
 16027  	for {
 16028  		t := auxToType(v.Aux)
 16029  		ptr := v_0
 16030  		val := v_1
 16031  		mem := v_2
 16032  		if !(t.Size() == 4 && t.IsFloat()) {
 16033  			break
 16034  		}
 16035  		v.reset(OpARMMOVFstore)
 16036  		v.AddArg3(ptr, val, mem)
 16037  		return true
 16038  	}
 16039  	// match: (Store {t} ptr val mem)
 16040  	// cond: t.Size() == 8 && t.IsFloat()
 16041  	// result: (MOVDstore ptr val mem)
 16042  	for {
 16043  		t := auxToType(v.Aux)
 16044  		ptr := v_0
 16045  		val := v_1
 16046  		mem := v_2
 16047  		if !(t.Size() == 8 && t.IsFloat()) {
 16048  			break
 16049  		}
 16050  		v.reset(OpARMMOVDstore)
 16051  		v.AddArg3(ptr, val, mem)
 16052  		return true
 16053  	}
 16054  	return false
 16055  }
 16056  func rewriteValueARM_OpZero(v *Value) bool {
 16057  	v_1 := v.Args[1]
 16058  	v_0 := v.Args[0]
 16059  	b := v.Block
 16060  	config := b.Func.Config
 16061  	typ := &b.Func.Config.Types
 16062  	// match: (Zero [0] _ mem)
 16063  	// result: mem
 16064  	for {
 16065  		if auxIntToInt64(v.AuxInt) != 0 {
 16066  			break
 16067  		}
 16068  		mem := v_1
 16069  		v.copyOf(mem)
 16070  		return true
 16071  	}
 16072  	// match: (Zero [1] ptr mem)
 16073  	// result: (MOVBstore ptr (MOVWconst [0]) mem)
 16074  	for {
 16075  		if auxIntToInt64(v.AuxInt) != 1 {
 16076  			break
 16077  		}
 16078  		ptr := v_0
 16079  		mem := v_1
 16080  		v.reset(OpARMMOVBstore)
 16081  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16082  		v0.AuxInt = int32ToAuxInt(0)
 16083  		v.AddArg3(ptr, v0, mem)
 16084  		return true
 16085  	}
 16086  	// match: (Zero [2] {t} ptr mem)
 16087  	// cond: t.Alignment()%2 == 0
 16088  	// result: (MOVHstore ptr (MOVWconst [0]) mem)
 16089  	for {
 16090  		if auxIntToInt64(v.AuxInt) != 2 {
 16091  			break
 16092  		}
 16093  		t := auxToType(v.Aux)
 16094  		ptr := v_0
 16095  		mem := v_1
 16096  		if !(t.Alignment()%2 == 0) {
 16097  			break
 16098  		}
 16099  		v.reset(OpARMMOVHstore)
 16100  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16101  		v0.AuxInt = int32ToAuxInt(0)
 16102  		v.AddArg3(ptr, v0, mem)
 16103  		return true
 16104  	}
 16105  	// match: (Zero [2] ptr mem)
 16106  	// result: (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))
 16107  	for {
 16108  		if auxIntToInt64(v.AuxInt) != 2 {
 16109  			break
 16110  		}
 16111  		ptr := v_0
 16112  		mem := v_1
 16113  		v.reset(OpARMMOVBstore)
 16114  		v.AuxInt = int32ToAuxInt(1)
 16115  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16116  		v0.AuxInt = int32ToAuxInt(0)
 16117  		v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 16118  		v1.AuxInt = int32ToAuxInt(0)
 16119  		v1.AddArg3(ptr, v0, mem)
 16120  		v.AddArg3(ptr, v0, v1)
 16121  		return true
 16122  	}
 16123  	// match: (Zero [4] {t} ptr mem)
 16124  	// cond: t.Alignment()%4 == 0
 16125  	// result: (MOVWstore ptr (MOVWconst [0]) mem)
 16126  	for {
 16127  		if auxIntToInt64(v.AuxInt) != 4 {
 16128  			break
 16129  		}
 16130  		t := auxToType(v.Aux)
 16131  		ptr := v_0
 16132  		mem := v_1
 16133  		if !(t.Alignment()%4 == 0) {
 16134  			break
 16135  		}
 16136  		v.reset(OpARMMOVWstore)
 16137  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16138  		v0.AuxInt = int32ToAuxInt(0)
 16139  		v.AddArg3(ptr, v0, mem)
 16140  		return true
 16141  	}
 16142  	// match: (Zero [4] {t} ptr mem)
 16143  	// cond: t.Alignment()%2 == 0
 16144  	// result: (MOVHstore [2] ptr (MOVWconst [0]) (MOVHstore [0] ptr (MOVWconst [0]) mem))
 16145  	for {
 16146  		if auxIntToInt64(v.AuxInt) != 4 {
 16147  			break
 16148  		}
 16149  		t := auxToType(v.Aux)
 16150  		ptr := v_0
 16151  		mem := v_1
 16152  		if !(t.Alignment()%2 == 0) {
 16153  			break
 16154  		}
 16155  		v.reset(OpARMMOVHstore)
 16156  		v.AuxInt = int32ToAuxInt(2)
 16157  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16158  		v0.AuxInt = int32ToAuxInt(0)
 16159  		v1 := b.NewValue0(v.Pos, OpARMMOVHstore, types.TypeMem)
 16160  		v1.AuxInt = int32ToAuxInt(0)
 16161  		v1.AddArg3(ptr, v0, mem)
 16162  		v.AddArg3(ptr, v0, v1)
 16163  		return true
 16164  	}
 16165  	// match: (Zero [4] ptr mem)
 16166  	// result: (MOVBstore [3] ptr (MOVWconst [0]) (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem))))
 16167  	for {
 16168  		if auxIntToInt64(v.AuxInt) != 4 {
 16169  			break
 16170  		}
 16171  		ptr := v_0
 16172  		mem := v_1
 16173  		v.reset(OpARMMOVBstore)
 16174  		v.AuxInt = int32ToAuxInt(3)
 16175  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16176  		v0.AuxInt = int32ToAuxInt(0)
 16177  		v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 16178  		v1.AuxInt = int32ToAuxInt(2)
 16179  		v2 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 16180  		v2.AuxInt = int32ToAuxInt(1)
 16181  		v3 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 16182  		v3.AuxInt = int32ToAuxInt(0)
 16183  		v3.AddArg3(ptr, v0, mem)
 16184  		v2.AddArg3(ptr, v0, v3)
 16185  		v1.AddArg3(ptr, v0, v2)
 16186  		v.AddArg3(ptr, v0, v1)
 16187  		return true
 16188  	}
 16189  	// match: (Zero [3] ptr mem)
 16190  	// result: (MOVBstore [2] ptr (MOVWconst [0]) (MOVBstore [1] ptr (MOVWconst [0]) (MOVBstore [0] ptr (MOVWconst [0]) mem)))
 16191  	for {
 16192  		if auxIntToInt64(v.AuxInt) != 3 {
 16193  			break
 16194  		}
 16195  		ptr := v_0
 16196  		mem := v_1
 16197  		v.reset(OpARMMOVBstore)
 16198  		v.AuxInt = int32ToAuxInt(2)
 16199  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16200  		v0.AuxInt = int32ToAuxInt(0)
 16201  		v1 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 16202  		v1.AuxInt = int32ToAuxInt(1)
 16203  		v2 := b.NewValue0(v.Pos, OpARMMOVBstore, types.TypeMem)
 16204  		v2.AuxInt = int32ToAuxInt(0)
 16205  		v2.AddArg3(ptr, v0, mem)
 16206  		v1.AddArg3(ptr, v0, v2)
 16207  		v.AddArg3(ptr, v0, v1)
 16208  		return true
 16209  	}
 16210  	// match: (Zero [s] {t} ptr mem)
 16211  	// cond: s%4 == 0 && s > 4 && s <= 512 && t.Alignment()%4 == 0
 16212  	// result: (DUFFZERO [4 * (128 - s/4)] ptr (MOVWconst [0]) mem)
 16213  	for {
 16214  		s := auxIntToInt64(v.AuxInt)
 16215  		t := auxToType(v.Aux)
 16216  		ptr := v_0
 16217  		mem := v_1
 16218  		if !(s%4 == 0 && s > 4 && s <= 512 && t.Alignment()%4 == 0) {
 16219  			break
 16220  		}
 16221  		v.reset(OpARMDUFFZERO)
 16222  		v.AuxInt = int64ToAuxInt(4 * (128 - s/4))
 16223  		v0 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16224  		v0.AuxInt = int32ToAuxInt(0)
 16225  		v.AddArg3(ptr, v0, mem)
 16226  		return true
 16227  	}
 16228  	// match: (Zero [s] {t} ptr mem)
 16229  	// cond: s > 512 || t.Alignment()%4 != 0
 16230  	// result: (LoweredZero [t.Alignment()] ptr (ADDconst <ptr.Type> ptr [int32(s-moveSize(t.Alignment(), config))]) (MOVWconst [0]) mem)
 16231  	for {
 16232  		s := auxIntToInt64(v.AuxInt)
 16233  		t := auxToType(v.Aux)
 16234  		ptr := v_0
 16235  		mem := v_1
 16236  		if !(s > 512 || t.Alignment()%4 != 0) {
 16237  			break
 16238  		}
 16239  		v.reset(OpARMLoweredZero)
 16240  		v.AuxInt = int64ToAuxInt(t.Alignment())
 16241  		v0 := b.NewValue0(v.Pos, OpARMADDconst, ptr.Type)
 16242  		v0.AuxInt = int32ToAuxInt(int32(s - moveSize(t.Alignment(), config)))
 16243  		v0.AddArg(ptr)
 16244  		v1 := b.NewValue0(v.Pos, OpARMMOVWconst, typ.UInt32)
 16245  		v1.AuxInt = int32ToAuxInt(0)
 16246  		v.AddArg4(ptr, v0, v1, mem)
 16247  		return true
 16248  	}
 16249  	return false
 16250  }
 16251  func rewriteValueARM_OpZeromask(v *Value) bool {
 16252  	v_0 := v.Args[0]
 16253  	b := v.Block
 16254  	typ := &b.Func.Config.Types
 16255  	// match: (Zeromask x)
 16256  	// result: (SRAconst (RSBshiftRL <typ.Int32> x x [1]) [31])
 16257  	for {
 16258  		x := v_0
 16259  		v.reset(OpARMSRAconst)
 16260  		v.AuxInt = int32ToAuxInt(31)
 16261  		v0 := b.NewValue0(v.Pos, OpARMRSBshiftRL, typ.Int32)
 16262  		v0.AuxInt = int32ToAuxInt(1)
 16263  		v0.AddArg2(x, x)
 16264  		v.AddArg(v0)
 16265  		return true
 16266  	}
 16267  }
 16268  func rewriteBlockARM(b *Block) bool {
 16269  	switch b.Kind {
 16270  	case BlockARMEQ:
 16271  		// match: (EQ (FlagConstant [fc]) yes no)
 16272  		// cond: fc.eq()
 16273  		// result: (First yes no)
 16274  		for b.Controls[0].Op == OpARMFlagConstant {
 16275  			v_0 := b.Controls[0]
 16276  			fc := auxIntToFlagConstant(v_0.AuxInt)
 16277  			if !(fc.eq()) {
 16278  				break
 16279  			}
 16280  			b.Reset(BlockFirst)
 16281  			return true
 16282  		}
 16283  		// match: (EQ (FlagConstant [fc]) yes no)
 16284  		// cond: !fc.eq()
 16285  		// result: (First no yes)
 16286  		for b.Controls[0].Op == OpARMFlagConstant {
 16287  			v_0 := b.Controls[0]
 16288  			fc := auxIntToFlagConstant(v_0.AuxInt)
 16289  			if !(!fc.eq()) {
 16290  				break
 16291  			}
 16292  			b.Reset(BlockFirst)
 16293  			b.swapSuccessors()
 16294  			return true
 16295  		}
 16296  		// match: (EQ (InvertFlags cmp) yes no)
 16297  		// result: (EQ cmp yes no)
 16298  		for b.Controls[0].Op == OpARMInvertFlags {
 16299  			v_0 := b.Controls[0]
 16300  			cmp := v_0.Args[0]
 16301  			b.resetWithControl(BlockARMEQ, cmp)
 16302  			return true
 16303  		}
 16304  		// match: (EQ (CMP x (RSBconst [0] y)))
 16305  		// result: (EQ (CMN x y))
 16306  		for b.Controls[0].Op == OpARMCMP {
 16307  			v_0 := b.Controls[0]
 16308  			_ = v_0.Args[1]
 16309  			x := v_0.Args[0]
 16310  			v_0_1 := v_0.Args[1]
 16311  			if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 {
 16312  				break
 16313  			}
 16314  			y := v_0_1.Args[0]
 16315  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 16316  			v0.AddArg2(x, y)
 16317  			b.resetWithControl(BlockARMEQ, v0)
 16318  			return true
 16319  		}
 16320  		// match: (EQ (CMN x (RSBconst [0] y)))
 16321  		// result: (EQ (CMP x y))
 16322  		for b.Controls[0].Op == OpARMCMN {
 16323  			v_0 := b.Controls[0]
 16324  			_ = v_0.Args[1]
 16325  			v_0_0 := v_0.Args[0]
 16326  			v_0_1 := v_0.Args[1]
 16327  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
 16328  				x := v_0_0
 16329  				if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 {
 16330  					continue
 16331  				}
 16332  				y := v_0_1.Args[0]
 16333  				v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 16334  				v0.AddArg2(x, y)
 16335  				b.resetWithControl(BlockARMEQ, v0)
 16336  				return true
 16337  			}
 16338  			break
 16339  		}
 16340  		// match: (EQ (CMPconst [0] l:(SUB x y)) yes no)
 16341  		// cond: l.Uses==1
 16342  		// result: (EQ (CMP x y) yes no)
 16343  		for b.Controls[0].Op == OpARMCMPconst {
 16344  			v_0 := b.Controls[0]
 16345  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16346  				break
 16347  			}
 16348  			l := v_0.Args[0]
 16349  			if l.Op != OpARMSUB {
 16350  				break
 16351  			}
 16352  			y := l.Args[1]
 16353  			x := l.Args[0]
 16354  			if !(l.Uses == 1) {
 16355  				break
 16356  			}
 16357  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 16358  			v0.AddArg2(x, y)
 16359  			b.resetWithControl(BlockARMEQ, v0)
 16360  			return true
 16361  		}
 16362  		// match: (EQ (CMPconst [0] l:(MULS x y a)) yes no)
 16363  		// cond: l.Uses==1
 16364  		// result: (EQ (CMP a (MUL <x.Type> x y)) yes no)
 16365  		for b.Controls[0].Op == OpARMCMPconst {
 16366  			v_0 := b.Controls[0]
 16367  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16368  				break
 16369  			}
 16370  			l := v_0.Args[0]
 16371  			if l.Op != OpARMMULS {
 16372  				break
 16373  			}
 16374  			a := l.Args[2]
 16375  			x := l.Args[0]
 16376  			y := l.Args[1]
 16377  			if !(l.Uses == 1) {
 16378  				break
 16379  			}
 16380  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 16381  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 16382  			v1.AddArg2(x, y)
 16383  			v0.AddArg2(a, v1)
 16384  			b.resetWithControl(BlockARMEQ, v0)
 16385  			return true
 16386  		}
 16387  		// match: (EQ (CMPconst [0] l:(SUBconst [c] x)) yes no)
 16388  		// cond: l.Uses==1
 16389  		// result: (EQ (CMPconst [c] x) yes no)
 16390  		for b.Controls[0].Op == OpARMCMPconst {
 16391  			v_0 := b.Controls[0]
 16392  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16393  				break
 16394  			}
 16395  			l := v_0.Args[0]
 16396  			if l.Op != OpARMSUBconst {
 16397  				break
 16398  			}
 16399  			c := auxIntToInt32(l.AuxInt)
 16400  			x := l.Args[0]
 16401  			if !(l.Uses == 1) {
 16402  				break
 16403  			}
 16404  			v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
 16405  			v0.AuxInt = int32ToAuxInt(c)
 16406  			v0.AddArg(x)
 16407  			b.resetWithControl(BlockARMEQ, v0)
 16408  			return true
 16409  		}
 16410  		// match: (EQ (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
 16411  		// cond: l.Uses==1
 16412  		// result: (EQ (CMPshiftLL x y [c]) yes no)
 16413  		for b.Controls[0].Op == OpARMCMPconst {
 16414  			v_0 := b.Controls[0]
 16415  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16416  				break
 16417  			}
 16418  			l := v_0.Args[0]
 16419  			if l.Op != OpARMSUBshiftLL {
 16420  				break
 16421  			}
 16422  			c := auxIntToInt32(l.AuxInt)
 16423  			y := l.Args[1]
 16424  			x := l.Args[0]
 16425  			if !(l.Uses == 1) {
 16426  				break
 16427  			}
 16428  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
 16429  			v0.AuxInt = int32ToAuxInt(c)
 16430  			v0.AddArg2(x, y)
 16431  			b.resetWithControl(BlockARMEQ, v0)
 16432  			return true
 16433  		}
 16434  		// match: (EQ (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
 16435  		// cond: l.Uses==1
 16436  		// result: (EQ (CMPshiftRL x y [c]) yes no)
 16437  		for b.Controls[0].Op == OpARMCMPconst {
 16438  			v_0 := b.Controls[0]
 16439  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16440  				break
 16441  			}
 16442  			l := v_0.Args[0]
 16443  			if l.Op != OpARMSUBshiftRL {
 16444  				break
 16445  			}
 16446  			c := auxIntToInt32(l.AuxInt)
 16447  			y := l.Args[1]
 16448  			x := l.Args[0]
 16449  			if !(l.Uses == 1) {
 16450  				break
 16451  			}
 16452  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
 16453  			v0.AuxInt = int32ToAuxInt(c)
 16454  			v0.AddArg2(x, y)
 16455  			b.resetWithControl(BlockARMEQ, v0)
 16456  			return true
 16457  		}
 16458  		// match: (EQ (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
 16459  		// cond: l.Uses==1
 16460  		// result: (EQ (CMPshiftRA x y [c]) yes no)
 16461  		for b.Controls[0].Op == OpARMCMPconst {
 16462  			v_0 := b.Controls[0]
 16463  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16464  				break
 16465  			}
 16466  			l := v_0.Args[0]
 16467  			if l.Op != OpARMSUBshiftRA {
 16468  				break
 16469  			}
 16470  			c := auxIntToInt32(l.AuxInt)
 16471  			y := l.Args[1]
 16472  			x := l.Args[0]
 16473  			if !(l.Uses == 1) {
 16474  				break
 16475  			}
 16476  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
 16477  			v0.AuxInt = int32ToAuxInt(c)
 16478  			v0.AddArg2(x, y)
 16479  			b.resetWithControl(BlockARMEQ, v0)
 16480  			return true
 16481  		}
 16482  		// match: (EQ (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
 16483  		// cond: l.Uses==1
 16484  		// result: (EQ (CMPshiftLLreg x y z) yes no)
 16485  		for b.Controls[0].Op == OpARMCMPconst {
 16486  			v_0 := b.Controls[0]
 16487  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16488  				break
 16489  			}
 16490  			l := v_0.Args[0]
 16491  			if l.Op != OpARMSUBshiftLLreg {
 16492  				break
 16493  			}
 16494  			z := l.Args[2]
 16495  			x := l.Args[0]
 16496  			y := l.Args[1]
 16497  			if !(l.Uses == 1) {
 16498  				break
 16499  			}
 16500  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
 16501  			v0.AddArg3(x, y, z)
 16502  			b.resetWithControl(BlockARMEQ, v0)
 16503  			return true
 16504  		}
 16505  		// match: (EQ (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
 16506  		// cond: l.Uses==1
 16507  		// result: (EQ (CMPshiftRLreg x y z) yes no)
 16508  		for b.Controls[0].Op == OpARMCMPconst {
 16509  			v_0 := b.Controls[0]
 16510  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16511  				break
 16512  			}
 16513  			l := v_0.Args[0]
 16514  			if l.Op != OpARMSUBshiftRLreg {
 16515  				break
 16516  			}
 16517  			z := l.Args[2]
 16518  			x := l.Args[0]
 16519  			y := l.Args[1]
 16520  			if !(l.Uses == 1) {
 16521  				break
 16522  			}
 16523  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
 16524  			v0.AddArg3(x, y, z)
 16525  			b.resetWithControl(BlockARMEQ, v0)
 16526  			return true
 16527  		}
 16528  		// match: (EQ (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
 16529  		// cond: l.Uses==1
 16530  		// result: (EQ (CMPshiftRAreg x y z) yes no)
 16531  		for b.Controls[0].Op == OpARMCMPconst {
 16532  			v_0 := b.Controls[0]
 16533  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16534  				break
 16535  			}
 16536  			l := v_0.Args[0]
 16537  			if l.Op != OpARMSUBshiftRAreg {
 16538  				break
 16539  			}
 16540  			z := l.Args[2]
 16541  			x := l.Args[0]
 16542  			y := l.Args[1]
 16543  			if !(l.Uses == 1) {
 16544  				break
 16545  			}
 16546  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
 16547  			v0.AddArg3(x, y, z)
 16548  			b.resetWithControl(BlockARMEQ, v0)
 16549  			return true
 16550  		}
 16551  		// match: (EQ (CMPconst [0] l:(ADD x y)) yes no)
 16552  		// cond: l.Uses==1
 16553  		// result: (EQ (CMN x y) yes no)
 16554  		for b.Controls[0].Op == OpARMCMPconst {
 16555  			v_0 := b.Controls[0]
 16556  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16557  				break
 16558  			}
 16559  			l := v_0.Args[0]
 16560  			if l.Op != OpARMADD {
 16561  				break
 16562  			}
 16563  			_ = l.Args[1]
 16564  			l_0 := l.Args[0]
 16565  			l_1 := l.Args[1]
 16566  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 16567  				x := l_0
 16568  				y := l_1
 16569  				if !(l.Uses == 1) {
 16570  					continue
 16571  				}
 16572  				v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 16573  				v0.AddArg2(x, y)
 16574  				b.resetWithControl(BlockARMEQ, v0)
 16575  				return true
 16576  			}
 16577  			break
 16578  		}
 16579  		// match: (EQ (CMPconst [0] l:(MULA x y a)) yes no)
 16580  		// cond: l.Uses==1
 16581  		// result: (EQ (CMN a (MUL <x.Type> x y)) yes no)
 16582  		for b.Controls[0].Op == OpARMCMPconst {
 16583  			v_0 := b.Controls[0]
 16584  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16585  				break
 16586  			}
 16587  			l := v_0.Args[0]
 16588  			if l.Op != OpARMMULA {
 16589  				break
 16590  			}
 16591  			a := l.Args[2]
 16592  			x := l.Args[0]
 16593  			y := l.Args[1]
 16594  			if !(l.Uses == 1) {
 16595  				break
 16596  			}
 16597  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 16598  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 16599  			v1.AddArg2(x, y)
 16600  			v0.AddArg2(a, v1)
 16601  			b.resetWithControl(BlockARMEQ, v0)
 16602  			return true
 16603  		}
 16604  		// match: (EQ (CMPconst [0] l:(ADDconst [c] x)) yes no)
 16605  		// cond: l.Uses==1
 16606  		// result: (EQ (CMNconst [c] x) yes no)
 16607  		for b.Controls[0].Op == OpARMCMPconst {
 16608  			v_0 := b.Controls[0]
 16609  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16610  				break
 16611  			}
 16612  			l := v_0.Args[0]
 16613  			if l.Op != OpARMADDconst {
 16614  				break
 16615  			}
 16616  			c := auxIntToInt32(l.AuxInt)
 16617  			x := l.Args[0]
 16618  			if !(l.Uses == 1) {
 16619  				break
 16620  			}
 16621  			v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
 16622  			v0.AuxInt = int32ToAuxInt(c)
 16623  			v0.AddArg(x)
 16624  			b.resetWithControl(BlockARMEQ, v0)
 16625  			return true
 16626  		}
 16627  		// match: (EQ (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
 16628  		// cond: l.Uses==1
 16629  		// result: (EQ (CMNshiftLL x y [c]) yes no)
 16630  		for b.Controls[0].Op == OpARMCMPconst {
 16631  			v_0 := b.Controls[0]
 16632  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16633  				break
 16634  			}
 16635  			l := v_0.Args[0]
 16636  			if l.Op != OpARMADDshiftLL {
 16637  				break
 16638  			}
 16639  			c := auxIntToInt32(l.AuxInt)
 16640  			y := l.Args[1]
 16641  			x := l.Args[0]
 16642  			if !(l.Uses == 1) {
 16643  				break
 16644  			}
 16645  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
 16646  			v0.AuxInt = int32ToAuxInt(c)
 16647  			v0.AddArg2(x, y)
 16648  			b.resetWithControl(BlockARMEQ, v0)
 16649  			return true
 16650  		}
 16651  		// match: (EQ (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
 16652  		// cond: l.Uses==1
 16653  		// result: (EQ (CMNshiftRL x y [c]) yes no)
 16654  		for b.Controls[0].Op == OpARMCMPconst {
 16655  			v_0 := b.Controls[0]
 16656  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16657  				break
 16658  			}
 16659  			l := v_0.Args[0]
 16660  			if l.Op != OpARMADDshiftRL {
 16661  				break
 16662  			}
 16663  			c := auxIntToInt32(l.AuxInt)
 16664  			y := l.Args[1]
 16665  			x := l.Args[0]
 16666  			if !(l.Uses == 1) {
 16667  				break
 16668  			}
 16669  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
 16670  			v0.AuxInt = int32ToAuxInt(c)
 16671  			v0.AddArg2(x, y)
 16672  			b.resetWithControl(BlockARMEQ, v0)
 16673  			return true
 16674  		}
 16675  		// match: (EQ (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
 16676  		// cond: l.Uses==1
 16677  		// result: (EQ (CMNshiftRA x y [c]) yes no)
 16678  		for b.Controls[0].Op == OpARMCMPconst {
 16679  			v_0 := b.Controls[0]
 16680  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16681  				break
 16682  			}
 16683  			l := v_0.Args[0]
 16684  			if l.Op != OpARMADDshiftRA {
 16685  				break
 16686  			}
 16687  			c := auxIntToInt32(l.AuxInt)
 16688  			y := l.Args[1]
 16689  			x := l.Args[0]
 16690  			if !(l.Uses == 1) {
 16691  				break
 16692  			}
 16693  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
 16694  			v0.AuxInt = int32ToAuxInt(c)
 16695  			v0.AddArg2(x, y)
 16696  			b.resetWithControl(BlockARMEQ, v0)
 16697  			return true
 16698  		}
 16699  		// match: (EQ (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
 16700  		// cond: l.Uses==1
 16701  		// result: (EQ (CMNshiftLLreg x y z) yes no)
 16702  		for b.Controls[0].Op == OpARMCMPconst {
 16703  			v_0 := b.Controls[0]
 16704  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16705  				break
 16706  			}
 16707  			l := v_0.Args[0]
 16708  			if l.Op != OpARMADDshiftLLreg {
 16709  				break
 16710  			}
 16711  			z := l.Args[2]
 16712  			x := l.Args[0]
 16713  			y := l.Args[1]
 16714  			if !(l.Uses == 1) {
 16715  				break
 16716  			}
 16717  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
 16718  			v0.AddArg3(x, y, z)
 16719  			b.resetWithControl(BlockARMEQ, v0)
 16720  			return true
 16721  		}
 16722  		// match: (EQ (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
 16723  		// cond: l.Uses==1
 16724  		// result: (EQ (CMNshiftRLreg x y z) yes no)
 16725  		for b.Controls[0].Op == OpARMCMPconst {
 16726  			v_0 := b.Controls[0]
 16727  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16728  				break
 16729  			}
 16730  			l := v_0.Args[0]
 16731  			if l.Op != OpARMADDshiftRLreg {
 16732  				break
 16733  			}
 16734  			z := l.Args[2]
 16735  			x := l.Args[0]
 16736  			y := l.Args[1]
 16737  			if !(l.Uses == 1) {
 16738  				break
 16739  			}
 16740  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
 16741  			v0.AddArg3(x, y, z)
 16742  			b.resetWithControl(BlockARMEQ, v0)
 16743  			return true
 16744  		}
 16745  		// match: (EQ (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
 16746  		// cond: l.Uses==1
 16747  		// result: (EQ (CMNshiftRAreg x y z) yes no)
 16748  		for b.Controls[0].Op == OpARMCMPconst {
 16749  			v_0 := b.Controls[0]
 16750  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16751  				break
 16752  			}
 16753  			l := v_0.Args[0]
 16754  			if l.Op != OpARMADDshiftRAreg {
 16755  				break
 16756  			}
 16757  			z := l.Args[2]
 16758  			x := l.Args[0]
 16759  			y := l.Args[1]
 16760  			if !(l.Uses == 1) {
 16761  				break
 16762  			}
 16763  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
 16764  			v0.AddArg3(x, y, z)
 16765  			b.resetWithControl(BlockARMEQ, v0)
 16766  			return true
 16767  		}
 16768  		// match: (EQ (CMPconst [0] l:(AND x y)) yes no)
 16769  		// cond: l.Uses==1
 16770  		// result: (EQ (TST x y) yes no)
 16771  		for b.Controls[0].Op == OpARMCMPconst {
 16772  			v_0 := b.Controls[0]
 16773  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16774  				break
 16775  			}
 16776  			l := v_0.Args[0]
 16777  			if l.Op != OpARMAND {
 16778  				break
 16779  			}
 16780  			_ = l.Args[1]
 16781  			l_0 := l.Args[0]
 16782  			l_1 := l.Args[1]
 16783  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 16784  				x := l_0
 16785  				y := l_1
 16786  				if !(l.Uses == 1) {
 16787  					continue
 16788  				}
 16789  				v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
 16790  				v0.AddArg2(x, y)
 16791  				b.resetWithControl(BlockARMEQ, v0)
 16792  				return true
 16793  			}
 16794  			break
 16795  		}
 16796  		// match: (EQ (CMPconst [0] l:(ANDconst [c] x)) yes no)
 16797  		// cond: l.Uses==1
 16798  		// result: (EQ (TSTconst [c] x) yes no)
 16799  		for b.Controls[0].Op == OpARMCMPconst {
 16800  			v_0 := b.Controls[0]
 16801  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16802  				break
 16803  			}
 16804  			l := v_0.Args[0]
 16805  			if l.Op != OpARMANDconst {
 16806  				break
 16807  			}
 16808  			c := auxIntToInt32(l.AuxInt)
 16809  			x := l.Args[0]
 16810  			if !(l.Uses == 1) {
 16811  				break
 16812  			}
 16813  			v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
 16814  			v0.AuxInt = int32ToAuxInt(c)
 16815  			v0.AddArg(x)
 16816  			b.resetWithControl(BlockARMEQ, v0)
 16817  			return true
 16818  		}
 16819  		// match: (EQ (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
 16820  		// cond: l.Uses==1
 16821  		// result: (EQ (TSTshiftLL x y [c]) yes no)
 16822  		for b.Controls[0].Op == OpARMCMPconst {
 16823  			v_0 := b.Controls[0]
 16824  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16825  				break
 16826  			}
 16827  			l := v_0.Args[0]
 16828  			if l.Op != OpARMANDshiftLL {
 16829  				break
 16830  			}
 16831  			c := auxIntToInt32(l.AuxInt)
 16832  			y := l.Args[1]
 16833  			x := l.Args[0]
 16834  			if !(l.Uses == 1) {
 16835  				break
 16836  			}
 16837  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
 16838  			v0.AuxInt = int32ToAuxInt(c)
 16839  			v0.AddArg2(x, y)
 16840  			b.resetWithControl(BlockARMEQ, v0)
 16841  			return true
 16842  		}
 16843  		// match: (EQ (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
 16844  		// cond: l.Uses==1
 16845  		// result: (EQ (TSTshiftRL x y [c]) yes no)
 16846  		for b.Controls[0].Op == OpARMCMPconst {
 16847  			v_0 := b.Controls[0]
 16848  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16849  				break
 16850  			}
 16851  			l := v_0.Args[0]
 16852  			if l.Op != OpARMANDshiftRL {
 16853  				break
 16854  			}
 16855  			c := auxIntToInt32(l.AuxInt)
 16856  			y := l.Args[1]
 16857  			x := l.Args[0]
 16858  			if !(l.Uses == 1) {
 16859  				break
 16860  			}
 16861  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
 16862  			v0.AuxInt = int32ToAuxInt(c)
 16863  			v0.AddArg2(x, y)
 16864  			b.resetWithControl(BlockARMEQ, v0)
 16865  			return true
 16866  		}
 16867  		// match: (EQ (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
 16868  		// cond: l.Uses==1
 16869  		// result: (EQ (TSTshiftRA x y [c]) yes no)
 16870  		for b.Controls[0].Op == OpARMCMPconst {
 16871  			v_0 := b.Controls[0]
 16872  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16873  				break
 16874  			}
 16875  			l := v_0.Args[0]
 16876  			if l.Op != OpARMANDshiftRA {
 16877  				break
 16878  			}
 16879  			c := auxIntToInt32(l.AuxInt)
 16880  			y := l.Args[1]
 16881  			x := l.Args[0]
 16882  			if !(l.Uses == 1) {
 16883  				break
 16884  			}
 16885  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
 16886  			v0.AuxInt = int32ToAuxInt(c)
 16887  			v0.AddArg2(x, y)
 16888  			b.resetWithControl(BlockARMEQ, v0)
 16889  			return true
 16890  		}
 16891  		// match: (EQ (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
 16892  		// cond: l.Uses==1
 16893  		// result: (EQ (TSTshiftLLreg x y z) yes no)
 16894  		for b.Controls[0].Op == OpARMCMPconst {
 16895  			v_0 := b.Controls[0]
 16896  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16897  				break
 16898  			}
 16899  			l := v_0.Args[0]
 16900  			if l.Op != OpARMANDshiftLLreg {
 16901  				break
 16902  			}
 16903  			z := l.Args[2]
 16904  			x := l.Args[0]
 16905  			y := l.Args[1]
 16906  			if !(l.Uses == 1) {
 16907  				break
 16908  			}
 16909  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
 16910  			v0.AddArg3(x, y, z)
 16911  			b.resetWithControl(BlockARMEQ, v0)
 16912  			return true
 16913  		}
 16914  		// match: (EQ (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
 16915  		// cond: l.Uses==1
 16916  		// result: (EQ (TSTshiftRLreg x y z) yes no)
 16917  		for b.Controls[0].Op == OpARMCMPconst {
 16918  			v_0 := b.Controls[0]
 16919  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16920  				break
 16921  			}
 16922  			l := v_0.Args[0]
 16923  			if l.Op != OpARMANDshiftRLreg {
 16924  				break
 16925  			}
 16926  			z := l.Args[2]
 16927  			x := l.Args[0]
 16928  			y := l.Args[1]
 16929  			if !(l.Uses == 1) {
 16930  				break
 16931  			}
 16932  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
 16933  			v0.AddArg3(x, y, z)
 16934  			b.resetWithControl(BlockARMEQ, v0)
 16935  			return true
 16936  		}
 16937  		// match: (EQ (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
 16938  		// cond: l.Uses==1
 16939  		// result: (EQ (TSTshiftRAreg x y z) yes no)
 16940  		for b.Controls[0].Op == OpARMCMPconst {
 16941  			v_0 := b.Controls[0]
 16942  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16943  				break
 16944  			}
 16945  			l := v_0.Args[0]
 16946  			if l.Op != OpARMANDshiftRAreg {
 16947  				break
 16948  			}
 16949  			z := l.Args[2]
 16950  			x := l.Args[0]
 16951  			y := l.Args[1]
 16952  			if !(l.Uses == 1) {
 16953  				break
 16954  			}
 16955  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
 16956  			v0.AddArg3(x, y, z)
 16957  			b.resetWithControl(BlockARMEQ, v0)
 16958  			return true
 16959  		}
 16960  		// match: (EQ (CMPconst [0] l:(XOR x y)) yes no)
 16961  		// cond: l.Uses==1
 16962  		// result: (EQ (TEQ x y) yes no)
 16963  		for b.Controls[0].Op == OpARMCMPconst {
 16964  			v_0 := b.Controls[0]
 16965  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16966  				break
 16967  			}
 16968  			l := v_0.Args[0]
 16969  			if l.Op != OpARMXOR {
 16970  				break
 16971  			}
 16972  			_ = l.Args[1]
 16973  			l_0 := l.Args[0]
 16974  			l_1 := l.Args[1]
 16975  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 16976  				x := l_0
 16977  				y := l_1
 16978  				if !(l.Uses == 1) {
 16979  					continue
 16980  				}
 16981  				v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
 16982  				v0.AddArg2(x, y)
 16983  				b.resetWithControl(BlockARMEQ, v0)
 16984  				return true
 16985  			}
 16986  			break
 16987  		}
 16988  		// match: (EQ (CMPconst [0] l:(XORconst [c] x)) yes no)
 16989  		// cond: l.Uses==1
 16990  		// result: (EQ (TEQconst [c] x) yes no)
 16991  		for b.Controls[0].Op == OpARMCMPconst {
 16992  			v_0 := b.Controls[0]
 16993  			if auxIntToInt32(v_0.AuxInt) != 0 {
 16994  				break
 16995  			}
 16996  			l := v_0.Args[0]
 16997  			if l.Op != OpARMXORconst {
 16998  				break
 16999  			}
 17000  			c := auxIntToInt32(l.AuxInt)
 17001  			x := l.Args[0]
 17002  			if !(l.Uses == 1) {
 17003  				break
 17004  			}
 17005  			v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
 17006  			v0.AuxInt = int32ToAuxInt(c)
 17007  			v0.AddArg(x)
 17008  			b.resetWithControl(BlockARMEQ, v0)
 17009  			return true
 17010  		}
 17011  		// match: (EQ (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
 17012  		// cond: l.Uses==1
 17013  		// result: (EQ (TEQshiftLL x y [c]) yes no)
 17014  		for b.Controls[0].Op == OpARMCMPconst {
 17015  			v_0 := b.Controls[0]
 17016  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17017  				break
 17018  			}
 17019  			l := v_0.Args[0]
 17020  			if l.Op != OpARMXORshiftLL {
 17021  				break
 17022  			}
 17023  			c := auxIntToInt32(l.AuxInt)
 17024  			y := l.Args[1]
 17025  			x := l.Args[0]
 17026  			if !(l.Uses == 1) {
 17027  				break
 17028  			}
 17029  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
 17030  			v0.AuxInt = int32ToAuxInt(c)
 17031  			v0.AddArg2(x, y)
 17032  			b.resetWithControl(BlockARMEQ, v0)
 17033  			return true
 17034  		}
 17035  		// match: (EQ (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
 17036  		// cond: l.Uses==1
 17037  		// result: (EQ (TEQshiftRL x y [c]) yes no)
 17038  		for b.Controls[0].Op == OpARMCMPconst {
 17039  			v_0 := b.Controls[0]
 17040  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17041  				break
 17042  			}
 17043  			l := v_0.Args[0]
 17044  			if l.Op != OpARMXORshiftRL {
 17045  				break
 17046  			}
 17047  			c := auxIntToInt32(l.AuxInt)
 17048  			y := l.Args[1]
 17049  			x := l.Args[0]
 17050  			if !(l.Uses == 1) {
 17051  				break
 17052  			}
 17053  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
 17054  			v0.AuxInt = int32ToAuxInt(c)
 17055  			v0.AddArg2(x, y)
 17056  			b.resetWithControl(BlockARMEQ, v0)
 17057  			return true
 17058  		}
 17059  		// match: (EQ (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
 17060  		// cond: l.Uses==1
 17061  		// result: (EQ (TEQshiftRA x y [c]) yes no)
 17062  		for b.Controls[0].Op == OpARMCMPconst {
 17063  			v_0 := b.Controls[0]
 17064  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17065  				break
 17066  			}
 17067  			l := v_0.Args[0]
 17068  			if l.Op != OpARMXORshiftRA {
 17069  				break
 17070  			}
 17071  			c := auxIntToInt32(l.AuxInt)
 17072  			y := l.Args[1]
 17073  			x := l.Args[0]
 17074  			if !(l.Uses == 1) {
 17075  				break
 17076  			}
 17077  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
 17078  			v0.AuxInt = int32ToAuxInt(c)
 17079  			v0.AddArg2(x, y)
 17080  			b.resetWithControl(BlockARMEQ, v0)
 17081  			return true
 17082  		}
 17083  		// match: (EQ (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
 17084  		// cond: l.Uses==1
 17085  		// result: (EQ (TEQshiftLLreg x y z) yes no)
 17086  		for b.Controls[0].Op == OpARMCMPconst {
 17087  			v_0 := b.Controls[0]
 17088  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17089  				break
 17090  			}
 17091  			l := v_0.Args[0]
 17092  			if l.Op != OpARMXORshiftLLreg {
 17093  				break
 17094  			}
 17095  			z := l.Args[2]
 17096  			x := l.Args[0]
 17097  			y := l.Args[1]
 17098  			if !(l.Uses == 1) {
 17099  				break
 17100  			}
 17101  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
 17102  			v0.AddArg3(x, y, z)
 17103  			b.resetWithControl(BlockARMEQ, v0)
 17104  			return true
 17105  		}
 17106  		// match: (EQ (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
 17107  		// cond: l.Uses==1
 17108  		// result: (EQ (TEQshiftRLreg x y z) yes no)
 17109  		for b.Controls[0].Op == OpARMCMPconst {
 17110  			v_0 := b.Controls[0]
 17111  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17112  				break
 17113  			}
 17114  			l := v_0.Args[0]
 17115  			if l.Op != OpARMXORshiftRLreg {
 17116  				break
 17117  			}
 17118  			z := l.Args[2]
 17119  			x := l.Args[0]
 17120  			y := l.Args[1]
 17121  			if !(l.Uses == 1) {
 17122  				break
 17123  			}
 17124  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
 17125  			v0.AddArg3(x, y, z)
 17126  			b.resetWithControl(BlockARMEQ, v0)
 17127  			return true
 17128  		}
 17129  		// match: (EQ (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
 17130  		// cond: l.Uses==1
 17131  		// result: (EQ (TEQshiftRAreg x y z) yes no)
 17132  		for b.Controls[0].Op == OpARMCMPconst {
 17133  			v_0 := b.Controls[0]
 17134  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17135  				break
 17136  			}
 17137  			l := v_0.Args[0]
 17138  			if l.Op != OpARMXORshiftRAreg {
 17139  				break
 17140  			}
 17141  			z := l.Args[2]
 17142  			x := l.Args[0]
 17143  			y := l.Args[1]
 17144  			if !(l.Uses == 1) {
 17145  				break
 17146  			}
 17147  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
 17148  			v0.AddArg3(x, y, z)
 17149  			b.resetWithControl(BlockARMEQ, v0)
 17150  			return true
 17151  		}
 17152  	case BlockARMGE:
 17153  		// match: (GE (FlagConstant [fc]) yes no)
 17154  		// cond: fc.ge()
 17155  		// result: (First yes no)
 17156  		for b.Controls[0].Op == OpARMFlagConstant {
 17157  			v_0 := b.Controls[0]
 17158  			fc := auxIntToFlagConstant(v_0.AuxInt)
 17159  			if !(fc.ge()) {
 17160  				break
 17161  			}
 17162  			b.Reset(BlockFirst)
 17163  			return true
 17164  		}
 17165  		// match: (GE (FlagConstant [fc]) yes no)
 17166  		// cond: !fc.ge()
 17167  		// result: (First no yes)
 17168  		for b.Controls[0].Op == OpARMFlagConstant {
 17169  			v_0 := b.Controls[0]
 17170  			fc := auxIntToFlagConstant(v_0.AuxInt)
 17171  			if !(!fc.ge()) {
 17172  				break
 17173  			}
 17174  			b.Reset(BlockFirst)
 17175  			b.swapSuccessors()
 17176  			return true
 17177  		}
 17178  		// match: (GE (InvertFlags cmp) yes no)
 17179  		// result: (LE cmp yes no)
 17180  		for b.Controls[0].Op == OpARMInvertFlags {
 17181  			v_0 := b.Controls[0]
 17182  			cmp := v_0.Args[0]
 17183  			b.resetWithControl(BlockARMLE, cmp)
 17184  			return true
 17185  		}
 17186  		// match: (GE (CMPconst [0] l:(SUB x y)) yes no)
 17187  		// cond: l.Uses==1
 17188  		// result: (GEnoov (CMP x y) yes no)
 17189  		for b.Controls[0].Op == OpARMCMPconst {
 17190  			v_0 := b.Controls[0]
 17191  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17192  				break
 17193  			}
 17194  			l := v_0.Args[0]
 17195  			if l.Op != OpARMSUB {
 17196  				break
 17197  			}
 17198  			y := l.Args[1]
 17199  			x := l.Args[0]
 17200  			if !(l.Uses == 1) {
 17201  				break
 17202  			}
 17203  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 17204  			v0.AddArg2(x, y)
 17205  			b.resetWithControl(BlockARMGEnoov, v0)
 17206  			return true
 17207  		}
 17208  		// match: (GE (CMPconst [0] l:(MULS x y a)) yes no)
 17209  		// cond: l.Uses==1
 17210  		// result: (GEnoov (CMP a (MUL <x.Type> x y)) yes no)
 17211  		for b.Controls[0].Op == OpARMCMPconst {
 17212  			v_0 := b.Controls[0]
 17213  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17214  				break
 17215  			}
 17216  			l := v_0.Args[0]
 17217  			if l.Op != OpARMMULS {
 17218  				break
 17219  			}
 17220  			a := l.Args[2]
 17221  			x := l.Args[0]
 17222  			y := l.Args[1]
 17223  			if !(l.Uses == 1) {
 17224  				break
 17225  			}
 17226  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 17227  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 17228  			v1.AddArg2(x, y)
 17229  			v0.AddArg2(a, v1)
 17230  			b.resetWithControl(BlockARMGEnoov, v0)
 17231  			return true
 17232  		}
 17233  		// match: (GE (CMPconst [0] l:(SUBconst [c] x)) yes no)
 17234  		// cond: l.Uses==1
 17235  		// result: (GEnoov (CMPconst [c] x) yes no)
 17236  		for b.Controls[0].Op == OpARMCMPconst {
 17237  			v_0 := b.Controls[0]
 17238  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17239  				break
 17240  			}
 17241  			l := v_0.Args[0]
 17242  			if l.Op != OpARMSUBconst {
 17243  				break
 17244  			}
 17245  			c := auxIntToInt32(l.AuxInt)
 17246  			x := l.Args[0]
 17247  			if !(l.Uses == 1) {
 17248  				break
 17249  			}
 17250  			v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
 17251  			v0.AuxInt = int32ToAuxInt(c)
 17252  			v0.AddArg(x)
 17253  			b.resetWithControl(BlockARMGEnoov, v0)
 17254  			return true
 17255  		}
 17256  		// match: (GE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
 17257  		// cond: l.Uses==1
 17258  		// result: (GEnoov (CMPshiftLL x y [c]) yes no)
 17259  		for b.Controls[0].Op == OpARMCMPconst {
 17260  			v_0 := b.Controls[0]
 17261  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17262  				break
 17263  			}
 17264  			l := v_0.Args[0]
 17265  			if l.Op != OpARMSUBshiftLL {
 17266  				break
 17267  			}
 17268  			c := auxIntToInt32(l.AuxInt)
 17269  			y := l.Args[1]
 17270  			x := l.Args[0]
 17271  			if !(l.Uses == 1) {
 17272  				break
 17273  			}
 17274  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
 17275  			v0.AuxInt = int32ToAuxInt(c)
 17276  			v0.AddArg2(x, y)
 17277  			b.resetWithControl(BlockARMGEnoov, v0)
 17278  			return true
 17279  		}
 17280  		// match: (GE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
 17281  		// cond: l.Uses==1
 17282  		// result: (GEnoov (CMPshiftRL x y [c]) yes no)
 17283  		for b.Controls[0].Op == OpARMCMPconst {
 17284  			v_0 := b.Controls[0]
 17285  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17286  				break
 17287  			}
 17288  			l := v_0.Args[0]
 17289  			if l.Op != OpARMSUBshiftRL {
 17290  				break
 17291  			}
 17292  			c := auxIntToInt32(l.AuxInt)
 17293  			y := l.Args[1]
 17294  			x := l.Args[0]
 17295  			if !(l.Uses == 1) {
 17296  				break
 17297  			}
 17298  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
 17299  			v0.AuxInt = int32ToAuxInt(c)
 17300  			v0.AddArg2(x, y)
 17301  			b.resetWithControl(BlockARMGEnoov, v0)
 17302  			return true
 17303  		}
 17304  		// match: (GE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
 17305  		// cond: l.Uses==1
 17306  		// result: (GEnoov (CMPshiftRA x y [c]) yes no)
 17307  		for b.Controls[0].Op == OpARMCMPconst {
 17308  			v_0 := b.Controls[0]
 17309  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17310  				break
 17311  			}
 17312  			l := v_0.Args[0]
 17313  			if l.Op != OpARMSUBshiftRA {
 17314  				break
 17315  			}
 17316  			c := auxIntToInt32(l.AuxInt)
 17317  			y := l.Args[1]
 17318  			x := l.Args[0]
 17319  			if !(l.Uses == 1) {
 17320  				break
 17321  			}
 17322  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
 17323  			v0.AuxInt = int32ToAuxInt(c)
 17324  			v0.AddArg2(x, y)
 17325  			b.resetWithControl(BlockARMGEnoov, v0)
 17326  			return true
 17327  		}
 17328  		// match: (GE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
 17329  		// cond: l.Uses==1
 17330  		// result: (GEnoov (CMPshiftLLreg x y z) yes no)
 17331  		for b.Controls[0].Op == OpARMCMPconst {
 17332  			v_0 := b.Controls[0]
 17333  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17334  				break
 17335  			}
 17336  			l := v_0.Args[0]
 17337  			if l.Op != OpARMSUBshiftLLreg {
 17338  				break
 17339  			}
 17340  			z := l.Args[2]
 17341  			x := l.Args[0]
 17342  			y := l.Args[1]
 17343  			if !(l.Uses == 1) {
 17344  				break
 17345  			}
 17346  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
 17347  			v0.AddArg3(x, y, z)
 17348  			b.resetWithControl(BlockARMGEnoov, v0)
 17349  			return true
 17350  		}
 17351  		// match: (GE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
 17352  		// cond: l.Uses==1
 17353  		// result: (GEnoov (CMPshiftRLreg x y z) yes no)
 17354  		for b.Controls[0].Op == OpARMCMPconst {
 17355  			v_0 := b.Controls[0]
 17356  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17357  				break
 17358  			}
 17359  			l := v_0.Args[0]
 17360  			if l.Op != OpARMSUBshiftRLreg {
 17361  				break
 17362  			}
 17363  			z := l.Args[2]
 17364  			x := l.Args[0]
 17365  			y := l.Args[1]
 17366  			if !(l.Uses == 1) {
 17367  				break
 17368  			}
 17369  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
 17370  			v0.AddArg3(x, y, z)
 17371  			b.resetWithControl(BlockARMGEnoov, v0)
 17372  			return true
 17373  		}
 17374  		// match: (GE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
 17375  		// cond: l.Uses==1
 17376  		// result: (GEnoov (CMPshiftRAreg x y z) yes no)
 17377  		for b.Controls[0].Op == OpARMCMPconst {
 17378  			v_0 := b.Controls[0]
 17379  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17380  				break
 17381  			}
 17382  			l := v_0.Args[0]
 17383  			if l.Op != OpARMSUBshiftRAreg {
 17384  				break
 17385  			}
 17386  			z := l.Args[2]
 17387  			x := l.Args[0]
 17388  			y := l.Args[1]
 17389  			if !(l.Uses == 1) {
 17390  				break
 17391  			}
 17392  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
 17393  			v0.AddArg3(x, y, z)
 17394  			b.resetWithControl(BlockARMGEnoov, v0)
 17395  			return true
 17396  		}
 17397  		// match: (GE (CMPconst [0] l:(ADD x y)) yes no)
 17398  		// cond: l.Uses==1
 17399  		// result: (GEnoov (CMN x y) yes no)
 17400  		for b.Controls[0].Op == OpARMCMPconst {
 17401  			v_0 := b.Controls[0]
 17402  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17403  				break
 17404  			}
 17405  			l := v_0.Args[0]
 17406  			if l.Op != OpARMADD {
 17407  				break
 17408  			}
 17409  			_ = l.Args[1]
 17410  			l_0 := l.Args[0]
 17411  			l_1 := l.Args[1]
 17412  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 17413  				x := l_0
 17414  				y := l_1
 17415  				if !(l.Uses == 1) {
 17416  					continue
 17417  				}
 17418  				v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 17419  				v0.AddArg2(x, y)
 17420  				b.resetWithControl(BlockARMGEnoov, v0)
 17421  				return true
 17422  			}
 17423  			break
 17424  		}
 17425  		// match: (GE (CMPconst [0] l:(MULA x y a)) yes no)
 17426  		// cond: l.Uses==1
 17427  		// result: (GEnoov (CMN a (MUL <x.Type> x y)) yes no)
 17428  		for b.Controls[0].Op == OpARMCMPconst {
 17429  			v_0 := b.Controls[0]
 17430  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17431  				break
 17432  			}
 17433  			l := v_0.Args[0]
 17434  			if l.Op != OpARMMULA {
 17435  				break
 17436  			}
 17437  			a := l.Args[2]
 17438  			x := l.Args[0]
 17439  			y := l.Args[1]
 17440  			if !(l.Uses == 1) {
 17441  				break
 17442  			}
 17443  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 17444  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 17445  			v1.AddArg2(x, y)
 17446  			v0.AddArg2(a, v1)
 17447  			b.resetWithControl(BlockARMGEnoov, v0)
 17448  			return true
 17449  		}
 17450  		// match: (GE (CMPconst [0] l:(ADDconst [c] x)) yes no)
 17451  		// cond: l.Uses==1
 17452  		// result: (GEnoov (CMNconst [c] x) yes no)
 17453  		for b.Controls[0].Op == OpARMCMPconst {
 17454  			v_0 := b.Controls[0]
 17455  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17456  				break
 17457  			}
 17458  			l := v_0.Args[0]
 17459  			if l.Op != OpARMADDconst {
 17460  				break
 17461  			}
 17462  			c := auxIntToInt32(l.AuxInt)
 17463  			x := l.Args[0]
 17464  			if !(l.Uses == 1) {
 17465  				break
 17466  			}
 17467  			v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
 17468  			v0.AuxInt = int32ToAuxInt(c)
 17469  			v0.AddArg(x)
 17470  			b.resetWithControl(BlockARMGEnoov, v0)
 17471  			return true
 17472  		}
 17473  		// match: (GE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
 17474  		// cond: l.Uses==1
 17475  		// result: (GEnoov (CMNshiftLL x y [c]) yes no)
 17476  		for b.Controls[0].Op == OpARMCMPconst {
 17477  			v_0 := b.Controls[0]
 17478  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17479  				break
 17480  			}
 17481  			l := v_0.Args[0]
 17482  			if l.Op != OpARMADDshiftLL {
 17483  				break
 17484  			}
 17485  			c := auxIntToInt32(l.AuxInt)
 17486  			y := l.Args[1]
 17487  			x := l.Args[0]
 17488  			if !(l.Uses == 1) {
 17489  				break
 17490  			}
 17491  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
 17492  			v0.AuxInt = int32ToAuxInt(c)
 17493  			v0.AddArg2(x, y)
 17494  			b.resetWithControl(BlockARMGEnoov, v0)
 17495  			return true
 17496  		}
 17497  		// match: (GE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
 17498  		// cond: l.Uses==1
 17499  		// result: (GEnoov (CMNshiftRL x y [c]) yes no)
 17500  		for b.Controls[0].Op == OpARMCMPconst {
 17501  			v_0 := b.Controls[0]
 17502  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17503  				break
 17504  			}
 17505  			l := v_0.Args[0]
 17506  			if l.Op != OpARMADDshiftRL {
 17507  				break
 17508  			}
 17509  			c := auxIntToInt32(l.AuxInt)
 17510  			y := l.Args[1]
 17511  			x := l.Args[0]
 17512  			if !(l.Uses == 1) {
 17513  				break
 17514  			}
 17515  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
 17516  			v0.AuxInt = int32ToAuxInt(c)
 17517  			v0.AddArg2(x, y)
 17518  			b.resetWithControl(BlockARMGEnoov, v0)
 17519  			return true
 17520  		}
 17521  		// match: (GE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
 17522  		// cond: l.Uses==1
 17523  		// result: (GEnoov (CMNshiftRA x y [c]) yes no)
 17524  		for b.Controls[0].Op == OpARMCMPconst {
 17525  			v_0 := b.Controls[0]
 17526  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17527  				break
 17528  			}
 17529  			l := v_0.Args[0]
 17530  			if l.Op != OpARMADDshiftRA {
 17531  				break
 17532  			}
 17533  			c := auxIntToInt32(l.AuxInt)
 17534  			y := l.Args[1]
 17535  			x := l.Args[0]
 17536  			if !(l.Uses == 1) {
 17537  				break
 17538  			}
 17539  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
 17540  			v0.AuxInt = int32ToAuxInt(c)
 17541  			v0.AddArg2(x, y)
 17542  			b.resetWithControl(BlockARMGEnoov, v0)
 17543  			return true
 17544  		}
 17545  		// match: (GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
 17546  		// cond: l.Uses==1
 17547  		// result: (GEnoov (CMNshiftLLreg x y z) yes no)
 17548  		for b.Controls[0].Op == OpARMCMPconst {
 17549  			v_0 := b.Controls[0]
 17550  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17551  				break
 17552  			}
 17553  			l := v_0.Args[0]
 17554  			if l.Op != OpARMADDshiftLLreg {
 17555  				break
 17556  			}
 17557  			z := l.Args[2]
 17558  			x := l.Args[0]
 17559  			y := l.Args[1]
 17560  			if !(l.Uses == 1) {
 17561  				break
 17562  			}
 17563  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
 17564  			v0.AddArg3(x, y, z)
 17565  			b.resetWithControl(BlockARMGEnoov, v0)
 17566  			return true
 17567  		}
 17568  		// match: (GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
 17569  		// cond: l.Uses==1
 17570  		// result: (GEnoov (CMNshiftRLreg x y z) yes no)
 17571  		for b.Controls[0].Op == OpARMCMPconst {
 17572  			v_0 := b.Controls[0]
 17573  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17574  				break
 17575  			}
 17576  			l := v_0.Args[0]
 17577  			if l.Op != OpARMADDshiftRLreg {
 17578  				break
 17579  			}
 17580  			z := l.Args[2]
 17581  			x := l.Args[0]
 17582  			y := l.Args[1]
 17583  			if !(l.Uses == 1) {
 17584  				break
 17585  			}
 17586  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
 17587  			v0.AddArg3(x, y, z)
 17588  			b.resetWithControl(BlockARMGEnoov, v0)
 17589  			return true
 17590  		}
 17591  		// match: (GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
 17592  		// cond: l.Uses==1
 17593  		// result: (GEnoov (CMNshiftRAreg x y z) yes no)
 17594  		for b.Controls[0].Op == OpARMCMPconst {
 17595  			v_0 := b.Controls[0]
 17596  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17597  				break
 17598  			}
 17599  			l := v_0.Args[0]
 17600  			if l.Op != OpARMADDshiftRAreg {
 17601  				break
 17602  			}
 17603  			z := l.Args[2]
 17604  			x := l.Args[0]
 17605  			y := l.Args[1]
 17606  			if !(l.Uses == 1) {
 17607  				break
 17608  			}
 17609  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
 17610  			v0.AddArg3(x, y, z)
 17611  			b.resetWithControl(BlockARMGEnoov, v0)
 17612  			return true
 17613  		}
 17614  		// match: (GE (CMPconst [0] l:(AND x y)) yes no)
 17615  		// cond: l.Uses==1
 17616  		// result: (GEnoov (TST x y) yes no)
 17617  		for b.Controls[0].Op == OpARMCMPconst {
 17618  			v_0 := b.Controls[0]
 17619  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17620  				break
 17621  			}
 17622  			l := v_0.Args[0]
 17623  			if l.Op != OpARMAND {
 17624  				break
 17625  			}
 17626  			_ = l.Args[1]
 17627  			l_0 := l.Args[0]
 17628  			l_1 := l.Args[1]
 17629  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 17630  				x := l_0
 17631  				y := l_1
 17632  				if !(l.Uses == 1) {
 17633  					continue
 17634  				}
 17635  				v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
 17636  				v0.AddArg2(x, y)
 17637  				b.resetWithControl(BlockARMGEnoov, v0)
 17638  				return true
 17639  			}
 17640  			break
 17641  		}
 17642  		// match: (GE (CMPconst [0] l:(ANDconst [c] x)) yes no)
 17643  		// cond: l.Uses==1
 17644  		// result: (GEnoov (TSTconst [c] x) yes no)
 17645  		for b.Controls[0].Op == OpARMCMPconst {
 17646  			v_0 := b.Controls[0]
 17647  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17648  				break
 17649  			}
 17650  			l := v_0.Args[0]
 17651  			if l.Op != OpARMANDconst {
 17652  				break
 17653  			}
 17654  			c := auxIntToInt32(l.AuxInt)
 17655  			x := l.Args[0]
 17656  			if !(l.Uses == 1) {
 17657  				break
 17658  			}
 17659  			v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
 17660  			v0.AuxInt = int32ToAuxInt(c)
 17661  			v0.AddArg(x)
 17662  			b.resetWithControl(BlockARMGEnoov, v0)
 17663  			return true
 17664  		}
 17665  		// match: (GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
 17666  		// cond: l.Uses==1
 17667  		// result: (GEnoov (TSTshiftLL x y [c]) yes no)
 17668  		for b.Controls[0].Op == OpARMCMPconst {
 17669  			v_0 := b.Controls[0]
 17670  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17671  				break
 17672  			}
 17673  			l := v_0.Args[0]
 17674  			if l.Op != OpARMANDshiftLL {
 17675  				break
 17676  			}
 17677  			c := auxIntToInt32(l.AuxInt)
 17678  			y := l.Args[1]
 17679  			x := l.Args[0]
 17680  			if !(l.Uses == 1) {
 17681  				break
 17682  			}
 17683  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
 17684  			v0.AuxInt = int32ToAuxInt(c)
 17685  			v0.AddArg2(x, y)
 17686  			b.resetWithControl(BlockARMGEnoov, v0)
 17687  			return true
 17688  		}
 17689  		// match: (GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
 17690  		// cond: l.Uses==1
 17691  		// result: (GEnoov (TSTshiftRL x y [c]) yes no)
 17692  		for b.Controls[0].Op == OpARMCMPconst {
 17693  			v_0 := b.Controls[0]
 17694  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17695  				break
 17696  			}
 17697  			l := v_0.Args[0]
 17698  			if l.Op != OpARMANDshiftRL {
 17699  				break
 17700  			}
 17701  			c := auxIntToInt32(l.AuxInt)
 17702  			y := l.Args[1]
 17703  			x := l.Args[0]
 17704  			if !(l.Uses == 1) {
 17705  				break
 17706  			}
 17707  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
 17708  			v0.AuxInt = int32ToAuxInt(c)
 17709  			v0.AddArg2(x, y)
 17710  			b.resetWithControl(BlockARMGEnoov, v0)
 17711  			return true
 17712  		}
 17713  		// match: (GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
 17714  		// cond: l.Uses==1
 17715  		// result: (GEnoov (TSTshiftRA x y [c]) yes no)
 17716  		for b.Controls[0].Op == OpARMCMPconst {
 17717  			v_0 := b.Controls[0]
 17718  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17719  				break
 17720  			}
 17721  			l := v_0.Args[0]
 17722  			if l.Op != OpARMANDshiftRA {
 17723  				break
 17724  			}
 17725  			c := auxIntToInt32(l.AuxInt)
 17726  			y := l.Args[1]
 17727  			x := l.Args[0]
 17728  			if !(l.Uses == 1) {
 17729  				break
 17730  			}
 17731  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
 17732  			v0.AuxInt = int32ToAuxInt(c)
 17733  			v0.AddArg2(x, y)
 17734  			b.resetWithControl(BlockARMGEnoov, v0)
 17735  			return true
 17736  		}
 17737  		// match: (GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
 17738  		// cond: l.Uses==1
 17739  		// result: (GEnoov (TSTshiftLLreg x y z) yes no)
 17740  		for b.Controls[0].Op == OpARMCMPconst {
 17741  			v_0 := b.Controls[0]
 17742  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17743  				break
 17744  			}
 17745  			l := v_0.Args[0]
 17746  			if l.Op != OpARMANDshiftLLreg {
 17747  				break
 17748  			}
 17749  			z := l.Args[2]
 17750  			x := l.Args[0]
 17751  			y := l.Args[1]
 17752  			if !(l.Uses == 1) {
 17753  				break
 17754  			}
 17755  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
 17756  			v0.AddArg3(x, y, z)
 17757  			b.resetWithControl(BlockARMGEnoov, v0)
 17758  			return true
 17759  		}
 17760  		// match: (GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
 17761  		// cond: l.Uses==1
 17762  		// result: (GEnoov (TSTshiftRLreg x y z) yes no)
 17763  		for b.Controls[0].Op == OpARMCMPconst {
 17764  			v_0 := b.Controls[0]
 17765  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17766  				break
 17767  			}
 17768  			l := v_0.Args[0]
 17769  			if l.Op != OpARMANDshiftRLreg {
 17770  				break
 17771  			}
 17772  			z := l.Args[2]
 17773  			x := l.Args[0]
 17774  			y := l.Args[1]
 17775  			if !(l.Uses == 1) {
 17776  				break
 17777  			}
 17778  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
 17779  			v0.AddArg3(x, y, z)
 17780  			b.resetWithControl(BlockARMGEnoov, v0)
 17781  			return true
 17782  		}
 17783  		// match: (GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
 17784  		// cond: l.Uses==1
 17785  		// result: (GEnoov (TSTshiftRAreg x y z) yes no)
 17786  		for b.Controls[0].Op == OpARMCMPconst {
 17787  			v_0 := b.Controls[0]
 17788  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17789  				break
 17790  			}
 17791  			l := v_0.Args[0]
 17792  			if l.Op != OpARMANDshiftRAreg {
 17793  				break
 17794  			}
 17795  			z := l.Args[2]
 17796  			x := l.Args[0]
 17797  			y := l.Args[1]
 17798  			if !(l.Uses == 1) {
 17799  				break
 17800  			}
 17801  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
 17802  			v0.AddArg3(x, y, z)
 17803  			b.resetWithControl(BlockARMGEnoov, v0)
 17804  			return true
 17805  		}
 17806  		// match: (GE (CMPconst [0] l:(XOR x y)) yes no)
 17807  		// cond: l.Uses==1
 17808  		// result: (GEnoov (TEQ x y) yes no)
 17809  		for b.Controls[0].Op == OpARMCMPconst {
 17810  			v_0 := b.Controls[0]
 17811  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17812  				break
 17813  			}
 17814  			l := v_0.Args[0]
 17815  			if l.Op != OpARMXOR {
 17816  				break
 17817  			}
 17818  			_ = l.Args[1]
 17819  			l_0 := l.Args[0]
 17820  			l_1 := l.Args[1]
 17821  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 17822  				x := l_0
 17823  				y := l_1
 17824  				if !(l.Uses == 1) {
 17825  					continue
 17826  				}
 17827  				v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
 17828  				v0.AddArg2(x, y)
 17829  				b.resetWithControl(BlockARMGEnoov, v0)
 17830  				return true
 17831  			}
 17832  			break
 17833  		}
 17834  		// match: (GE (CMPconst [0] l:(XORconst [c] x)) yes no)
 17835  		// cond: l.Uses==1
 17836  		// result: (GEnoov (TEQconst [c] x) yes no)
 17837  		for b.Controls[0].Op == OpARMCMPconst {
 17838  			v_0 := b.Controls[0]
 17839  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17840  				break
 17841  			}
 17842  			l := v_0.Args[0]
 17843  			if l.Op != OpARMXORconst {
 17844  				break
 17845  			}
 17846  			c := auxIntToInt32(l.AuxInt)
 17847  			x := l.Args[0]
 17848  			if !(l.Uses == 1) {
 17849  				break
 17850  			}
 17851  			v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
 17852  			v0.AuxInt = int32ToAuxInt(c)
 17853  			v0.AddArg(x)
 17854  			b.resetWithControl(BlockARMGEnoov, v0)
 17855  			return true
 17856  		}
 17857  		// match: (GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
 17858  		// cond: l.Uses==1
 17859  		// result: (GEnoov (TEQshiftLL x y [c]) yes no)
 17860  		for b.Controls[0].Op == OpARMCMPconst {
 17861  			v_0 := b.Controls[0]
 17862  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17863  				break
 17864  			}
 17865  			l := v_0.Args[0]
 17866  			if l.Op != OpARMXORshiftLL {
 17867  				break
 17868  			}
 17869  			c := auxIntToInt32(l.AuxInt)
 17870  			y := l.Args[1]
 17871  			x := l.Args[0]
 17872  			if !(l.Uses == 1) {
 17873  				break
 17874  			}
 17875  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
 17876  			v0.AuxInt = int32ToAuxInt(c)
 17877  			v0.AddArg2(x, y)
 17878  			b.resetWithControl(BlockARMGEnoov, v0)
 17879  			return true
 17880  		}
 17881  		// match: (GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
 17882  		// cond: l.Uses==1
 17883  		// result: (GEnoov (TEQshiftRL x y [c]) yes no)
 17884  		for b.Controls[0].Op == OpARMCMPconst {
 17885  			v_0 := b.Controls[0]
 17886  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17887  				break
 17888  			}
 17889  			l := v_0.Args[0]
 17890  			if l.Op != OpARMXORshiftRL {
 17891  				break
 17892  			}
 17893  			c := auxIntToInt32(l.AuxInt)
 17894  			y := l.Args[1]
 17895  			x := l.Args[0]
 17896  			if !(l.Uses == 1) {
 17897  				break
 17898  			}
 17899  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
 17900  			v0.AuxInt = int32ToAuxInt(c)
 17901  			v0.AddArg2(x, y)
 17902  			b.resetWithControl(BlockARMGEnoov, v0)
 17903  			return true
 17904  		}
 17905  		// match: (GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
 17906  		// cond: l.Uses==1
 17907  		// result: (GEnoov (TEQshiftRA x y [c]) yes no)
 17908  		for b.Controls[0].Op == OpARMCMPconst {
 17909  			v_0 := b.Controls[0]
 17910  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17911  				break
 17912  			}
 17913  			l := v_0.Args[0]
 17914  			if l.Op != OpARMXORshiftRA {
 17915  				break
 17916  			}
 17917  			c := auxIntToInt32(l.AuxInt)
 17918  			y := l.Args[1]
 17919  			x := l.Args[0]
 17920  			if !(l.Uses == 1) {
 17921  				break
 17922  			}
 17923  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
 17924  			v0.AuxInt = int32ToAuxInt(c)
 17925  			v0.AddArg2(x, y)
 17926  			b.resetWithControl(BlockARMGEnoov, v0)
 17927  			return true
 17928  		}
 17929  		// match: (GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
 17930  		// cond: l.Uses==1
 17931  		// result: (GEnoov (TEQshiftLLreg x y z) yes no)
 17932  		for b.Controls[0].Op == OpARMCMPconst {
 17933  			v_0 := b.Controls[0]
 17934  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17935  				break
 17936  			}
 17937  			l := v_0.Args[0]
 17938  			if l.Op != OpARMXORshiftLLreg {
 17939  				break
 17940  			}
 17941  			z := l.Args[2]
 17942  			x := l.Args[0]
 17943  			y := l.Args[1]
 17944  			if !(l.Uses == 1) {
 17945  				break
 17946  			}
 17947  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
 17948  			v0.AddArg3(x, y, z)
 17949  			b.resetWithControl(BlockARMGEnoov, v0)
 17950  			return true
 17951  		}
 17952  		// match: (GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
 17953  		// cond: l.Uses==1
 17954  		// result: (GEnoov (TEQshiftRLreg x y z) yes no)
 17955  		for b.Controls[0].Op == OpARMCMPconst {
 17956  			v_0 := b.Controls[0]
 17957  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17958  				break
 17959  			}
 17960  			l := v_0.Args[0]
 17961  			if l.Op != OpARMXORshiftRLreg {
 17962  				break
 17963  			}
 17964  			z := l.Args[2]
 17965  			x := l.Args[0]
 17966  			y := l.Args[1]
 17967  			if !(l.Uses == 1) {
 17968  				break
 17969  			}
 17970  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
 17971  			v0.AddArg3(x, y, z)
 17972  			b.resetWithControl(BlockARMGEnoov, v0)
 17973  			return true
 17974  		}
 17975  		// match: (GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
 17976  		// cond: l.Uses==1
 17977  		// result: (GEnoov (TEQshiftRAreg x y z) yes no)
 17978  		for b.Controls[0].Op == OpARMCMPconst {
 17979  			v_0 := b.Controls[0]
 17980  			if auxIntToInt32(v_0.AuxInt) != 0 {
 17981  				break
 17982  			}
 17983  			l := v_0.Args[0]
 17984  			if l.Op != OpARMXORshiftRAreg {
 17985  				break
 17986  			}
 17987  			z := l.Args[2]
 17988  			x := l.Args[0]
 17989  			y := l.Args[1]
 17990  			if !(l.Uses == 1) {
 17991  				break
 17992  			}
 17993  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
 17994  			v0.AddArg3(x, y, z)
 17995  			b.resetWithControl(BlockARMGEnoov, v0)
 17996  			return true
 17997  		}
 17998  	case BlockARMGEnoov:
 17999  		// match: (GEnoov (FlagConstant [fc]) yes no)
 18000  		// cond: fc.geNoov()
 18001  		// result: (First yes no)
 18002  		for b.Controls[0].Op == OpARMFlagConstant {
 18003  			v_0 := b.Controls[0]
 18004  			fc := auxIntToFlagConstant(v_0.AuxInt)
 18005  			if !(fc.geNoov()) {
 18006  				break
 18007  			}
 18008  			b.Reset(BlockFirst)
 18009  			return true
 18010  		}
 18011  		// match: (GEnoov (FlagConstant [fc]) yes no)
 18012  		// cond: !fc.geNoov()
 18013  		// result: (First no yes)
 18014  		for b.Controls[0].Op == OpARMFlagConstant {
 18015  			v_0 := b.Controls[0]
 18016  			fc := auxIntToFlagConstant(v_0.AuxInt)
 18017  			if !(!fc.geNoov()) {
 18018  				break
 18019  			}
 18020  			b.Reset(BlockFirst)
 18021  			b.swapSuccessors()
 18022  			return true
 18023  		}
 18024  		// match: (GEnoov (InvertFlags cmp) yes no)
 18025  		// result: (LEnoov cmp yes no)
 18026  		for b.Controls[0].Op == OpARMInvertFlags {
 18027  			v_0 := b.Controls[0]
 18028  			cmp := v_0.Args[0]
 18029  			b.resetWithControl(BlockARMLEnoov, cmp)
 18030  			return true
 18031  		}
 18032  	case BlockARMGT:
 18033  		// match: (GT (FlagConstant [fc]) yes no)
 18034  		// cond: fc.gt()
 18035  		// result: (First yes no)
 18036  		for b.Controls[0].Op == OpARMFlagConstant {
 18037  			v_0 := b.Controls[0]
 18038  			fc := auxIntToFlagConstant(v_0.AuxInt)
 18039  			if !(fc.gt()) {
 18040  				break
 18041  			}
 18042  			b.Reset(BlockFirst)
 18043  			return true
 18044  		}
 18045  		// match: (GT (FlagConstant [fc]) yes no)
 18046  		// cond: !fc.gt()
 18047  		// result: (First no yes)
 18048  		for b.Controls[0].Op == OpARMFlagConstant {
 18049  			v_0 := b.Controls[0]
 18050  			fc := auxIntToFlagConstant(v_0.AuxInt)
 18051  			if !(!fc.gt()) {
 18052  				break
 18053  			}
 18054  			b.Reset(BlockFirst)
 18055  			b.swapSuccessors()
 18056  			return true
 18057  		}
 18058  		// match: (GT (InvertFlags cmp) yes no)
 18059  		// result: (LT cmp yes no)
 18060  		for b.Controls[0].Op == OpARMInvertFlags {
 18061  			v_0 := b.Controls[0]
 18062  			cmp := v_0.Args[0]
 18063  			b.resetWithControl(BlockARMLT, cmp)
 18064  			return true
 18065  		}
 18066  		// match: (GT (CMPconst [0] l:(SUB x y)) yes no)
 18067  		// cond: l.Uses==1
 18068  		// result: (GTnoov (CMP x y) yes no)
 18069  		for b.Controls[0].Op == OpARMCMPconst {
 18070  			v_0 := b.Controls[0]
 18071  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18072  				break
 18073  			}
 18074  			l := v_0.Args[0]
 18075  			if l.Op != OpARMSUB {
 18076  				break
 18077  			}
 18078  			y := l.Args[1]
 18079  			x := l.Args[0]
 18080  			if !(l.Uses == 1) {
 18081  				break
 18082  			}
 18083  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 18084  			v0.AddArg2(x, y)
 18085  			b.resetWithControl(BlockARMGTnoov, v0)
 18086  			return true
 18087  		}
 18088  		// match: (GT (CMPconst [0] l:(MULS x y a)) yes no)
 18089  		// cond: l.Uses==1
 18090  		// result: (GTnoov (CMP a (MUL <x.Type> x y)) yes no)
 18091  		for b.Controls[0].Op == OpARMCMPconst {
 18092  			v_0 := b.Controls[0]
 18093  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18094  				break
 18095  			}
 18096  			l := v_0.Args[0]
 18097  			if l.Op != OpARMMULS {
 18098  				break
 18099  			}
 18100  			a := l.Args[2]
 18101  			x := l.Args[0]
 18102  			y := l.Args[1]
 18103  			if !(l.Uses == 1) {
 18104  				break
 18105  			}
 18106  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 18107  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 18108  			v1.AddArg2(x, y)
 18109  			v0.AddArg2(a, v1)
 18110  			b.resetWithControl(BlockARMGTnoov, v0)
 18111  			return true
 18112  		}
 18113  		// match: (GT (CMPconst [0] l:(SUBconst [c] x)) yes no)
 18114  		// cond: l.Uses==1
 18115  		// result: (GTnoov (CMPconst [c] x) yes no)
 18116  		for b.Controls[0].Op == OpARMCMPconst {
 18117  			v_0 := b.Controls[0]
 18118  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18119  				break
 18120  			}
 18121  			l := v_0.Args[0]
 18122  			if l.Op != OpARMSUBconst {
 18123  				break
 18124  			}
 18125  			c := auxIntToInt32(l.AuxInt)
 18126  			x := l.Args[0]
 18127  			if !(l.Uses == 1) {
 18128  				break
 18129  			}
 18130  			v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
 18131  			v0.AuxInt = int32ToAuxInt(c)
 18132  			v0.AddArg(x)
 18133  			b.resetWithControl(BlockARMGTnoov, v0)
 18134  			return true
 18135  		}
 18136  		// match: (GT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
 18137  		// cond: l.Uses==1
 18138  		// result: (GTnoov (CMPshiftLL x y [c]) yes no)
 18139  		for b.Controls[0].Op == OpARMCMPconst {
 18140  			v_0 := b.Controls[0]
 18141  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18142  				break
 18143  			}
 18144  			l := v_0.Args[0]
 18145  			if l.Op != OpARMSUBshiftLL {
 18146  				break
 18147  			}
 18148  			c := auxIntToInt32(l.AuxInt)
 18149  			y := l.Args[1]
 18150  			x := l.Args[0]
 18151  			if !(l.Uses == 1) {
 18152  				break
 18153  			}
 18154  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
 18155  			v0.AuxInt = int32ToAuxInt(c)
 18156  			v0.AddArg2(x, y)
 18157  			b.resetWithControl(BlockARMGTnoov, v0)
 18158  			return true
 18159  		}
 18160  		// match: (GT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
 18161  		// cond: l.Uses==1
 18162  		// result: (GTnoov (CMPshiftRL x y [c]) yes no)
 18163  		for b.Controls[0].Op == OpARMCMPconst {
 18164  			v_0 := b.Controls[0]
 18165  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18166  				break
 18167  			}
 18168  			l := v_0.Args[0]
 18169  			if l.Op != OpARMSUBshiftRL {
 18170  				break
 18171  			}
 18172  			c := auxIntToInt32(l.AuxInt)
 18173  			y := l.Args[1]
 18174  			x := l.Args[0]
 18175  			if !(l.Uses == 1) {
 18176  				break
 18177  			}
 18178  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
 18179  			v0.AuxInt = int32ToAuxInt(c)
 18180  			v0.AddArg2(x, y)
 18181  			b.resetWithControl(BlockARMGTnoov, v0)
 18182  			return true
 18183  		}
 18184  		// match: (GT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
 18185  		// cond: l.Uses==1
 18186  		// result: (GTnoov (CMPshiftRA x y [c]) yes no)
 18187  		for b.Controls[0].Op == OpARMCMPconst {
 18188  			v_0 := b.Controls[0]
 18189  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18190  				break
 18191  			}
 18192  			l := v_0.Args[0]
 18193  			if l.Op != OpARMSUBshiftRA {
 18194  				break
 18195  			}
 18196  			c := auxIntToInt32(l.AuxInt)
 18197  			y := l.Args[1]
 18198  			x := l.Args[0]
 18199  			if !(l.Uses == 1) {
 18200  				break
 18201  			}
 18202  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
 18203  			v0.AuxInt = int32ToAuxInt(c)
 18204  			v0.AddArg2(x, y)
 18205  			b.resetWithControl(BlockARMGTnoov, v0)
 18206  			return true
 18207  		}
 18208  		// match: (GT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
 18209  		// cond: l.Uses==1
 18210  		// result: (GTnoov (CMPshiftLLreg x y z) yes no)
 18211  		for b.Controls[0].Op == OpARMCMPconst {
 18212  			v_0 := b.Controls[0]
 18213  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18214  				break
 18215  			}
 18216  			l := v_0.Args[0]
 18217  			if l.Op != OpARMSUBshiftLLreg {
 18218  				break
 18219  			}
 18220  			z := l.Args[2]
 18221  			x := l.Args[0]
 18222  			y := l.Args[1]
 18223  			if !(l.Uses == 1) {
 18224  				break
 18225  			}
 18226  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
 18227  			v0.AddArg3(x, y, z)
 18228  			b.resetWithControl(BlockARMGTnoov, v0)
 18229  			return true
 18230  		}
 18231  		// match: (GT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
 18232  		// cond: l.Uses==1
 18233  		// result: (GTnoov (CMPshiftRLreg x y z) yes no)
 18234  		for b.Controls[0].Op == OpARMCMPconst {
 18235  			v_0 := b.Controls[0]
 18236  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18237  				break
 18238  			}
 18239  			l := v_0.Args[0]
 18240  			if l.Op != OpARMSUBshiftRLreg {
 18241  				break
 18242  			}
 18243  			z := l.Args[2]
 18244  			x := l.Args[0]
 18245  			y := l.Args[1]
 18246  			if !(l.Uses == 1) {
 18247  				break
 18248  			}
 18249  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
 18250  			v0.AddArg3(x, y, z)
 18251  			b.resetWithControl(BlockARMGTnoov, v0)
 18252  			return true
 18253  		}
 18254  		// match: (GT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
 18255  		// cond: l.Uses==1
 18256  		// result: (GTnoov (CMPshiftRAreg x y z) yes no)
 18257  		for b.Controls[0].Op == OpARMCMPconst {
 18258  			v_0 := b.Controls[0]
 18259  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18260  				break
 18261  			}
 18262  			l := v_0.Args[0]
 18263  			if l.Op != OpARMSUBshiftRAreg {
 18264  				break
 18265  			}
 18266  			z := l.Args[2]
 18267  			x := l.Args[0]
 18268  			y := l.Args[1]
 18269  			if !(l.Uses == 1) {
 18270  				break
 18271  			}
 18272  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
 18273  			v0.AddArg3(x, y, z)
 18274  			b.resetWithControl(BlockARMGTnoov, v0)
 18275  			return true
 18276  		}
 18277  		// match: (GT (CMPconst [0] l:(ADD x y)) yes no)
 18278  		// cond: l.Uses==1
 18279  		// result: (GTnoov (CMN x y) yes no)
 18280  		for b.Controls[0].Op == OpARMCMPconst {
 18281  			v_0 := b.Controls[0]
 18282  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18283  				break
 18284  			}
 18285  			l := v_0.Args[0]
 18286  			if l.Op != OpARMADD {
 18287  				break
 18288  			}
 18289  			_ = l.Args[1]
 18290  			l_0 := l.Args[0]
 18291  			l_1 := l.Args[1]
 18292  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 18293  				x := l_0
 18294  				y := l_1
 18295  				if !(l.Uses == 1) {
 18296  					continue
 18297  				}
 18298  				v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 18299  				v0.AddArg2(x, y)
 18300  				b.resetWithControl(BlockARMGTnoov, v0)
 18301  				return true
 18302  			}
 18303  			break
 18304  		}
 18305  		// match: (GT (CMPconst [0] l:(ADDconst [c] x)) yes no)
 18306  		// cond: l.Uses==1
 18307  		// result: (GTnoov (CMNconst [c] x) yes no)
 18308  		for b.Controls[0].Op == OpARMCMPconst {
 18309  			v_0 := b.Controls[0]
 18310  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18311  				break
 18312  			}
 18313  			l := v_0.Args[0]
 18314  			if l.Op != OpARMADDconst {
 18315  				break
 18316  			}
 18317  			c := auxIntToInt32(l.AuxInt)
 18318  			x := l.Args[0]
 18319  			if !(l.Uses == 1) {
 18320  				break
 18321  			}
 18322  			v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
 18323  			v0.AuxInt = int32ToAuxInt(c)
 18324  			v0.AddArg(x)
 18325  			b.resetWithControl(BlockARMGTnoov, v0)
 18326  			return true
 18327  		}
 18328  		// match: (GT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
 18329  		// cond: l.Uses==1
 18330  		// result: (GTnoov (CMNshiftLL x y [c]) yes no)
 18331  		for b.Controls[0].Op == OpARMCMPconst {
 18332  			v_0 := b.Controls[0]
 18333  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18334  				break
 18335  			}
 18336  			l := v_0.Args[0]
 18337  			if l.Op != OpARMADDshiftLL {
 18338  				break
 18339  			}
 18340  			c := auxIntToInt32(l.AuxInt)
 18341  			y := l.Args[1]
 18342  			x := l.Args[0]
 18343  			if !(l.Uses == 1) {
 18344  				break
 18345  			}
 18346  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
 18347  			v0.AuxInt = int32ToAuxInt(c)
 18348  			v0.AddArg2(x, y)
 18349  			b.resetWithControl(BlockARMGTnoov, v0)
 18350  			return true
 18351  		}
 18352  		// match: (GT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
 18353  		// cond: l.Uses==1
 18354  		// result: (GTnoov (CMNshiftRL x y [c]) yes no)
 18355  		for b.Controls[0].Op == OpARMCMPconst {
 18356  			v_0 := b.Controls[0]
 18357  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18358  				break
 18359  			}
 18360  			l := v_0.Args[0]
 18361  			if l.Op != OpARMADDshiftRL {
 18362  				break
 18363  			}
 18364  			c := auxIntToInt32(l.AuxInt)
 18365  			y := l.Args[1]
 18366  			x := l.Args[0]
 18367  			if !(l.Uses == 1) {
 18368  				break
 18369  			}
 18370  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
 18371  			v0.AuxInt = int32ToAuxInt(c)
 18372  			v0.AddArg2(x, y)
 18373  			b.resetWithControl(BlockARMGTnoov, v0)
 18374  			return true
 18375  		}
 18376  		// match: (GT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
 18377  		// cond: l.Uses==1
 18378  		// result: (GTnoov (CMNshiftRA x y [c]) yes no)
 18379  		for b.Controls[0].Op == OpARMCMPconst {
 18380  			v_0 := b.Controls[0]
 18381  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18382  				break
 18383  			}
 18384  			l := v_0.Args[0]
 18385  			if l.Op != OpARMADDshiftRA {
 18386  				break
 18387  			}
 18388  			c := auxIntToInt32(l.AuxInt)
 18389  			y := l.Args[1]
 18390  			x := l.Args[0]
 18391  			if !(l.Uses == 1) {
 18392  				break
 18393  			}
 18394  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
 18395  			v0.AuxInt = int32ToAuxInt(c)
 18396  			v0.AddArg2(x, y)
 18397  			b.resetWithControl(BlockARMGTnoov, v0)
 18398  			return true
 18399  		}
 18400  		// match: (GT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
 18401  		// cond: l.Uses==1
 18402  		// result: (GTnoov (CMNshiftLLreg x y z) yes no)
 18403  		for b.Controls[0].Op == OpARMCMPconst {
 18404  			v_0 := b.Controls[0]
 18405  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18406  				break
 18407  			}
 18408  			l := v_0.Args[0]
 18409  			if l.Op != OpARMADDshiftLLreg {
 18410  				break
 18411  			}
 18412  			z := l.Args[2]
 18413  			x := l.Args[0]
 18414  			y := l.Args[1]
 18415  			if !(l.Uses == 1) {
 18416  				break
 18417  			}
 18418  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
 18419  			v0.AddArg3(x, y, z)
 18420  			b.resetWithControl(BlockARMGTnoov, v0)
 18421  			return true
 18422  		}
 18423  		// match: (GT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
 18424  		// cond: l.Uses==1
 18425  		// result: (GTnoov (CMNshiftRLreg x y z) yes no)
 18426  		for b.Controls[0].Op == OpARMCMPconst {
 18427  			v_0 := b.Controls[0]
 18428  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18429  				break
 18430  			}
 18431  			l := v_0.Args[0]
 18432  			if l.Op != OpARMADDshiftRLreg {
 18433  				break
 18434  			}
 18435  			z := l.Args[2]
 18436  			x := l.Args[0]
 18437  			y := l.Args[1]
 18438  			if !(l.Uses == 1) {
 18439  				break
 18440  			}
 18441  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
 18442  			v0.AddArg3(x, y, z)
 18443  			b.resetWithControl(BlockARMGTnoov, v0)
 18444  			return true
 18445  		}
 18446  		// match: (GT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
 18447  		// cond: l.Uses==1
 18448  		// result: (GTnoov (CMNshiftRAreg x y z) yes no)
 18449  		for b.Controls[0].Op == OpARMCMPconst {
 18450  			v_0 := b.Controls[0]
 18451  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18452  				break
 18453  			}
 18454  			l := v_0.Args[0]
 18455  			if l.Op != OpARMADDshiftRAreg {
 18456  				break
 18457  			}
 18458  			z := l.Args[2]
 18459  			x := l.Args[0]
 18460  			y := l.Args[1]
 18461  			if !(l.Uses == 1) {
 18462  				break
 18463  			}
 18464  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
 18465  			v0.AddArg3(x, y, z)
 18466  			b.resetWithControl(BlockARMGTnoov, v0)
 18467  			return true
 18468  		}
 18469  		// match: (GT (CMPconst [0] l:(MULA x y a)) yes no)
 18470  		// cond: l.Uses==1
 18471  		// result: (GTnoov (CMN a (MUL <x.Type> x y)) yes no)
 18472  		for b.Controls[0].Op == OpARMCMPconst {
 18473  			v_0 := b.Controls[0]
 18474  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18475  				break
 18476  			}
 18477  			l := v_0.Args[0]
 18478  			if l.Op != OpARMMULA {
 18479  				break
 18480  			}
 18481  			a := l.Args[2]
 18482  			x := l.Args[0]
 18483  			y := l.Args[1]
 18484  			if !(l.Uses == 1) {
 18485  				break
 18486  			}
 18487  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 18488  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 18489  			v1.AddArg2(x, y)
 18490  			v0.AddArg2(a, v1)
 18491  			b.resetWithControl(BlockARMGTnoov, v0)
 18492  			return true
 18493  		}
 18494  		// match: (GT (CMPconst [0] l:(AND x y)) yes no)
 18495  		// cond: l.Uses==1
 18496  		// result: (GTnoov (TST x y) yes no)
 18497  		for b.Controls[0].Op == OpARMCMPconst {
 18498  			v_0 := b.Controls[0]
 18499  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18500  				break
 18501  			}
 18502  			l := v_0.Args[0]
 18503  			if l.Op != OpARMAND {
 18504  				break
 18505  			}
 18506  			_ = l.Args[1]
 18507  			l_0 := l.Args[0]
 18508  			l_1 := l.Args[1]
 18509  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 18510  				x := l_0
 18511  				y := l_1
 18512  				if !(l.Uses == 1) {
 18513  					continue
 18514  				}
 18515  				v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
 18516  				v0.AddArg2(x, y)
 18517  				b.resetWithControl(BlockARMGTnoov, v0)
 18518  				return true
 18519  			}
 18520  			break
 18521  		}
 18522  		// match: (GT (CMPconst [0] l:(ANDconst [c] x)) yes no)
 18523  		// cond: l.Uses==1
 18524  		// result: (GTnoov (TSTconst [c] x) yes no)
 18525  		for b.Controls[0].Op == OpARMCMPconst {
 18526  			v_0 := b.Controls[0]
 18527  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18528  				break
 18529  			}
 18530  			l := v_0.Args[0]
 18531  			if l.Op != OpARMANDconst {
 18532  				break
 18533  			}
 18534  			c := auxIntToInt32(l.AuxInt)
 18535  			x := l.Args[0]
 18536  			if !(l.Uses == 1) {
 18537  				break
 18538  			}
 18539  			v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
 18540  			v0.AuxInt = int32ToAuxInt(c)
 18541  			v0.AddArg(x)
 18542  			b.resetWithControl(BlockARMGTnoov, v0)
 18543  			return true
 18544  		}
 18545  		// match: (GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
 18546  		// cond: l.Uses==1
 18547  		// result: (GTnoov (TSTshiftLL x y [c]) yes no)
 18548  		for b.Controls[0].Op == OpARMCMPconst {
 18549  			v_0 := b.Controls[0]
 18550  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18551  				break
 18552  			}
 18553  			l := v_0.Args[0]
 18554  			if l.Op != OpARMANDshiftLL {
 18555  				break
 18556  			}
 18557  			c := auxIntToInt32(l.AuxInt)
 18558  			y := l.Args[1]
 18559  			x := l.Args[0]
 18560  			if !(l.Uses == 1) {
 18561  				break
 18562  			}
 18563  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
 18564  			v0.AuxInt = int32ToAuxInt(c)
 18565  			v0.AddArg2(x, y)
 18566  			b.resetWithControl(BlockARMGTnoov, v0)
 18567  			return true
 18568  		}
 18569  		// match: (GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
 18570  		// cond: l.Uses==1
 18571  		// result: (GTnoov (TSTshiftRL x y [c]) yes no)
 18572  		for b.Controls[0].Op == OpARMCMPconst {
 18573  			v_0 := b.Controls[0]
 18574  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18575  				break
 18576  			}
 18577  			l := v_0.Args[0]
 18578  			if l.Op != OpARMANDshiftRL {
 18579  				break
 18580  			}
 18581  			c := auxIntToInt32(l.AuxInt)
 18582  			y := l.Args[1]
 18583  			x := l.Args[0]
 18584  			if !(l.Uses == 1) {
 18585  				break
 18586  			}
 18587  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
 18588  			v0.AuxInt = int32ToAuxInt(c)
 18589  			v0.AddArg2(x, y)
 18590  			b.resetWithControl(BlockARMGTnoov, v0)
 18591  			return true
 18592  		}
 18593  		// match: (GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
 18594  		// cond: l.Uses==1
 18595  		// result: (GTnoov (TSTshiftRA x y [c]) yes no)
 18596  		for b.Controls[0].Op == OpARMCMPconst {
 18597  			v_0 := b.Controls[0]
 18598  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18599  				break
 18600  			}
 18601  			l := v_0.Args[0]
 18602  			if l.Op != OpARMANDshiftRA {
 18603  				break
 18604  			}
 18605  			c := auxIntToInt32(l.AuxInt)
 18606  			y := l.Args[1]
 18607  			x := l.Args[0]
 18608  			if !(l.Uses == 1) {
 18609  				break
 18610  			}
 18611  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
 18612  			v0.AuxInt = int32ToAuxInt(c)
 18613  			v0.AddArg2(x, y)
 18614  			b.resetWithControl(BlockARMGTnoov, v0)
 18615  			return true
 18616  		}
 18617  		// match: (GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
 18618  		// cond: l.Uses==1
 18619  		// result: (GTnoov (TSTshiftLLreg x y z) yes no)
 18620  		for b.Controls[0].Op == OpARMCMPconst {
 18621  			v_0 := b.Controls[0]
 18622  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18623  				break
 18624  			}
 18625  			l := v_0.Args[0]
 18626  			if l.Op != OpARMANDshiftLLreg {
 18627  				break
 18628  			}
 18629  			z := l.Args[2]
 18630  			x := l.Args[0]
 18631  			y := l.Args[1]
 18632  			if !(l.Uses == 1) {
 18633  				break
 18634  			}
 18635  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
 18636  			v0.AddArg3(x, y, z)
 18637  			b.resetWithControl(BlockARMGTnoov, v0)
 18638  			return true
 18639  		}
 18640  		// match: (GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
 18641  		// cond: l.Uses==1
 18642  		// result: (GTnoov (TSTshiftRLreg x y z) yes no)
 18643  		for b.Controls[0].Op == OpARMCMPconst {
 18644  			v_0 := b.Controls[0]
 18645  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18646  				break
 18647  			}
 18648  			l := v_0.Args[0]
 18649  			if l.Op != OpARMANDshiftRLreg {
 18650  				break
 18651  			}
 18652  			z := l.Args[2]
 18653  			x := l.Args[0]
 18654  			y := l.Args[1]
 18655  			if !(l.Uses == 1) {
 18656  				break
 18657  			}
 18658  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
 18659  			v0.AddArg3(x, y, z)
 18660  			b.resetWithControl(BlockARMGTnoov, v0)
 18661  			return true
 18662  		}
 18663  		// match: (GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
 18664  		// cond: l.Uses==1
 18665  		// result: (GTnoov (TSTshiftRAreg x y z) yes no)
 18666  		for b.Controls[0].Op == OpARMCMPconst {
 18667  			v_0 := b.Controls[0]
 18668  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18669  				break
 18670  			}
 18671  			l := v_0.Args[0]
 18672  			if l.Op != OpARMANDshiftRAreg {
 18673  				break
 18674  			}
 18675  			z := l.Args[2]
 18676  			x := l.Args[0]
 18677  			y := l.Args[1]
 18678  			if !(l.Uses == 1) {
 18679  				break
 18680  			}
 18681  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
 18682  			v0.AddArg3(x, y, z)
 18683  			b.resetWithControl(BlockARMGTnoov, v0)
 18684  			return true
 18685  		}
 18686  		// match: (GT (CMPconst [0] l:(XOR x y)) yes no)
 18687  		// cond: l.Uses==1
 18688  		// result: (GTnoov (TEQ x y) yes no)
 18689  		for b.Controls[0].Op == OpARMCMPconst {
 18690  			v_0 := b.Controls[0]
 18691  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18692  				break
 18693  			}
 18694  			l := v_0.Args[0]
 18695  			if l.Op != OpARMXOR {
 18696  				break
 18697  			}
 18698  			_ = l.Args[1]
 18699  			l_0 := l.Args[0]
 18700  			l_1 := l.Args[1]
 18701  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 18702  				x := l_0
 18703  				y := l_1
 18704  				if !(l.Uses == 1) {
 18705  					continue
 18706  				}
 18707  				v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
 18708  				v0.AddArg2(x, y)
 18709  				b.resetWithControl(BlockARMGTnoov, v0)
 18710  				return true
 18711  			}
 18712  			break
 18713  		}
 18714  		// match: (GT (CMPconst [0] l:(XORconst [c] x)) yes no)
 18715  		// cond: l.Uses==1
 18716  		// result: (GTnoov (TEQconst [c] x) yes no)
 18717  		for b.Controls[0].Op == OpARMCMPconst {
 18718  			v_0 := b.Controls[0]
 18719  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18720  				break
 18721  			}
 18722  			l := v_0.Args[0]
 18723  			if l.Op != OpARMXORconst {
 18724  				break
 18725  			}
 18726  			c := auxIntToInt32(l.AuxInt)
 18727  			x := l.Args[0]
 18728  			if !(l.Uses == 1) {
 18729  				break
 18730  			}
 18731  			v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
 18732  			v0.AuxInt = int32ToAuxInt(c)
 18733  			v0.AddArg(x)
 18734  			b.resetWithControl(BlockARMGTnoov, v0)
 18735  			return true
 18736  		}
 18737  		// match: (GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
 18738  		// cond: l.Uses==1
 18739  		// result: (GTnoov (TEQshiftLL x y [c]) yes no)
 18740  		for b.Controls[0].Op == OpARMCMPconst {
 18741  			v_0 := b.Controls[0]
 18742  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18743  				break
 18744  			}
 18745  			l := v_0.Args[0]
 18746  			if l.Op != OpARMXORshiftLL {
 18747  				break
 18748  			}
 18749  			c := auxIntToInt32(l.AuxInt)
 18750  			y := l.Args[1]
 18751  			x := l.Args[0]
 18752  			if !(l.Uses == 1) {
 18753  				break
 18754  			}
 18755  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
 18756  			v0.AuxInt = int32ToAuxInt(c)
 18757  			v0.AddArg2(x, y)
 18758  			b.resetWithControl(BlockARMGTnoov, v0)
 18759  			return true
 18760  		}
 18761  		// match: (GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
 18762  		// cond: l.Uses==1
 18763  		// result: (GTnoov (TEQshiftRL x y [c]) yes no)
 18764  		for b.Controls[0].Op == OpARMCMPconst {
 18765  			v_0 := b.Controls[0]
 18766  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18767  				break
 18768  			}
 18769  			l := v_0.Args[0]
 18770  			if l.Op != OpARMXORshiftRL {
 18771  				break
 18772  			}
 18773  			c := auxIntToInt32(l.AuxInt)
 18774  			y := l.Args[1]
 18775  			x := l.Args[0]
 18776  			if !(l.Uses == 1) {
 18777  				break
 18778  			}
 18779  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
 18780  			v0.AuxInt = int32ToAuxInt(c)
 18781  			v0.AddArg2(x, y)
 18782  			b.resetWithControl(BlockARMGTnoov, v0)
 18783  			return true
 18784  		}
 18785  		// match: (GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
 18786  		// cond: l.Uses==1
 18787  		// result: (GTnoov (TEQshiftRA x y [c]) yes no)
 18788  		for b.Controls[0].Op == OpARMCMPconst {
 18789  			v_0 := b.Controls[0]
 18790  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18791  				break
 18792  			}
 18793  			l := v_0.Args[0]
 18794  			if l.Op != OpARMXORshiftRA {
 18795  				break
 18796  			}
 18797  			c := auxIntToInt32(l.AuxInt)
 18798  			y := l.Args[1]
 18799  			x := l.Args[0]
 18800  			if !(l.Uses == 1) {
 18801  				break
 18802  			}
 18803  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
 18804  			v0.AuxInt = int32ToAuxInt(c)
 18805  			v0.AddArg2(x, y)
 18806  			b.resetWithControl(BlockARMGTnoov, v0)
 18807  			return true
 18808  		}
 18809  		// match: (GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
 18810  		// cond: l.Uses==1
 18811  		// result: (GTnoov (TEQshiftLLreg x y z) yes no)
 18812  		for b.Controls[0].Op == OpARMCMPconst {
 18813  			v_0 := b.Controls[0]
 18814  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18815  				break
 18816  			}
 18817  			l := v_0.Args[0]
 18818  			if l.Op != OpARMXORshiftLLreg {
 18819  				break
 18820  			}
 18821  			z := l.Args[2]
 18822  			x := l.Args[0]
 18823  			y := l.Args[1]
 18824  			if !(l.Uses == 1) {
 18825  				break
 18826  			}
 18827  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
 18828  			v0.AddArg3(x, y, z)
 18829  			b.resetWithControl(BlockARMGTnoov, v0)
 18830  			return true
 18831  		}
 18832  		// match: (GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
 18833  		// cond: l.Uses==1
 18834  		// result: (GTnoov (TEQshiftRLreg x y z) yes no)
 18835  		for b.Controls[0].Op == OpARMCMPconst {
 18836  			v_0 := b.Controls[0]
 18837  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18838  				break
 18839  			}
 18840  			l := v_0.Args[0]
 18841  			if l.Op != OpARMXORshiftRLreg {
 18842  				break
 18843  			}
 18844  			z := l.Args[2]
 18845  			x := l.Args[0]
 18846  			y := l.Args[1]
 18847  			if !(l.Uses == 1) {
 18848  				break
 18849  			}
 18850  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
 18851  			v0.AddArg3(x, y, z)
 18852  			b.resetWithControl(BlockARMGTnoov, v0)
 18853  			return true
 18854  		}
 18855  		// match: (GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
 18856  		// cond: l.Uses==1
 18857  		// result: (GTnoov (TEQshiftRAreg x y z) yes no)
 18858  		for b.Controls[0].Op == OpARMCMPconst {
 18859  			v_0 := b.Controls[0]
 18860  			if auxIntToInt32(v_0.AuxInt) != 0 {
 18861  				break
 18862  			}
 18863  			l := v_0.Args[0]
 18864  			if l.Op != OpARMXORshiftRAreg {
 18865  				break
 18866  			}
 18867  			z := l.Args[2]
 18868  			x := l.Args[0]
 18869  			y := l.Args[1]
 18870  			if !(l.Uses == 1) {
 18871  				break
 18872  			}
 18873  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
 18874  			v0.AddArg3(x, y, z)
 18875  			b.resetWithControl(BlockARMGTnoov, v0)
 18876  			return true
 18877  		}
 18878  	case BlockARMGTnoov:
 18879  		// match: (GTnoov (FlagConstant [fc]) yes no)
 18880  		// cond: fc.gtNoov()
 18881  		// result: (First yes no)
 18882  		for b.Controls[0].Op == OpARMFlagConstant {
 18883  			v_0 := b.Controls[0]
 18884  			fc := auxIntToFlagConstant(v_0.AuxInt)
 18885  			if !(fc.gtNoov()) {
 18886  				break
 18887  			}
 18888  			b.Reset(BlockFirst)
 18889  			return true
 18890  		}
 18891  		// match: (GTnoov (FlagConstant [fc]) yes no)
 18892  		// cond: !fc.gtNoov()
 18893  		// result: (First no yes)
 18894  		for b.Controls[0].Op == OpARMFlagConstant {
 18895  			v_0 := b.Controls[0]
 18896  			fc := auxIntToFlagConstant(v_0.AuxInt)
 18897  			if !(!fc.gtNoov()) {
 18898  				break
 18899  			}
 18900  			b.Reset(BlockFirst)
 18901  			b.swapSuccessors()
 18902  			return true
 18903  		}
 18904  		// match: (GTnoov (InvertFlags cmp) yes no)
 18905  		// result: (LTnoov cmp yes no)
 18906  		for b.Controls[0].Op == OpARMInvertFlags {
 18907  			v_0 := b.Controls[0]
 18908  			cmp := v_0.Args[0]
 18909  			b.resetWithControl(BlockARMLTnoov, cmp)
 18910  			return true
 18911  		}
 18912  	case BlockIf:
 18913  		// match: (If (Equal cc) yes no)
 18914  		// result: (EQ cc yes no)
 18915  		for b.Controls[0].Op == OpARMEqual {
 18916  			v_0 := b.Controls[0]
 18917  			cc := v_0.Args[0]
 18918  			b.resetWithControl(BlockARMEQ, cc)
 18919  			return true
 18920  		}
 18921  		// match: (If (NotEqual cc) yes no)
 18922  		// result: (NE cc yes no)
 18923  		for b.Controls[0].Op == OpARMNotEqual {
 18924  			v_0 := b.Controls[0]
 18925  			cc := v_0.Args[0]
 18926  			b.resetWithControl(BlockARMNE, cc)
 18927  			return true
 18928  		}
 18929  		// match: (If (LessThan cc) yes no)
 18930  		// result: (LT cc yes no)
 18931  		for b.Controls[0].Op == OpARMLessThan {
 18932  			v_0 := b.Controls[0]
 18933  			cc := v_0.Args[0]
 18934  			b.resetWithControl(BlockARMLT, cc)
 18935  			return true
 18936  		}
 18937  		// match: (If (LessThanU cc) yes no)
 18938  		// result: (ULT cc yes no)
 18939  		for b.Controls[0].Op == OpARMLessThanU {
 18940  			v_0 := b.Controls[0]
 18941  			cc := v_0.Args[0]
 18942  			b.resetWithControl(BlockARMULT, cc)
 18943  			return true
 18944  		}
 18945  		// match: (If (LessEqual cc) yes no)
 18946  		// result: (LE cc yes no)
 18947  		for b.Controls[0].Op == OpARMLessEqual {
 18948  			v_0 := b.Controls[0]
 18949  			cc := v_0.Args[0]
 18950  			b.resetWithControl(BlockARMLE, cc)
 18951  			return true
 18952  		}
 18953  		// match: (If (LessEqualU cc) yes no)
 18954  		// result: (ULE cc yes no)
 18955  		for b.Controls[0].Op == OpARMLessEqualU {
 18956  			v_0 := b.Controls[0]
 18957  			cc := v_0.Args[0]
 18958  			b.resetWithControl(BlockARMULE, cc)
 18959  			return true
 18960  		}
 18961  		// match: (If (GreaterThan cc) yes no)
 18962  		// result: (GT cc yes no)
 18963  		for b.Controls[0].Op == OpARMGreaterThan {
 18964  			v_0 := b.Controls[0]
 18965  			cc := v_0.Args[0]
 18966  			b.resetWithControl(BlockARMGT, cc)
 18967  			return true
 18968  		}
 18969  		// match: (If (GreaterThanU cc) yes no)
 18970  		// result: (UGT cc yes no)
 18971  		for b.Controls[0].Op == OpARMGreaterThanU {
 18972  			v_0 := b.Controls[0]
 18973  			cc := v_0.Args[0]
 18974  			b.resetWithControl(BlockARMUGT, cc)
 18975  			return true
 18976  		}
 18977  		// match: (If (GreaterEqual cc) yes no)
 18978  		// result: (GE cc yes no)
 18979  		for b.Controls[0].Op == OpARMGreaterEqual {
 18980  			v_0 := b.Controls[0]
 18981  			cc := v_0.Args[0]
 18982  			b.resetWithControl(BlockARMGE, cc)
 18983  			return true
 18984  		}
 18985  		// match: (If (GreaterEqualU cc) yes no)
 18986  		// result: (UGE cc yes no)
 18987  		for b.Controls[0].Op == OpARMGreaterEqualU {
 18988  			v_0 := b.Controls[0]
 18989  			cc := v_0.Args[0]
 18990  			b.resetWithControl(BlockARMUGE, cc)
 18991  			return true
 18992  		}
 18993  		// match: (If cond yes no)
 18994  		// result: (NE (CMPconst [0] cond) yes no)
 18995  		for {
 18996  			cond := b.Controls[0]
 18997  			v0 := b.NewValue0(cond.Pos, OpARMCMPconst, types.TypeFlags)
 18998  			v0.AuxInt = int32ToAuxInt(0)
 18999  			v0.AddArg(cond)
 19000  			b.resetWithControl(BlockARMNE, v0)
 19001  			return true
 19002  		}
 19003  	case BlockARMLE:
 19004  		// match: (LE (FlagConstant [fc]) yes no)
 19005  		// cond: fc.le()
 19006  		// result: (First yes no)
 19007  		for b.Controls[0].Op == OpARMFlagConstant {
 19008  			v_0 := b.Controls[0]
 19009  			fc := auxIntToFlagConstant(v_0.AuxInt)
 19010  			if !(fc.le()) {
 19011  				break
 19012  			}
 19013  			b.Reset(BlockFirst)
 19014  			return true
 19015  		}
 19016  		// match: (LE (FlagConstant [fc]) yes no)
 19017  		// cond: !fc.le()
 19018  		// result: (First no yes)
 19019  		for b.Controls[0].Op == OpARMFlagConstant {
 19020  			v_0 := b.Controls[0]
 19021  			fc := auxIntToFlagConstant(v_0.AuxInt)
 19022  			if !(!fc.le()) {
 19023  				break
 19024  			}
 19025  			b.Reset(BlockFirst)
 19026  			b.swapSuccessors()
 19027  			return true
 19028  		}
 19029  		// match: (LE (InvertFlags cmp) yes no)
 19030  		// result: (GE cmp yes no)
 19031  		for b.Controls[0].Op == OpARMInvertFlags {
 19032  			v_0 := b.Controls[0]
 19033  			cmp := v_0.Args[0]
 19034  			b.resetWithControl(BlockARMGE, cmp)
 19035  			return true
 19036  		}
 19037  		// match: (LE (CMPconst [0] l:(SUB x y)) yes no)
 19038  		// cond: l.Uses==1
 19039  		// result: (LEnoov (CMP x y) yes no)
 19040  		for b.Controls[0].Op == OpARMCMPconst {
 19041  			v_0 := b.Controls[0]
 19042  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19043  				break
 19044  			}
 19045  			l := v_0.Args[0]
 19046  			if l.Op != OpARMSUB {
 19047  				break
 19048  			}
 19049  			y := l.Args[1]
 19050  			x := l.Args[0]
 19051  			if !(l.Uses == 1) {
 19052  				break
 19053  			}
 19054  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 19055  			v0.AddArg2(x, y)
 19056  			b.resetWithControl(BlockARMLEnoov, v0)
 19057  			return true
 19058  		}
 19059  		// match: (LE (CMPconst [0] l:(MULS x y a)) yes no)
 19060  		// cond: l.Uses==1
 19061  		// result: (LEnoov (CMP a (MUL <x.Type> x y)) yes no)
 19062  		for b.Controls[0].Op == OpARMCMPconst {
 19063  			v_0 := b.Controls[0]
 19064  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19065  				break
 19066  			}
 19067  			l := v_0.Args[0]
 19068  			if l.Op != OpARMMULS {
 19069  				break
 19070  			}
 19071  			a := l.Args[2]
 19072  			x := l.Args[0]
 19073  			y := l.Args[1]
 19074  			if !(l.Uses == 1) {
 19075  				break
 19076  			}
 19077  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 19078  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 19079  			v1.AddArg2(x, y)
 19080  			v0.AddArg2(a, v1)
 19081  			b.resetWithControl(BlockARMLEnoov, v0)
 19082  			return true
 19083  		}
 19084  		// match: (LE (CMPconst [0] l:(SUBconst [c] x)) yes no)
 19085  		// cond: l.Uses==1
 19086  		// result: (LEnoov (CMPconst [c] x) yes no)
 19087  		for b.Controls[0].Op == OpARMCMPconst {
 19088  			v_0 := b.Controls[0]
 19089  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19090  				break
 19091  			}
 19092  			l := v_0.Args[0]
 19093  			if l.Op != OpARMSUBconst {
 19094  				break
 19095  			}
 19096  			c := auxIntToInt32(l.AuxInt)
 19097  			x := l.Args[0]
 19098  			if !(l.Uses == 1) {
 19099  				break
 19100  			}
 19101  			v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
 19102  			v0.AuxInt = int32ToAuxInt(c)
 19103  			v0.AddArg(x)
 19104  			b.resetWithControl(BlockARMLEnoov, v0)
 19105  			return true
 19106  		}
 19107  		// match: (LE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
 19108  		// cond: l.Uses==1
 19109  		// result: (LEnoov (CMPshiftLL x y [c]) yes no)
 19110  		for b.Controls[0].Op == OpARMCMPconst {
 19111  			v_0 := b.Controls[0]
 19112  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19113  				break
 19114  			}
 19115  			l := v_0.Args[0]
 19116  			if l.Op != OpARMSUBshiftLL {
 19117  				break
 19118  			}
 19119  			c := auxIntToInt32(l.AuxInt)
 19120  			y := l.Args[1]
 19121  			x := l.Args[0]
 19122  			if !(l.Uses == 1) {
 19123  				break
 19124  			}
 19125  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
 19126  			v0.AuxInt = int32ToAuxInt(c)
 19127  			v0.AddArg2(x, y)
 19128  			b.resetWithControl(BlockARMLEnoov, v0)
 19129  			return true
 19130  		}
 19131  		// match: (LE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
 19132  		// cond: l.Uses==1
 19133  		// result: (LEnoov (CMPshiftRL x y [c]) yes no)
 19134  		for b.Controls[0].Op == OpARMCMPconst {
 19135  			v_0 := b.Controls[0]
 19136  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19137  				break
 19138  			}
 19139  			l := v_0.Args[0]
 19140  			if l.Op != OpARMSUBshiftRL {
 19141  				break
 19142  			}
 19143  			c := auxIntToInt32(l.AuxInt)
 19144  			y := l.Args[1]
 19145  			x := l.Args[0]
 19146  			if !(l.Uses == 1) {
 19147  				break
 19148  			}
 19149  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
 19150  			v0.AuxInt = int32ToAuxInt(c)
 19151  			v0.AddArg2(x, y)
 19152  			b.resetWithControl(BlockARMLEnoov, v0)
 19153  			return true
 19154  		}
 19155  		// match: (LE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
 19156  		// cond: l.Uses==1
 19157  		// result: (LEnoov (CMPshiftRA x y [c]) yes no)
 19158  		for b.Controls[0].Op == OpARMCMPconst {
 19159  			v_0 := b.Controls[0]
 19160  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19161  				break
 19162  			}
 19163  			l := v_0.Args[0]
 19164  			if l.Op != OpARMSUBshiftRA {
 19165  				break
 19166  			}
 19167  			c := auxIntToInt32(l.AuxInt)
 19168  			y := l.Args[1]
 19169  			x := l.Args[0]
 19170  			if !(l.Uses == 1) {
 19171  				break
 19172  			}
 19173  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
 19174  			v0.AuxInt = int32ToAuxInt(c)
 19175  			v0.AddArg2(x, y)
 19176  			b.resetWithControl(BlockARMLEnoov, v0)
 19177  			return true
 19178  		}
 19179  		// match: (LE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
 19180  		// cond: l.Uses==1
 19181  		// result: (LEnoov (CMPshiftLLreg x y z) yes no)
 19182  		for b.Controls[0].Op == OpARMCMPconst {
 19183  			v_0 := b.Controls[0]
 19184  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19185  				break
 19186  			}
 19187  			l := v_0.Args[0]
 19188  			if l.Op != OpARMSUBshiftLLreg {
 19189  				break
 19190  			}
 19191  			z := l.Args[2]
 19192  			x := l.Args[0]
 19193  			y := l.Args[1]
 19194  			if !(l.Uses == 1) {
 19195  				break
 19196  			}
 19197  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
 19198  			v0.AddArg3(x, y, z)
 19199  			b.resetWithControl(BlockARMLEnoov, v0)
 19200  			return true
 19201  		}
 19202  		// match: (LE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
 19203  		// cond: l.Uses==1
 19204  		// result: (LEnoov (CMPshiftRLreg x y z) yes no)
 19205  		for b.Controls[0].Op == OpARMCMPconst {
 19206  			v_0 := b.Controls[0]
 19207  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19208  				break
 19209  			}
 19210  			l := v_0.Args[0]
 19211  			if l.Op != OpARMSUBshiftRLreg {
 19212  				break
 19213  			}
 19214  			z := l.Args[2]
 19215  			x := l.Args[0]
 19216  			y := l.Args[1]
 19217  			if !(l.Uses == 1) {
 19218  				break
 19219  			}
 19220  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
 19221  			v0.AddArg3(x, y, z)
 19222  			b.resetWithControl(BlockARMLEnoov, v0)
 19223  			return true
 19224  		}
 19225  		// match: (LE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
 19226  		// cond: l.Uses==1
 19227  		// result: (LEnoov (CMPshiftRAreg x y z) yes no)
 19228  		for b.Controls[0].Op == OpARMCMPconst {
 19229  			v_0 := b.Controls[0]
 19230  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19231  				break
 19232  			}
 19233  			l := v_0.Args[0]
 19234  			if l.Op != OpARMSUBshiftRAreg {
 19235  				break
 19236  			}
 19237  			z := l.Args[2]
 19238  			x := l.Args[0]
 19239  			y := l.Args[1]
 19240  			if !(l.Uses == 1) {
 19241  				break
 19242  			}
 19243  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
 19244  			v0.AddArg3(x, y, z)
 19245  			b.resetWithControl(BlockARMLEnoov, v0)
 19246  			return true
 19247  		}
 19248  		// match: (LE (CMPconst [0] l:(ADD x y)) yes no)
 19249  		// cond: l.Uses==1
 19250  		// result: (LEnoov (CMN x y) yes no)
 19251  		for b.Controls[0].Op == OpARMCMPconst {
 19252  			v_0 := b.Controls[0]
 19253  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19254  				break
 19255  			}
 19256  			l := v_0.Args[0]
 19257  			if l.Op != OpARMADD {
 19258  				break
 19259  			}
 19260  			_ = l.Args[1]
 19261  			l_0 := l.Args[0]
 19262  			l_1 := l.Args[1]
 19263  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 19264  				x := l_0
 19265  				y := l_1
 19266  				if !(l.Uses == 1) {
 19267  					continue
 19268  				}
 19269  				v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 19270  				v0.AddArg2(x, y)
 19271  				b.resetWithControl(BlockARMLEnoov, v0)
 19272  				return true
 19273  			}
 19274  			break
 19275  		}
 19276  		// match: (LE (CMPconst [0] l:(MULA x y a)) yes no)
 19277  		// cond: l.Uses==1
 19278  		// result: (LEnoov (CMN a (MUL <x.Type> x y)) yes no)
 19279  		for b.Controls[0].Op == OpARMCMPconst {
 19280  			v_0 := b.Controls[0]
 19281  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19282  				break
 19283  			}
 19284  			l := v_0.Args[0]
 19285  			if l.Op != OpARMMULA {
 19286  				break
 19287  			}
 19288  			a := l.Args[2]
 19289  			x := l.Args[0]
 19290  			y := l.Args[1]
 19291  			if !(l.Uses == 1) {
 19292  				break
 19293  			}
 19294  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 19295  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 19296  			v1.AddArg2(x, y)
 19297  			v0.AddArg2(a, v1)
 19298  			b.resetWithControl(BlockARMLEnoov, v0)
 19299  			return true
 19300  		}
 19301  		// match: (LE (CMPconst [0] l:(ADDconst [c] x)) yes no)
 19302  		// cond: l.Uses==1
 19303  		// result: (LEnoov (CMNconst [c] x) yes no)
 19304  		for b.Controls[0].Op == OpARMCMPconst {
 19305  			v_0 := b.Controls[0]
 19306  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19307  				break
 19308  			}
 19309  			l := v_0.Args[0]
 19310  			if l.Op != OpARMADDconst {
 19311  				break
 19312  			}
 19313  			c := auxIntToInt32(l.AuxInt)
 19314  			x := l.Args[0]
 19315  			if !(l.Uses == 1) {
 19316  				break
 19317  			}
 19318  			v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
 19319  			v0.AuxInt = int32ToAuxInt(c)
 19320  			v0.AddArg(x)
 19321  			b.resetWithControl(BlockARMLEnoov, v0)
 19322  			return true
 19323  		}
 19324  		// match: (LE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
 19325  		// cond: l.Uses==1
 19326  		// result: (LEnoov (CMNshiftLL x y [c]) yes no)
 19327  		for b.Controls[0].Op == OpARMCMPconst {
 19328  			v_0 := b.Controls[0]
 19329  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19330  				break
 19331  			}
 19332  			l := v_0.Args[0]
 19333  			if l.Op != OpARMADDshiftLL {
 19334  				break
 19335  			}
 19336  			c := auxIntToInt32(l.AuxInt)
 19337  			y := l.Args[1]
 19338  			x := l.Args[0]
 19339  			if !(l.Uses == 1) {
 19340  				break
 19341  			}
 19342  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
 19343  			v0.AuxInt = int32ToAuxInt(c)
 19344  			v0.AddArg2(x, y)
 19345  			b.resetWithControl(BlockARMLEnoov, v0)
 19346  			return true
 19347  		}
 19348  		// match: (LE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
 19349  		// cond: l.Uses==1
 19350  		// result: (LEnoov (CMNshiftRL x y [c]) yes no)
 19351  		for b.Controls[0].Op == OpARMCMPconst {
 19352  			v_0 := b.Controls[0]
 19353  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19354  				break
 19355  			}
 19356  			l := v_0.Args[0]
 19357  			if l.Op != OpARMADDshiftRL {
 19358  				break
 19359  			}
 19360  			c := auxIntToInt32(l.AuxInt)
 19361  			y := l.Args[1]
 19362  			x := l.Args[0]
 19363  			if !(l.Uses == 1) {
 19364  				break
 19365  			}
 19366  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
 19367  			v0.AuxInt = int32ToAuxInt(c)
 19368  			v0.AddArg2(x, y)
 19369  			b.resetWithControl(BlockARMLEnoov, v0)
 19370  			return true
 19371  		}
 19372  		// match: (LE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
 19373  		// cond: l.Uses==1
 19374  		// result: (LEnoov (CMNshiftRA x y [c]) yes no)
 19375  		for b.Controls[0].Op == OpARMCMPconst {
 19376  			v_0 := b.Controls[0]
 19377  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19378  				break
 19379  			}
 19380  			l := v_0.Args[0]
 19381  			if l.Op != OpARMADDshiftRA {
 19382  				break
 19383  			}
 19384  			c := auxIntToInt32(l.AuxInt)
 19385  			y := l.Args[1]
 19386  			x := l.Args[0]
 19387  			if !(l.Uses == 1) {
 19388  				break
 19389  			}
 19390  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
 19391  			v0.AuxInt = int32ToAuxInt(c)
 19392  			v0.AddArg2(x, y)
 19393  			b.resetWithControl(BlockARMLEnoov, v0)
 19394  			return true
 19395  		}
 19396  		// match: (LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
 19397  		// cond: l.Uses==1
 19398  		// result: (LEnoov (CMNshiftLLreg x y z) yes no)
 19399  		for b.Controls[0].Op == OpARMCMPconst {
 19400  			v_0 := b.Controls[0]
 19401  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19402  				break
 19403  			}
 19404  			l := v_0.Args[0]
 19405  			if l.Op != OpARMADDshiftLLreg {
 19406  				break
 19407  			}
 19408  			z := l.Args[2]
 19409  			x := l.Args[0]
 19410  			y := l.Args[1]
 19411  			if !(l.Uses == 1) {
 19412  				break
 19413  			}
 19414  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
 19415  			v0.AddArg3(x, y, z)
 19416  			b.resetWithControl(BlockARMLEnoov, v0)
 19417  			return true
 19418  		}
 19419  		// match: (LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
 19420  		// cond: l.Uses==1
 19421  		// result: (LEnoov (CMNshiftRLreg x y z) yes no)
 19422  		for b.Controls[0].Op == OpARMCMPconst {
 19423  			v_0 := b.Controls[0]
 19424  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19425  				break
 19426  			}
 19427  			l := v_0.Args[0]
 19428  			if l.Op != OpARMADDshiftRLreg {
 19429  				break
 19430  			}
 19431  			z := l.Args[2]
 19432  			x := l.Args[0]
 19433  			y := l.Args[1]
 19434  			if !(l.Uses == 1) {
 19435  				break
 19436  			}
 19437  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
 19438  			v0.AddArg3(x, y, z)
 19439  			b.resetWithControl(BlockARMLEnoov, v0)
 19440  			return true
 19441  		}
 19442  		// match: (LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
 19443  		// cond: l.Uses==1
 19444  		// result: (LEnoov (CMNshiftRAreg x y z) yes no)
 19445  		for b.Controls[0].Op == OpARMCMPconst {
 19446  			v_0 := b.Controls[0]
 19447  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19448  				break
 19449  			}
 19450  			l := v_0.Args[0]
 19451  			if l.Op != OpARMADDshiftRAreg {
 19452  				break
 19453  			}
 19454  			z := l.Args[2]
 19455  			x := l.Args[0]
 19456  			y := l.Args[1]
 19457  			if !(l.Uses == 1) {
 19458  				break
 19459  			}
 19460  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
 19461  			v0.AddArg3(x, y, z)
 19462  			b.resetWithControl(BlockARMLEnoov, v0)
 19463  			return true
 19464  		}
 19465  		// match: (LE (CMPconst [0] l:(AND x y)) yes no)
 19466  		// cond: l.Uses==1
 19467  		// result: (LEnoov (TST x y) yes no)
 19468  		for b.Controls[0].Op == OpARMCMPconst {
 19469  			v_0 := b.Controls[0]
 19470  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19471  				break
 19472  			}
 19473  			l := v_0.Args[0]
 19474  			if l.Op != OpARMAND {
 19475  				break
 19476  			}
 19477  			_ = l.Args[1]
 19478  			l_0 := l.Args[0]
 19479  			l_1 := l.Args[1]
 19480  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 19481  				x := l_0
 19482  				y := l_1
 19483  				if !(l.Uses == 1) {
 19484  					continue
 19485  				}
 19486  				v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
 19487  				v0.AddArg2(x, y)
 19488  				b.resetWithControl(BlockARMLEnoov, v0)
 19489  				return true
 19490  			}
 19491  			break
 19492  		}
 19493  		// match: (LE (CMPconst [0] l:(ANDconst [c] x)) yes no)
 19494  		// cond: l.Uses==1
 19495  		// result: (LEnoov (TSTconst [c] x) yes no)
 19496  		for b.Controls[0].Op == OpARMCMPconst {
 19497  			v_0 := b.Controls[0]
 19498  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19499  				break
 19500  			}
 19501  			l := v_0.Args[0]
 19502  			if l.Op != OpARMANDconst {
 19503  				break
 19504  			}
 19505  			c := auxIntToInt32(l.AuxInt)
 19506  			x := l.Args[0]
 19507  			if !(l.Uses == 1) {
 19508  				break
 19509  			}
 19510  			v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
 19511  			v0.AuxInt = int32ToAuxInt(c)
 19512  			v0.AddArg(x)
 19513  			b.resetWithControl(BlockARMLEnoov, v0)
 19514  			return true
 19515  		}
 19516  		// match: (LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
 19517  		// cond: l.Uses==1
 19518  		// result: (LEnoov (TSTshiftLL x y [c]) yes no)
 19519  		for b.Controls[0].Op == OpARMCMPconst {
 19520  			v_0 := b.Controls[0]
 19521  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19522  				break
 19523  			}
 19524  			l := v_0.Args[0]
 19525  			if l.Op != OpARMANDshiftLL {
 19526  				break
 19527  			}
 19528  			c := auxIntToInt32(l.AuxInt)
 19529  			y := l.Args[1]
 19530  			x := l.Args[0]
 19531  			if !(l.Uses == 1) {
 19532  				break
 19533  			}
 19534  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
 19535  			v0.AuxInt = int32ToAuxInt(c)
 19536  			v0.AddArg2(x, y)
 19537  			b.resetWithControl(BlockARMLEnoov, v0)
 19538  			return true
 19539  		}
 19540  		// match: (LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
 19541  		// cond: l.Uses==1
 19542  		// result: (LEnoov (TSTshiftRL x y [c]) yes no)
 19543  		for b.Controls[0].Op == OpARMCMPconst {
 19544  			v_0 := b.Controls[0]
 19545  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19546  				break
 19547  			}
 19548  			l := v_0.Args[0]
 19549  			if l.Op != OpARMANDshiftRL {
 19550  				break
 19551  			}
 19552  			c := auxIntToInt32(l.AuxInt)
 19553  			y := l.Args[1]
 19554  			x := l.Args[0]
 19555  			if !(l.Uses == 1) {
 19556  				break
 19557  			}
 19558  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
 19559  			v0.AuxInt = int32ToAuxInt(c)
 19560  			v0.AddArg2(x, y)
 19561  			b.resetWithControl(BlockARMLEnoov, v0)
 19562  			return true
 19563  		}
 19564  		// match: (LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
 19565  		// cond: l.Uses==1
 19566  		// result: (LEnoov (TSTshiftRA x y [c]) yes no)
 19567  		for b.Controls[0].Op == OpARMCMPconst {
 19568  			v_0 := b.Controls[0]
 19569  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19570  				break
 19571  			}
 19572  			l := v_0.Args[0]
 19573  			if l.Op != OpARMANDshiftRA {
 19574  				break
 19575  			}
 19576  			c := auxIntToInt32(l.AuxInt)
 19577  			y := l.Args[1]
 19578  			x := l.Args[0]
 19579  			if !(l.Uses == 1) {
 19580  				break
 19581  			}
 19582  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
 19583  			v0.AuxInt = int32ToAuxInt(c)
 19584  			v0.AddArg2(x, y)
 19585  			b.resetWithControl(BlockARMLEnoov, v0)
 19586  			return true
 19587  		}
 19588  		// match: (LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
 19589  		// cond: l.Uses==1
 19590  		// result: (LEnoov (TSTshiftLLreg x y z) yes no)
 19591  		for b.Controls[0].Op == OpARMCMPconst {
 19592  			v_0 := b.Controls[0]
 19593  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19594  				break
 19595  			}
 19596  			l := v_0.Args[0]
 19597  			if l.Op != OpARMANDshiftLLreg {
 19598  				break
 19599  			}
 19600  			z := l.Args[2]
 19601  			x := l.Args[0]
 19602  			y := l.Args[1]
 19603  			if !(l.Uses == 1) {
 19604  				break
 19605  			}
 19606  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
 19607  			v0.AddArg3(x, y, z)
 19608  			b.resetWithControl(BlockARMLEnoov, v0)
 19609  			return true
 19610  		}
 19611  		// match: (LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
 19612  		// cond: l.Uses==1
 19613  		// result: (LEnoov (TSTshiftRLreg x y z) yes no)
 19614  		for b.Controls[0].Op == OpARMCMPconst {
 19615  			v_0 := b.Controls[0]
 19616  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19617  				break
 19618  			}
 19619  			l := v_0.Args[0]
 19620  			if l.Op != OpARMANDshiftRLreg {
 19621  				break
 19622  			}
 19623  			z := l.Args[2]
 19624  			x := l.Args[0]
 19625  			y := l.Args[1]
 19626  			if !(l.Uses == 1) {
 19627  				break
 19628  			}
 19629  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
 19630  			v0.AddArg3(x, y, z)
 19631  			b.resetWithControl(BlockARMLEnoov, v0)
 19632  			return true
 19633  		}
 19634  		// match: (LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
 19635  		// cond: l.Uses==1
 19636  		// result: (LEnoov (TSTshiftRAreg x y z) yes no)
 19637  		for b.Controls[0].Op == OpARMCMPconst {
 19638  			v_0 := b.Controls[0]
 19639  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19640  				break
 19641  			}
 19642  			l := v_0.Args[0]
 19643  			if l.Op != OpARMANDshiftRAreg {
 19644  				break
 19645  			}
 19646  			z := l.Args[2]
 19647  			x := l.Args[0]
 19648  			y := l.Args[1]
 19649  			if !(l.Uses == 1) {
 19650  				break
 19651  			}
 19652  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
 19653  			v0.AddArg3(x, y, z)
 19654  			b.resetWithControl(BlockARMLEnoov, v0)
 19655  			return true
 19656  		}
 19657  		// match: (LE (CMPconst [0] l:(XOR x y)) yes no)
 19658  		// cond: l.Uses==1
 19659  		// result: (LEnoov (TEQ x y) yes no)
 19660  		for b.Controls[0].Op == OpARMCMPconst {
 19661  			v_0 := b.Controls[0]
 19662  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19663  				break
 19664  			}
 19665  			l := v_0.Args[0]
 19666  			if l.Op != OpARMXOR {
 19667  				break
 19668  			}
 19669  			_ = l.Args[1]
 19670  			l_0 := l.Args[0]
 19671  			l_1 := l.Args[1]
 19672  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 19673  				x := l_0
 19674  				y := l_1
 19675  				if !(l.Uses == 1) {
 19676  					continue
 19677  				}
 19678  				v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
 19679  				v0.AddArg2(x, y)
 19680  				b.resetWithControl(BlockARMLEnoov, v0)
 19681  				return true
 19682  			}
 19683  			break
 19684  		}
 19685  		// match: (LE (CMPconst [0] l:(XORconst [c] x)) yes no)
 19686  		// cond: l.Uses==1
 19687  		// result: (LEnoov (TEQconst [c] x) yes no)
 19688  		for b.Controls[0].Op == OpARMCMPconst {
 19689  			v_0 := b.Controls[0]
 19690  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19691  				break
 19692  			}
 19693  			l := v_0.Args[0]
 19694  			if l.Op != OpARMXORconst {
 19695  				break
 19696  			}
 19697  			c := auxIntToInt32(l.AuxInt)
 19698  			x := l.Args[0]
 19699  			if !(l.Uses == 1) {
 19700  				break
 19701  			}
 19702  			v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
 19703  			v0.AuxInt = int32ToAuxInt(c)
 19704  			v0.AddArg(x)
 19705  			b.resetWithControl(BlockARMLEnoov, v0)
 19706  			return true
 19707  		}
 19708  		// match: (LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
 19709  		// cond: l.Uses==1
 19710  		// result: (LEnoov (TEQshiftLL x y [c]) yes no)
 19711  		for b.Controls[0].Op == OpARMCMPconst {
 19712  			v_0 := b.Controls[0]
 19713  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19714  				break
 19715  			}
 19716  			l := v_0.Args[0]
 19717  			if l.Op != OpARMXORshiftLL {
 19718  				break
 19719  			}
 19720  			c := auxIntToInt32(l.AuxInt)
 19721  			y := l.Args[1]
 19722  			x := l.Args[0]
 19723  			if !(l.Uses == 1) {
 19724  				break
 19725  			}
 19726  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
 19727  			v0.AuxInt = int32ToAuxInt(c)
 19728  			v0.AddArg2(x, y)
 19729  			b.resetWithControl(BlockARMLEnoov, v0)
 19730  			return true
 19731  		}
 19732  		// match: (LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
 19733  		// cond: l.Uses==1
 19734  		// result: (LEnoov (TEQshiftRL x y [c]) yes no)
 19735  		for b.Controls[0].Op == OpARMCMPconst {
 19736  			v_0 := b.Controls[0]
 19737  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19738  				break
 19739  			}
 19740  			l := v_0.Args[0]
 19741  			if l.Op != OpARMXORshiftRL {
 19742  				break
 19743  			}
 19744  			c := auxIntToInt32(l.AuxInt)
 19745  			y := l.Args[1]
 19746  			x := l.Args[0]
 19747  			if !(l.Uses == 1) {
 19748  				break
 19749  			}
 19750  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
 19751  			v0.AuxInt = int32ToAuxInt(c)
 19752  			v0.AddArg2(x, y)
 19753  			b.resetWithControl(BlockARMLEnoov, v0)
 19754  			return true
 19755  		}
 19756  		// match: (LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
 19757  		// cond: l.Uses==1
 19758  		// result: (LEnoov (TEQshiftRA x y [c]) yes no)
 19759  		for b.Controls[0].Op == OpARMCMPconst {
 19760  			v_0 := b.Controls[0]
 19761  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19762  				break
 19763  			}
 19764  			l := v_0.Args[0]
 19765  			if l.Op != OpARMXORshiftRA {
 19766  				break
 19767  			}
 19768  			c := auxIntToInt32(l.AuxInt)
 19769  			y := l.Args[1]
 19770  			x := l.Args[0]
 19771  			if !(l.Uses == 1) {
 19772  				break
 19773  			}
 19774  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
 19775  			v0.AuxInt = int32ToAuxInt(c)
 19776  			v0.AddArg2(x, y)
 19777  			b.resetWithControl(BlockARMLEnoov, v0)
 19778  			return true
 19779  		}
 19780  		// match: (LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
 19781  		// cond: l.Uses==1
 19782  		// result: (LEnoov (TEQshiftLLreg x y z) yes no)
 19783  		for b.Controls[0].Op == OpARMCMPconst {
 19784  			v_0 := b.Controls[0]
 19785  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19786  				break
 19787  			}
 19788  			l := v_0.Args[0]
 19789  			if l.Op != OpARMXORshiftLLreg {
 19790  				break
 19791  			}
 19792  			z := l.Args[2]
 19793  			x := l.Args[0]
 19794  			y := l.Args[1]
 19795  			if !(l.Uses == 1) {
 19796  				break
 19797  			}
 19798  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
 19799  			v0.AddArg3(x, y, z)
 19800  			b.resetWithControl(BlockARMLEnoov, v0)
 19801  			return true
 19802  		}
 19803  		// match: (LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
 19804  		// cond: l.Uses==1
 19805  		// result: (LEnoov (TEQshiftRLreg x y z) yes no)
 19806  		for b.Controls[0].Op == OpARMCMPconst {
 19807  			v_0 := b.Controls[0]
 19808  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19809  				break
 19810  			}
 19811  			l := v_0.Args[0]
 19812  			if l.Op != OpARMXORshiftRLreg {
 19813  				break
 19814  			}
 19815  			z := l.Args[2]
 19816  			x := l.Args[0]
 19817  			y := l.Args[1]
 19818  			if !(l.Uses == 1) {
 19819  				break
 19820  			}
 19821  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
 19822  			v0.AddArg3(x, y, z)
 19823  			b.resetWithControl(BlockARMLEnoov, v0)
 19824  			return true
 19825  		}
 19826  		// match: (LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
 19827  		// cond: l.Uses==1
 19828  		// result: (LEnoov (TEQshiftRAreg x y z) yes no)
 19829  		for b.Controls[0].Op == OpARMCMPconst {
 19830  			v_0 := b.Controls[0]
 19831  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19832  				break
 19833  			}
 19834  			l := v_0.Args[0]
 19835  			if l.Op != OpARMXORshiftRAreg {
 19836  				break
 19837  			}
 19838  			z := l.Args[2]
 19839  			x := l.Args[0]
 19840  			y := l.Args[1]
 19841  			if !(l.Uses == 1) {
 19842  				break
 19843  			}
 19844  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
 19845  			v0.AddArg3(x, y, z)
 19846  			b.resetWithControl(BlockARMLEnoov, v0)
 19847  			return true
 19848  		}
 19849  	case BlockARMLEnoov:
 19850  		// match: (LEnoov (FlagConstant [fc]) yes no)
 19851  		// cond: fc.leNoov()
 19852  		// result: (First yes no)
 19853  		for b.Controls[0].Op == OpARMFlagConstant {
 19854  			v_0 := b.Controls[0]
 19855  			fc := auxIntToFlagConstant(v_0.AuxInt)
 19856  			if !(fc.leNoov()) {
 19857  				break
 19858  			}
 19859  			b.Reset(BlockFirst)
 19860  			return true
 19861  		}
 19862  		// match: (LEnoov (FlagConstant [fc]) yes no)
 19863  		// cond: !fc.leNoov()
 19864  		// result: (First no yes)
 19865  		for b.Controls[0].Op == OpARMFlagConstant {
 19866  			v_0 := b.Controls[0]
 19867  			fc := auxIntToFlagConstant(v_0.AuxInt)
 19868  			if !(!fc.leNoov()) {
 19869  				break
 19870  			}
 19871  			b.Reset(BlockFirst)
 19872  			b.swapSuccessors()
 19873  			return true
 19874  		}
 19875  		// match: (LEnoov (InvertFlags cmp) yes no)
 19876  		// result: (GEnoov cmp yes no)
 19877  		for b.Controls[0].Op == OpARMInvertFlags {
 19878  			v_0 := b.Controls[0]
 19879  			cmp := v_0.Args[0]
 19880  			b.resetWithControl(BlockARMGEnoov, cmp)
 19881  			return true
 19882  		}
 19883  	case BlockARMLT:
 19884  		// match: (LT (FlagConstant [fc]) yes no)
 19885  		// cond: fc.lt()
 19886  		// result: (First yes no)
 19887  		for b.Controls[0].Op == OpARMFlagConstant {
 19888  			v_0 := b.Controls[0]
 19889  			fc := auxIntToFlagConstant(v_0.AuxInt)
 19890  			if !(fc.lt()) {
 19891  				break
 19892  			}
 19893  			b.Reset(BlockFirst)
 19894  			return true
 19895  		}
 19896  		// match: (LT (FlagConstant [fc]) yes no)
 19897  		// cond: !fc.lt()
 19898  		// result: (First no yes)
 19899  		for b.Controls[0].Op == OpARMFlagConstant {
 19900  			v_0 := b.Controls[0]
 19901  			fc := auxIntToFlagConstant(v_0.AuxInt)
 19902  			if !(!fc.lt()) {
 19903  				break
 19904  			}
 19905  			b.Reset(BlockFirst)
 19906  			b.swapSuccessors()
 19907  			return true
 19908  		}
 19909  		// match: (LT (InvertFlags cmp) yes no)
 19910  		// result: (GT cmp yes no)
 19911  		for b.Controls[0].Op == OpARMInvertFlags {
 19912  			v_0 := b.Controls[0]
 19913  			cmp := v_0.Args[0]
 19914  			b.resetWithControl(BlockARMGT, cmp)
 19915  			return true
 19916  		}
 19917  		// match: (LT (CMPconst [0] l:(SUB x y)) yes no)
 19918  		// cond: l.Uses==1
 19919  		// result: (LTnoov (CMP x y) yes no)
 19920  		for b.Controls[0].Op == OpARMCMPconst {
 19921  			v_0 := b.Controls[0]
 19922  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19923  				break
 19924  			}
 19925  			l := v_0.Args[0]
 19926  			if l.Op != OpARMSUB {
 19927  				break
 19928  			}
 19929  			y := l.Args[1]
 19930  			x := l.Args[0]
 19931  			if !(l.Uses == 1) {
 19932  				break
 19933  			}
 19934  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 19935  			v0.AddArg2(x, y)
 19936  			b.resetWithControl(BlockARMLTnoov, v0)
 19937  			return true
 19938  		}
 19939  		// match: (LT (CMPconst [0] l:(MULS x y a)) yes no)
 19940  		// cond: l.Uses==1
 19941  		// result: (LTnoov (CMP a (MUL <x.Type> x y)) yes no)
 19942  		for b.Controls[0].Op == OpARMCMPconst {
 19943  			v_0 := b.Controls[0]
 19944  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19945  				break
 19946  			}
 19947  			l := v_0.Args[0]
 19948  			if l.Op != OpARMMULS {
 19949  				break
 19950  			}
 19951  			a := l.Args[2]
 19952  			x := l.Args[0]
 19953  			y := l.Args[1]
 19954  			if !(l.Uses == 1) {
 19955  				break
 19956  			}
 19957  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 19958  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 19959  			v1.AddArg2(x, y)
 19960  			v0.AddArg2(a, v1)
 19961  			b.resetWithControl(BlockARMLTnoov, v0)
 19962  			return true
 19963  		}
 19964  		// match: (LT (CMPconst [0] l:(SUBconst [c] x)) yes no)
 19965  		// cond: l.Uses==1
 19966  		// result: (LTnoov (CMPconst [c] x) yes no)
 19967  		for b.Controls[0].Op == OpARMCMPconst {
 19968  			v_0 := b.Controls[0]
 19969  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19970  				break
 19971  			}
 19972  			l := v_0.Args[0]
 19973  			if l.Op != OpARMSUBconst {
 19974  				break
 19975  			}
 19976  			c := auxIntToInt32(l.AuxInt)
 19977  			x := l.Args[0]
 19978  			if !(l.Uses == 1) {
 19979  				break
 19980  			}
 19981  			v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
 19982  			v0.AuxInt = int32ToAuxInt(c)
 19983  			v0.AddArg(x)
 19984  			b.resetWithControl(BlockARMLTnoov, v0)
 19985  			return true
 19986  		}
 19987  		// match: (LT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
 19988  		// cond: l.Uses==1
 19989  		// result: (LTnoov (CMPshiftLL x y [c]) yes no)
 19990  		for b.Controls[0].Op == OpARMCMPconst {
 19991  			v_0 := b.Controls[0]
 19992  			if auxIntToInt32(v_0.AuxInt) != 0 {
 19993  				break
 19994  			}
 19995  			l := v_0.Args[0]
 19996  			if l.Op != OpARMSUBshiftLL {
 19997  				break
 19998  			}
 19999  			c := auxIntToInt32(l.AuxInt)
 20000  			y := l.Args[1]
 20001  			x := l.Args[0]
 20002  			if !(l.Uses == 1) {
 20003  				break
 20004  			}
 20005  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
 20006  			v0.AuxInt = int32ToAuxInt(c)
 20007  			v0.AddArg2(x, y)
 20008  			b.resetWithControl(BlockARMLTnoov, v0)
 20009  			return true
 20010  		}
 20011  		// match: (LT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
 20012  		// cond: l.Uses==1
 20013  		// result: (LTnoov (CMPshiftRL x y [c]) yes no)
 20014  		for b.Controls[0].Op == OpARMCMPconst {
 20015  			v_0 := b.Controls[0]
 20016  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20017  				break
 20018  			}
 20019  			l := v_0.Args[0]
 20020  			if l.Op != OpARMSUBshiftRL {
 20021  				break
 20022  			}
 20023  			c := auxIntToInt32(l.AuxInt)
 20024  			y := l.Args[1]
 20025  			x := l.Args[0]
 20026  			if !(l.Uses == 1) {
 20027  				break
 20028  			}
 20029  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
 20030  			v0.AuxInt = int32ToAuxInt(c)
 20031  			v0.AddArg2(x, y)
 20032  			b.resetWithControl(BlockARMLTnoov, v0)
 20033  			return true
 20034  		}
 20035  		// match: (LT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
 20036  		// cond: l.Uses==1
 20037  		// result: (LTnoov (CMPshiftRA x y [c]) yes no)
 20038  		for b.Controls[0].Op == OpARMCMPconst {
 20039  			v_0 := b.Controls[0]
 20040  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20041  				break
 20042  			}
 20043  			l := v_0.Args[0]
 20044  			if l.Op != OpARMSUBshiftRA {
 20045  				break
 20046  			}
 20047  			c := auxIntToInt32(l.AuxInt)
 20048  			y := l.Args[1]
 20049  			x := l.Args[0]
 20050  			if !(l.Uses == 1) {
 20051  				break
 20052  			}
 20053  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
 20054  			v0.AuxInt = int32ToAuxInt(c)
 20055  			v0.AddArg2(x, y)
 20056  			b.resetWithControl(BlockARMLTnoov, v0)
 20057  			return true
 20058  		}
 20059  		// match: (LT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
 20060  		// cond: l.Uses==1
 20061  		// result: (LTnoov (CMPshiftLLreg x y z) yes no)
 20062  		for b.Controls[0].Op == OpARMCMPconst {
 20063  			v_0 := b.Controls[0]
 20064  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20065  				break
 20066  			}
 20067  			l := v_0.Args[0]
 20068  			if l.Op != OpARMSUBshiftLLreg {
 20069  				break
 20070  			}
 20071  			z := l.Args[2]
 20072  			x := l.Args[0]
 20073  			y := l.Args[1]
 20074  			if !(l.Uses == 1) {
 20075  				break
 20076  			}
 20077  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
 20078  			v0.AddArg3(x, y, z)
 20079  			b.resetWithControl(BlockARMLTnoov, v0)
 20080  			return true
 20081  		}
 20082  		// match: (LT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
 20083  		// cond: l.Uses==1
 20084  		// result: (LTnoov (CMPshiftRLreg x y z) yes no)
 20085  		for b.Controls[0].Op == OpARMCMPconst {
 20086  			v_0 := b.Controls[0]
 20087  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20088  				break
 20089  			}
 20090  			l := v_0.Args[0]
 20091  			if l.Op != OpARMSUBshiftRLreg {
 20092  				break
 20093  			}
 20094  			z := l.Args[2]
 20095  			x := l.Args[0]
 20096  			y := l.Args[1]
 20097  			if !(l.Uses == 1) {
 20098  				break
 20099  			}
 20100  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
 20101  			v0.AddArg3(x, y, z)
 20102  			b.resetWithControl(BlockARMLTnoov, v0)
 20103  			return true
 20104  		}
 20105  		// match: (LT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
 20106  		// cond: l.Uses==1
 20107  		// result: (LTnoov (CMPshiftRAreg x y z) yes no)
 20108  		for b.Controls[0].Op == OpARMCMPconst {
 20109  			v_0 := b.Controls[0]
 20110  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20111  				break
 20112  			}
 20113  			l := v_0.Args[0]
 20114  			if l.Op != OpARMSUBshiftRAreg {
 20115  				break
 20116  			}
 20117  			z := l.Args[2]
 20118  			x := l.Args[0]
 20119  			y := l.Args[1]
 20120  			if !(l.Uses == 1) {
 20121  				break
 20122  			}
 20123  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
 20124  			v0.AddArg3(x, y, z)
 20125  			b.resetWithControl(BlockARMLTnoov, v0)
 20126  			return true
 20127  		}
 20128  		// match: (LT (CMPconst [0] l:(ADD x y)) yes no)
 20129  		// cond: l.Uses==1
 20130  		// result: (LTnoov (CMN x y) yes no)
 20131  		for b.Controls[0].Op == OpARMCMPconst {
 20132  			v_0 := b.Controls[0]
 20133  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20134  				break
 20135  			}
 20136  			l := v_0.Args[0]
 20137  			if l.Op != OpARMADD {
 20138  				break
 20139  			}
 20140  			_ = l.Args[1]
 20141  			l_0 := l.Args[0]
 20142  			l_1 := l.Args[1]
 20143  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 20144  				x := l_0
 20145  				y := l_1
 20146  				if !(l.Uses == 1) {
 20147  					continue
 20148  				}
 20149  				v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 20150  				v0.AddArg2(x, y)
 20151  				b.resetWithControl(BlockARMLTnoov, v0)
 20152  				return true
 20153  			}
 20154  			break
 20155  		}
 20156  		// match: (LT (CMPconst [0] l:(MULA x y a)) yes no)
 20157  		// cond: l.Uses==1
 20158  		// result: (LTnoov (CMN a (MUL <x.Type> x y)) yes no)
 20159  		for b.Controls[0].Op == OpARMCMPconst {
 20160  			v_0 := b.Controls[0]
 20161  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20162  				break
 20163  			}
 20164  			l := v_0.Args[0]
 20165  			if l.Op != OpARMMULA {
 20166  				break
 20167  			}
 20168  			a := l.Args[2]
 20169  			x := l.Args[0]
 20170  			y := l.Args[1]
 20171  			if !(l.Uses == 1) {
 20172  				break
 20173  			}
 20174  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 20175  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 20176  			v1.AddArg2(x, y)
 20177  			v0.AddArg2(a, v1)
 20178  			b.resetWithControl(BlockARMLTnoov, v0)
 20179  			return true
 20180  		}
 20181  		// match: (LT (CMPconst [0] l:(ADDconst [c] x)) yes no)
 20182  		// cond: l.Uses==1
 20183  		// result: (LTnoov (CMNconst [c] x) yes no)
 20184  		for b.Controls[0].Op == OpARMCMPconst {
 20185  			v_0 := b.Controls[0]
 20186  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20187  				break
 20188  			}
 20189  			l := v_0.Args[0]
 20190  			if l.Op != OpARMADDconst {
 20191  				break
 20192  			}
 20193  			c := auxIntToInt32(l.AuxInt)
 20194  			x := l.Args[0]
 20195  			if !(l.Uses == 1) {
 20196  				break
 20197  			}
 20198  			v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
 20199  			v0.AuxInt = int32ToAuxInt(c)
 20200  			v0.AddArg(x)
 20201  			b.resetWithControl(BlockARMLTnoov, v0)
 20202  			return true
 20203  		}
 20204  		// match: (LT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
 20205  		// cond: l.Uses==1
 20206  		// result: (LTnoov (CMNshiftLL x y [c]) yes no)
 20207  		for b.Controls[0].Op == OpARMCMPconst {
 20208  			v_0 := b.Controls[0]
 20209  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20210  				break
 20211  			}
 20212  			l := v_0.Args[0]
 20213  			if l.Op != OpARMADDshiftLL {
 20214  				break
 20215  			}
 20216  			c := auxIntToInt32(l.AuxInt)
 20217  			y := l.Args[1]
 20218  			x := l.Args[0]
 20219  			if !(l.Uses == 1) {
 20220  				break
 20221  			}
 20222  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
 20223  			v0.AuxInt = int32ToAuxInt(c)
 20224  			v0.AddArg2(x, y)
 20225  			b.resetWithControl(BlockARMLTnoov, v0)
 20226  			return true
 20227  		}
 20228  		// match: (LT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
 20229  		// cond: l.Uses==1
 20230  		// result: (LTnoov (CMNshiftRL x y [c]) yes no)
 20231  		for b.Controls[0].Op == OpARMCMPconst {
 20232  			v_0 := b.Controls[0]
 20233  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20234  				break
 20235  			}
 20236  			l := v_0.Args[0]
 20237  			if l.Op != OpARMADDshiftRL {
 20238  				break
 20239  			}
 20240  			c := auxIntToInt32(l.AuxInt)
 20241  			y := l.Args[1]
 20242  			x := l.Args[0]
 20243  			if !(l.Uses == 1) {
 20244  				break
 20245  			}
 20246  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
 20247  			v0.AuxInt = int32ToAuxInt(c)
 20248  			v0.AddArg2(x, y)
 20249  			b.resetWithControl(BlockARMLTnoov, v0)
 20250  			return true
 20251  		}
 20252  		// match: (LT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
 20253  		// cond: l.Uses==1
 20254  		// result: (LTnoov (CMNshiftRA x y [c]) yes no)
 20255  		for b.Controls[0].Op == OpARMCMPconst {
 20256  			v_0 := b.Controls[0]
 20257  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20258  				break
 20259  			}
 20260  			l := v_0.Args[0]
 20261  			if l.Op != OpARMADDshiftRA {
 20262  				break
 20263  			}
 20264  			c := auxIntToInt32(l.AuxInt)
 20265  			y := l.Args[1]
 20266  			x := l.Args[0]
 20267  			if !(l.Uses == 1) {
 20268  				break
 20269  			}
 20270  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
 20271  			v0.AuxInt = int32ToAuxInt(c)
 20272  			v0.AddArg2(x, y)
 20273  			b.resetWithControl(BlockARMLTnoov, v0)
 20274  			return true
 20275  		}
 20276  		// match: (LT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
 20277  		// cond: l.Uses==1
 20278  		// result: (LTnoov (CMNshiftLLreg x y z) yes no)
 20279  		for b.Controls[0].Op == OpARMCMPconst {
 20280  			v_0 := b.Controls[0]
 20281  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20282  				break
 20283  			}
 20284  			l := v_0.Args[0]
 20285  			if l.Op != OpARMADDshiftLLreg {
 20286  				break
 20287  			}
 20288  			z := l.Args[2]
 20289  			x := l.Args[0]
 20290  			y := l.Args[1]
 20291  			if !(l.Uses == 1) {
 20292  				break
 20293  			}
 20294  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
 20295  			v0.AddArg3(x, y, z)
 20296  			b.resetWithControl(BlockARMLTnoov, v0)
 20297  			return true
 20298  		}
 20299  		// match: (LT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
 20300  		// cond: l.Uses==1
 20301  		// result: (LTnoov (CMNshiftRLreg x y z) yes no)
 20302  		for b.Controls[0].Op == OpARMCMPconst {
 20303  			v_0 := b.Controls[0]
 20304  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20305  				break
 20306  			}
 20307  			l := v_0.Args[0]
 20308  			if l.Op != OpARMADDshiftRLreg {
 20309  				break
 20310  			}
 20311  			z := l.Args[2]
 20312  			x := l.Args[0]
 20313  			y := l.Args[1]
 20314  			if !(l.Uses == 1) {
 20315  				break
 20316  			}
 20317  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
 20318  			v0.AddArg3(x, y, z)
 20319  			b.resetWithControl(BlockARMLTnoov, v0)
 20320  			return true
 20321  		}
 20322  		// match: (LT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
 20323  		// cond: l.Uses==1
 20324  		// result: (LTnoov (CMNshiftRAreg x y z) yes no)
 20325  		for b.Controls[0].Op == OpARMCMPconst {
 20326  			v_0 := b.Controls[0]
 20327  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20328  				break
 20329  			}
 20330  			l := v_0.Args[0]
 20331  			if l.Op != OpARMADDshiftRAreg {
 20332  				break
 20333  			}
 20334  			z := l.Args[2]
 20335  			x := l.Args[0]
 20336  			y := l.Args[1]
 20337  			if !(l.Uses == 1) {
 20338  				break
 20339  			}
 20340  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
 20341  			v0.AddArg3(x, y, z)
 20342  			b.resetWithControl(BlockARMLTnoov, v0)
 20343  			return true
 20344  		}
 20345  		// match: (LT (CMPconst [0] l:(AND x y)) yes no)
 20346  		// cond: l.Uses==1
 20347  		// result: (LTnoov (TST x y) yes no)
 20348  		for b.Controls[0].Op == OpARMCMPconst {
 20349  			v_0 := b.Controls[0]
 20350  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20351  				break
 20352  			}
 20353  			l := v_0.Args[0]
 20354  			if l.Op != OpARMAND {
 20355  				break
 20356  			}
 20357  			_ = l.Args[1]
 20358  			l_0 := l.Args[0]
 20359  			l_1 := l.Args[1]
 20360  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 20361  				x := l_0
 20362  				y := l_1
 20363  				if !(l.Uses == 1) {
 20364  					continue
 20365  				}
 20366  				v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
 20367  				v0.AddArg2(x, y)
 20368  				b.resetWithControl(BlockARMLTnoov, v0)
 20369  				return true
 20370  			}
 20371  			break
 20372  		}
 20373  		// match: (LT (CMPconst [0] l:(ANDconst [c] x)) yes no)
 20374  		// cond: l.Uses==1
 20375  		// result: (LTnoov (TSTconst [c] x) yes no)
 20376  		for b.Controls[0].Op == OpARMCMPconst {
 20377  			v_0 := b.Controls[0]
 20378  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20379  				break
 20380  			}
 20381  			l := v_0.Args[0]
 20382  			if l.Op != OpARMANDconst {
 20383  				break
 20384  			}
 20385  			c := auxIntToInt32(l.AuxInt)
 20386  			x := l.Args[0]
 20387  			if !(l.Uses == 1) {
 20388  				break
 20389  			}
 20390  			v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
 20391  			v0.AuxInt = int32ToAuxInt(c)
 20392  			v0.AddArg(x)
 20393  			b.resetWithControl(BlockARMLTnoov, v0)
 20394  			return true
 20395  		}
 20396  		// match: (LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
 20397  		// cond: l.Uses==1
 20398  		// result: (LTnoov (TSTshiftLL x y [c]) yes no)
 20399  		for b.Controls[0].Op == OpARMCMPconst {
 20400  			v_0 := b.Controls[0]
 20401  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20402  				break
 20403  			}
 20404  			l := v_0.Args[0]
 20405  			if l.Op != OpARMANDshiftLL {
 20406  				break
 20407  			}
 20408  			c := auxIntToInt32(l.AuxInt)
 20409  			y := l.Args[1]
 20410  			x := l.Args[0]
 20411  			if !(l.Uses == 1) {
 20412  				break
 20413  			}
 20414  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
 20415  			v0.AuxInt = int32ToAuxInt(c)
 20416  			v0.AddArg2(x, y)
 20417  			b.resetWithControl(BlockARMLTnoov, v0)
 20418  			return true
 20419  		}
 20420  		// match: (LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
 20421  		// cond: l.Uses==1
 20422  		// result: (LTnoov (TSTshiftRL x y [c]) yes no)
 20423  		for b.Controls[0].Op == OpARMCMPconst {
 20424  			v_0 := b.Controls[0]
 20425  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20426  				break
 20427  			}
 20428  			l := v_0.Args[0]
 20429  			if l.Op != OpARMANDshiftRL {
 20430  				break
 20431  			}
 20432  			c := auxIntToInt32(l.AuxInt)
 20433  			y := l.Args[1]
 20434  			x := l.Args[0]
 20435  			if !(l.Uses == 1) {
 20436  				break
 20437  			}
 20438  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
 20439  			v0.AuxInt = int32ToAuxInt(c)
 20440  			v0.AddArg2(x, y)
 20441  			b.resetWithControl(BlockARMLTnoov, v0)
 20442  			return true
 20443  		}
 20444  		// match: (LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
 20445  		// cond: l.Uses==1
 20446  		// result: (LTnoov (TSTshiftRA x y [c]) yes no)
 20447  		for b.Controls[0].Op == OpARMCMPconst {
 20448  			v_0 := b.Controls[0]
 20449  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20450  				break
 20451  			}
 20452  			l := v_0.Args[0]
 20453  			if l.Op != OpARMANDshiftRA {
 20454  				break
 20455  			}
 20456  			c := auxIntToInt32(l.AuxInt)
 20457  			y := l.Args[1]
 20458  			x := l.Args[0]
 20459  			if !(l.Uses == 1) {
 20460  				break
 20461  			}
 20462  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
 20463  			v0.AuxInt = int32ToAuxInt(c)
 20464  			v0.AddArg2(x, y)
 20465  			b.resetWithControl(BlockARMLTnoov, v0)
 20466  			return true
 20467  		}
 20468  		// match: (LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
 20469  		// cond: l.Uses==1
 20470  		// result: (LTnoov (TSTshiftLLreg x y z) yes no)
 20471  		for b.Controls[0].Op == OpARMCMPconst {
 20472  			v_0 := b.Controls[0]
 20473  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20474  				break
 20475  			}
 20476  			l := v_0.Args[0]
 20477  			if l.Op != OpARMANDshiftLLreg {
 20478  				break
 20479  			}
 20480  			z := l.Args[2]
 20481  			x := l.Args[0]
 20482  			y := l.Args[1]
 20483  			if !(l.Uses == 1) {
 20484  				break
 20485  			}
 20486  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
 20487  			v0.AddArg3(x, y, z)
 20488  			b.resetWithControl(BlockARMLTnoov, v0)
 20489  			return true
 20490  		}
 20491  		// match: (LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
 20492  		// cond: l.Uses==1
 20493  		// result: (LTnoov (TSTshiftRLreg x y z) yes no)
 20494  		for b.Controls[0].Op == OpARMCMPconst {
 20495  			v_0 := b.Controls[0]
 20496  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20497  				break
 20498  			}
 20499  			l := v_0.Args[0]
 20500  			if l.Op != OpARMANDshiftRLreg {
 20501  				break
 20502  			}
 20503  			z := l.Args[2]
 20504  			x := l.Args[0]
 20505  			y := l.Args[1]
 20506  			if !(l.Uses == 1) {
 20507  				break
 20508  			}
 20509  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
 20510  			v0.AddArg3(x, y, z)
 20511  			b.resetWithControl(BlockARMLTnoov, v0)
 20512  			return true
 20513  		}
 20514  		// match: (LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
 20515  		// cond: l.Uses==1
 20516  		// result: (LTnoov (TSTshiftRAreg x y z) yes no)
 20517  		for b.Controls[0].Op == OpARMCMPconst {
 20518  			v_0 := b.Controls[0]
 20519  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20520  				break
 20521  			}
 20522  			l := v_0.Args[0]
 20523  			if l.Op != OpARMANDshiftRAreg {
 20524  				break
 20525  			}
 20526  			z := l.Args[2]
 20527  			x := l.Args[0]
 20528  			y := l.Args[1]
 20529  			if !(l.Uses == 1) {
 20530  				break
 20531  			}
 20532  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
 20533  			v0.AddArg3(x, y, z)
 20534  			b.resetWithControl(BlockARMLTnoov, v0)
 20535  			return true
 20536  		}
 20537  		// match: (LT (CMPconst [0] l:(XOR x y)) yes no)
 20538  		// cond: l.Uses==1
 20539  		// result: (LTnoov (TEQ x y) yes no)
 20540  		for b.Controls[0].Op == OpARMCMPconst {
 20541  			v_0 := b.Controls[0]
 20542  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20543  				break
 20544  			}
 20545  			l := v_0.Args[0]
 20546  			if l.Op != OpARMXOR {
 20547  				break
 20548  			}
 20549  			_ = l.Args[1]
 20550  			l_0 := l.Args[0]
 20551  			l_1 := l.Args[1]
 20552  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 20553  				x := l_0
 20554  				y := l_1
 20555  				if !(l.Uses == 1) {
 20556  					continue
 20557  				}
 20558  				v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
 20559  				v0.AddArg2(x, y)
 20560  				b.resetWithControl(BlockARMLTnoov, v0)
 20561  				return true
 20562  			}
 20563  			break
 20564  		}
 20565  		// match: (LT (CMPconst [0] l:(XORconst [c] x)) yes no)
 20566  		// cond: l.Uses==1
 20567  		// result: (LTnoov (TEQconst [c] x) yes no)
 20568  		for b.Controls[0].Op == OpARMCMPconst {
 20569  			v_0 := b.Controls[0]
 20570  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20571  				break
 20572  			}
 20573  			l := v_0.Args[0]
 20574  			if l.Op != OpARMXORconst {
 20575  				break
 20576  			}
 20577  			c := auxIntToInt32(l.AuxInt)
 20578  			x := l.Args[0]
 20579  			if !(l.Uses == 1) {
 20580  				break
 20581  			}
 20582  			v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
 20583  			v0.AuxInt = int32ToAuxInt(c)
 20584  			v0.AddArg(x)
 20585  			b.resetWithControl(BlockARMLTnoov, v0)
 20586  			return true
 20587  		}
 20588  		// match: (LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
 20589  		// cond: l.Uses==1
 20590  		// result: (LTnoov (TEQshiftLL x y [c]) yes no)
 20591  		for b.Controls[0].Op == OpARMCMPconst {
 20592  			v_0 := b.Controls[0]
 20593  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20594  				break
 20595  			}
 20596  			l := v_0.Args[0]
 20597  			if l.Op != OpARMXORshiftLL {
 20598  				break
 20599  			}
 20600  			c := auxIntToInt32(l.AuxInt)
 20601  			y := l.Args[1]
 20602  			x := l.Args[0]
 20603  			if !(l.Uses == 1) {
 20604  				break
 20605  			}
 20606  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
 20607  			v0.AuxInt = int32ToAuxInt(c)
 20608  			v0.AddArg2(x, y)
 20609  			b.resetWithControl(BlockARMLTnoov, v0)
 20610  			return true
 20611  		}
 20612  		// match: (LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
 20613  		// cond: l.Uses==1
 20614  		// result: (LTnoov (TEQshiftRL x y [c]) yes no)
 20615  		for b.Controls[0].Op == OpARMCMPconst {
 20616  			v_0 := b.Controls[0]
 20617  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20618  				break
 20619  			}
 20620  			l := v_0.Args[0]
 20621  			if l.Op != OpARMXORshiftRL {
 20622  				break
 20623  			}
 20624  			c := auxIntToInt32(l.AuxInt)
 20625  			y := l.Args[1]
 20626  			x := l.Args[0]
 20627  			if !(l.Uses == 1) {
 20628  				break
 20629  			}
 20630  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
 20631  			v0.AuxInt = int32ToAuxInt(c)
 20632  			v0.AddArg2(x, y)
 20633  			b.resetWithControl(BlockARMLTnoov, v0)
 20634  			return true
 20635  		}
 20636  		// match: (LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
 20637  		// cond: l.Uses==1
 20638  		// result: (LTnoov (TEQshiftRA x y [c]) yes no)
 20639  		for b.Controls[0].Op == OpARMCMPconst {
 20640  			v_0 := b.Controls[0]
 20641  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20642  				break
 20643  			}
 20644  			l := v_0.Args[0]
 20645  			if l.Op != OpARMXORshiftRA {
 20646  				break
 20647  			}
 20648  			c := auxIntToInt32(l.AuxInt)
 20649  			y := l.Args[1]
 20650  			x := l.Args[0]
 20651  			if !(l.Uses == 1) {
 20652  				break
 20653  			}
 20654  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
 20655  			v0.AuxInt = int32ToAuxInt(c)
 20656  			v0.AddArg2(x, y)
 20657  			b.resetWithControl(BlockARMLTnoov, v0)
 20658  			return true
 20659  		}
 20660  		// match: (LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
 20661  		// cond: l.Uses==1
 20662  		// result: (LTnoov (TEQshiftLLreg x y z) yes no)
 20663  		for b.Controls[0].Op == OpARMCMPconst {
 20664  			v_0 := b.Controls[0]
 20665  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20666  				break
 20667  			}
 20668  			l := v_0.Args[0]
 20669  			if l.Op != OpARMXORshiftLLreg {
 20670  				break
 20671  			}
 20672  			z := l.Args[2]
 20673  			x := l.Args[0]
 20674  			y := l.Args[1]
 20675  			if !(l.Uses == 1) {
 20676  				break
 20677  			}
 20678  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
 20679  			v0.AddArg3(x, y, z)
 20680  			b.resetWithControl(BlockARMLTnoov, v0)
 20681  			return true
 20682  		}
 20683  		// match: (LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
 20684  		// cond: l.Uses==1
 20685  		// result: (LTnoov (TEQshiftRLreg x y z) yes no)
 20686  		for b.Controls[0].Op == OpARMCMPconst {
 20687  			v_0 := b.Controls[0]
 20688  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20689  				break
 20690  			}
 20691  			l := v_0.Args[0]
 20692  			if l.Op != OpARMXORshiftRLreg {
 20693  				break
 20694  			}
 20695  			z := l.Args[2]
 20696  			x := l.Args[0]
 20697  			y := l.Args[1]
 20698  			if !(l.Uses == 1) {
 20699  				break
 20700  			}
 20701  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
 20702  			v0.AddArg3(x, y, z)
 20703  			b.resetWithControl(BlockARMLTnoov, v0)
 20704  			return true
 20705  		}
 20706  		// match: (LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
 20707  		// cond: l.Uses==1
 20708  		// result: (LTnoov (TEQshiftRAreg x y z) yes no)
 20709  		for b.Controls[0].Op == OpARMCMPconst {
 20710  			v_0 := b.Controls[0]
 20711  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20712  				break
 20713  			}
 20714  			l := v_0.Args[0]
 20715  			if l.Op != OpARMXORshiftRAreg {
 20716  				break
 20717  			}
 20718  			z := l.Args[2]
 20719  			x := l.Args[0]
 20720  			y := l.Args[1]
 20721  			if !(l.Uses == 1) {
 20722  				break
 20723  			}
 20724  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
 20725  			v0.AddArg3(x, y, z)
 20726  			b.resetWithControl(BlockARMLTnoov, v0)
 20727  			return true
 20728  		}
 20729  	case BlockARMLTnoov:
 20730  		// match: (LTnoov (FlagConstant [fc]) yes no)
 20731  		// cond: fc.ltNoov()
 20732  		// result: (First yes no)
 20733  		for b.Controls[0].Op == OpARMFlagConstant {
 20734  			v_0 := b.Controls[0]
 20735  			fc := auxIntToFlagConstant(v_0.AuxInt)
 20736  			if !(fc.ltNoov()) {
 20737  				break
 20738  			}
 20739  			b.Reset(BlockFirst)
 20740  			return true
 20741  		}
 20742  		// match: (LTnoov (FlagConstant [fc]) yes no)
 20743  		// cond: !fc.ltNoov()
 20744  		// result: (First no yes)
 20745  		for b.Controls[0].Op == OpARMFlagConstant {
 20746  			v_0 := b.Controls[0]
 20747  			fc := auxIntToFlagConstant(v_0.AuxInt)
 20748  			if !(!fc.ltNoov()) {
 20749  				break
 20750  			}
 20751  			b.Reset(BlockFirst)
 20752  			b.swapSuccessors()
 20753  			return true
 20754  		}
 20755  		// match: (LTnoov (InvertFlags cmp) yes no)
 20756  		// result: (GTnoov cmp yes no)
 20757  		for b.Controls[0].Op == OpARMInvertFlags {
 20758  			v_0 := b.Controls[0]
 20759  			cmp := v_0.Args[0]
 20760  			b.resetWithControl(BlockARMGTnoov, cmp)
 20761  			return true
 20762  		}
 20763  	case BlockARMNE:
 20764  		// match: (NE (CMPconst [0] (Equal cc)) yes no)
 20765  		// result: (EQ cc yes no)
 20766  		for b.Controls[0].Op == OpARMCMPconst {
 20767  			v_0 := b.Controls[0]
 20768  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20769  				break
 20770  			}
 20771  			v_0_0 := v_0.Args[0]
 20772  			if v_0_0.Op != OpARMEqual {
 20773  				break
 20774  			}
 20775  			cc := v_0_0.Args[0]
 20776  			b.resetWithControl(BlockARMEQ, cc)
 20777  			return true
 20778  		}
 20779  		// match: (NE (CMPconst [0] (NotEqual cc)) yes no)
 20780  		// result: (NE cc yes no)
 20781  		for b.Controls[0].Op == OpARMCMPconst {
 20782  			v_0 := b.Controls[0]
 20783  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20784  				break
 20785  			}
 20786  			v_0_0 := v_0.Args[0]
 20787  			if v_0_0.Op != OpARMNotEqual {
 20788  				break
 20789  			}
 20790  			cc := v_0_0.Args[0]
 20791  			b.resetWithControl(BlockARMNE, cc)
 20792  			return true
 20793  		}
 20794  		// match: (NE (CMPconst [0] (LessThan cc)) yes no)
 20795  		// result: (LT cc yes no)
 20796  		for b.Controls[0].Op == OpARMCMPconst {
 20797  			v_0 := b.Controls[0]
 20798  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20799  				break
 20800  			}
 20801  			v_0_0 := v_0.Args[0]
 20802  			if v_0_0.Op != OpARMLessThan {
 20803  				break
 20804  			}
 20805  			cc := v_0_0.Args[0]
 20806  			b.resetWithControl(BlockARMLT, cc)
 20807  			return true
 20808  		}
 20809  		// match: (NE (CMPconst [0] (LessThanU cc)) yes no)
 20810  		// result: (ULT cc yes no)
 20811  		for b.Controls[0].Op == OpARMCMPconst {
 20812  			v_0 := b.Controls[0]
 20813  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20814  				break
 20815  			}
 20816  			v_0_0 := v_0.Args[0]
 20817  			if v_0_0.Op != OpARMLessThanU {
 20818  				break
 20819  			}
 20820  			cc := v_0_0.Args[0]
 20821  			b.resetWithControl(BlockARMULT, cc)
 20822  			return true
 20823  		}
 20824  		// match: (NE (CMPconst [0] (LessEqual cc)) yes no)
 20825  		// result: (LE cc yes no)
 20826  		for b.Controls[0].Op == OpARMCMPconst {
 20827  			v_0 := b.Controls[0]
 20828  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20829  				break
 20830  			}
 20831  			v_0_0 := v_0.Args[0]
 20832  			if v_0_0.Op != OpARMLessEqual {
 20833  				break
 20834  			}
 20835  			cc := v_0_0.Args[0]
 20836  			b.resetWithControl(BlockARMLE, cc)
 20837  			return true
 20838  		}
 20839  		// match: (NE (CMPconst [0] (LessEqualU cc)) yes no)
 20840  		// result: (ULE cc yes no)
 20841  		for b.Controls[0].Op == OpARMCMPconst {
 20842  			v_0 := b.Controls[0]
 20843  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20844  				break
 20845  			}
 20846  			v_0_0 := v_0.Args[0]
 20847  			if v_0_0.Op != OpARMLessEqualU {
 20848  				break
 20849  			}
 20850  			cc := v_0_0.Args[0]
 20851  			b.resetWithControl(BlockARMULE, cc)
 20852  			return true
 20853  		}
 20854  		// match: (NE (CMPconst [0] (GreaterThan cc)) yes no)
 20855  		// result: (GT cc yes no)
 20856  		for b.Controls[0].Op == OpARMCMPconst {
 20857  			v_0 := b.Controls[0]
 20858  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20859  				break
 20860  			}
 20861  			v_0_0 := v_0.Args[0]
 20862  			if v_0_0.Op != OpARMGreaterThan {
 20863  				break
 20864  			}
 20865  			cc := v_0_0.Args[0]
 20866  			b.resetWithControl(BlockARMGT, cc)
 20867  			return true
 20868  		}
 20869  		// match: (NE (CMPconst [0] (GreaterThanU cc)) yes no)
 20870  		// result: (UGT cc yes no)
 20871  		for b.Controls[0].Op == OpARMCMPconst {
 20872  			v_0 := b.Controls[0]
 20873  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20874  				break
 20875  			}
 20876  			v_0_0 := v_0.Args[0]
 20877  			if v_0_0.Op != OpARMGreaterThanU {
 20878  				break
 20879  			}
 20880  			cc := v_0_0.Args[0]
 20881  			b.resetWithControl(BlockARMUGT, cc)
 20882  			return true
 20883  		}
 20884  		// match: (NE (CMPconst [0] (GreaterEqual cc)) yes no)
 20885  		// result: (GE cc yes no)
 20886  		for b.Controls[0].Op == OpARMCMPconst {
 20887  			v_0 := b.Controls[0]
 20888  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20889  				break
 20890  			}
 20891  			v_0_0 := v_0.Args[0]
 20892  			if v_0_0.Op != OpARMGreaterEqual {
 20893  				break
 20894  			}
 20895  			cc := v_0_0.Args[0]
 20896  			b.resetWithControl(BlockARMGE, cc)
 20897  			return true
 20898  		}
 20899  		// match: (NE (CMPconst [0] (GreaterEqualU cc)) yes no)
 20900  		// result: (UGE cc yes no)
 20901  		for b.Controls[0].Op == OpARMCMPconst {
 20902  			v_0 := b.Controls[0]
 20903  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20904  				break
 20905  			}
 20906  			v_0_0 := v_0.Args[0]
 20907  			if v_0_0.Op != OpARMGreaterEqualU {
 20908  				break
 20909  			}
 20910  			cc := v_0_0.Args[0]
 20911  			b.resetWithControl(BlockARMUGE, cc)
 20912  			return true
 20913  		}
 20914  		// match: (NE (FlagConstant [fc]) yes no)
 20915  		// cond: fc.ne()
 20916  		// result: (First yes no)
 20917  		for b.Controls[0].Op == OpARMFlagConstant {
 20918  			v_0 := b.Controls[0]
 20919  			fc := auxIntToFlagConstant(v_0.AuxInt)
 20920  			if !(fc.ne()) {
 20921  				break
 20922  			}
 20923  			b.Reset(BlockFirst)
 20924  			return true
 20925  		}
 20926  		// match: (NE (FlagConstant [fc]) yes no)
 20927  		// cond: !fc.ne()
 20928  		// result: (First no yes)
 20929  		for b.Controls[0].Op == OpARMFlagConstant {
 20930  			v_0 := b.Controls[0]
 20931  			fc := auxIntToFlagConstant(v_0.AuxInt)
 20932  			if !(!fc.ne()) {
 20933  				break
 20934  			}
 20935  			b.Reset(BlockFirst)
 20936  			b.swapSuccessors()
 20937  			return true
 20938  		}
 20939  		// match: (NE (InvertFlags cmp) yes no)
 20940  		// result: (NE cmp yes no)
 20941  		for b.Controls[0].Op == OpARMInvertFlags {
 20942  			v_0 := b.Controls[0]
 20943  			cmp := v_0.Args[0]
 20944  			b.resetWithControl(BlockARMNE, cmp)
 20945  			return true
 20946  		}
 20947  		// match: (NE (CMP x (RSBconst [0] y)))
 20948  		// result: (NE (CMN x y))
 20949  		for b.Controls[0].Op == OpARMCMP {
 20950  			v_0 := b.Controls[0]
 20951  			_ = v_0.Args[1]
 20952  			x := v_0.Args[0]
 20953  			v_0_1 := v_0.Args[1]
 20954  			if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 {
 20955  				break
 20956  			}
 20957  			y := v_0_1.Args[0]
 20958  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 20959  			v0.AddArg2(x, y)
 20960  			b.resetWithControl(BlockARMNE, v0)
 20961  			return true
 20962  		}
 20963  		// match: (NE (CMN x (RSBconst [0] y)))
 20964  		// result: (NE (CMP x y))
 20965  		for b.Controls[0].Op == OpARMCMN {
 20966  			v_0 := b.Controls[0]
 20967  			_ = v_0.Args[1]
 20968  			v_0_0 := v_0.Args[0]
 20969  			v_0_1 := v_0.Args[1]
 20970  			for _i0 := 0; _i0 <= 1; _i0, v_0_0, v_0_1 = _i0+1, v_0_1, v_0_0 {
 20971  				x := v_0_0
 20972  				if v_0_1.Op != OpARMRSBconst || auxIntToInt32(v_0_1.AuxInt) != 0 {
 20973  					continue
 20974  				}
 20975  				y := v_0_1.Args[0]
 20976  				v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 20977  				v0.AddArg2(x, y)
 20978  				b.resetWithControl(BlockARMNE, v0)
 20979  				return true
 20980  			}
 20981  			break
 20982  		}
 20983  		// match: (NE (CMPconst [0] l:(SUB x y)) yes no)
 20984  		// cond: l.Uses==1
 20985  		// result: (NE (CMP x y) yes no)
 20986  		for b.Controls[0].Op == OpARMCMPconst {
 20987  			v_0 := b.Controls[0]
 20988  			if auxIntToInt32(v_0.AuxInt) != 0 {
 20989  				break
 20990  			}
 20991  			l := v_0.Args[0]
 20992  			if l.Op != OpARMSUB {
 20993  				break
 20994  			}
 20995  			y := l.Args[1]
 20996  			x := l.Args[0]
 20997  			if !(l.Uses == 1) {
 20998  				break
 20999  			}
 21000  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 21001  			v0.AddArg2(x, y)
 21002  			b.resetWithControl(BlockARMNE, v0)
 21003  			return true
 21004  		}
 21005  		// match: (NE (CMPconst [0] l:(MULS x y a)) yes no)
 21006  		// cond: l.Uses==1
 21007  		// result: (NE (CMP a (MUL <x.Type> x y)) yes no)
 21008  		for b.Controls[0].Op == OpARMCMPconst {
 21009  			v_0 := b.Controls[0]
 21010  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21011  				break
 21012  			}
 21013  			l := v_0.Args[0]
 21014  			if l.Op != OpARMMULS {
 21015  				break
 21016  			}
 21017  			a := l.Args[2]
 21018  			x := l.Args[0]
 21019  			y := l.Args[1]
 21020  			if !(l.Uses == 1) {
 21021  				break
 21022  			}
 21023  			v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
 21024  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 21025  			v1.AddArg2(x, y)
 21026  			v0.AddArg2(a, v1)
 21027  			b.resetWithControl(BlockARMNE, v0)
 21028  			return true
 21029  		}
 21030  		// match: (NE (CMPconst [0] l:(SUBconst [c] x)) yes no)
 21031  		// cond: l.Uses==1
 21032  		// result: (NE (CMPconst [c] x) yes no)
 21033  		for b.Controls[0].Op == OpARMCMPconst {
 21034  			v_0 := b.Controls[0]
 21035  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21036  				break
 21037  			}
 21038  			l := v_0.Args[0]
 21039  			if l.Op != OpARMSUBconst {
 21040  				break
 21041  			}
 21042  			c := auxIntToInt32(l.AuxInt)
 21043  			x := l.Args[0]
 21044  			if !(l.Uses == 1) {
 21045  				break
 21046  			}
 21047  			v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
 21048  			v0.AuxInt = int32ToAuxInt(c)
 21049  			v0.AddArg(x)
 21050  			b.resetWithControl(BlockARMNE, v0)
 21051  			return true
 21052  		}
 21053  		// match: (NE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
 21054  		// cond: l.Uses==1
 21055  		// result: (NE (CMPshiftLL x y [c]) yes no)
 21056  		for b.Controls[0].Op == OpARMCMPconst {
 21057  			v_0 := b.Controls[0]
 21058  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21059  				break
 21060  			}
 21061  			l := v_0.Args[0]
 21062  			if l.Op != OpARMSUBshiftLL {
 21063  				break
 21064  			}
 21065  			c := auxIntToInt32(l.AuxInt)
 21066  			y := l.Args[1]
 21067  			x := l.Args[0]
 21068  			if !(l.Uses == 1) {
 21069  				break
 21070  			}
 21071  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
 21072  			v0.AuxInt = int32ToAuxInt(c)
 21073  			v0.AddArg2(x, y)
 21074  			b.resetWithControl(BlockARMNE, v0)
 21075  			return true
 21076  		}
 21077  		// match: (NE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
 21078  		// cond: l.Uses==1
 21079  		// result: (NE (CMPshiftRL x y [c]) yes no)
 21080  		for b.Controls[0].Op == OpARMCMPconst {
 21081  			v_0 := b.Controls[0]
 21082  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21083  				break
 21084  			}
 21085  			l := v_0.Args[0]
 21086  			if l.Op != OpARMSUBshiftRL {
 21087  				break
 21088  			}
 21089  			c := auxIntToInt32(l.AuxInt)
 21090  			y := l.Args[1]
 21091  			x := l.Args[0]
 21092  			if !(l.Uses == 1) {
 21093  				break
 21094  			}
 21095  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
 21096  			v0.AuxInt = int32ToAuxInt(c)
 21097  			v0.AddArg2(x, y)
 21098  			b.resetWithControl(BlockARMNE, v0)
 21099  			return true
 21100  		}
 21101  		// match: (NE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
 21102  		// cond: l.Uses==1
 21103  		// result: (NE (CMPshiftRA x y [c]) yes no)
 21104  		for b.Controls[0].Op == OpARMCMPconst {
 21105  			v_0 := b.Controls[0]
 21106  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21107  				break
 21108  			}
 21109  			l := v_0.Args[0]
 21110  			if l.Op != OpARMSUBshiftRA {
 21111  				break
 21112  			}
 21113  			c := auxIntToInt32(l.AuxInt)
 21114  			y := l.Args[1]
 21115  			x := l.Args[0]
 21116  			if !(l.Uses == 1) {
 21117  				break
 21118  			}
 21119  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
 21120  			v0.AuxInt = int32ToAuxInt(c)
 21121  			v0.AddArg2(x, y)
 21122  			b.resetWithControl(BlockARMNE, v0)
 21123  			return true
 21124  		}
 21125  		// match: (NE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
 21126  		// cond: l.Uses==1
 21127  		// result: (NE (CMPshiftLLreg x y z) yes no)
 21128  		for b.Controls[0].Op == OpARMCMPconst {
 21129  			v_0 := b.Controls[0]
 21130  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21131  				break
 21132  			}
 21133  			l := v_0.Args[0]
 21134  			if l.Op != OpARMSUBshiftLLreg {
 21135  				break
 21136  			}
 21137  			z := l.Args[2]
 21138  			x := l.Args[0]
 21139  			y := l.Args[1]
 21140  			if !(l.Uses == 1) {
 21141  				break
 21142  			}
 21143  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
 21144  			v0.AddArg3(x, y, z)
 21145  			b.resetWithControl(BlockARMNE, v0)
 21146  			return true
 21147  		}
 21148  		// match: (NE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
 21149  		// cond: l.Uses==1
 21150  		// result: (NE (CMPshiftRLreg x y z) yes no)
 21151  		for b.Controls[0].Op == OpARMCMPconst {
 21152  			v_0 := b.Controls[0]
 21153  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21154  				break
 21155  			}
 21156  			l := v_0.Args[0]
 21157  			if l.Op != OpARMSUBshiftRLreg {
 21158  				break
 21159  			}
 21160  			z := l.Args[2]
 21161  			x := l.Args[0]
 21162  			y := l.Args[1]
 21163  			if !(l.Uses == 1) {
 21164  				break
 21165  			}
 21166  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
 21167  			v0.AddArg3(x, y, z)
 21168  			b.resetWithControl(BlockARMNE, v0)
 21169  			return true
 21170  		}
 21171  		// match: (NE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
 21172  		// cond: l.Uses==1
 21173  		// result: (NE (CMPshiftRAreg x y z) yes no)
 21174  		for b.Controls[0].Op == OpARMCMPconst {
 21175  			v_0 := b.Controls[0]
 21176  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21177  				break
 21178  			}
 21179  			l := v_0.Args[0]
 21180  			if l.Op != OpARMSUBshiftRAreg {
 21181  				break
 21182  			}
 21183  			z := l.Args[2]
 21184  			x := l.Args[0]
 21185  			y := l.Args[1]
 21186  			if !(l.Uses == 1) {
 21187  				break
 21188  			}
 21189  			v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
 21190  			v0.AddArg3(x, y, z)
 21191  			b.resetWithControl(BlockARMNE, v0)
 21192  			return true
 21193  		}
 21194  		// match: (NE (CMPconst [0] l:(ADD x y)) yes no)
 21195  		// cond: l.Uses==1
 21196  		// result: (NE (CMN x y) yes no)
 21197  		for b.Controls[0].Op == OpARMCMPconst {
 21198  			v_0 := b.Controls[0]
 21199  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21200  				break
 21201  			}
 21202  			l := v_0.Args[0]
 21203  			if l.Op != OpARMADD {
 21204  				break
 21205  			}
 21206  			_ = l.Args[1]
 21207  			l_0 := l.Args[0]
 21208  			l_1 := l.Args[1]
 21209  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 21210  				x := l_0
 21211  				y := l_1
 21212  				if !(l.Uses == 1) {
 21213  					continue
 21214  				}
 21215  				v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 21216  				v0.AddArg2(x, y)
 21217  				b.resetWithControl(BlockARMNE, v0)
 21218  				return true
 21219  			}
 21220  			break
 21221  		}
 21222  		// match: (NE (CMPconst [0] l:(MULA x y a)) yes no)
 21223  		// cond: l.Uses==1
 21224  		// result: (NE (CMN a (MUL <x.Type> x y)) yes no)
 21225  		for b.Controls[0].Op == OpARMCMPconst {
 21226  			v_0 := b.Controls[0]
 21227  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21228  				break
 21229  			}
 21230  			l := v_0.Args[0]
 21231  			if l.Op != OpARMMULA {
 21232  				break
 21233  			}
 21234  			a := l.Args[2]
 21235  			x := l.Args[0]
 21236  			y := l.Args[1]
 21237  			if !(l.Uses == 1) {
 21238  				break
 21239  			}
 21240  			v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
 21241  			v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
 21242  			v1.AddArg2(x, y)
 21243  			v0.AddArg2(a, v1)
 21244  			b.resetWithControl(BlockARMNE, v0)
 21245  			return true
 21246  		}
 21247  		// match: (NE (CMPconst [0] l:(ADDconst [c] x)) yes no)
 21248  		// cond: l.Uses==1
 21249  		// result: (NE (CMNconst [c] x) yes no)
 21250  		for b.Controls[0].Op == OpARMCMPconst {
 21251  			v_0 := b.Controls[0]
 21252  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21253  				break
 21254  			}
 21255  			l := v_0.Args[0]
 21256  			if l.Op != OpARMADDconst {
 21257  				break
 21258  			}
 21259  			c := auxIntToInt32(l.AuxInt)
 21260  			x := l.Args[0]
 21261  			if !(l.Uses == 1) {
 21262  				break
 21263  			}
 21264  			v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
 21265  			v0.AuxInt = int32ToAuxInt(c)
 21266  			v0.AddArg(x)
 21267  			b.resetWithControl(BlockARMNE, v0)
 21268  			return true
 21269  		}
 21270  		// match: (NE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
 21271  		// cond: l.Uses==1
 21272  		// result: (NE (CMNshiftLL x y [c]) yes no)
 21273  		for b.Controls[0].Op == OpARMCMPconst {
 21274  			v_0 := b.Controls[0]
 21275  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21276  				break
 21277  			}
 21278  			l := v_0.Args[0]
 21279  			if l.Op != OpARMADDshiftLL {
 21280  				break
 21281  			}
 21282  			c := auxIntToInt32(l.AuxInt)
 21283  			y := l.Args[1]
 21284  			x := l.Args[0]
 21285  			if !(l.Uses == 1) {
 21286  				break
 21287  			}
 21288  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
 21289  			v0.AuxInt = int32ToAuxInt(c)
 21290  			v0.AddArg2(x, y)
 21291  			b.resetWithControl(BlockARMNE, v0)
 21292  			return true
 21293  		}
 21294  		// match: (NE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
 21295  		// cond: l.Uses==1
 21296  		// result: (NE (CMNshiftRL x y [c]) yes no)
 21297  		for b.Controls[0].Op == OpARMCMPconst {
 21298  			v_0 := b.Controls[0]
 21299  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21300  				break
 21301  			}
 21302  			l := v_0.Args[0]
 21303  			if l.Op != OpARMADDshiftRL {
 21304  				break
 21305  			}
 21306  			c := auxIntToInt32(l.AuxInt)
 21307  			y := l.Args[1]
 21308  			x := l.Args[0]
 21309  			if !(l.Uses == 1) {
 21310  				break
 21311  			}
 21312  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
 21313  			v0.AuxInt = int32ToAuxInt(c)
 21314  			v0.AddArg2(x, y)
 21315  			b.resetWithControl(BlockARMNE, v0)
 21316  			return true
 21317  		}
 21318  		// match: (NE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
 21319  		// cond: l.Uses==1
 21320  		// result: (NE (CMNshiftRA x y [c]) yes no)
 21321  		for b.Controls[0].Op == OpARMCMPconst {
 21322  			v_0 := b.Controls[0]
 21323  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21324  				break
 21325  			}
 21326  			l := v_0.Args[0]
 21327  			if l.Op != OpARMADDshiftRA {
 21328  				break
 21329  			}
 21330  			c := auxIntToInt32(l.AuxInt)
 21331  			y := l.Args[1]
 21332  			x := l.Args[0]
 21333  			if !(l.Uses == 1) {
 21334  				break
 21335  			}
 21336  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
 21337  			v0.AuxInt = int32ToAuxInt(c)
 21338  			v0.AddArg2(x, y)
 21339  			b.resetWithControl(BlockARMNE, v0)
 21340  			return true
 21341  		}
 21342  		// match: (NE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
 21343  		// cond: l.Uses==1
 21344  		// result: (NE (CMNshiftLLreg x y z) yes no)
 21345  		for b.Controls[0].Op == OpARMCMPconst {
 21346  			v_0 := b.Controls[0]
 21347  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21348  				break
 21349  			}
 21350  			l := v_0.Args[0]
 21351  			if l.Op != OpARMADDshiftLLreg {
 21352  				break
 21353  			}
 21354  			z := l.Args[2]
 21355  			x := l.Args[0]
 21356  			y := l.Args[1]
 21357  			if !(l.Uses == 1) {
 21358  				break
 21359  			}
 21360  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
 21361  			v0.AddArg3(x, y, z)
 21362  			b.resetWithControl(BlockARMNE, v0)
 21363  			return true
 21364  		}
 21365  		// match: (NE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
 21366  		// cond: l.Uses==1
 21367  		// result: (NE (CMNshiftRLreg x y z) yes no)
 21368  		for b.Controls[0].Op == OpARMCMPconst {
 21369  			v_0 := b.Controls[0]
 21370  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21371  				break
 21372  			}
 21373  			l := v_0.Args[0]
 21374  			if l.Op != OpARMADDshiftRLreg {
 21375  				break
 21376  			}
 21377  			z := l.Args[2]
 21378  			x := l.Args[0]
 21379  			y := l.Args[1]
 21380  			if !(l.Uses == 1) {
 21381  				break
 21382  			}
 21383  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
 21384  			v0.AddArg3(x, y, z)
 21385  			b.resetWithControl(BlockARMNE, v0)
 21386  			return true
 21387  		}
 21388  		// match: (NE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
 21389  		// cond: l.Uses==1
 21390  		// result: (NE (CMNshiftRAreg x y z) yes no)
 21391  		for b.Controls[0].Op == OpARMCMPconst {
 21392  			v_0 := b.Controls[0]
 21393  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21394  				break
 21395  			}
 21396  			l := v_0.Args[0]
 21397  			if l.Op != OpARMADDshiftRAreg {
 21398  				break
 21399  			}
 21400  			z := l.Args[2]
 21401  			x := l.Args[0]
 21402  			y := l.Args[1]
 21403  			if !(l.Uses == 1) {
 21404  				break
 21405  			}
 21406  			v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
 21407  			v0.AddArg3(x, y, z)
 21408  			b.resetWithControl(BlockARMNE, v0)
 21409  			return true
 21410  		}
 21411  		// match: (NE (CMPconst [0] l:(AND x y)) yes no)
 21412  		// cond: l.Uses==1
 21413  		// result: (NE (TST x y) yes no)
 21414  		for b.Controls[0].Op == OpARMCMPconst {
 21415  			v_0 := b.Controls[0]
 21416  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21417  				break
 21418  			}
 21419  			l := v_0.Args[0]
 21420  			if l.Op != OpARMAND {
 21421  				break
 21422  			}
 21423  			_ = l.Args[1]
 21424  			l_0 := l.Args[0]
 21425  			l_1 := l.Args[1]
 21426  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 21427  				x := l_0
 21428  				y := l_1
 21429  				if !(l.Uses == 1) {
 21430  					continue
 21431  				}
 21432  				v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
 21433  				v0.AddArg2(x, y)
 21434  				b.resetWithControl(BlockARMNE, v0)
 21435  				return true
 21436  			}
 21437  			break
 21438  		}
 21439  		// match: (NE (CMPconst [0] l:(ANDconst [c] x)) yes no)
 21440  		// cond: l.Uses==1
 21441  		// result: (NE (TSTconst [c] x) yes no)
 21442  		for b.Controls[0].Op == OpARMCMPconst {
 21443  			v_0 := b.Controls[0]
 21444  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21445  				break
 21446  			}
 21447  			l := v_0.Args[0]
 21448  			if l.Op != OpARMANDconst {
 21449  				break
 21450  			}
 21451  			c := auxIntToInt32(l.AuxInt)
 21452  			x := l.Args[0]
 21453  			if !(l.Uses == 1) {
 21454  				break
 21455  			}
 21456  			v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
 21457  			v0.AuxInt = int32ToAuxInt(c)
 21458  			v0.AddArg(x)
 21459  			b.resetWithControl(BlockARMNE, v0)
 21460  			return true
 21461  		}
 21462  		// match: (NE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
 21463  		// cond: l.Uses==1
 21464  		// result: (NE (TSTshiftLL x y [c]) yes no)
 21465  		for b.Controls[0].Op == OpARMCMPconst {
 21466  			v_0 := b.Controls[0]
 21467  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21468  				break
 21469  			}
 21470  			l := v_0.Args[0]
 21471  			if l.Op != OpARMANDshiftLL {
 21472  				break
 21473  			}
 21474  			c := auxIntToInt32(l.AuxInt)
 21475  			y := l.Args[1]
 21476  			x := l.Args[0]
 21477  			if !(l.Uses == 1) {
 21478  				break
 21479  			}
 21480  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
 21481  			v0.AuxInt = int32ToAuxInt(c)
 21482  			v0.AddArg2(x, y)
 21483  			b.resetWithControl(BlockARMNE, v0)
 21484  			return true
 21485  		}
 21486  		// match: (NE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
 21487  		// cond: l.Uses==1
 21488  		// result: (NE (TSTshiftRL x y [c]) yes no)
 21489  		for b.Controls[0].Op == OpARMCMPconst {
 21490  			v_0 := b.Controls[0]
 21491  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21492  				break
 21493  			}
 21494  			l := v_0.Args[0]
 21495  			if l.Op != OpARMANDshiftRL {
 21496  				break
 21497  			}
 21498  			c := auxIntToInt32(l.AuxInt)
 21499  			y := l.Args[1]
 21500  			x := l.Args[0]
 21501  			if !(l.Uses == 1) {
 21502  				break
 21503  			}
 21504  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
 21505  			v0.AuxInt = int32ToAuxInt(c)
 21506  			v0.AddArg2(x, y)
 21507  			b.resetWithControl(BlockARMNE, v0)
 21508  			return true
 21509  		}
 21510  		// match: (NE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
 21511  		// cond: l.Uses==1
 21512  		// result: (NE (TSTshiftRA x y [c]) yes no)
 21513  		for b.Controls[0].Op == OpARMCMPconst {
 21514  			v_0 := b.Controls[0]
 21515  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21516  				break
 21517  			}
 21518  			l := v_0.Args[0]
 21519  			if l.Op != OpARMANDshiftRA {
 21520  				break
 21521  			}
 21522  			c := auxIntToInt32(l.AuxInt)
 21523  			y := l.Args[1]
 21524  			x := l.Args[0]
 21525  			if !(l.Uses == 1) {
 21526  				break
 21527  			}
 21528  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
 21529  			v0.AuxInt = int32ToAuxInt(c)
 21530  			v0.AddArg2(x, y)
 21531  			b.resetWithControl(BlockARMNE, v0)
 21532  			return true
 21533  		}
 21534  		// match: (NE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
 21535  		// cond: l.Uses==1
 21536  		// result: (NE (TSTshiftLLreg x y z) yes no)
 21537  		for b.Controls[0].Op == OpARMCMPconst {
 21538  			v_0 := b.Controls[0]
 21539  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21540  				break
 21541  			}
 21542  			l := v_0.Args[0]
 21543  			if l.Op != OpARMANDshiftLLreg {
 21544  				break
 21545  			}
 21546  			z := l.Args[2]
 21547  			x := l.Args[0]
 21548  			y := l.Args[1]
 21549  			if !(l.Uses == 1) {
 21550  				break
 21551  			}
 21552  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
 21553  			v0.AddArg3(x, y, z)
 21554  			b.resetWithControl(BlockARMNE, v0)
 21555  			return true
 21556  		}
 21557  		// match: (NE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
 21558  		// cond: l.Uses==1
 21559  		// result: (NE (TSTshiftRLreg x y z) yes no)
 21560  		for b.Controls[0].Op == OpARMCMPconst {
 21561  			v_0 := b.Controls[0]
 21562  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21563  				break
 21564  			}
 21565  			l := v_0.Args[0]
 21566  			if l.Op != OpARMANDshiftRLreg {
 21567  				break
 21568  			}
 21569  			z := l.Args[2]
 21570  			x := l.Args[0]
 21571  			y := l.Args[1]
 21572  			if !(l.Uses == 1) {
 21573  				break
 21574  			}
 21575  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
 21576  			v0.AddArg3(x, y, z)
 21577  			b.resetWithControl(BlockARMNE, v0)
 21578  			return true
 21579  		}
 21580  		// match: (NE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
 21581  		// cond: l.Uses==1
 21582  		// result: (NE (TSTshiftRAreg x y z) yes no)
 21583  		for b.Controls[0].Op == OpARMCMPconst {
 21584  			v_0 := b.Controls[0]
 21585  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21586  				break
 21587  			}
 21588  			l := v_0.Args[0]
 21589  			if l.Op != OpARMANDshiftRAreg {
 21590  				break
 21591  			}
 21592  			z := l.Args[2]
 21593  			x := l.Args[0]
 21594  			y := l.Args[1]
 21595  			if !(l.Uses == 1) {
 21596  				break
 21597  			}
 21598  			v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
 21599  			v0.AddArg3(x, y, z)
 21600  			b.resetWithControl(BlockARMNE, v0)
 21601  			return true
 21602  		}
 21603  		// match: (NE (CMPconst [0] l:(XOR x y)) yes no)
 21604  		// cond: l.Uses==1
 21605  		// result: (NE (TEQ x y) yes no)
 21606  		for b.Controls[0].Op == OpARMCMPconst {
 21607  			v_0 := b.Controls[0]
 21608  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21609  				break
 21610  			}
 21611  			l := v_0.Args[0]
 21612  			if l.Op != OpARMXOR {
 21613  				break
 21614  			}
 21615  			_ = l.Args[1]
 21616  			l_0 := l.Args[0]
 21617  			l_1 := l.Args[1]
 21618  			for _i0 := 0; _i0 <= 1; _i0, l_0, l_1 = _i0+1, l_1, l_0 {
 21619  				x := l_0
 21620  				y := l_1
 21621  				if !(l.Uses == 1) {
 21622  					continue
 21623  				}
 21624  				v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
 21625  				v0.AddArg2(x, y)
 21626  				b.resetWithControl(BlockARMNE, v0)
 21627  				return true
 21628  			}
 21629  			break
 21630  		}
 21631  		// match: (NE (CMPconst [0] l:(XORconst [c] x)) yes no)
 21632  		// cond: l.Uses==1
 21633  		// result: (NE (TEQconst [c] x) yes no)
 21634  		for b.Controls[0].Op == OpARMCMPconst {
 21635  			v_0 := b.Controls[0]
 21636  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21637  				break
 21638  			}
 21639  			l := v_0.Args[0]
 21640  			if l.Op != OpARMXORconst {
 21641  				break
 21642  			}
 21643  			c := auxIntToInt32(l.AuxInt)
 21644  			x := l.Args[0]
 21645  			if !(l.Uses == 1) {
 21646  				break
 21647  			}
 21648  			v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
 21649  			v0.AuxInt = int32ToAuxInt(c)
 21650  			v0.AddArg(x)
 21651  			b.resetWithControl(BlockARMNE, v0)
 21652  			return true
 21653  		}
 21654  		// match: (NE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
 21655  		// cond: l.Uses==1
 21656  		// result: (NE (TEQshiftLL x y [c]) yes no)
 21657  		for b.Controls[0].Op == OpARMCMPconst {
 21658  			v_0 := b.Controls[0]
 21659  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21660  				break
 21661  			}
 21662  			l := v_0.Args[0]
 21663  			if l.Op != OpARMXORshiftLL {
 21664  				break
 21665  			}
 21666  			c := auxIntToInt32(l.AuxInt)
 21667  			y := l.Args[1]
 21668  			x := l.Args[0]
 21669  			if !(l.Uses == 1) {
 21670  				break
 21671  			}
 21672  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
 21673  			v0.AuxInt = int32ToAuxInt(c)
 21674  			v0.AddArg2(x, y)
 21675  			b.resetWithControl(BlockARMNE, v0)
 21676  			return true
 21677  		}
 21678  		// match: (NE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
 21679  		// cond: l.Uses==1
 21680  		// result: (NE (TEQshiftRL x y [c]) yes no)
 21681  		for b.Controls[0].Op == OpARMCMPconst {
 21682  			v_0 := b.Controls[0]
 21683  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21684  				break
 21685  			}
 21686  			l := v_0.Args[0]
 21687  			if l.Op != OpARMXORshiftRL {
 21688  				break
 21689  			}
 21690  			c := auxIntToInt32(l.AuxInt)
 21691  			y := l.Args[1]
 21692  			x := l.Args[0]
 21693  			if !(l.Uses == 1) {
 21694  				break
 21695  			}
 21696  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
 21697  			v0.AuxInt = int32ToAuxInt(c)
 21698  			v0.AddArg2(x, y)
 21699  			b.resetWithControl(BlockARMNE, v0)
 21700  			return true
 21701  		}
 21702  		// match: (NE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
 21703  		// cond: l.Uses==1
 21704  		// result: (NE (TEQshiftRA x y [c]) yes no)
 21705  		for b.Controls[0].Op == OpARMCMPconst {
 21706  			v_0 := b.Controls[0]
 21707  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21708  				break
 21709  			}
 21710  			l := v_0.Args[0]
 21711  			if l.Op != OpARMXORshiftRA {
 21712  				break
 21713  			}
 21714  			c := auxIntToInt32(l.AuxInt)
 21715  			y := l.Args[1]
 21716  			x := l.Args[0]
 21717  			if !(l.Uses == 1) {
 21718  				break
 21719  			}
 21720  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
 21721  			v0.AuxInt = int32ToAuxInt(c)
 21722  			v0.AddArg2(x, y)
 21723  			b.resetWithControl(BlockARMNE, v0)
 21724  			return true
 21725  		}
 21726  		// match: (NE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
 21727  		// cond: l.Uses==1
 21728  		// result: (NE (TEQshiftLLreg x y z) yes no)
 21729  		for b.Controls[0].Op == OpARMCMPconst {
 21730  			v_0 := b.Controls[0]
 21731  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21732  				break
 21733  			}
 21734  			l := v_0.Args[0]
 21735  			if l.Op != OpARMXORshiftLLreg {
 21736  				break
 21737  			}
 21738  			z := l.Args[2]
 21739  			x := l.Args[0]
 21740  			y := l.Args[1]
 21741  			if !(l.Uses == 1) {
 21742  				break
 21743  			}
 21744  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
 21745  			v0.AddArg3(x, y, z)
 21746  			b.resetWithControl(BlockARMNE, v0)
 21747  			return true
 21748  		}
 21749  		// match: (NE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
 21750  		// cond: l.Uses==1
 21751  		// result: (NE (TEQshiftRLreg x y z) yes no)
 21752  		for b.Controls[0].Op == OpARMCMPconst {
 21753  			v_0 := b.Controls[0]
 21754  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21755  				break
 21756  			}
 21757  			l := v_0.Args[0]
 21758  			if l.Op != OpARMXORshiftRLreg {
 21759  				break
 21760  			}
 21761  			z := l.Args[2]
 21762  			x := l.Args[0]
 21763  			y := l.Args[1]
 21764  			if !(l.Uses == 1) {
 21765  				break
 21766  			}
 21767  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
 21768  			v0.AddArg3(x, y, z)
 21769  			b.resetWithControl(BlockARMNE, v0)
 21770  			return true
 21771  		}
 21772  		// match: (NE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
 21773  		// cond: l.Uses==1
 21774  		// result: (NE (TEQshiftRAreg x y z) yes no)
 21775  		for b.Controls[0].Op == OpARMCMPconst {
 21776  			v_0 := b.Controls[0]
 21777  			if auxIntToInt32(v_0.AuxInt) != 0 {
 21778  				break
 21779  			}
 21780  			l := v_0.Args[0]
 21781  			if l.Op != OpARMXORshiftRAreg {
 21782  				break
 21783  			}
 21784  			z := l.Args[2]
 21785  			x := l.Args[0]
 21786  			y := l.Args[1]
 21787  			if !(l.Uses == 1) {
 21788  				break
 21789  			}
 21790  			v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
 21791  			v0.AddArg3(x, y, z)
 21792  			b.resetWithControl(BlockARMNE, v0)
 21793  			return true
 21794  		}
 21795  	case BlockARMUGE:
 21796  		// match: (UGE (FlagConstant [fc]) yes no)
 21797  		// cond: fc.uge()
 21798  		// result: (First yes no)
 21799  		for b.Controls[0].Op == OpARMFlagConstant {
 21800  			v_0 := b.Controls[0]
 21801  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21802  			if !(fc.uge()) {
 21803  				break
 21804  			}
 21805  			b.Reset(BlockFirst)
 21806  			return true
 21807  		}
 21808  		// match: (UGE (FlagConstant [fc]) yes no)
 21809  		// cond: !fc.uge()
 21810  		// result: (First no yes)
 21811  		for b.Controls[0].Op == OpARMFlagConstant {
 21812  			v_0 := b.Controls[0]
 21813  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21814  			if !(!fc.uge()) {
 21815  				break
 21816  			}
 21817  			b.Reset(BlockFirst)
 21818  			b.swapSuccessors()
 21819  			return true
 21820  		}
 21821  		// match: (UGE (InvertFlags cmp) yes no)
 21822  		// result: (ULE cmp yes no)
 21823  		for b.Controls[0].Op == OpARMInvertFlags {
 21824  			v_0 := b.Controls[0]
 21825  			cmp := v_0.Args[0]
 21826  			b.resetWithControl(BlockARMULE, cmp)
 21827  			return true
 21828  		}
 21829  	case BlockARMUGT:
 21830  		// match: (UGT (FlagConstant [fc]) yes no)
 21831  		// cond: fc.ugt()
 21832  		// result: (First yes no)
 21833  		for b.Controls[0].Op == OpARMFlagConstant {
 21834  			v_0 := b.Controls[0]
 21835  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21836  			if !(fc.ugt()) {
 21837  				break
 21838  			}
 21839  			b.Reset(BlockFirst)
 21840  			return true
 21841  		}
 21842  		// match: (UGT (FlagConstant [fc]) yes no)
 21843  		// cond: !fc.ugt()
 21844  		// result: (First no yes)
 21845  		for b.Controls[0].Op == OpARMFlagConstant {
 21846  			v_0 := b.Controls[0]
 21847  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21848  			if !(!fc.ugt()) {
 21849  				break
 21850  			}
 21851  			b.Reset(BlockFirst)
 21852  			b.swapSuccessors()
 21853  			return true
 21854  		}
 21855  		// match: (UGT (InvertFlags cmp) yes no)
 21856  		// result: (ULT cmp yes no)
 21857  		for b.Controls[0].Op == OpARMInvertFlags {
 21858  			v_0 := b.Controls[0]
 21859  			cmp := v_0.Args[0]
 21860  			b.resetWithControl(BlockARMULT, cmp)
 21861  			return true
 21862  		}
 21863  	case BlockARMULE:
 21864  		// match: (ULE (FlagConstant [fc]) yes no)
 21865  		// cond: fc.ule()
 21866  		// result: (First yes no)
 21867  		for b.Controls[0].Op == OpARMFlagConstant {
 21868  			v_0 := b.Controls[0]
 21869  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21870  			if !(fc.ule()) {
 21871  				break
 21872  			}
 21873  			b.Reset(BlockFirst)
 21874  			return true
 21875  		}
 21876  		// match: (ULE (FlagConstant [fc]) yes no)
 21877  		// cond: !fc.ule()
 21878  		// result: (First no yes)
 21879  		for b.Controls[0].Op == OpARMFlagConstant {
 21880  			v_0 := b.Controls[0]
 21881  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21882  			if !(!fc.ule()) {
 21883  				break
 21884  			}
 21885  			b.Reset(BlockFirst)
 21886  			b.swapSuccessors()
 21887  			return true
 21888  		}
 21889  		// match: (ULE (InvertFlags cmp) yes no)
 21890  		// result: (UGE cmp yes no)
 21891  		for b.Controls[0].Op == OpARMInvertFlags {
 21892  			v_0 := b.Controls[0]
 21893  			cmp := v_0.Args[0]
 21894  			b.resetWithControl(BlockARMUGE, cmp)
 21895  			return true
 21896  		}
 21897  	case BlockARMULT:
 21898  		// match: (ULT (FlagConstant [fc]) yes no)
 21899  		// cond: fc.ult()
 21900  		// result: (First yes no)
 21901  		for b.Controls[0].Op == OpARMFlagConstant {
 21902  			v_0 := b.Controls[0]
 21903  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21904  			if !(fc.ult()) {
 21905  				break
 21906  			}
 21907  			b.Reset(BlockFirst)
 21908  			return true
 21909  		}
 21910  		// match: (ULT (FlagConstant [fc]) yes no)
 21911  		// cond: !fc.ult()
 21912  		// result: (First no yes)
 21913  		for b.Controls[0].Op == OpARMFlagConstant {
 21914  			v_0 := b.Controls[0]
 21915  			fc := auxIntToFlagConstant(v_0.AuxInt)
 21916  			if !(!fc.ult()) {
 21917  				break
 21918  			}
 21919  			b.Reset(BlockFirst)
 21920  			b.swapSuccessors()
 21921  			return true
 21922  		}
 21923  		// match: (ULT (InvertFlags cmp) yes no)
 21924  		// result: (UGT cmp yes no)
 21925  		for b.Controls[0].Op == OpARMInvertFlags {
 21926  			v_0 := b.Controls[0]
 21927  			cmp := v_0.Args[0]
 21928  			b.resetWithControl(BlockARMUGT, cmp)
 21929  			return true
 21930  		}
 21931  	}
 21932  	return false
 21933  }
 21934