Home | History | Annotate | Download | only in ssa 
      1 // Code generated from gen/S390X.rules; DO NOT EDIT.
      2 // generated with: cd gen; go run *.go
      3 
      4 package ssa
      5 
      6 import "math"
      7 import "cmd/internal/obj"
      8 import "cmd/internal/objabi"
      9 import "cmd/compile/internal/types"
     10 
     11 var _ = math.MinInt8  // in case not otherwise used
     12 var _ = obj.ANOP      // in case not otherwise used
     13 var _ = objabi.GOROOT // in case not otherwise used
     14 var _ = types.TypeMem // in case not otherwise used
     15 
     16 func rewriteValueS390X(v *Value) bool {
     17 	switch v.Op {
     18 	case OpAdd16:
     19 		return rewriteValueS390X_OpAdd16_0(v)
     20 	case OpAdd32:
     21 		return rewriteValueS390X_OpAdd32_0(v)
     22 	case OpAdd32F:
     23 		return rewriteValueS390X_OpAdd32F_0(v)
     24 	case OpAdd64:
     25 		return rewriteValueS390X_OpAdd64_0(v)
     26 	case OpAdd64F:
     27 		return rewriteValueS390X_OpAdd64F_0(v)
     28 	case OpAdd8:
     29 		return rewriteValueS390X_OpAdd8_0(v)
     30 	case OpAddPtr:
     31 		return rewriteValueS390X_OpAddPtr_0(v)
     32 	case OpAddr:
     33 		return rewriteValueS390X_OpAddr_0(v)
     34 	case OpAnd16:
     35 		return rewriteValueS390X_OpAnd16_0(v)
     36 	case OpAnd32:
     37 		return rewriteValueS390X_OpAnd32_0(v)
     38 	case OpAnd64:
     39 		return rewriteValueS390X_OpAnd64_0(v)
     40 	case OpAnd8:
     41 		return rewriteValueS390X_OpAnd8_0(v)
     42 	case OpAndB:
     43 		return rewriteValueS390X_OpAndB_0(v)
     44 	case OpAtomicAdd32:
     45 		return rewriteValueS390X_OpAtomicAdd32_0(v)
     46 	case OpAtomicAdd64:
     47 		return rewriteValueS390X_OpAtomicAdd64_0(v)
     48 	case OpAtomicCompareAndSwap32:
     49 		return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
     50 	case OpAtomicCompareAndSwap64:
     51 		return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
     52 	case OpAtomicExchange32:
     53 		return rewriteValueS390X_OpAtomicExchange32_0(v)
     54 	case OpAtomicExchange64:
     55 		return rewriteValueS390X_OpAtomicExchange64_0(v)
     56 	case OpAtomicLoad32:
     57 		return rewriteValueS390X_OpAtomicLoad32_0(v)
     58 	case OpAtomicLoad64:
     59 		return rewriteValueS390X_OpAtomicLoad64_0(v)
     60 	case OpAtomicLoadPtr:
     61 		return rewriteValueS390X_OpAtomicLoadPtr_0(v)
     62 	case OpAtomicStore32:
     63 		return rewriteValueS390X_OpAtomicStore32_0(v)
     64 	case OpAtomicStore64:
     65 		return rewriteValueS390X_OpAtomicStore64_0(v)
     66 	case OpAtomicStorePtrNoWB:
     67 		return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
     68 	case OpAvg64u:
     69 		return rewriteValueS390X_OpAvg64u_0(v)
     70 	case OpBitLen64:
     71 		return rewriteValueS390X_OpBitLen64_0(v)
     72 	case OpBswap32:
     73 		return rewriteValueS390X_OpBswap32_0(v)
     74 	case OpBswap64:
     75 		return rewriteValueS390X_OpBswap64_0(v)
     76 	case OpCeil:
     77 		return rewriteValueS390X_OpCeil_0(v)
     78 	case OpClosureCall:
     79 		return rewriteValueS390X_OpClosureCall_0(v)
     80 	case OpCom16:
     81 		return rewriteValueS390X_OpCom16_0(v)
     82 	case OpCom32:
     83 		return rewriteValueS390X_OpCom32_0(v)
     84 	case OpCom64:
     85 		return rewriteValueS390X_OpCom64_0(v)
     86 	case OpCom8:
     87 		return rewriteValueS390X_OpCom8_0(v)
     88 	case OpConst16:
     89 		return rewriteValueS390X_OpConst16_0(v)
     90 	case OpConst32:
     91 		return rewriteValueS390X_OpConst32_0(v)
     92 	case OpConst32F:
     93 		return rewriteValueS390X_OpConst32F_0(v)
     94 	case OpConst64:
     95 		return rewriteValueS390X_OpConst64_0(v)
     96 	case OpConst64F:
     97 		return rewriteValueS390X_OpConst64F_0(v)
     98 	case OpConst8:
     99 		return rewriteValueS390X_OpConst8_0(v)
    100 	case OpConstBool:
    101 		return rewriteValueS390X_OpConstBool_0(v)
    102 	case OpConstNil:
    103 		return rewriteValueS390X_OpConstNil_0(v)
    104 	case OpConvert:
    105 		return rewriteValueS390X_OpConvert_0(v)
    106 	case OpCtz32:
    107 		return rewriteValueS390X_OpCtz32_0(v)
    108 	case OpCtz64:
    109 		return rewriteValueS390X_OpCtz64_0(v)
    110 	case OpCvt32Fto32:
    111 		return rewriteValueS390X_OpCvt32Fto32_0(v)
    112 	case OpCvt32Fto64:
    113 		return rewriteValueS390X_OpCvt32Fto64_0(v)
    114 	case OpCvt32Fto64F:
    115 		return rewriteValueS390X_OpCvt32Fto64F_0(v)
    116 	case OpCvt32to32F:
    117 		return rewriteValueS390X_OpCvt32to32F_0(v)
    118 	case OpCvt32to64F:
    119 		return rewriteValueS390X_OpCvt32to64F_0(v)
    120 	case OpCvt64Fto32:
    121 		return rewriteValueS390X_OpCvt64Fto32_0(v)
    122 	case OpCvt64Fto32F:
    123 		return rewriteValueS390X_OpCvt64Fto32F_0(v)
    124 	case OpCvt64Fto64:
    125 		return rewriteValueS390X_OpCvt64Fto64_0(v)
    126 	case OpCvt64to32F:
    127 		return rewriteValueS390X_OpCvt64to32F_0(v)
    128 	case OpCvt64to64F:
    129 		return rewriteValueS390X_OpCvt64to64F_0(v)
    130 	case OpDiv16:
    131 		return rewriteValueS390X_OpDiv16_0(v)
    132 	case OpDiv16u:
    133 		return rewriteValueS390X_OpDiv16u_0(v)
    134 	case OpDiv32:
    135 		return rewriteValueS390X_OpDiv32_0(v)
    136 	case OpDiv32F:
    137 		return rewriteValueS390X_OpDiv32F_0(v)
    138 	case OpDiv32u:
    139 		return rewriteValueS390X_OpDiv32u_0(v)
    140 	case OpDiv64:
    141 		return rewriteValueS390X_OpDiv64_0(v)
    142 	case OpDiv64F:
    143 		return rewriteValueS390X_OpDiv64F_0(v)
    144 	case OpDiv64u:
    145 		return rewriteValueS390X_OpDiv64u_0(v)
    146 	case OpDiv8:
    147 		return rewriteValueS390X_OpDiv8_0(v)
    148 	case OpDiv8u:
    149 		return rewriteValueS390X_OpDiv8u_0(v)
    150 	case OpEq16:
    151 		return rewriteValueS390X_OpEq16_0(v)
    152 	case OpEq32:
    153 		return rewriteValueS390X_OpEq32_0(v)
    154 	case OpEq32F:
    155 		return rewriteValueS390X_OpEq32F_0(v)
    156 	case OpEq64:
    157 		return rewriteValueS390X_OpEq64_0(v)
    158 	case OpEq64F:
    159 		return rewriteValueS390X_OpEq64F_0(v)
    160 	case OpEq8:
    161 		return rewriteValueS390X_OpEq8_0(v)
    162 	case OpEqB:
    163 		return rewriteValueS390X_OpEqB_0(v)
    164 	case OpEqPtr:
    165 		return rewriteValueS390X_OpEqPtr_0(v)
    166 	case OpFloor:
    167 		return rewriteValueS390X_OpFloor_0(v)
    168 	case OpGeq16:
    169 		return rewriteValueS390X_OpGeq16_0(v)
    170 	case OpGeq16U:
    171 		return rewriteValueS390X_OpGeq16U_0(v)
    172 	case OpGeq32:
    173 		return rewriteValueS390X_OpGeq32_0(v)
    174 	case OpGeq32F:
    175 		return rewriteValueS390X_OpGeq32F_0(v)
    176 	case OpGeq32U:
    177 		return rewriteValueS390X_OpGeq32U_0(v)
    178 	case OpGeq64:
    179 		return rewriteValueS390X_OpGeq64_0(v)
    180 	case OpGeq64F:
    181 		return rewriteValueS390X_OpGeq64F_0(v)
    182 	case OpGeq64U:
    183 		return rewriteValueS390X_OpGeq64U_0(v)
    184 	case OpGeq8:
    185 		return rewriteValueS390X_OpGeq8_0(v)
    186 	case OpGeq8U:
    187 		return rewriteValueS390X_OpGeq8U_0(v)
    188 	case OpGetCallerSP:
    189 		return rewriteValueS390X_OpGetCallerSP_0(v)
    190 	case OpGetClosurePtr:
    191 		return rewriteValueS390X_OpGetClosurePtr_0(v)
    192 	case OpGetG:
    193 		return rewriteValueS390X_OpGetG_0(v)
    194 	case OpGreater16:
    195 		return rewriteValueS390X_OpGreater16_0(v)
    196 	case OpGreater16U:
    197 		return rewriteValueS390X_OpGreater16U_0(v)
    198 	case OpGreater32:
    199 		return rewriteValueS390X_OpGreater32_0(v)
    200 	case OpGreater32F:
    201 		return rewriteValueS390X_OpGreater32F_0(v)
    202 	case OpGreater32U:
    203 		return rewriteValueS390X_OpGreater32U_0(v)
    204 	case OpGreater64:
    205 		return rewriteValueS390X_OpGreater64_0(v)
    206 	case OpGreater64F:
    207 		return rewriteValueS390X_OpGreater64F_0(v)
    208 	case OpGreater64U:
    209 		return rewriteValueS390X_OpGreater64U_0(v)
    210 	case OpGreater8:
    211 		return rewriteValueS390X_OpGreater8_0(v)
    212 	case OpGreater8U:
    213 		return rewriteValueS390X_OpGreater8U_0(v)
    214 	case OpHmul32:
    215 		return rewriteValueS390X_OpHmul32_0(v)
    216 	case OpHmul32u:
    217 		return rewriteValueS390X_OpHmul32u_0(v)
    218 	case OpHmul64:
    219 		return rewriteValueS390X_OpHmul64_0(v)
    220 	case OpHmul64u:
    221 		return rewriteValueS390X_OpHmul64u_0(v)
    222 	case OpITab:
    223 		return rewriteValueS390X_OpITab_0(v)
    224 	case OpInterCall:
    225 		return rewriteValueS390X_OpInterCall_0(v)
    226 	case OpIsInBounds:
    227 		return rewriteValueS390X_OpIsInBounds_0(v)
    228 	case OpIsNonNil:
    229 		return rewriteValueS390X_OpIsNonNil_0(v)
    230 	case OpIsSliceInBounds:
    231 		return rewriteValueS390X_OpIsSliceInBounds_0(v)
    232 	case OpLeq16:
    233 		return rewriteValueS390X_OpLeq16_0(v)
    234 	case OpLeq16U:
    235 		return rewriteValueS390X_OpLeq16U_0(v)
    236 	case OpLeq32:
    237 		return rewriteValueS390X_OpLeq32_0(v)
    238 	case OpLeq32F:
    239 		return rewriteValueS390X_OpLeq32F_0(v)
    240 	case OpLeq32U:
    241 		return rewriteValueS390X_OpLeq32U_0(v)
    242 	case OpLeq64:
    243 		return rewriteValueS390X_OpLeq64_0(v)
    244 	case OpLeq64F:
    245 		return rewriteValueS390X_OpLeq64F_0(v)
    246 	case OpLeq64U:
    247 		return rewriteValueS390X_OpLeq64U_0(v)
    248 	case OpLeq8:
    249 		return rewriteValueS390X_OpLeq8_0(v)
    250 	case OpLeq8U:
    251 		return rewriteValueS390X_OpLeq8U_0(v)
    252 	case OpLess16:
    253 		return rewriteValueS390X_OpLess16_0(v)
    254 	case OpLess16U:
    255 		return rewriteValueS390X_OpLess16U_0(v)
    256 	case OpLess32:
    257 		return rewriteValueS390X_OpLess32_0(v)
    258 	case OpLess32F:
    259 		return rewriteValueS390X_OpLess32F_0(v)
    260 	case OpLess32U:
    261 		return rewriteValueS390X_OpLess32U_0(v)
    262 	case OpLess64:
    263 		return rewriteValueS390X_OpLess64_0(v)
    264 	case OpLess64F:
    265 		return rewriteValueS390X_OpLess64F_0(v)
    266 	case OpLess64U:
    267 		return rewriteValueS390X_OpLess64U_0(v)
    268 	case OpLess8:
    269 		return rewriteValueS390X_OpLess8_0(v)
    270 	case OpLess8U:
    271 		return rewriteValueS390X_OpLess8U_0(v)
    272 	case OpLoad:
    273 		return rewriteValueS390X_OpLoad_0(v)
    274 	case OpLsh16x16:
    275 		return rewriteValueS390X_OpLsh16x16_0(v)
    276 	case OpLsh16x32:
    277 		return rewriteValueS390X_OpLsh16x32_0(v)
    278 	case OpLsh16x64:
    279 		return rewriteValueS390X_OpLsh16x64_0(v)
    280 	case OpLsh16x8:
    281 		return rewriteValueS390X_OpLsh16x8_0(v)
    282 	case OpLsh32x16:
    283 		return rewriteValueS390X_OpLsh32x16_0(v)
    284 	case OpLsh32x32:
    285 		return rewriteValueS390X_OpLsh32x32_0(v)
    286 	case OpLsh32x64:
    287 		return rewriteValueS390X_OpLsh32x64_0(v)
    288 	case OpLsh32x8:
    289 		return rewriteValueS390X_OpLsh32x8_0(v)
    290 	case OpLsh64x16:
    291 		return rewriteValueS390X_OpLsh64x16_0(v)
    292 	case OpLsh64x32:
    293 		return rewriteValueS390X_OpLsh64x32_0(v)
    294 	case OpLsh64x64:
    295 		return rewriteValueS390X_OpLsh64x64_0(v)
    296 	case OpLsh64x8:
    297 		return rewriteValueS390X_OpLsh64x8_0(v)
    298 	case OpLsh8x16:
    299 		return rewriteValueS390X_OpLsh8x16_0(v)
    300 	case OpLsh8x32:
    301 		return rewriteValueS390X_OpLsh8x32_0(v)
    302 	case OpLsh8x64:
    303 		return rewriteValueS390X_OpLsh8x64_0(v)
    304 	case OpLsh8x8:
    305 		return rewriteValueS390X_OpLsh8x8_0(v)
    306 	case OpMod16:
    307 		return rewriteValueS390X_OpMod16_0(v)
    308 	case OpMod16u:
    309 		return rewriteValueS390X_OpMod16u_0(v)
    310 	case OpMod32:
    311 		return rewriteValueS390X_OpMod32_0(v)
    312 	case OpMod32u:
    313 		return rewriteValueS390X_OpMod32u_0(v)
    314 	case OpMod64:
    315 		return rewriteValueS390X_OpMod64_0(v)
    316 	case OpMod64u:
    317 		return rewriteValueS390X_OpMod64u_0(v)
    318 	case OpMod8:
    319 		return rewriteValueS390X_OpMod8_0(v)
    320 	case OpMod8u:
    321 		return rewriteValueS390X_OpMod8u_0(v)
    322 	case OpMove:
    323 		return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
    324 	case OpMul16:
    325 		return rewriteValueS390X_OpMul16_0(v)
    326 	case OpMul32:
    327 		return rewriteValueS390X_OpMul32_0(v)
    328 	case OpMul32F:
    329 		return rewriteValueS390X_OpMul32F_0(v)
    330 	case OpMul64:
    331 		return rewriteValueS390X_OpMul64_0(v)
    332 	case OpMul64F:
    333 		return rewriteValueS390X_OpMul64F_0(v)
    334 	case OpMul8:
    335 		return rewriteValueS390X_OpMul8_0(v)
    336 	case OpNeg16:
    337 		return rewriteValueS390X_OpNeg16_0(v)
    338 	case OpNeg32:
    339 		return rewriteValueS390X_OpNeg32_0(v)
    340 	case OpNeg32F:
    341 		return rewriteValueS390X_OpNeg32F_0(v)
    342 	case OpNeg64:
    343 		return rewriteValueS390X_OpNeg64_0(v)
    344 	case OpNeg64F:
    345 		return rewriteValueS390X_OpNeg64F_0(v)
    346 	case OpNeg8:
    347 		return rewriteValueS390X_OpNeg8_0(v)
    348 	case OpNeq16:
    349 		return rewriteValueS390X_OpNeq16_0(v)
    350 	case OpNeq32:
    351 		return rewriteValueS390X_OpNeq32_0(v)
    352 	case OpNeq32F:
    353 		return rewriteValueS390X_OpNeq32F_0(v)
    354 	case OpNeq64:
    355 		return rewriteValueS390X_OpNeq64_0(v)
    356 	case OpNeq64F:
    357 		return rewriteValueS390X_OpNeq64F_0(v)
    358 	case OpNeq8:
    359 		return rewriteValueS390X_OpNeq8_0(v)
    360 	case OpNeqB:
    361 		return rewriteValueS390X_OpNeqB_0(v)
    362 	case OpNeqPtr:
    363 		return rewriteValueS390X_OpNeqPtr_0(v)
    364 	case OpNilCheck:
    365 		return rewriteValueS390X_OpNilCheck_0(v)
    366 	case OpNot:
    367 		return rewriteValueS390X_OpNot_0(v)
    368 	case OpOffPtr:
    369 		return rewriteValueS390X_OpOffPtr_0(v)
    370 	case OpOr16:
    371 		return rewriteValueS390X_OpOr16_0(v)
    372 	case OpOr32:
    373 		return rewriteValueS390X_OpOr32_0(v)
    374 	case OpOr64:
    375 		return rewriteValueS390X_OpOr64_0(v)
    376 	case OpOr8:
    377 		return rewriteValueS390X_OpOr8_0(v)
    378 	case OpOrB:
    379 		return rewriteValueS390X_OpOrB_0(v)
    380 	case OpRound:
    381 		return rewriteValueS390X_OpRound_0(v)
    382 	case OpRound32F:
    383 		return rewriteValueS390X_OpRound32F_0(v)
    384 	case OpRound64F:
    385 		return rewriteValueS390X_OpRound64F_0(v)
    386 	case OpRoundToEven:
    387 		return rewriteValueS390X_OpRoundToEven_0(v)
    388 	case OpRsh16Ux16:
    389 		return rewriteValueS390X_OpRsh16Ux16_0(v)
    390 	case OpRsh16Ux32:
    391 		return rewriteValueS390X_OpRsh16Ux32_0(v)
    392 	case OpRsh16Ux64:
    393 		return rewriteValueS390X_OpRsh16Ux64_0(v)
    394 	case OpRsh16Ux8:
    395 		return rewriteValueS390X_OpRsh16Ux8_0(v)
    396 	case OpRsh16x16:
    397 		return rewriteValueS390X_OpRsh16x16_0(v)
    398 	case OpRsh16x32:
    399 		return rewriteValueS390X_OpRsh16x32_0(v)
    400 	case OpRsh16x64:
    401 		return rewriteValueS390X_OpRsh16x64_0(v)
    402 	case OpRsh16x8:
    403 		return rewriteValueS390X_OpRsh16x8_0(v)
    404 	case OpRsh32Ux16:
    405 		return rewriteValueS390X_OpRsh32Ux16_0(v)
    406 	case OpRsh32Ux32:
    407 		return rewriteValueS390X_OpRsh32Ux32_0(v)
    408 	case OpRsh32Ux64:
    409 		return rewriteValueS390X_OpRsh32Ux64_0(v)
    410 	case OpRsh32Ux8:
    411 		return rewriteValueS390X_OpRsh32Ux8_0(v)
    412 	case OpRsh32x16:
    413 		return rewriteValueS390X_OpRsh32x16_0(v)
    414 	case OpRsh32x32:
    415 		return rewriteValueS390X_OpRsh32x32_0(v)
    416 	case OpRsh32x64:
    417 		return rewriteValueS390X_OpRsh32x64_0(v)
    418 	case OpRsh32x8:
    419 		return rewriteValueS390X_OpRsh32x8_0(v)
    420 	case OpRsh64Ux16:
    421 		return rewriteValueS390X_OpRsh64Ux16_0(v)
    422 	case OpRsh64Ux32:
    423 		return rewriteValueS390X_OpRsh64Ux32_0(v)
    424 	case OpRsh64Ux64:
    425 		return rewriteValueS390X_OpRsh64Ux64_0(v)
    426 	case OpRsh64Ux8:
    427 		return rewriteValueS390X_OpRsh64Ux8_0(v)
    428 	case OpRsh64x16:
    429 		return rewriteValueS390X_OpRsh64x16_0(v)
    430 	case OpRsh64x32:
    431 		return rewriteValueS390X_OpRsh64x32_0(v)
    432 	case OpRsh64x64:
    433 		return rewriteValueS390X_OpRsh64x64_0(v)
    434 	case OpRsh64x8:
    435 		return rewriteValueS390X_OpRsh64x8_0(v)
    436 	case OpRsh8Ux16:
    437 		return rewriteValueS390X_OpRsh8Ux16_0(v)
    438 	case OpRsh8Ux32:
    439 		return rewriteValueS390X_OpRsh8Ux32_0(v)
    440 	case OpRsh8Ux64:
    441 		return rewriteValueS390X_OpRsh8Ux64_0(v)
    442 	case OpRsh8Ux8:
    443 		return rewriteValueS390X_OpRsh8Ux8_0(v)
    444 	case OpRsh8x16:
    445 		return rewriteValueS390X_OpRsh8x16_0(v)
    446 	case OpRsh8x32:
    447 		return rewriteValueS390X_OpRsh8x32_0(v)
    448 	case OpRsh8x64:
    449 		return rewriteValueS390X_OpRsh8x64_0(v)
    450 	case OpRsh8x8:
    451 		return rewriteValueS390X_OpRsh8x8_0(v)
    452 	case OpS390XADD:
    453 		return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v)
    454 	case OpS390XADDW:
    455 		return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v)
    456 	case OpS390XADDWconst:
    457 		return rewriteValueS390X_OpS390XADDWconst_0(v)
    458 	case OpS390XADDWload:
    459 		return rewriteValueS390X_OpS390XADDWload_0(v)
    460 	case OpS390XADDconst:
    461 		return rewriteValueS390X_OpS390XADDconst_0(v)
    462 	case OpS390XADDload:
    463 		return rewriteValueS390X_OpS390XADDload_0(v)
    464 	case OpS390XAND:
    465 		return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v)
    466 	case OpS390XANDW:
    467 		return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v)
    468 	case OpS390XANDWconst:
    469 		return rewriteValueS390X_OpS390XANDWconst_0(v)
    470 	case OpS390XANDWload:
    471 		return rewriteValueS390X_OpS390XANDWload_0(v)
    472 	case OpS390XANDconst:
    473 		return rewriteValueS390X_OpS390XANDconst_0(v)
    474 	case OpS390XANDload:
    475 		return rewriteValueS390X_OpS390XANDload_0(v)
    476 	case OpS390XCMP:
    477 		return rewriteValueS390X_OpS390XCMP_0(v)
    478 	case OpS390XCMPU:
    479 		return rewriteValueS390X_OpS390XCMPU_0(v)
    480 	case OpS390XCMPUconst:
    481 		return rewriteValueS390X_OpS390XCMPUconst_0(v)
    482 	case OpS390XCMPW:
    483 		return rewriteValueS390X_OpS390XCMPW_0(v)
    484 	case OpS390XCMPWU:
    485 		return rewriteValueS390X_OpS390XCMPWU_0(v)
    486 	case OpS390XCMPWUconst:
    487 		return rewriteValueS390X_OpS390XCMPWUconst_0(v)
    488 	case OpS390XCMPWconst:
    489 		return rewriteValueS390X_OpS390XCMPWconst_0(v)
    490 	case OpS390XCMPconst:
    491 		return rewriteValueS390X_OpS390XCMPconst_0(v)
    492 	case OpS390XCPSDR:
    493 		return rewriteValueS390X_OpS390XCPSDR_0(v)
    494 	case OpS390XFADD:
    495 		return rewriteValueS390X_OpS390XFADD_0(v)
    496 	case OpS390XFADDS:
    497 		return rewriteValueS390X_OpS390XFADDS_0(v)
    498 	case OpS390XFMOVDload:
    499 		return rewriteValueS390X_OpS390XFMOVDload_0(v)
    500 	case OpS390XFMOVDloadidx:
    501 		return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
    502 	case OpS390XFMOVDstore:
    503 		return rewriteValueS390X_OpS390XFMOVDstore_0(v)
    504 	case OpS390XFMOVDstoreidx:
    505 		return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
    506 	case OpS390XFMOVSload:
    507 		return rewriteValueS390X_OpS390XFMOVSload_0(v)
    508 	case OpS390XFMOVSloadidx:
    509 		return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
    510 	case OpS390XFMOVSstore:
    511 		return rewriteValueS390X_OpS390XFMOVSstore_0(v)
    512 	case OpS390XFMOVSstoreidx:
    513 		return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
    514 	case OpS390XFNEG:
    515 		return rewriteValueS390X_OpS390XFNEG_0(v)
    516 	case OpS390XFNEGS:
    517 		return rewriteValueS390X_OpS390XFNEGS_0(v)
    518 	case OpS390XFSUB:
    519 		return rewriteValueS390X_OpS390XFSUB_0(v)
    520 	case OpS390XFSUBS:
    521 		return rewriteValueS390X_OpS390XFSUBS_0(v)
    522 	case OpS390XLDGR:
    523 		return rewriteValueS390X_OpS390XLDGR_0(v)
    524 	case OpS390XLEDBR:
    525 		return rewriteValueS390X_OpS390XLEDBR_0(v)
    526 	case OpS390XLGDR:
    527 		return rewriteValueS390X_OpS390XLGDR_0(v)
    528 	case OpS390XLoweredRound32F:
    529 		return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
    530 	case OpS390XLoweredRound64F:
    531 		return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
    532 	case OpS390XMOVBZload:
    533 		return rewriteValueS390X_OpS390XMOVBZload_0(v)
    534 	case OpS390XMOVBZloadidx:
    535 		return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
    536 	case OpS390XMOVBZreg:
    537 		return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
    538 	case OpS390XMOVBload:
    539 		return rewriteValueS390X_OpS390XMOVBload_0(v)
    540 	case OpS390XMOVBloadidx:
    541 		return rewriteValueS390X_OpS390XMOVBloadidx_0(v)
    542 	case OpS390XMOVBreg:
    543 		return rewriteValueS390X_OpS390XMOVBreg_0(v)
    544 	case OpS390XMOVBstore:
    545 		return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
    546 	case OpS390XMOVBstoreconst:
    547 		return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
    548 	case OpS390XMOVBstoreidx:
    549 		return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v)
    550 	case OpS390XMOVDEQ:
    551 		return rewriteValueS390X_OpS390XMOVDEQ_0(v)
    552 	case OpS390XMOVDGE:
    553 		return rewriteValueS390X_OpS390XMOVDGE_0(v)
    554 	case OpS390XMOVDGT:
    555 		return rewriteValueS390X_OpS390XMOVDGT_0(v)
    556 	case OpS390XMOVDLE:
    557 		return rewriteValueS390X_OpS390XMOVDLE_0(v)
    558 	case OpS390XMOVDLT:
    559 		return rewriteValueS390X_OpS390XMOVDLT_0(v)
    560 	case OpS390XMOVDNE:
    561 		return rewriteValueS390X_OpS390XMOVDNE_0(v)
    562 	case OpS390XMOVDaddridx:
    563 		return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
    564 	case OpS390XMOVDload:
    565 		return rewriteValueS390X_OpS390XMOVDload_0(v)
    566 	case OpS390XMOVDloadidx:
    567 		return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
    568 	case OpS390XMOVDnop:
    569 		return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v)
    570 	case OpS390XMOVDreg:
    571 		return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v)
    572 	case OpS390XMOVDstore:
    573 		return rewriteValueS390X_OpS390XMOVDstore_0(v)
    574 	case OpS390XMOVDstoreconst:
    575 		return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
    576 	case OpS390XMOVDstoreidx:
    577 		return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
    578 	case OpS390XMOVHBRstore:
    579 		return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
    580 	case OpS390XMOVHBRstoreidx:
    581 		return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v)
    582 	case OpS390XMOVHZload:
    583 		return rewriteValueS390X_OpS390XMOVHZload_0(v)
    584 	case OpS390XMOVHZloadidx:
    585 		return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
    586 	case OpS390XMOVHZreg:
    587 		return rewriteValueS390X_OpS390XMOVHZreg_0(v)
    588 	case OpS390XMOVHload:
    589 		return rewriteValueS390X_OpS390XMOVHload_0(v)
    590 	case OpS390XMOVHloadidx:
    591 		return rewriteValueS390X_OpS390XMOVHloadidx_0(v)
    592 	case OpS390XMOVHreg:
    593 		return rewriteValueS390X_OpS390XMOVHreg_0(v) || rewriteValueS390X_OpS390XMOVHreg_10(v)
    594 	case OpS390XMOVHstore:
    595 		return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
    596 	case OpS390XMOVHstoreconst:
    597 		return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
    598 	case OpS390XMOVHstoreidx:
    599 		return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v)
    600 	case OpS390XMOVWBRstore:
    601 		return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
    602 	case OpS390XMOVWBRstoreidx:
    603 		return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
    604 	case OpS390XMOVWZload:
    605 		return rewriteValueS390X_OpS390XMOVWZload_0(v)
    606 	case OpS390XMOVWZloadidx:
    607 		return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
    608 	case OpS390XMOVWZreg:
    609 		return rewriteValueS390X_OpS390XMOVWZreg_0(v) || rewriteValueS390X_OpS390XMOVWZreg_10(v)
    610 	case OpS390XMOVWload:
    611 		return rewriteValueS390X_OpS390XMOVWload_0(v)
    612 	case OpS390XMOVWloadidx:
    613 		return rewriteValueS390X_OpS390XMOVWloadidx_0(v)
    614 	case OpS390XMOVWreg:
    615 		return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
    616 	case OpS390XMOVWstore:
    617 		return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
    618 	case OpS390XMOVWstoreconst:
    619 		return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
    620 	case OpS390XMOVWstoreidx:
    621 		return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v)
    622 	case OpS390XMULLD:
    623 		return rewriteValueS390X_OpS390XMULLD_0(v)
    624 	case OpS390XMULLDconst:
    625 		return rewriteValueS390X_OpS390XMULLDconst_0(v)
    626 	case OpS390XMULLDload:
    627 		return rewriteValueS390X_OpS390XMULLDload_0(v)
    628 	case OpS390XMULLW:
    629 		return rewriteValueS390X_OpS390XMULLW_0(v)
    630 	case OpS390XMULLWconst:
    631 		return rewriteValueS390X_OpS390XMULLWconst_0(v)
    632 	case OpS390XMULLWload:
    633 		return rewriteValueS390X_OpS390XMULLWload_0(v)
    634 	case OpS390XNEG:
    635 		return rewriteValueS390X_OpS390XNEG_0(v)
    636 	case OpS390XNEGW:
    637 		return rewriteValueS390X_OpS390XNEGW_0(v)
    638 	case OpS390XNOT:
    639 		return rewriteValueS390X_OpS390XNOT_0(v)
    640 	case OpS390XNOTW:
    641 		return rewriteValueS390X_OpS390XNOTW_0(v)
    642 	case OpS390XOR:
    643 		return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v)
    644 	case OpS390XORW:
    645 		return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v)
    646 	case OpS390XORWconst:
    647 		return rewriteValueS390X_OpS390XORWconst_0(v)
    648 	case OpS390XORWload:
    649 		return rewriteValueS390X_OpS390XORWload_0(v)
    650 	case OpS390XORconst:
    651 		return rewriteValueS390X_OpS390XORconst_0(v)
    652 	case OpS390XORload:
    653 		return rewriteValueS390X_OpS390XORload_0(v)
    654 	case OpS390XSLD:
    655 		return rewriteValueS390X_OpS390XSLD_0(v)
    656 	case OpS390XSLW:
    657 		return rewriteValueS390X_OpS390XSLW_0(v)
    658 	case OpS390XSRAD:
    659 		return rewriteValueS390X_OpS390XSRAD_0(v)
    660 	case OpS390XSRADconst:
    661 		return rewriteValueS390X_OpS390XSRADconst_0(v)
    662 	case OpS390XSRAW:
    663 		return rewriteValueS390X_OpS390XSRAW_0(v)
    664 	case OpS390XSRAWconst:
    665 		return rewriteValueS390X_OpS390XSRAWconst_0(v)
    666 	case OpS390XSRD:
    667 		return rewriteValueS390X_OpS390XSRD_0(v)
    668 	case OpS390XSRDconst:
    669 		return rewriteValueS390X_OpS390XSRDconst_0(v)
    670 	case OpS390XSRW:
    671 		return rewriteValueS390X_OpS390XSRW_0(v)
    672 	case OpS390XSTM2:
    673 		return rewriteValueS390X_OpS390XSTM2_0(v)
    674 	case OpS390XSTMG2:
    675 		return rewriteValueS390X_OpS390XSTMG2_0(v)
    676 	case OpS390XSUB:
    677 		return rewriteValueS390X_OpS390XSUB_0(v)
    678 	case OpS390XSUBEWcarrymask:
    679 		return rewriteValueS390X_OpS390XSUBEWcarrymask_0(v)
    680 	case OpS390XSUBEcarrymask:
    681 		return rewriteValueS390X_OpS390XSUBEcarrymask_0(v)
    682 	case OpS390XSUBW:
    683 		return rewriteValueS390X_OpS390XSUBW_0(v)
    684 	case OpS390XSUBWconst:
    685 		return rewriteValueS390X_OpS390XSUBWconst_0(v)
    686 	case OpS390XSUBWload:
    687 		return rewriteValueS390X_OpS390XSUBWload_0(v)
    688 	case OpS390XSUBconst:
    689 		return rewriteValueS390X_OpS390XSUBconst_0(v)
    690 	case OpS390XSUBload:
    691 		return rewriteValueS390X_OpS390XSUBload_0(v)
    692 	case OpS390XXOR:
    693 		return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v)
    694 	case OpS390XXORW:
    695 		return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v)
    696 	case OpS390XXORWconst:
    697 		return rewriteValueS390X_OpS390XXORWconst_0(v)
    698 	case OpS390XXORWload:
    699 		return rewriteValueS390X_OpS390XXORWload_0(v)
    700 	case OpS390XXORconst:
    701 		return rewriteValueS390X_OpS390XXORconst_0(v)
    702 	case OpS390XXORload:
    703 		return rewriteValueS390X_OpS390XXORload_0(v)
    704 	case OpSelect0:
    705 		return rewriteValueS390X_OpSelect0_0(v)
    706 	case OpSelect1:
    707 		return rewriteValueS390X_OpSelect1_0(v)
    708 	case OpSignExt16to32:
    709 		return rewriteValueS390X_OpSignExt16to32_0(v)
    710 	case OpSignExt16to64:
    711 		return rewriteValueS390X_OpSignExt16to64_0(v)
    712 	case OpSignExt32to64:
    713 		return rewriteValueS390X_OpSignExt32to64_0(v)
    714 	case OpSignExt8to16:
    715 		return rewriteValueS390X_OpSignExt8to16_0(v)
    716 	case OpSignExt8to32:
    717 		return rewriteValueS390X_OpSignExt8to32_0(v)
    718 	case OpSignExt8to64:
    719 		return rewriteValueS390X_OpSignExt8to64_0(v)
    720 	case OpSlicemask:
    721 		return rewriteValueS390X_OpSlicemask_0(v)
    722 	case OpSqrt:
    723 		return rewriteValueS390X_OpSqrt_0(v)
    724 	case OpStaticCall:
    725 		return rewriteValueS390X_OpStaticCall_0(v)
    726 	case OpStore:
    727 		return rewriteValueS390X_OpStore_0(v)
    728 	case OpSub16:
    729 		return rewriteValueS390X_OpSub16_0(v)
    730 	case OpSub32:
    731 		return rewriteValueS390X_OpSub32_0(v)
    732 	case OpSub32F:
    733 		return rewriteValueS390X_OpSub32F_0(v)
    734 	case OpSub64:
    735 		return rewriteValueS390X_OpSub64_0(v)
    736 	case OpSub64F:
    737 		return rewriteValueS390X_OpSub64F_0(v)
    738 	case OpSub8:
    739 		return rewriteValueS390X_OpSub8_0(v)
    740 	case OpSubPtr:
    741 		return rewriteValueS390X_OpSubPtr_0(v)
    742 	case OpTrunc:
    743 		return rewriteValueS390X_OpTrunc_0(v)
    744 	case OpTrunc16to8:
    745 		return rewriteValueS390X_OpTrunc16to8_0(v)
    746 	case OpTrunc32to16:
    747 		return rewriteValueS390X_OpTrunc32to16_0(v)
    748 	case OpTrunc32to8:
    749 		return rewriteValueS390X_OpTrunc32to8_0(v)
    750 	case OpTrunc64to16:
    751 		return rewriteValueS390X_OpTrunc64to16_0(v)
    752 	case OpTrunc64to32:
    753 		return rewriteValueS390X_OpTrunc64to32_0(v)
    754 	case OpTrunc64to8:
    755 		return rewriteValueS390X_OpTrunc64to8_0(v)
    756 	case OpXor16:
    757 		return rewriteValueS390X_OpXor16_0(v)
    758 	case OpXor32:
    759 		return rewriteValueS390X_OpXor32_0(v)
    760 	case OpXor64:
    761 		return rewriteValueS390X_OpXor64_0(v)
    762 	case OpXor8:
    763 		return rewriteValueS390X_OpXor8_0(v)
    764 	case OpZero:
    765 		return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
    766 	case OpZeroExt16to32:
    767 		return rewriteValueS390X_OpZeroExt16to32_0(v)
    768 	case OpZeroExt16to64:
    769 		return rewriteValueS390X_OpZeroExt16to64_0(v)
    770 	case OpZeroExt32to64:
    771 		return rewriteValueS390X_OpZeroExt32to64_0(v)
    772 	case OpZeroExt8to16:
    773 		return rewriteValueS390X_OpZeroExt8to16_0(v)
    774 	case OpZeroExt8to32:
    775 		return rewriteValueS390X_OpZeroExt8to32_0(v)
    776 	case OpZeroExt8to64:
    777 		return rewriteValueS390X_OpZeroExt8to64_0(v)
    778 	}
    779 	return false
    780 }
    781 func rewriteValueS390X_OpAdd16_0(v *Value) bool {
    782 	// match: (Add16 x y)
    783 	// cond:
    784 	// result: (ADDW  x y)
    785 	for {
    786 		_ = v.Args[1]
    787 		x := v.Args[0]
    788 		y := v.Args[1]
    789 		v.reset(OpS390XADDW)
    790 		v.AddArg(x)
    791 		v.AddArg(y)
    792 		return true
    793 	}
    794 }
    795 func rewriteValueS390X_OpAdd32_0(v *Value) bool {
    796 	// match: (Add32 x y)
    797 	// cond:
    798 	// result: (ADDW  x y)
    799 	for {
    800 		_ = v.Args[1]
    801 		x := v.Args[0]
    802 		y := v.Args[1]
    803 		v.reset(OpS390XADDW)
    804 		v.AddArg(x)
    805 		v.AddArg(y)
    806 		return true
    807 	}
    808 }
    809 func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
    810 	// match: (Add32F x y)
    811 	// cond:
    812 	// result: (FADDS x y)
    813 	for {
    814 		_ = v.Args[1]
    815 		x := v.Args[0]
    816 		y := v.Args[1]
    817 		v.reset(OpS390XFADDS)
    818 		v.AddArg(x)
    819 		v.AddArg(y)
    820 		return true
    821 	}
    822 }
    823 func rewriteValueS390X_OpAdd64_0(v *Value) bool {
    824 	// match: (Add64 x y)
    825 	// cond:
    826 	// result: (ADD  x y)
    827 	for {
    828 		_ = v.Args[1]
    829 		x := v.Args[0]
    830 		y := v.Args[1]
    831 		v.reset(OpS390XADD)
    832 		v.AddArg(x)
    833 		v.AddArg(y)
    834 		return true
    835 	}
    836 }
    837 func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
    838 	// match: (Add64F x y)
    839 	// cond:
    840 	// result: (FADD x y)
    841 	for {
    842 		_ = v.Args[1]
    843 		x := v.Args[0]
    844 		y := v.Args[1]
    845 		v.reset(OpS390XFADD)
    846 		v.AddArg(x)
    847 		v.AddArg(y)
    848 		return true
    849 	}
    850 }
    851 func rewriteValueS390X_OpAdd8_0(v *Value) bool {
    852 	// match: (Add8 x y)
    853 	// cond:
    854 	// result: (ADDW  x y)
    855 	for {
    856 		_ = v.Args[1]
    857 		x := v.Args[0]
    858 		y := v.Args[1]
    859 		v.reset(OpS390XADDW)
    860 		v.AddArg(x)
    861 		v.AddArg(y)
    862 		return true
    863 	}
    864 }
    865 func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
    866 	// match: (AddPtr x y)
    867 	// cond:
    868 	// result: (ADD  x y)
    869 	for {
    870 		_ = v.Args[1]
    871 		x := v.Args[0]
    872 		y := v.Args[1]
    873 		v.reset(OpS390XADD)
    874 		v.AddArg(x)
    875 		v.AddArg(y)
    876 		return true
    877 	}
    878 }
    879 func rewriteValueS390X_OpAddr_0(v *Value) bool {
    880 	// match: (Addr {sym} base)
    881 	// cond:
    882 	// result: (MOVDaddr {sym} base)
    883 	for {
    884 		sym := v.Aux
    885 		base := v.Args[0]
    886 		v.reset(OpS390XMOVDaddr)
    887 		v.Aux = sym
    888 		v.AddArg(base)
    889 		return true
    890 	}
    891 }
    892 func rewriteValueS390X_OpAnd16_0(v *Value) bool {
    893 	// match: (And16 x y)
    894 	// cond:
    895 	// result: (ANDW x y)
    896 	for {
    897 		_ = v.Args[1]
    898 		x := v.Args[0]
    899 		y := v.Args[1]
    900 		v.reset(OpS390XANDW)
    901 		v.AddArg(x)
    902 		v.AddArg(y)
    903 		return true
    904 	}
    905 }
    906 func rewriteValueS390X_OpAnd32_0(v *Value) bool {
    907 	// match: (And32 x y)
    908 	// cond:
    909 	// result: (ANDW x y)
    910 	for {
    911 		_ = v.Args[1]
    912 		x := v.Args[0]
    913 		y := v.Args[1]
    914 		v.reset(OpS390XANDW)
    915 		v.AddArg(x)
    916 		v.AddArg(y)
    917 		return true
    918 	}
    919 }
    920 func rewriteValueS390X_OpAnd64_0(v *Value) bool {
    921 	// match: (And64 x y)
    922 	// cond:
    923 	// result: (AND x y)
    924 	for {
    925 		_ = v.Args[1]
    926 		x := v.Args[0]
    927 		y := v.Args[1]
    928 		v.reset(OpS390XAND)
    929 		v.AddArg(x)
    930 		v.AddArg(y)
    931 		return true
    932 	}
    933 }
    934 func rewriteValueS390X_OpAnd8_0(v *Value) bool {
    935 	// match: (And8 x y)
    936 	// cond:
    937 	// result: (ANDW x y)
    938 	for {
    939 		_ = v.Args[1]
    940 		x := v.Args[0]
    941 		y := v.Args[1]
    942 		v.reset(OpS390XANDW)
    943 		v.AddArg(x)
    944 		v.AddArg(y)
    945 		return true
    946 	}
    947 }
    948 func rewriteValueS390X_OpAndB_0(v *Value) bool {
    949 	// match: (AndB x y)
    950 	// cond:
    951 	// result: (ANDW x y)
    952 	for {
    953 		_ = v.Args[1]
    954 		x := v.Args[0]
    955 		y := v.Args[1]
    956 		v.reset(OpS390XANDW)
    957 		v.AddArg(x)
    958 		v.AddArg(y)
    959 		return true
    960 	}
    961 }
    962 func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
    963 	b := v.Block
    964 	_ = b
    965 	typ := &b.Func.Config.Types
    966 	_ = typ
    967 	// match: (AtomicAdd32 ptr val mem)
    968 	// cond:
    969 	// result: (AddTupleFirst32 val (LAA ptr val mem))
    970 	for {
    971 		_ = v.Args[2]
    972 		ptr := v.Args[0]
    973 		val := v.Args[1]
    974 		mem := v.Args[2]
    975 		v.reset(OpS390XAddTupleFirst32)
    976 		v.AddArg(val)
    977 		v0 := b.NewValue0(v.Pos, OpS390XLAA, types.NewTuple(typ.UInt32, types.TypeMem))
    978 		v0.AddArg(ptr)
    979 		v0.AddArg(val)
    980 		v0.AddArg(mem)
    981 		v.AddArg(v0)
    982 		return true
    983 	}
    984 }
    985 func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
    986 	b := v.Block
    987 	_ = b
    988 	typ := &b.Func.Config.Types
    989 	_ = typ
    990 	// match: (AtomicAdd64 ptr val mem)
    991 	// cond:
    992 	// result: (AddTupleFirst64 val (LAAG ptr val mem))
    993 	for {
    994 		_ = v.Args[2]
    995 		ptr := v.Args[0]
    996 		val := v.Args[1]
    997 		mem := v.Args[2]
    998 		v.reset(OpS390XAddTupleFirst64)
    999 		v.AddArg(val)
   1000 		v0 := b.NewValue0(v.Pos, OpS390XLAAG, types.NewTuple(typ.UInt64, types.TypeMem))
   1001 		v0.AddArg(ptr)
   1002 		v0.AddArg(val)
   1003 		v0.AddArg(mem)
   1004 		v.AddArg(v0)
   1005 		return true
   1006 	}
   1007 }
   1008 func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
   1009 	// match: (AtomicCompareAndSwap32 ptr old new_ mem)
   1010 	// cond:
   1011 	// result: (LoweredAtomicCas32 ptr old new_ mem)
   1012 	for {
   1013 		_ = v.Args[3]
   1014 		ptr := v.Args[0]
   1015 		old := v.Args[1]
   1016 		new_ := v.Args[2]
   1017 		mem := v.Args[3]
   1018 		v.reset(OpS390XLoweredAtomicCas32)
   1019 		v.AddArg(ptr)
   1020 		v.AddArg(old)
   1021 		v.AddArg(new_)
   1022 		v.AddArg(mem)
   1023 		return true
   1024 	}
   1025 }
   1026 func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
   1027 	// match: (AtomicCompareAndSwap64 ptr old new_ mem)
   1028 	// cond:
   1029 	// result: (LoweredAtomicCas64 ptr old new_ mem)
   1030 	for {
   1031 		_ = v.Args[3]
   1032 		ptr := v.Args[0]
   1033 		old := v.Args[1]
   1034 		new_ := v.Args[2]
   1035 		mem := v.Args[3]
   1036 		v.reset(OpS390XLoweredAtomicCas64)
   1037 		v.AddArg(ptr)
   1038 		v.AddArg(old)
   1039 		v.AddArg(new_)
   1040 		v.AddArg(mem)
   1041 		return true
   1042 	}
   1043 }
   1044 func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
   1045 	// match: (AtomicExchange32 ptr val mem)
   1046 	// cond:
   1047 	// result: (LoweredAtomicExchange32 ptr val mem)
   1048 	for {
   1049 		_ = v.Args[2]
   1050 		ptr := v.Args[0]
   1051 		val := v.Args[1]
   1052 		mem := v.Args[2]
   1053 		v.reset(OpS390XLoweredAtomicExchange32)
   1054 		v.AddArg(ptr)
   1055 		v.AddArg(val)
   1056 		v.AddArg(mem)
   1057 		return true
   1058 	}
   1059 }
   1060 func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
   1061 	// match: (AtomicExchange64 ptr val mem)
   1062 	// cond:
   1063 	// result: (LoweredAtomicExchange64 ptr val mem)
   1064 	for {
   1065 		_ = v.Args[2]
   1066 		ptr := v.Args[0]
   1067 		val := v.Args[1]
   1068 		mem := v.Args[2]
   1069 		v.reset(OpS390XLoweredAtomicExchange64)
   1070 		v.AddArg(ptr)
   1071 		v.AddArg(val)
   1072 		v.AddArg(mem)
   1073 		return true
   1074 	}
   1075 }
   1076 func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
   1077 	// match: (AtomicLoad32 ptr mem)
   1078 	// cond:
   1079 	// result: (MOVWZatomicload ptr mem)
   1080 	for {
   1081 		_ = v.Args[1]
   1082 		ptr := v.Args[0]
   1083 		mem := v.Args[1]
   1084 		v.reset(OpS390XMOVWZatomicload)
   1085 		v.AddArg(ptr)
   1086 		v.AddArg(mem)
   1087 		return true
   1088 	}
   1089 }
   1090 func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
   1091 	// match: (AtomicLoad64 ptr mem)
   1092 	// cond:
   1093 	// result: (MOVDatomicload ptr mem)
   1094 	for {
   1095 		_ = v.Args[1]
   1096 		ptr := v.Args[0]
   1097 		mem := v.Args[1]
   1098 		v.reset(OpS390XMOVDatomicload)
   1099 		v.AddArg(ptr)
   1100 		v.AddArg(mem)
   1101 		return true
   1102 	}
   1103 }
   1104 func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
   1105 	// match: (AtomicLoadPtr ptr mem)
   1106 	// cond:
   1107 	// result: (MOVDatomicload ptr mem)
   1108 	for {
   1109 		_ = v.Args[1]
   1110 		ptr := v.Args[0]
   1111 		mem := v.Args[1]
   1112 		v.reset(OpS390XMOVDatomicload)
   1113 		v.AddArg(ptr)
   1114 		v.AddArg(mem)
   1115 		return true
   1116 	}
   1117 }
   1118 func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
   1119 	// match: (AtomicStore32 ptr val mem)
   1120 	// cond:
   1121 	// result: (MOVWatomicstore ptr val mem)
   1122 	for {
   1123 		_ = v.Args[2]
   1124 		ptr := v.Args[0]
   1125 		val := v.Args[1]
   1126 		mem := v.Args[2]
   1127 		v.reset(OpS390XMOVWatomicstore)
   1128 		v.AddArg(ptr)
   1129 		v.AddArg(val)
   1130 		v.AddArg(mem)
   1131 		return true
   1132 	}
   1133 }
   1134 func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
   1135 	// match: (AtomicStore64 ptr val mem)
   1136 	// cond:
   1137 	// result: (MOVDatomicstore ptr val mem)
   1138 	for {
   1139 		_ = v.Args[2]
   1140 		ptr := v.Args[0]
   1141 		val := v.Args[1]
   1142 		mem := v.Args[2]
   1143 		v.reset(OpS390XMOVDatomicstore)
   1144 		v.AddArg(ptr)
   1145 		v.AddArg(val)
   1146 		v.AddArg(mem)
   1147 		return true
   1148 	}
   1149 }
   1150 func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
   1151 	// match: (AtomicStorePtrNoWB ptr val mem)
   1152 	// cond:
   1153 	// result: (MOVDatomicstore ptr val mem)
   1154 	for {
   1155 		_ = v.Args[2]
   1156 		ptr := v.Args[0]
   1157 		val := v.Args[1]
   1158 		mem := v.Args[2]
   1159 		v.reset(OpS390XMOVDatomicstore)
   1160 		v.AddArg(ptr)
   1161 		v.AddArg(val)
   1162 		v.AddArg(mem)
   1163 		return true
   1164 	}
   1165 }
   1166 func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
   1167 	b := v.Block
   1168 	_ = b
   1169 	// match: (Avg64u <t> x y)
   1170 	// cond:
   1171 	// result: (ADD (SRDconst <t> (SUB <t> x y) [1]) y)
   1172 	for {
   1173 		t := v.Type
   1174 		_ = v.Args[1]
   1175 		x := v.Args[0]
   1176 		y := v.Args[1]
   1177 		v.reset(OpS390XADD)
   1178 		v0 := b.NewValue0(v.Pos, OpS390XSRDconst, t)
   1179 		v0.AuxInt = 1
   1180 		v1 := b.NewValue0(v.Pos, OpS390XSUB, t)
   1181 		v1.AddArg(x)
   1182 		v1.AddArg(y)
   1183 		v0.AddArg(v1)
   1184 		v.AddArg(v0)
   1185 		v.AddArg(y)
   1186 		return true
   1187 	}
   1188 }
   1189 func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
   1190 	b := v.Block
   1191 	_ = b
   1192 	typ := &b.Func.Config.Types
   1193 	_ = typ
   1194 	// match: (BitLen64 x)
   1195 	// cond:
   1196 	// result: (SUB (MOVDconst [64]) (FLOGR x))
   1197 	for {
   1198 		x := v.Args[0]
   1199 		v.reset(OpS390XSUB)
   1200 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1201 		v0.AuxInt = 64
   1202 		v.AddArg(v0)
   1203 		v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
   1204 		v1.AddArg(x)
   1205 		v.AddArg(v1)
   1206 		return true
   1207 	}
   1208 }
   1209 func rewriteValueS390X_OpBswap32_0(v *Value) bool {
   1210 	// match: (Bswap32 x)
   1211 	// cond:
   1212 	// result: (MOVWBR x)
   1213 	for {
   1214 		x := v.Args[0]
   1215 		v.reset(OpS390XMOVWBR)
   1216 		v.AddArg(x)
   1217 		return true
   1218 	}
   1219 }
   1220 func rewriteValueS390X_OpBswap64_0(v *Value) bool {
   1221 	// match: (Bswap64 x)
   1222 	// cond:
   1223 	// result: (MOVDBR x)
   1224 	for {
   1225 		x := v.Args[0]
   1226 		v.reset(OpS390XMOVDBR)
   1227 		v.AddArg(x)
   1228 		return true
   1229 	}
   1230 }
   1231 func rewriteValueS390X_OpCeil_0(v *Value) bool {
   1232 	// match: (Ceil x)
   1233 	// cond:
   1234 	// result: (FIDBR [6] x)
   1235 	for {
   1236 		x := v.Args[0]
   1237 		v.reset(OpS390XFIDBR)
   1238 		v.AuxInt = 6
   1239 		v.AddArg(x)
   1240 		return true
   1241 	}
   1242 }
   1243 func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
   1244 	// match: (ClosureCall [argwid] entry closure mem)
   1245 	// cond:
   1246 	// result: (CALLclosure [argwid] entry closure mem)
   1247 	for {
   1248 		argwid := v.AuxInt
   1249 		_ = v.Args[2]
   1250 		entry := v.Args[0]
   1251 		closure := v.Args[1]
   1252 		mem := v.Args[2]
   1253 		v.reset(OpS390XCALLclosure)
   1254 		v.AuxInt = argwid
   1255 		v.AddArg(entry)
   1256 		v.AddArg(closure)
   1257 		v.AddArg(mem)
   1258 		return true
   1259 	}
   1260 }
   1261 func rewriteValueS390X_OpCom16_0(v *Value) bool {
   1262 	// match: (Com16 x)
   1263 	// cond:
   1264 	// result: (NOTW x)
   1265 	for {
   1266 		x := v.Args[0]
   1267 		v.reset(OpS390XNOTW)
   1268 		v.AddArg(x)
   1269 		return true
   1270 	}
   1271 }
   1272 func rewriteValueS390X_OpCom32_0(v *Value) bool {
   1273 	// match: (Com32 x)
   1274 	// cond:
   1275 	// result: (NOTW x)
   1276 	for {
   1277 		x := v.Args[0]
   1278 		v.reset(OpS390XNOTW)
   1279 		v.AddArg(x)
   1280 		return true
   1281 	}
   1282 }
   1283 func rewriteValueS390X_OpCom64_0(v *Value) bool {
   1284 	// match: (Com64 x)
   1285 	// cond:
   1286 	// result: (NOT x)
   1287 	for {
   1288 		x := v.Args[0]
   1289 		v.reset(OpS390XNOT)
   1290 		v.AddArg(x)
   1291 		return true
   1292 	}
   1293 }
   1294 func rewriteValueS390X_OpCom8_0(v *Value) bool {
   1295 	// match: (Com8 x)
   1296 	// cond:
   1297 	// result: (NOTW x)
   1298 	for {
   1299 		x := v.Args[0]
   1300 		v.reset(OpS390XNOTW)
   1301 		v.AddArg(x)
   1302 		return true
   1303 	}
   1304 }
   1305 func rewriteValueS390X_OpConst16_0(v *Value) bool {
   1306 	// match: (Const16 [val])
   1307 	// cond:
   1308 	// result: (MOVDconst [val])
   1309 	for {
   1310 		val := v.AuxInt
   1311 		v.reset(OpS390XMOVDconst)
   1312 		v.AuxInt = val
   1313 		return true
   1314 	}
   1315 }
   1316 func rewriteValueS390X_OpConst32_0(v *Value) bool {
   1317 	// match: (Const32 [val])
   1318 	// cond:
   1319 	// result: (MOVDconst [val])
   1320 	for {
   1321 		val := v.AuxInt
   1322 		v.reset(OpS390XMOVDconst)
   1323 		v.AuxInt = val
   1324 		return true
   1325 	}
   1326 }
   1327 func rewriteValueS390X_OpConst32F_0(v *Value) bool {
   1328 	// match: (Const32F [val])
   1329 	// cond:
   1330 	// result: (FMOVSconst [val])
   1331 	for {
   1332 		val := v.AuxInt
   1333 		v.reset(OpS390XFMOVSconst)
   1334 		v.AuxInt = val
   1335 		return true
   1336 	}
   1337 }
   1338 func rewriteValueS390X_OpConst64_0(v *Value) bool {
   1339 	// match: (Const64 [val])
   1340 	// cond:
   1341 	// result: (MOVDconst [val])
   1342 	for {
   1343 		val := v.AuxInt
   1344 		v.reset(OpS390XMOVDconst)
   1345 		v.AuxInt = val
   1346 		return true
   1347 	}
   1348 }
   1349 func rewriteValueS390X_OpConst64F_0(v *Value) bool {
   1350 	// match: (Const64F [val])
   1351 	// cond:
   1352 	// result: (FMOVDconst [val])
   1353 	for {
   1354 		val := v.AuxInt
   1355 		v.reset(OpS390XFMOVDconst)
   1356 		v.AuxInt = val
   1357 		return true
   1358 	}
   1359 }
   1360 func rewriteValueS390X_OpConst8_0(v *Value) bool {
   1361 	// match: (Const8 [val])
   1362 	// cond:
   1363 	// result: (MOVDconst [val])
   1364 	for {
   1365 		val := v.AuxInt
   1366 		v.reset(OpS390XMOVDconst)
   1367 		v.AuxInt = val
   1368 		return true
   1369 	}
   1370 }
   1371 func rewriteValueS390X_OpConstBool_0(v *Value) bool {
   1372 	// match: (ConstBool [b])
   1373 	// cond:
   1374 	// result: (MOVDconst [b])
   1375 	for {
   1376 		b := v.AuxInt
   1377 		v.reset(OpS390XMOVDconst)
   1378 		v.AuxInt = b
   1379 		return true
   1380 	}
   1381 }
   1382 func rewriteValueS390X_OpConstNil_0(v *Value) bool {
   1383 	// match: (ConstNil)
   1384 	// cond:
   1385 	// result: (MOVDconst [0])
   1386 	for {
   1387 		v.reset(OpS390XMOVDconst)
   1388 		v.AuxInt = 0
   1389 		return true
   1390 	}
   1391 }
   1392 func rewriteValueS390X_OpConvert_0(v *Value) bool {
   1393 	// match: (Convert <t> x mem)
   1394 	// cond:
   1395 	// result: (MOVDconvert <t> x mem)
   1396 	for {
   1397 		t := v.Type
   1398 		_ = v.Args[1]
   1399 		x := v.Args[0]
   1400 		mem := v.Args[1]
   1401 		v.reset(OpS390XMOVDconvert)
   1402 		v.Type = t
   1403 		v.AddArg(x)
   1404 		v.AddArg(mem)
   1405 		return true
   1406 	}
   1407 }
   1408 func rewriteValueS390X_OpCtz32_0(v *Value) bool {
   1409 	b := v.Block
   1410 	_ = b
   1411 	typ := &b.Func.Config.Types
   1412 	_ = typ
   1413 	// match: (Ctz32 <t> x)
   1414 	// cond:
   1415 	// result: (SUB (MOVDconst [64]) (FLOGR (MOVWZreg (ANDW <t> (SUBWconst <t> [1] x) (NOTW <t> x)))))
   1416 	for {
   1417 		t := v.Type
   1418 		x := v.Args[0]
   1419 		v.reset(OpS390XSUB)
   1420 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1421 		v0.AuxInt = 64
   1422 		v.AddArg(v0)
   1423 		v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
   1424 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   1425 		v3 := b.NewValue0(v.Pos, OpS390XANDW, t)
   1426 		v4 := b.NewValue0(v.Pos, OpS390XSUBWconst, t)
   1427 		v4.AuxInt = 1
   1428 		v4.AddArg(x)
   1429 		v3.AddArg(v4)
   1430 		v5 := b.NewValue0(v.Pos, OpS390XNOTW, t)
   1431 		v5.AddArg(x)
   1432 		v3.AddArg(v5)
   1433 		v2.AddArg(v3)
   1434 		v1.AddArg(v2)
   1435 		v.AddArg(v1)
   1436 		return true
   1437 	}
   1438 }
   1439 func rewriteValueS390X_OpCtz64_0(v *Value) bool {
   1440 	b := v.Block
   1441 	_ = b
   1442 	typ := &b.Func.Config.Types
   1443 	_ = typ
   1444 	// match: (Ctz64 <t> x)
   1445 	// cond:
   1446 	// result: (SUB (MOVDconst [64]) (FLOGR (AND <t> (SUBconst <t> [1] x) (NOT <t> x))))
   1447 	for {
   1448 		t := v.Type
   1449 		x := v.Args[0]
   1450 		v.reset(OpS390XSUB)
   1451 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1452 		v0.AuxInt = 64
   1453 		v.AddArg(v0)
   1454 		v1 := b.NewValue0(v.Pos, OpS390XFLOGR, typ.UInt64)
   1455 		v2 := b.NewValue0(v.Pos, OpS390XAND, t)
   1456 		v3 := b.NewValue0(v.Pos, OpS390XSUBconst, t)
   1457 		v3.AuxInt = 1
   1458 		v3.AddArg(x)
   1459 		v2.AddArg(v3)
   1460 		v4 := b.NewValue0(v.Pos, OpS390XNOT, t)
   1461 		v4.AddArg(x)
   1462 		v2.AddArg(v4)
   1463 		v1.AddArg(v2)
   1464 		v.AddArg(v1)
   1465 		return true
   1466 	}
   1467 }
   1468 func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
   1469 	// match: (Cvt32Fto32 x)
   1470 	// cond:
   1471 	// result: (CFEBRA x)
   1472 	for {
   1473 		x := v.Args[0]
   1474 		v.reset(OpS390XCFEBRA)
   1475 		v.AddArg(x)
   1476 		return true
   1477 	}
   1478 }
   1479 func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
   1480 	// match: (Cvt32Fto64 x)
   1481 	// cond:
   1482 	// result: (CGEBRA x)
   1483 	for {
   1484 		x := v.Args[0]
   1485 		v.reset(OpS390XCGEBRA)
   1486 		v.AddArg(x)
   1487 		return true
   1488 	}
   1489 }
   1490 func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
   1491 	// match: (Cvt32Fto64F x)
   1492 	// cond:
   1493 	// result: (LDEBR x)
   1494 	for {
   1495 		x := v.Args[0]
   1496 		v.reset(OpS390XLDEBR)
   1497 		v.AddArg(x)
   1498 		return true
   1499 	}
   1500 }
   1501 func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
   1502 	// match: (Cvt32to32F x)
   1503 	// cond:
   1504 	// result: (CEFBRA x)
   1505 	for {
   1506 		x := v.Args[0]
   1507 		v.reset(OpS390XCEFBRA)
   1508 		v.AddArg(x)
   1509 		return true
   1510 	}
   1511 }
   1512 func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
   1513 	// match: (Cvt32to64F x)
   1514 	// cond:
   1515 	// result: (CDFBRA x)
   1516 	for {
   1517 		x := v.Args[0]
   1518 		v.reset(OpS390XCDFBRA)
   1519 		v.AddArg(x)
   1520 		return true
   1521 	}
   1522 }
   1523 func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
   1524 	// match: (Cvt64Fto32 x)
   1525 	// cond:
   1526 	// result: (CFDBRA x)
   1527 	for {
   1528 		x := v.Args[0]
   1529 		v.reset(OpS390XCFDBRA)
   1530 		v.AddArg(x)
   1531 		return true
   1532 	}
   1533 }
   1534 func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
   1535 	// match: (Cvt64Fto32F x)
   1536 	// cond:
   1537 	// result: (LEDBR x)
   1538 	for {
   1539 		x := v.Args[0]
   1540 		v.reset(OpS390XLEDBR)
   1541 		v.AddArg(x)
   1542 		return true
   1543 	}
   1544 }
   1545 func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
   1546 	// match: (Cvt64Fto64 x)
   1547 	// cond:
   1548 	// result: (CGDBRA x)
   1549 	for {
   1550 		x := v.Args[0]
   1551 		v.reset(OpS390XCGDBRA)
   1552 		v.AddArg(x)
   1553 		return true
   1554 	}
   1555 }
   1556 func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
   1557 	// match: (Cvt64to32F x)
   1558 	// cond:
   1559 	// result: (CEGBRA x)
   1560 	for {
   1561 		x := v.Args[0]
   1562 		v.reset(OpS390XCEGBRA)
   1563 		v.AddArg(x)
   1564 		return true
   1565 	}
   1566 }
   1567 func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
   1568 	// match: (Cvt64to64F x)
   1569 	// cond:
   1570 	// result: (CDGBRA x)
   1571 	for {
   1572 		x := v.Args[0]
   1573 		v.reset(OpS390XCDGBRA)
   1574 		v.AddArg(x)
   1575 		return true
   1576 	}
   1577 }
   1578 func rewriteValueS390X_OpDiv16_0(v *Value) bool {
   1579 	b := v.Block
   1580 	_ = b
   1581 	typ := &b.Func.Config.Types
   1582 	_ = typ
   1583 	// match: (Div16 x y)
   1584 	// cond:
   1585 	// result: (DIVW  (MOVHreg x) (MOVHreg y))
   1586 	for {
   1587 		_ = v.Args[1]
   1588 		x := v.Args[0]
   1589 		y := v.Args[1]
   1590 		v.reset(OpS390XDIVW)
   1591 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   1592 		v0.AddArg(x)
   1593 		v.AddArg(v0)
   1594 		v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   1595 		v1.AddArg(y)
   1596 		v.AddArg(v1)
   1597 		return true
   1598 	}
   1599 }
   1600 func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
   1601 	b := v.Block
   1602 	_ = b
   1603 	typ := &b.Func.Config.Types
   1604 	_ = typ
   1605 	// match: (Div16u x y)
   1606 	// cond:
   1607 	// result: (DIVWU (MOVHZreg x) (MOVHZreg y))
   1608 	for {
   1609 		_ = v.Args[1]
   1610 		x := v.Args[0]
   1611 		y := v.Args[1]
   1612 		v.reset(OpS390XDIVWU)
   1613 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   1614 		v0.AddArg(x)
   1615 		v.AddArg(v0)
   1616 		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   1617 		v1.AddArg(y)
   1618 		v.AddArg(v1)
   1619 		return true
   1620 	}
   1621 }
   1622 func rewriteValueS390X_OpDiv32_0(v *Value) bool {
   1623 	b := v.Block
   1624 	_ = b
   1625 	typ := &b.Func.Config.Types
   1626 	_ = typ
   1627 	// match: (Div32 x y)
   1628 	// cond:
   1629 	// result: (DIVW  (MOVWreg x) y)
   1630 	for {
   1631 		_ = v.Args[1]
   1632 		x := v.Args[0]
   1633 		y := v.Args[1]
   1634 		v.reset(OpS390XDIVW)
   1635 		v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
   1636 		v0.AddArg(x)
   1637 		v.AddArg(v0)
   1638 		v.AddArg(y)
   1639 		return true
   1640 	}
   1641 }
   1642 func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
   1643 	// match: (Div32F x y)
   1644 	// cond:
   1645 	// result: (FDIVS x y)
   1646 	for {
   1647 		_ = v.Args[1]
   1648 		x := v.Args[0]
   1649 		y := v.Args[1]
   1650 		v.reset(OpS390XFDIVS)
   1651 		v.AddArg(x)
   1652 		v.AddArg(y)
   1653 		return true
   1654 	}
   1655 }
   1656 func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
   1657 	b := v.Block
   1658 	_ = b
   1659 	typ := &b.Func.Config.Types
   1660 	_ = typ
   1661 	// match: (Div32u x y)
   1662 	// cond:
   1663 	// result: (DIVWU (MOVWZreg x) y)
   1664 	for {
   1665 		_ = v.Args[1]
   1666 		x := v.Args[0]
   1667 		y := v.Args[1]
   1668 		v.reset(OpS390XDIVWU)
   1669 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   1670 		v0.AddArg(x)
   1671 		v.AddArg(v0)
   1672 		v.AddArg(y)
   1673 		return true
   1674 	}
   1675 }
   1676 func rewriteValueS390X_OpDiv64_0(v *Value) bool {
   1677 	// match: (Div64 x y)
   1678 	// cond:
   1679 	// result: (DIVD  x y)
   1680 	for {
   1681 		_ = v.Args[1]
   1682 		x := v.Args[0]
   1683 		y := v.Args[1]
   1684 		v.reset(OpS390XDIVD)
   1685 		v.AddArg(x)
   1686 		v.AddArg(y)
   1687 		return true
   1688 	}
   1689 }
   1690 func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
   1691 	// match: (Div64F x y)
   1692 	// cond:
   1693 	// result: (FDIV x y)
   1694 	for {
   1695 		_ = v.Args[1]
   1696 		x := v.Args[0]
   1697 		y := v.Args[1]
   1698 		v.reset(OpS390XFDIV)
   1699 		v.AddArg(x)
   1700 		v.AddArg(y)
   1701 		return true
   1702 	}
   1703 }
   1704 func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
   1705 	// match: (Div64u x y)
   1706 	// cond:
   1707 	// result: (DIVDU x y)
   1708 	for {
   1709 		_ = v.Args[1]
   1710 		x := v.Args[0]
   1711 		y := v.Args[1]
   1712 		v.reset(OpS390XDIVDU)
   1713 		v.AddArg(x)
   1714 		v.AddArg(y)
   1715 		return true
   1716 	}
   1717 }
   1718 func rewriteValueS390X_OpDiv8_0(v *Value) bool {
   1719 	b := v.Block
   1720 	_ = b
   1721 	typ := &b.Func.Config.Types
   1722 	_ = typ
   1723 	// match: (Div8 x y)
   1724 	// cond:
   1725 	// result: (DIVW  (MOVBreg x) (MOVBreg y))
   1726 	for {
   1727 		_ = v.Args[1]
   1728 		x := v.Args[0]
   1729 		y := v.Args[1]
   1730 		v.reset(OpS390XDIVW)
   1731 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   1732 		v0.AddArg(x)
   1733 		v.AddArg(v0)
   1734 		v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   1735 		v1.AddArg(y)
   1736 		v.AddArg(v1)
   1737 		return true
   1738 	}
   1739 }
   1740 func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
   1741 	b := v.Block
   1742 	_ = b
   1743 	typ := &b.Func.Config.Types
   1744 	_ = typ
   1745 	// match: (Div8u x y)
   1746 	// cond:
   1747 	// result: (DIVWU (MOVBZreg x) (MOVBZreg y))
   1748 	for {
   1749 		_ = v.Args[1]
   1750 		x := v.Args[0]
   1751 		y := v.Args[1]
   1752 		v.reset(OpS390XDIVWU)
   1753 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   1754 		v0.AddArg(x)
   1755 		v.AddArg(v0)
   1756 		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   1757 		v1.AddArg(y)
   1758 		v.AddArg(v1)
   1759 		return true
   1760 	}
   1761 }
   1762 func rewriteValueS390X_OpEq16_0(v *Value) bool {
   1763 	b := v.Block
   1764 	_ = b
   1765 	typ := &b.Func.Config.Types
   1766 	_ = typ
   1767 	// match: (Eq16 x y)
   1768 	// cond:
   1769 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
   1770 	for {
   1771 		_ = v.Args[1]
   1772 		x := v.Args[0]
   1773 		y := v.Args[1]
   1774 		v.reset(OpS390XMOVDEQ)
   1775 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1776 		v0.AuxInt = 0
   1777 		v.AddArg(v0)
   1778 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1779 		v1.AuxInt = 1
   1780 		v.AddArg(v1)
   1781 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   1782 		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   1783 		v3.AddArg(x)
   1784 		v2.AddArg(v3)
   1785 		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   1786 		v4.AddArg(y)
   1787 		v2.AddArg(v4)
   1788 		v.AddArg(v2)
   1789 		return true
   1790 	}
   1791 }
   1792 func rewriteValueS390X_OpEq32_0(v *Value) bool {
   1793 	b := v.Block
   1794 	_ = b
   1795 	typ := &b.Func.Config.Types
   1796 	_ = typ
   1797 	// match: (Eq32 x y)
   1798 	// cond:
   1799 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
   1800 	for {
   1801 		_ = v.Args[1]
   1802 		x := v.Args[0]
   1803 		y := v.Args[1]
   1804 		v.reset(OpS390XMOVDEQ)
   1805 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1806 		v0.AuxInt = 0
   1807 		v.AddArg(v0)
   1808 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1809 		v1.AuxInt = 1
   1810 		v.AddArg(v1)
   1811 		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
   1812 		v2.AddArg(x)
   1813 		v2.AddArg(y)
   1814 		v.AddArg(v2)
   1815 		return true
   1816 	}
   1817 }
   1818 func rewriteValueS390X_OpEq32F_0(v *Value) bool {
   1819 	b := v.Block
   1820 	_ = b
   1821 	typ := &b.Func.Config.Types
   1822 	_ = typ
   1823 	// match: (Eq32F x y)
   1824 	// cond:
   1825 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
   1826 	for {
   1827 		_ = v.Args[1]
   1828 		x := v.Args[0]
   1829 		y := v.Args[1]
   1830 		v.reset(OpS390XMOVDEQ)
   1831 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1832 		v0.AuxInt = 0
   1833 		v.AddArg(v0)
   1834 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1835 		v1.AuxInt = 1
   1836 		v.AddArg(v1)
   1837 		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
   1838 		v2.AddArg(x)
   1839 		v2.AddArg(y)
   1840 		v.AddArg(v2)
   1841 		return true
   1842 	}
   1843 }
   1844 func rewriteValueS390X_OpEq64_0(v *Value) bool {
   1845 	b := v.Block
   1846 	_ = b
   1847 	typ := &b.Func.Config.Types
   1848 	_ = typ
   1849 	// match: (Eq64 x y)
   1850 	// cond:
   1851 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   1852 	for {
   1853 		_ = v.Args[1]
   1854 		x := v.Args[0]
   1855 		y := v.Args[1]
   1856 		v.reset(OpS390XMOVDEQ)
   1857 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1858 		v0.AuxInt = 0
   1859 		v.AddArg(v0)
   1860 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1861 		v1.AuxInt = 1
   1862 		v.AddArg(v1)
   1863 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   1864 		v2.AddArg(x)
   1865 		v2.AddArg(y)
   1866 		v.AddArg(v2)
   1867 		return true
   1868 	}
   1869 }
   1870 func rewriteValueS390X_OpEq64F_0(v *Value) bool {
   1871 	b := v.Block
   1872 	_ = b
   1873 	typ := &b.Func.Config.Types
   1874 	_ = typ
   1875 	// match: (Eq64F x y)
   1876 	// cond:
   1877 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
   1878 	for {
   1879 		_ = v.Args[1]
   1880 		x := v.Args[0]
   1881 		y := v.Args[1]
   1882 		v.reset(OpS390XMOVDEQ)
   1883 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1884 		v0.AuxInt = 0
   1885 		v.AddArg(v0)
   1886 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1887 		v1.AuxInt = 1
   1888 		v.AddArg(v1)
   1889 		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
   1890 		v2.AddArg(x)
   1891 		v2.AddArg(y)
   1892 		v.AddArg(v2)
   1893 		return true
   1894 	}
   1895 }
   1896 func rewriteValueS390X_OpEq8_0(v *Value) bool {
   1897 	b := v.Block
   1898 	_ = b
   1899 	typ := &b.Func.Config.Types
   1900 	_ = typ
   1901 	// match: (Eq8 x y)
   1902 	// cond:
   1903 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   1904 	for {
   1905 		_ = v.Args[1]
   1906 		x := v.Args[0]
   1907 		y := v.Args[1]
   1908 		v.reset(OpS390XMOVDEQ)
   1909 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1910 		v0.AuxInt = 0
   1911 		v.AddArg(v0)
   1912 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1913 		v1.AuxInt = 1
   1914 		v.AddArg(v1)
   1915 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   1916 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   1917 		v3.AddArg(x)
   1918 		v2.AddArg(v3)
   1919 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   1920 		v4.AddArg(y)
   1921 		v2.AddArg(v4)
   1922 		v.AddArg(v2)
   1923 		return true
   1924 	}
   1925 }
   1926 func rewriteValueS390X_OpEqB_0(v *Value) bool {
   1927 	b := v.Block
   1928 	_ = b
   1929 	typ := &b.Func.Config.Types
   1930 	_ = typ
   1931 	// match: (EqB x y)
   1932 	// cond:
   1933 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   1934 	for {
   1935 		_ = v.Args[1]
   1936 		x := v.Args[0]
   1937 		y := v.Args[1]
   1938 		v.reset(OpS390XMOVDEQ)
   1939 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1940 		v0.AuxInt = 0
   1941 		v.AddArg(v0)
   1942 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1943 		v1.AuxInt = 1
   1944 		v.AddArg(v1)
   1945 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   1946 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   1947 		v3.AddArg(x)
   1948 		v2.AddArg(v3)
   1949 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   1950 		v4.AddArg(y)
   1951 		v2.AddArg(v4)
   1952 		v.AddArg(v2)
   1953 		return true
   1954 	}
   1955 }
   1956 func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
   1957 	b := v.Block
   1958 	_ = b
   1959 	typ := &b.Func.Config.Types
   1960 	_ = typ
   1961 	// match: (EqPtr x y)
   1962 	// cond:
   1963 	// result: (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   1964 	for {
   1965 		_ = v.Args[1]
   1966 		x := v.Args[0]
   1967 		y := v.Args[1]
   1968 		v.reset(OpS390XMOVDEQ)
   1969 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1970 		v0.AuxInt = 0
   1971 		v.AddArg(v0)
   1972 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   1973 		v1.AuxInt = 1
   1974 		v.AddArg(v1)
   1975 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   1976 		v2.AddArg(x)
   1977 		v2.AddArg(y)
   1978 		v.AddArg(v2)
   1979 		return true
   1980 	}
   1981 }
   1982 func rewriteValueS390X_OpFloor_0(v *Value) bool {
   1983 	// match: (Floor x)
   1984 	// cond:
   1985 	// result: (FIDBR [7] x)
   1986 	for {
   1987 		x := v.Args[0]
   1988 		v.reset(OpS390XFIDBR)
   1989 		v.AuxInt = 7
   1990 		v.AddArg(x)
   1991 		return true
   1992 	}
   1993 }
   1994 func rewriteValueS390X_OpGeq16_0(v *Value) bool {
   1995 	b := v.Block
   1996 	_ = b
   1997 	typ := &b.Func.Config.Types
   1998 	_ = typ
   1999 	// match: (Geq16 x y)
   2000 	// cond:
   2001 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
   2002 	for {
   2003 		_ = v.Args[1]
   2004 		x := v.Args[0]
   2005 		y := v.Args[1]
   2006 		v.reset(OpS390XMOVDGE)
   2007 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2008 		v0.AuxInt = 0
   2009 		v.AddArg(v0)
   2010 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2011 		v1.AuxInt = 1
   2012 		v.AddArg(v1)
   2013 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2014 		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   2015 		v3.AddArg(x)
   2016 		v2.AddArg(v3)
   2017 		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   2018 		v4.AddArg(y)
   2019 		v2.AddArg(v4)
   2020 		v.AddArg(v2)
   2021 		return true
   2022 	}
   2023 }
   2024 func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
   2025 	b := v.Block
   2026 	_ = b
   2027 	typ := &b.Func.Config.Types
   2028 	_ = typ
   2029 	// match: (Geq16U x y)
   2030 	// cond:
   2031 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
   2032 	for {
   2033 		_ = v.Args[1]
   2034 		x := v.Args[0]
   2035 		y := v.Args[1]
   2036 		v.reset(OpS390XMOVDGE)
   2037 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2038 		v0.AuxInt = 0
   2039 		v.AddArg(v0)
   2040 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2041 		v1.AuxInt = 1
   2042 		v.AddArg(v1)
   2043 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2044 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   2045 		v3.AddArg(x)
   2046 		v2.AddArg(v3)
   2047 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   2048 		v4.AddArg(y)
   2049 		v2.AddArg(v4)
   2050 		v.AddArg(v2)
   2051 		return true
   2052 	}
   2053 }
   2054 func rewriteValueS390X_OpGeq32_0(v *Value) bool {
   2055 	b := v.Block
   2056 	_ = b
   2057 	typ := &b.Func.Config.Types
   2058 	_ = typ
   2059 	// match: (Geq32 x y)
   2060 	// cond:
   2061 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
   2062 	for {
   2063 		_ = v.Args[1]
   2064 		x := v.Args[0]
   2065 		y := v.Args[1]
   2066 		v.reset(OpS390XMOVDGE)
   2067 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2068 		v0.AuxInt = 0
   2069 		v.AddArg(v0)
   2070 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2071 		v1.AuxInt = 1
   2072 		v.AddArg(v1)
   2073 		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
   2074 		v2.AddArg(x)
   2075 		v2.AddArg(y)
   2076 		v.AddArg(v2)
   2077 		return true
   2078 	}
   2079 }
   2080 func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
   2081 	b := v.Block
   2082 	_ = b
   2083 	typ := &b.Func.Config.Types
   2084 	_ = typ
   2085 	// match: (Geq32F x y)
   2086 	// cond:
   2087 	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
   2088 	for {
   2089 		_ = v.Args[1]
   2090 		x := v.Args[0]
   2091 		y := v.Args[1]
   2092 		v.reset(OpS390XMOVDGEnoinv)
   2093 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2094 		v0.AuxInt = 0
   2095 		v.AddArg(v0)
   2096 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2097 		v1.AuxInt = 1
   2098 		v.AddArg(v1)
   2099 		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
   2100 		v2.AddArg(x)
   2101 		v2.AddArg(y)
   2102 		v.AddArg(v2)
   2103 		return true
   2104 	}
   2105 }
   2106 func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
   2107 	b := v.Block
   2108 	_ = b
   2109 	typ := &b.Func.Config.Types
   2110 	_ = typ
   2111 	// match: (Geq32U x y)
   2112 	// cond:
   2113 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
   2114 	for {
   2115 		_ = v.Args[1]
   2116 		x := v.Args[0]
   2117 		y := v.Args[1]
   2118 		v.reset(OpS390XMOVDGE)
   2119 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2120 		v0.AuxInt = 0
   2121 		v.AddArg(v0)
   2122 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2123 		v1.AuxInt = 1
   2124 		v.AddArg(v1)
   2125 		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
   2126 		v2.AddArg(x)
   2127 		v2.AddArg(y)
   2128 		v.AddArg(v2)
   2129 		return true
   2130 	}
   2131 }
   2132 func rewriteValueS390X_OpGeq64_0(v *Value) bool {
   2133 	b := v.Block
   2134 	_ = b
   2135 	typ := &b.Func.Config.Types
   2136 	_ = typ
   2137 	// match: (Geq64 x y)
   2138 	// cond:
   2139 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   2140 	for {
   2141 		_ = v.Args[1]
   2142 		x := v.Args[0]
   2143 		y := v.Args[1]
   2144 		v.reset(OpS390XMOVDGE)
   2145 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2146 		v0.AuxInt = 0
   2147 		v.AddArg(v0)
   2148 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2149 		v1.AuxInt = 1
   2150 		v.AddArg(v1)
   2151 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2152 		v2.AddArg(x)
   2153 		v2.AddArg(y)
   2154 		v.AddArg(v2)
   2155 		return true
   2156 	}
   2157 }
   2158 func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
   2159 	b := v.Block
   2160 	_ = b
   2161 	typ := &b.Func.Config.Types
   2162 	_ = typ
   2163 	// match: (Geq64F x y)
   2164 	// cond:
   2165 	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
   2166 	for {
   2167 		_ = v.Args[1]
   2168 		x := v.Args[0]
   2169 		y := v.Args[1]
   2170 		v.reset(OpS390XMOVDGEnoinv)
   2171 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2172 		v0.AuxInt = 0
   2173 		v.AddArg(v0)
   2174 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2175 		v1.AuxInt = 1
   2176 		v.AddArg(v1)
   2177 		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
   2178 		v2.AddArg(x)
   2179 		v2.AddArg(y)
   2180 		v.AddArg(v2)
   2181 		return true
   2182 	}
   2183 }
   2184 func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
   2185 	b := v.Block
   2186 	_ = b
   2187 	typ := &b.Func.Config.Types
   2188 	_ = typ
   2189 	// match: (Geq64U x y)
   2190 	// cond:
   2191 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
   2192 	for {
   2193 		_ = v.Args[1]
   2194 		x := v.Args[0]
   2195 		y := v.Args[1]
   2196 		v.reset(OpS390XMOVDGE)
   2197 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2198 		v0.AuxInt = 0
   2199 		v.AddArg(v0)
   2200 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2201 		v1.AuxInt = 1
   2202 		v.AddArg(v1)
   2203 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2204 		v2.AddArg(x)
   2205 		v2.AddArg(y)
   2206 		v.AddArg(v2)
   2207 		return true
   2208 	}
   2209 }
   2210 func rewriteValueS390X_OpGeq8_0(v *Value) bool {
   2211 	b := v.Block
   2212 	_ = b
   2213 	typ := &b.Func.Config.Types
   2214 	_ = typ
   2215 	// match: (Geq8 x y)
   2216 	// cond:
   2217 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   2218 	for {
   2219 		_ = v.Args[1]
   2220 		x := v.Args[0]
   2221 		y := v.Args[1]
   2222 		v.reset(OpS390XMOVDGE)
   2223 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2224 		v0.AuxInt = 0
   2225 		v.AddArg(v0)
   2226 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2227 		v1.AuxInt = 1
   2228 		v.AddArg(v1)
   2229 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2230 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   2231 		v3.AddArg(x)
   2232 		v2.AddArg(v3)
   2233 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   2234 		v4.AddArg(y)
   2235 		v2.AddArg(v4)
   2236 		v.AddArg(v2)
   2237 		return true
   2238 	}
   2239 }
   2240 func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
   2241 	b := v.Block
   2242 	_ = b
   2243 	typ := &b.Func.Config.Types
   2244 	_ = typ
   2245 	// match: (Geq8U x y)
   2246 	// cond:
   2247 	// result: (MOVDGE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
   2248 	for {
   2249 		_ = v.Args[1]
   2250 		x := v.Args[0]
   2251 		y := v.Args[1]
   2252 		v.reset(OpS390XMOVDGE)
   2253 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2254 		v0.AuxInt = 0
   2255 		v.AddArg(v0)
   2256 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2257 		v1.AuxInt = 1
   2258 		v.AddArg(v1)
   2259 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2260 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   2261 		v3.AddArg(x)
   2262 		v2.AddArg(v3)
   2263 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   2264 		v4.AddArg(y)
   2265 		v2.AddArg(v4)
   2266 		v.AddArg(v2)
   2267 		return true
   2268 	}
   2269 }
   2270 func rewriteValueS390X_OpGetCallerSP_0(v *Value) bool {
   2271 	// match: (GetCallerSP)
   2272 	// cond:
   2273 	// result: (LoweredGetCallerSP)
   2274 	for {
   2275 		v.reset(OpS390XLoweredGetCallerSP)
   2276 		return true
   2277 	}
   2278 }
   2279 func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
   2280 	// match: (GetClosurePtr)
   2281 	// cond:
   2282 	// result: (LoweredGetClosurePtr)
   2283 	for {
   2284 		v.reset(OpS390XLoweredGetClosurePtr)
   2285 		return true
   2286 	}
   2287 }
   2288 func rewriteValueS390X_OpGetG_0(v *Value) bool {
   2289 	// match: (GetG mem)
   2290 	// cond:
   2291 	// result: (LoweredGetG mem)
   2292 	for {
   2293 		mem := v.Args[0]
   2294 		v.reset(OpS390XLoweredGetG)
   2295 		v.AddArg(mem)
   2296 		return true
   2297 	}
   2298 }
   2299 func rewriteValueS390X_OpGreater16_0(v *Value) bool {
   2300 	b := v.Block
   2301 	_ = b
   2302 	typ := &b.Func.Config.Types
   2303 	_ = typ
   2304 	// match: (Greater16 x y)
   2305 	// cond:
   2306 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
   2307 	for {
   2308 		_ = v.Args[1]
   2309 		x := v.Args[0]
   2310 		y := v.Args[1]
   2311 		v.reset(OpS390XMOVDGT)
   2312 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2313 		v0.AuxInt = 0
   2314 		v.AddArg(v0)
   2315 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2316 		v1.AuxInt = 1
   2317 		v.AddArg(v1)
   2318 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2319 		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   2320 		v3.AddArg(x)
   2321 		v2.AddArg(v3)
   2322 		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   2323 		v4.AddArg(y)
   2324 		v2.AddArg(v4)
   2325 		v.AddArg(v2)
   2326 		return true
   2327 	}
   2328 }
   2329 func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
   2330 	b := v.Block
   2331 	_ = b
   2332 	typ := &b.Func.Config.Types
   2333 	_ = typ
   2334 	// match: (Greater16U x y)
   2335 	// cond:
   2336 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
   2337 	for {
   2338 		_ = v.Args[1]
   2339 		x := v.Args[0]
   2340 		y := v.Args[1]
   2341 		v.reset(OpS390XMOVDGT)
   2342 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2343 		v0.AuxInt = 0
   2344 		v.AddArg(v0)
   2345 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2346 		v1.AuxInt = 1
   2347 		v.AddArg(v1)
   2348 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2349 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   2350 		v3.AddArg(x)
   2351 		v2.AddArg(v3)
   2352 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   2353 		v4.AddArg(y)
   2354 		v2.AddArg(v4)
   2355 		v.AddArg(v2)
   2356 		return true
   2357 	}
   2358 }
   2359 func rewriteValueS390X_OpGreater32_0(v *Value) bool {
   2360 	b := v.Block
   2361 	_ = b
   2362 	typ := &b.Func.Config.Types
   2363 	_ = typ
   2364 	// match: (Greater32 x y)
   2365 	// cond:
   2366 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
   2367 	for {
   2368 		_ = v.Args[1]
   2369 		x := v.Args[0]
   2370 		y := v.Args[1]
   2371 		v.reset(OpS390XMOVDGT)
   2372 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2373 		v0.AuxInt = 0
   2374 		v.AddArg(v0)
   2375 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2376 		v1.AuxInt = 1
   2377 		v.AddArg(v1)
   2378 		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
   2379 		v2.AddArg(x)
   2380 		v2.AddArg(y)
   2381 		v.AddArg(v2)
   2382 		return true
   2383 	}
   2384 }
   2385 func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
   2386 	b := v.Block
   2387 	_ = b
   2388 	typ := &b.Func.Config.Types
   2389 	_ = typ
   2390 	// match: (Greater32F x y)
   2391 	// cond:
   2392 	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
   2393 	for {
   2394 		_ = v.Args[1]
   2395 		x := v.Args[0]
   2396 		y := v.Args[1]
   2397 		v.reset(OpS390XMOVDGTnoinv)
   2398 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2399 		v0.AuxInt = 0
   2400 		v.AddArg(v0)
   2401 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2402 		v1.AuxInt = 1
   2403 		v.AddArg(v1)
   2404 		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
   2405 		v2.AddArg(x)
   2406 		v2.AddArg(y)
   2407 		v.AddArg(v2)
   2408 		return true
   2409 	}
   2410 }
   2411 func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
   2412 	b := v.Block
   2413 	_ = b
   2414 	typ := &b.Func.Config.Types
   2415 	_ = typ
   2416 	// match: (Greater32U x y)
   2417 	// cond:
   2418 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
   2419 	for {
   2420 		_ = v.Args[1]
   2421 		x := v.Args[0]
   2422 		y := v.Args[1]
   2423 		v.reset(OpS390XMOVDGT)
   2424 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2425 		v0.AuxInt = 0
   2426 		v.AddArg(v0)
   2427 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2428 		v1.AuxInt = 1
   2429 		v.AddArg(v1)
   2430 		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
   2431 		v2.AddArg(x)
   2432 		v2.AddArg(y)
   2433 		v.AddArg(v2)
   2434 		return true
   2435 	}
   2436 }
   2437 func rewriteValueS390X_OpGreater64_0(v *Value) bool {
   2438 	b := v.Block
   2439 	_ = b
   2440 	typ := &b.Func.Config.Types
   2441 	_ = typ
   2442 	// match: (Greater64 x y)
   2443 	// cond:
   2444 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   2445 	for {
   2446 		_ = v.Args[1]
   2447 		x := v.Args[0]
   2448 		y := v.Args[1]
   2449 		v.reset(OpS390XMOVDGT)
   2450 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2451 		v0.AuxInt = 0
   2452 		v.AddArg(v0)
   2453 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2454 		v1.AuxInt = 1
   2455 		v.AddArg(v1)
   2456 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2457 		v2.AddArg(x)
   2458 		v2.AddArg(y)
   2459 		v.AddArg(v2)
   2460 		return true
   2461 	}
   2462 }
   2463 func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
   2464 	b := v.Block
   2465 	_ = b
   2466 	typ := &b.Func.Config.Types
   2467 	_ = typ
   2468 	// match: (Greater64F x y)
   2469 	// cond:
   2470 	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
   2471 	for {
   2472 		_ = v.Args[1]
   2473 		x := v.Args[0]
   2474 		y := v.Args[1]
   2475 		v.reset(OpS390XMOVDGTnoinv)
   2476 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2477 		v0.AuxInt = 0
   2478 		v.AddArg(v0)
   2479 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2480 		v1.AuxInt = 1
   2481 		v.AddArg(v1)
   2482 		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
   2483 		v2.AddArg(x)
   2484 		v2.AddArg(y)
   2485 		v.AddArg(v2)
   2486 		return true
   2487 	}
   2488 }
   2489 func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
   2490 	b := v.Block
   2491 	_ = b
   2492 	typ := &b.Func.Config.Types
   2493 	_ = typ
   2494 	// match: (Greater64U x y)
   2495 	// cond:
   2496 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
   2497 	for {
   2498 		_ = v.Args[1]
   2499 		x := v.Args[0]
   2500 		y := v.Args[1]
   2501 		v.reset(OpS390XMOVDGT)
   2502 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2503 		v0.AuxInt = 0
   2504 		v.AddArg(v0)
   2505 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2506 		v1.AuxInt = 1
   2507 		v.AddArg(v1)
   2508 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2509 		v2.AddArg(x)
   2510 		v2.AddArg(y)
   2511 		v.AddArg(v2)
   2512 		return true
   2513 	}
   2514 }
   2515 func rewriteValueS390X_OpGreater8_0(v *Value) bool {
   2516 	b := v.Block
   2517 	_ = b
   2518 	typ := &b.Func.Config.Types
   2519 	_ = typ
   2520 	// match: (Greater8 x y)
   2521 	// cond:
   2522 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   2523 	for {
   2524 		_ = v.Args[1]
   2525 		x := v.Args[0]
   2526 		y := v.Args[1]
   2527 		v.reset(OpS390XMOVDGT)
   2528 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2529 		v0.AuxInt = 0
   2530 		v.AddArg(v0)
   2531 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2532 		v1.AuxInt = 1
   2533 		v.AddArg(v1)
   2534 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2535 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   2536 		v3.AddArg(x)
   2537 		v2.AddArg(v3)
   2538 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   2539 		v4.AddArg(y)
   2540 		v2.AddArg(v4)
   2541 		v.AddArg(v2)
   2542 		return true
   2543 	}
   2544 }
   2545 func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
   2546 	b := v.Block
   2547 	_ = b
   2548 	typ := &b.Func.Config.Types
   2549 	_ = typ
   2550 	// match: (Greater8U x y)
   2551 	// cond:
   2552 	// result: (MOVDGT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
   2553 	for {
   2554 		_ = v.Args[1]
   2555 		x := v.Args[0]
   2556 		y := v.Args[1]
   2557 		v.reset(OpS390XMOVDGT)
   2558 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2559 		v0.AuxInt = 0
   2560 		v.AddArg(v0)
   2561 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2562 		v1.AuxInt = 1
   2563 		v.AddArg(v1)
   2564 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2565 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   2566 		v3.AddArg(x)
   2567 		v2.AddArg(v3)
   2568 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   2569 		v4.AddArg(y)
   2570 		v2.AddArg(v4)
   2571 		v.AddArg(v2)
   2572 		return true
   2573 	}
   2574 }
   2575 func rewriteValueS390X_OpHmul32_0(v *Value) bool {
   2576 	b := v.Block
   2577 	_ = b
   2578 	typ := &b.Func.Config.Types
   2579 	_ = typ
   2580 	// match: (Hmul32 x y)
   2581 	// cond:
   2582 	// result: (SRDconst [32] (MULLD (MOVWreg x) (MOVWreg y)))
   2583 	for {
   2584 		_ = v.Args[1]
   2585 		x := v.Args[0]
   2586 		y := v.Args[1]
   2587 		v.reset(OpS390XSRDconst)
   2588 		v.AuxInt = 32
   2589 		v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
   2590 		v1 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
   2591 		v1.AddArg(x)
   2592 		v0.AddArg(v1)
   2593 		v2 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
   2594 		v2.AddArg(y)
   2595 		v0.AddArg(v2)
   2596 		v.AddArg(v0)
   2597 		return true
   2598 	}
   2599 }
   2600 func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
   2601 	b := v.Block
   2602 	_ = b
   2603 	typ := &b.Func.Config.Types
   2604 	_ = typ
   2605 	// match: (Hmul32u x y)
   2606 	// cond:
   2607 	// result: (SRDconst [32] (MULLD (MOVWZreg x) (MOVWZreg y)))
   2608 	for {
   2609 		_ = v.Args[1]
   2610 		x := v.Args[0]
   2611 		y := v.Args[1]
   2612 		v.reset(OpS390XSRDconst)
   2613 		v.AuxInt = 32
   2614 		v0 := b.NewValue0(v.Pos, OpS390XMULLD, typ.Int64)
   2615 		v1 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   2616 		v1.AddArg(x)
   2617 		v0.AddArg(v1)
   2618 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   2619 		v2.AddArg(y)
   2620 		v0.AddArg(v2)
   2621 		v.AddArg(v0)
   2622 		return true
   2623 	}
   2624 }
   2625 func rewriteValueS390X_OpHmul64_0(v *Value) bool {
   2626 	// match: (Hmul64 x y)
   2627 	// cond:
   2628 	// result: (MULHD  x y)
   2629 	for {
   2630 		_ = v.Args[1]
   2631 		x := v.Args[0]
   2632 		y := v.Args[1]
   2633 		v.reset(OpS390XMULHD)
   2634 		v.AddArg(x)
   2635 		v.AddArg(y)
   2636 		return true
   2637 	}
   2638 }
   2639 func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
   2640 	// match: (Hmul64u x y)
   2641 	// cond:
   2642 	// result: (MULHDU x y)
   2643 	for {
   2644 		_ = v.Args[1]
   2645 		x := v.Args[0]
   2646 		y := v.Args[1]
   2647 		v.reset(OpS390XMULHDU)
   2648 		v.AddArg(x)
   2649 		v.AddArg(y)
   2650 		return true
   2651 	}
   2652 }
   2653 func rewriteValueS390X_OpITab_0(v *Value) bool {
   2654 	// match: (ITab (Load ptr mem))
   2655 	// cond:
   2656 	// result: (MOVDload ptr mem)
   2657 	for {
   2658 		v_0 := v.Args[0]
   2659 		if v_0.Op != OpLoad {
   2660 			break
   2661 		}
   2662 		_ = v_0.Args[1]
   2663 		ptr := v_0.Args[0]
   2664 		mem := v_0.Args[1]
   2665 		v.reset(OpS390XMOVDload)
   2666 		v.AddArg(ptr)
   2667 		v.AddArg(mem)
   2668 		return true
   2669 	}
   2670 	return false
   2671 }
   2672 func rewriteValueS390X_OpInterCall_0(v *Value) bool {
   2673 	// match: (InterCall [argwid] entry mem)
   2674 	// cond:
   2675 	// result: (CALLinter [argwid] entry mem)
   2676 	for {
   2677 		argwid := v.AuxInt
   2678 		_ = v.Args[1]
   2679 		entry := v.Args[0]
   2680 		mem := v.Args[1]
   2681 		v.reset(OpS390XCALLinter)
   2682 		v.AuxInt = argwid
   2683 		v.AddArg(entry)
   2684 		v.AddArg(mem)
   2685 		return true
   2686 	}
   2687 }
   2688 func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
   2689 	b := v.Block
   2690 	_ = b
   2691 	typ := &b.Func.Config.Types
   2692 	_ = typ
   2693 	// match: (IsInBounds idx len)
   2694 	// cond:
   2695 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
   2696 	for {
   2697 		_ = v.Args[1]
   2698 		idx := v.Args[0]
   2699 		len := v.Args[1]
   2700 		v.reset(OpS390XMOVDLT)
   2701 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2702 		v0.AuxInt = 0
   2703 		v.AddArg(v0)
   2704 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2705 		v1.AuxInt = 1
   2706 		v.AddArg(v1)
   2707 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2708 		v2.AddArg(idx)
   2709 		v2.AddArg(len)
   2710 		v.AddArg(v2)
   2711 		return true
   2712 	}
   2713 }
   2714 func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
   2715 	b := v.Block
   2716 	_ = b
   2717 	typ := &b.Func.Config.Types
   2718 	_ = typ
   2719 	// match: (IsNonNil p)
   2720 	// cond:
   2721 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPconst p [0]))
   2722 	for {
   2723 		p := v.Args[0]
   2724 		v.reset(OpS390XMOVDNE)
   2725 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2726 		v0.AuxInt = 0
   2727 		v.AddArg(v0)
   2728 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2729 		v1.AuxInt = 1
   2730 		v.AddArg(v1)
   2731 		v2 := b.NewValue0(v.Pos, OpS390XCMPconst, types.TypeFlags)
   2732 		v2.AuxInt = 0
   2733 		v2.AddArg(p)
   2734 		v.AddArg(v2)
   2735 		return true
   2736 	}
   2737 }
   2738 func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
   2739 	b := v.Block
   2740 	_ = b
   2741 	typ := &b.Func.Config.Types
   2742 	_ = typ
   2743 	// match: (IsSliceInBounds idx len)
   2744 	// cond:
   2745 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU idx len))
   2746 	for {
   2747 		_ = v.Args[1]
   2748 		idx := v.Args[0]
   2749 		len := v.Args[1]
   2750 		v.reset(OpS390XMOVDLE)
   2751 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2752 		v0.AuxInt = 0
   2753 		v.AddArg(v0)
   2754 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2755 		v1.AuxInt = 1
   2756 		v.AddArg(v1)
   2757 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2758 		v2.AddArg(idx)
   2759 		v2.AddArg(len)
   2760 		v.AddArg(v2)
   2761 		return true
   2762 	}
   2763 }
   2764 func rewriteValueS390X_OpLeq16_0(v *Value) bool {
   2765 	b := v.Block
   2766 	_ = b
   2767 	typ := &b.Func.Config.Types
   2768 	_ = typ
   2769 	// match: (Leq16 x y)
   2770 	// cond:
   2771 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
   2772 	for {
   2773 		_ = v.Args[1]
   2774 		x := v.Args[0]
   2775 		y := v.Args[1]
   2776 		v.reset(OpS390XMOVDLE)
   2777 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2778 		v0.AuxInt = 0
   2779 		v.AddArg(v0)
   2780 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2781 		v1.AuxInt = 1
   2782 		v.AddArg(v1)
   2783 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2784 		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   2785 		v3.AddArg(x)
   2786 		v2.AddArg(v3)
   2787 		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   2788 		v4.AddArg(y)
   2789 		v2.AddArg(v4)
   2790 		v.AddArg(v2)
   2791 		return true
   2792 	}
   2793 }
   2794 func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
   2795 	b := v.Block
   2796 	_ = b
   2797 	typ := &b.Func.Config.Types
   2798 	_ = typ
   2799 	// match: (Leq16U x y)
   2800 	// cond:
   2801 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
   2802 	for {
   2803 		_ = v.Args[1]
   2804 		x := v.Args[0]
   2805 		y := v.Args[1]
   2806 		v.reset(OpS390XMOVDLE)
   2807 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2808 		v0.AuxInt = 0
   2809 		v.AddArg(v0)
   2810 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2811 		v1.AuxInt = 1
   2812 		v.AddArg(v1)
   2813 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2814 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   2815 		v3.AddArg(x)
   2816 		v2.AddArg(v3)
   2817 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   2818 		v4.AddArg(y)
   2819 		v2.AddArg(v4)
   2820 		v.AddArg(v2)
   2821 		return true
   2822 	}
   2823 }
   2824 func rewriteValueS390X_OpLeq32_0(v *Value) bool {
   2825 	b := v.Block
   2826 	_ = b
   2827 	typ := &b.Func.Config.Types
   2828 	_ = typ
   2829 	// match: (Leq32 x y)
   2830 	// cond:
   2831 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
   2832 	for {
   2833 		_ = v.Args[1]
   2834 		x := v.Args[0]
   2835 		y := v.Args[1]
   2836 		v.reset(OpS390XMOVDLE)
   2837 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2838 		v0.AuxInt = 0
   2839 		v.AddArg(v0)
   2840 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2841 		v1.AuxInt = 1
   2842 		v.AddArg(v1)
   2843 		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
   2844 		v2.AddArg(x)
   2845 		v2.AddArg(y)
   2846 		v.AddArg(v2)
   2847 		return true
   2848 	}
   2849 }
   2850 func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
   2851 	b := v.Block
   2852 	_ = b
   2853 	typ := &b.Func.Config.Types
   2854 	_ = typ
   2855 	// match: (Leq32F x y)
   2856 	// cond:
   2857 	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
   2858 	for {
   2859 		_ = v.Args[1]
   2860 		x := v.Args[0]
   2861 		y := v.Args[1]
   2862 		v.reset(OpS390XMOVDGEnoinv)
   2863 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2864 		v0.AuxInt = 0
   2865 		v.AddArg(v0)
   2866 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2867 		v1.AuxInt = 1
   2868 		v.AddArg(v1)
   2869 		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
   2870 		v2.AddArg(y)
   2871 		v2.AddArg(x)
   2872 		v.AddArg(v2)
   2873 		return true
   2874 	}
   2875 }
   2876 func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
   2877 	b := v.Block
   2878 	_ = b
   2879 	typ := &b.Func.Config.Types
   2880 	_ = typ
   2881 	// match: (Leq32U x y)
   2882 	// cond:
   2883 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
   2884 	for {
   2885 		_ = v.Args[1]
   2886 		x := v.Args[0]
   2887 		y := v.Args[1]
   2888 		v.reset(OpS390XMOVDLE)
   2889 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2890 		v0.AuxInt = 0
   2891 		v.AddArg(v0)
   2892 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2893 		v1.AuxInt = 1
   2894 		v.AddArg(v1)
   2895 		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
   2896 		v2.AddArg(x)
   2897 		v2.AddArg(y)
   2898 		v.AddArg(v2)
   2899 		return true
   2900 	}
   2901 }
   2902 func rewriteValueS390X_OpLeq64_0(v *Value) bool {
   2903 	b := v.Block
   2904 	_ = b
   2905 	typ := &b.Func.Config.Types
   2906 	_ = typ
   2907 	// match: (Leq64 x y)
   2908 	// cond:
   2909 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   2910 	for {
   2911 		_ = v.Args[1]
   2912 		x := v.Args[0]
   2913 		y := v.Args[1]
   2914 		v.reset(OpS390XMOVDLE)
   2915 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2916 		v0.AuxInt = 0
   2917 		v.AddArg(v0)
   2918 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2919 		v1.AuxInt = 1
   2920 		v.AddArg(v1)
   2921 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   2922 		v2.AddArg(x)
   2923 		v2.AddArg(y)
   2924 		v.AddArg(v2)
   2925 		return true
   2926 	}
   2927 }
   2928 func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
   2929 	b := v.Block
   2930 	_ = b
   2931 	typ := &b.Func.Config.Types
   2932 	_ = typ
   2933 	// match: (Leq64F x y)
   2934 	// cond:
   2935 	// result: (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
   2936 	for {
   2937 		_ = v.Args[1]
   2938 		x := v.Args[0]
   2939 		y := v.Args[1]
   2940 		v.reset(OpS390XMOVDGEnoinv)
   2941 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2942 		v0.AuxInt = 0
   2943 		v.AddArg(v0)
   2944 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2945 		v1.AuxInt = 1
   2946 		v.AddArg(v1)
   2947 		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
   2948 		v2.AddArg(y)
   2949 		v2.AddArg(x)
   2950 		v.AddArg(v2)
   2951 		return true
   2952 	}
   2953 }
   2954 func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
   2955 	b := v.Block
   2956 	_ = b
   2957 	typ := &b.Func.Config.Types
   2958 	_ = typ
   2959 	// match: (Leq64U x y)
   2960 	// cond:
   2961 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
   2962 	for {
   2963 		_ = v.Args[1]
   2964 		x := v.Args[0]
   2965 		y := v.Args[1]
   2966 		v.reset(OpS390XMOVDLE)
   2967 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2968 		v0.AuxInt = 0
   2969 		v.AddArg(v0)
   2970 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2971 		v1.AuxInt = 1
   2972 		v.AddArg(v1)
   2973 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   2974 		v2.AddArg(x)
   2975 		v2.AddArg(y)
   2976 		v.AddArg(v2)
   2977 		return true
   2978 	}
   2979 }
   2980 func rewriteValueS390X_OpLeq8_0(v *Value) bool {
   2981 	b := v.Block
   2982 	_ = b
   2983 	typ := &b.Func.Config.Types
   2984 	_ = typ
   2985 	// match: (Leq8 x y)
   2986 	// cond:
   2987 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   2988 	for {
   2989 		_ = v.Args[1]
   2990 		x := v.Args[0]
   2991 		y := v.Args[1]
   2992 		v.reset(OpS390XMOVDLE)
   2993 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2994 		v0.AuxInt = 0
   2995 		v.AddArg(v0)
   2996 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   2997 		v1.AuxInt = 1
   2998 		v.AddArg(v1)
   2999 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   3000 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   3001 		v3.AddArg(x)
   3002 		v2.AddArg(v3)
   3003 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   3004 		v4.AddArg(y)
   3005 		v2.AddArg(v4)
   3006 		v.AddArg(v2)
   3007 		return true
   3008 	}
   3009 }
   3010 func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
   3011 	b := v.Block
   3012 	_ = b
   3013 	typ := &b.Func.Config.Types
   3014 	_ = typ
   3015 	// match: (Leq8U x y)
   3016 	// cond:
   3017 	// result: (MOVDLE (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
   3018 	for {
   3019 		_ = v.Args[1]
   3020 		x := v.Args[0]
   3021 		y := v.Args[1]
   3022 		v.reset(OpS390XMOVDLE)
   3023 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3024 		v0.AuxInt = 0
   3025 		v.AddArg(v0)
   3026 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3027 		v1.AuxInt = 1
   3028 		v.AddArg(v1)
   3029 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   3030 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3031 		v3.AddArg(x)
   3032 		v2.AddArg(v3)
   3033 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3034 		v4.AddArg(y)
   3035 		v2.AddArg(v4)
   3036 		v.AddArg(v2)
   3037 		return true
   3038 	}
   3039 }
   3040 func rewriteValueS390X_OpLess16_0(v *Value) bool {
   3041 	b := v.Block
   3042 	_ = b
   3043 	typ := &b.Func.Config.Types
   3044 	_ = typ
   3045 	// match: (Less16 x y)
   3046 	// cond:
   3047 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
   3048 	for {
   3049 		_ = v.Args[1]
   3050 		x := v.Args[0]
   3051 		y := v.Args[1]
   3052 		v.reset(OpS390XMOVDLT)
   3053 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3054 		v0.AuxInt = 0
   3055 		v.AddArg(v0)
   3056 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3057 		v1.AuxInt = 1
   3058 		v.AddArg(v1)
   3059 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   3060 		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   3061 		v3.AddArg(x)
   3062 		v2.AddArg(v3)
   3063 		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   3064 		v4.AddArg(y)
   3065 		v2.AddArg(v4)
   3066 		v.AddArg(v2)
   3067 		return true
   3068 	}
   3069 }
   3070 func rewriteValueS390X_OpLess16U_0(v *Value) bool {
   3071 	b := v.Block
   3072 	_ = b
   3073 	typ := &b.Func.Config.Types
   3074 	_ = typ
   3075 	// match: (Less16U x y)
   3076 	// cond:
   3077 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVHZreg x) (MOVHZreg y)))
   3078 	for {
   3079 		_ = v.Args[1]
   3080 		x := v.Args[0]
   3081 		y := v.Args[1]
   3082 		v.reset(OpS390XMOVDLT)
   3083 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3084 		v0.AuxInt = 0
   3085 		v.AddArg(v0)
   3086 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3087 		v1.AuxInt = 1
   3088 		v.AddArg(v1)
   3089 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   3090 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3091 		v3.AddArg(x)
   3092 		v2.AddArg(v3)
   3093 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3094 		v4.AddArg(y)
   3095 		v2.AddArg(v4)
   3096 		v.AddArg(v2)
   3097 		return true
   3098 	}
   3099 }
   3100 func rewriteValueS390X_OpLess32_0(v *Value) bool {
   3101 	b := v.Block
   3102 	_ = b
   3103 	typ := &b.Func.Config.Types
   3104 	_ = typ
   3105 	// match: (Less32 x y)
   3106 	// cond:
   3107 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
   3108 	for {
   3109 		_ = v.Args[1]
   3110 		x := v.Args[0]
   3111 		y := v.Args[1]
   3112 		v.reset(OpS390XMOVDLT)
   3113 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3114 		v0.AuxInt = 0
   3115 		v.AddArg(v0)
   3116 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3117 		v1.AuxInt = 1
   3118 		v.AddArg(v1)
   3119 		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
   3120 		v2.AddArg(x)
   3121 		v2.AddArg(y)
   3122 		v.AddArg(v2)
   3123 		return true
   3124 	}
   3125 }
   3126 func rewriteValueS390X_OpLess32F_0(v *Value) bool {
   3127 	b := v.Block
   3128 	_ = b
   3129 	typ := &b.Func.Config.Types
   3130 	_ = typ
   3131 	// match: (Less32F x y)
   3132 	// cond:
   3133 	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMPS y x))
   3134 	for {
   3135 		_ = v.Args[1]
   3136 		x := v.Args[0]
   3137 		y := v.Args[1]
   3138 		v.reset(OpS390XMOVDGTnoinv)
   3139 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3140 		v0.AuxInt = 0
   3141 		v.AddArg(v0)
   3142 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3143 		v1.AuxInt = 1
   3144 		v.AddArg(v1)
   3145 		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
   3146 		v2.AddArg(y)
   3147 		v2.AddArg(x)
   3148 		v.AddArg(v2)
   3149 		return true
   3150 	}
   3151 }
   3152 func rewriteValueS390X_OpLess32U_0(v *Value) bool {
   3153 	b := v.Block
   3154 	_ = b
   3155 	typ := &b.Func.Config.Types
   3156 	_ = typ
   3157 	// match: (Less32U x y)
   3158 	// cond:
   3159 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPWU x y))
   3160 	for {
   3161 		_ = v.Args[1]
   3162 		x := v.Args[0]
   3163 		y := v.Args[1]
   3164 		v.reset(OpS390XMOVDLT)
   3165 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3166 		v0.AuxInt = 0
   3167 		v.AddArg(v0)
   3168 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3169 		v1.AuxInt = 1
   3170 		v.AddArg(v1)
   3171 		v2 := b.NewValue0(v.Pos, OpS390XCMPWU, types.TypeFlags)
   3172 		v2.AddArg(x)
   3173 		v2.AddArg(y)
   3174 		v.AddArg(v2)
   3175 		return true
   3176 	}
   3177 }
   3178 func rewriteValueS390X_OpLess64_0(v *Value) bool {
   3179 	b := v.Block
   3180 	_ = b
   3181 	typ := &b.Func.Config.Types
   3182 	_ = typ
   3183 	// match: (Less64 x y)
   3184 	// cond:
   3185 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   3186 	for {
   3187 		_ = v.Args[1]
   3188 		x := v.Args[0]
   3189 		y := v.Args[1]
   3190 		v.reset(OpS390XMOVDLT)
   3191 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3192 		v0.AuxInt = 0
   3193 		v.AddArg(v0)
   3194 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3195 		v1.AuxInt = 1
   3196 		v.AddArg(v1)
   3197 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   3198 		v2.AddArg(x)
   3199 		v2.AddArg(y)
   3200 		v.AddArg(v2)
   3201 		return true
   3202 	}
   3203 }
   3204 func rewriteValueS390X_OpLess64F_0(v *Value) bool {
   3205 	b := v.Block
   3206 	_ = b
   3207 	typ := &b.Func.Config.Types
   3208 	_ = typ
   3209 	// match: (Less64F x y)
   3210 	// cond:
   3211 	// result: (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) (FCMP y x))
   3212 	for {
   3213 		_ = v.Args[1]
   3214 		x := v.Args[0]
   3215 		y := v.Args[1]
   3216 		v.reset(OpS390XMOVDGTnoinv)
   3217 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3218 		v0.AuxInt = 0
   3219 		v.AddArg(v0)
   3220 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3221 		v1.AuxInt = 1
   3222 		v.AddArg(v1)
   3223 		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
   3224 		v2.AddArg(y)
   3225 		v2.AddArg(x)
   3226 		v.AddArg(v2)
   3227 		return true
   3228 	}
   3229 }
   3230 func rewriteValueS390X_OpLess64U_0(v *Value) bool {
   3231 	b := v.Block
   3232 	_ = b
   3233 	typ := &b.Func.Config.Types
   3234 	_ = typ
   3235 	// match: (Less64U x y)
   3236 	// cond:
   3237 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU x y))
   3238 	for {
   3239 		_ = v.Args[1]
   3240 		x := v.Args[0]
   3241 		y := v.Args[1]
   3242 		v.reset(OpS390XMOVDLT)
   3243 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3244 		v0.AuxInt = 0
   3245 		v.AddArg(v0)
   3246 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3247 		v1.AuxInt = 1
   3248 		v.AddArg(v1)
   3249 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   3250 		v2.AddArg(x)
   3251 		v2.AddArg(y)
   3252 		v.AddArg(v2)
   3253 		return true
   3254 	}
   3255 }
   3256 func rewriteValueS390X_OpLess8_0(v *Value) bool {
   3257 	b := v.Block
   3258 	_ = b
   3259 	typ := &b.Func.Config.Types
   3260 	_ = typ
   3261 	// match: (Less8 x y)
   3262 	// cond:
   3263 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   3264 	for {
   3265 		_ = v.Args[1]
   3266 		x := v.Args[0]
   3267 		y := v.Args[1]
   3268 		v.reset(OpS390XMOVDLT)
   3269 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3270 		v0.AuxInt = 0
   3271 		v.AddArg(v0)
   3272 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3273 		v1.AuxInt = 1
   3274 		v.AddArg(v1)
   3275 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   3276 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   3277 		v3.AddArg(x)
   3278 		v2.AddArg(v3)
   3279 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   3280 		v4.AddArg(y)
   3281 		v2.AddArg(v4)
   3282 		v.AddArg(v2)
   3283 		return true
   3284 	}
   3285 }
   3286 func rewriteValueS390X_OpLess8U_0(v *Value) bool {
   3287 	b := v.Block
   3288 	_ = b
   3289 	typ := &b.Func.Config.Types
   3290 	_ = typ
   3291 	// match: (Less8U x y)
   3292 	// cond:
   3293 	// result: (MOVDLT (MOVDconst [0]) (MOVDconst [1]) (CMPU (MOVBZreg x) (MOVBZreg y)))
   3294 	for {
   3295 		_ = v.Args[1]
   3296 		x := v.Args[0]
   3297 		y := v.Args[1]
   3298 		v.reset(OpS390XMOVDLT)
   3299 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3300 		v0.AuxInt = 0
   3301 		v.AddArg(v0)
   3302 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   3303 		v1.AuxInt = 1
   3304 		v.AddArg(v1)
   3305 		v2 := b.NewValue0(v.Pos, OpS390XCMPU, types.TypeFlags)
   3306 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3307 		v3.AddArg(x)
   3308 		v2.AddArg(v3)
   3309 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3310 		v4.AddArg(y)
   3311 		v2.AddArg(v4)
   3312 		v.AddArg(v2)
   3313 		return true
   3314 	}
   3315 }
   3316 func rewriteValueS390X_OpLoad_0(v *Value) bool {
   3317 	// match: (Load <t> ptr mem)
   3318 	// cond: (is64BitInt(t) || isPtr(t))
   3319 	// result: (MOVDload ptr mem)
   3320 	for {
   3321 		t := v.Type
   3322 		_ = v.Args[1]
   3323 		ptr := v.Args[0]
   3324 		mem := v.Args[1]
   3325 		if !(is64BitInt(t) || isPtr(t)) {
   3326 			break
   3327 		}
   3328 		v.reset(OpS390XMOVDload)
   3329 		v.AddArg(ptr)
   3330 		v.AddArg(mem)
   3331 		return true
   3332 	}
   3333 	// match: (Load <t> ptr mem)
   3334 	// cond: is32BitInt(t) && isSigned(t)
   3335 	// result: (MOVWload ptr mem)
   3336 	for {
   3337 		t := v.Type
   3338 		_ = v.Args[1]
   3339 		ptr := v.Args[0]
   3340 		mem := v.Args[1]
   3341 		if !(is32BitInt(t) && isSigned(t)) {
   3342 			break
   3343 		}
   3344 		v.reset(OpS390XMOVWload)
   3345 		v.AddArg(ptr)
   3346 		v.AddArg(mem)
   3347 		return true
   3348 	}
   3349 	// match: (Load <t> ptr mem)
   3350 	// cond: is32BitInt(t) && !isSigned(t)
   3351 	// result: (MOVWZload ptr mem)
   3352 	for {
   3353 		t := v.Type
   3354 		_ = v.Args[1]
   3355 		ptr := v.Args[0]
   3356 		mem := v.Args[1]
   3357 		if !(is32BitInt(t) && !isSigned(t)) {
   3358 			break
   3359 		}
   3360 		v.reset(OpS390XMOVWZload)
   3361 		v.AddArg(ptr)
   3362 		v.AddArg(mem)
   3363 		return true
   3364 	}
   3365 	// match: (Load <t> ptr mem)
   3366 	// cond: is16BitInt(t) && isSigned(t)
   3367 	// result: (MOVHload ptr mem)
   3368 	for {
   3369 		t := v.Type
   3370 		_ = v.Args[1]
   3371 		ptr := v.Args[0]
   3372 		mem := v.Args[1]
   3373 		if !(is16BitInt(t) && isSigned(t)) {
   3374 			break
   3375 		}
   3376 		v.reset(OpS390XMOVHload)
   3377 		v.AddArg(ptr)
   3378 		v.AddArg(mem)
   3379 		return true
   3380 	}
   3381 	// match: (Load <t> ptr mem)
   3382 	// cond: is16BitInt(t) && !isSigned(t)
   3383 	// result: (MOVHZload ptr mem)
   3384 	for {
   3385 		t := v.Type
   3386 		_ = v.Args[1]
   3387 		ptr := v.Args[0]
   3388 		mem := v.Args[1]
   3389 		if !(is16BitInt(t) && !isSigned(t)) {
   3390 			break
   3391 		}
   3392 		v.reset(OpS390XMOVHZload)
   3393 		v.AddArg(ptr)
   3394 		v.AddArg(mem)
   3395 		return true
   3396 	}
   3397 	// match: (Load <t> ptr mem)
   3398 	// cond: is8BitInt(t) && isSigned(t)
   3399 	// result: (MOVBload ptr mem)
   3400 	for {
   3401 		t := v.Type
   3402 		_ = v.Args[1]
   3403 		ptr := v.Args[0]
   3404 		mem := v.Args[1]
   3405 		if !(is8BitInt(t) && isSigned(t)) {
   3406 			break
   3407 		}
   3408 		v.reset(OpS390XMOVBload)
   3409 		v.AddArg(ptr)
   3410 		v.AddArg(mem)
   3411 		return true
   3412 	}
   3413 	// match: (Load <t> ptr mem)
   3414 	// cond: (t.IsBoolean() || (is8BitInt(t) && !isSigned(t)))
   3415 	// result: (MOVBZload ptr mem)
   3416 	for {
   3417 		t := v.Type
   3418 		_ = v.Args[1]
   3419 		ptr := v.Args[0]
   3420 		mem := v.Args[1]
   3421 		if !(t.IsBoolean() || (is8BitInt(t) && !isSigned(t))) {
   3422 			break
   3423 		}
   3424 		v.reset(OpS390XMOVBZload)
   3425 		v.AddArg(ptr)
   3426 		v.AddArg(mem)
   3427 		return true
   3428 	}
   3429 	// match: (Load <t> ptr mem)
   3430 	// cond: is32BitFloat(t)
   3431 	// result: (FMOVSload ptr mem)
   3432 	for {
   3433 		t := v.Type
   3434 		_ = v.Args[1]
   3435 		ptr := v.Args[0]
   3436 		mem := v.Args[1]
   3437 		if !(is32BitFloat(t)) {
   3438 			break
   3439 		}
   3440 		v.reset(OpS390XFMOVSload)
   3441 		v.AddArg(ptr)
   3442 		v.AddArg(mem)
   3443 		return true
   3444 	}
   3445 	// match: (Load <t> ptr mem)
   3446 	// cond: is64BitFloat(t)
   3447 	// result: (FMOVDload ptr mem)
   3448 	for {
   3449 		t := v.Type
   3450 		_ = v.Args[1]
   3451 		ptr := v.Args[0]
   3452 		mem := v.Args[1]
   3453 		if !(is64BitFloat(t)) {
   3454 			break
   3455 		}
   3456 		v.reset(OpS390XFMOVDload)
   3457 		v.AddArg(ptr)
   3458 		v.AddArg(mem)
   3459 		return true
   3460 	}
   3461 	return false
   3462 }
   3463 func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
   3464 	b := v.Block
   3465 	_ = b
   3466 	typ := &b.Func.Config.Types
   3467 	_ = typ
   3468 	// match: (Lsh16x16 <t> x y)
   3469 	// cond:
   3470 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
   3471 	for {
   3472 		t := v.Type
   3473 		_ = v.Args[1]
   3474 		x := v.Args[0]
   3475 		y := v.Args[1]
   3476 		v.reset(OpS390XANDW)
   3477 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3478 		v0.AddArg(x)
   3479 		v0.AddArg(y)
   3480 		v.AddArg(v0)
   3481 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3482 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3483 		v2.AuxInt = 31
   3484 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3485 		v3.AddArg(y)
   3486 		v2.AddArg(v3)
   3487 		v1.AddArg(v2)
   3488 		v.AddArg(v1)
   3489 		return true
   3490 	}
   3491 }
   3492 func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
   3493 	b := v.Block
   3494 	_ = b
   3495 	// match: (Lsh16x32 <t> x y)
   3496 	// cond:
   3497 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst y [31])))
   3498 	for {
   3499 		t := v.Type
   3500 		_ = v.Args[1]
   3501 		x := v.Args[0]
   3502 		y := v.Args[1]
   3503 		v.reset(OpS390XANDW)
   3504 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3505 		v0.AddArg(x)
   3506 		v0.AddArg(y)
   3507 		v.AddArg(v0)
   3508 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3509 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3510 		v2.AuxInt = 31
   3511 		v2.AddArg(y)
   3512 		v1.AddArg(v2)
   3513 		v.AddArg(v1)
   3514 		return true
   3515 	}
   3516 }
   3517 func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
   3518 	b := v.Block
   3519 	_ = b
   3520 	// match: (Lsh16x64 <t> x y)
   3521 	// cond:
   3522 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPUconst y [31])))
   3523 	for {
   3524 		t := v.Type
   3525 		_ = v.Args[1]
   3526 		x := v.Args[0]
   3527 		y := v.Args[1]
   3528 		v.reset(OpS390XANDW)
   3529 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3530 		v0.AddArg(x)
   3531 		v0.AddArg(y)
   3532 		v.AddArg(v0)
   3533 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3534 		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   3535 		v2.AuxInt = 31
   3536 		v2.AddArg(y)
   3537 		v1.AddArg(v2)
   3538 		v.AddArg(v1)
   3539 		return true
   3540 	}
   3541 }
   3542 func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
   3543 	b := v.Block
   3544 	_ = b
   3545 	typ := &b.Func.Config.Types
   3546 	_ = typ
   3547 	// match: (Lsh16x8 <t> x y)
   3548 	// cond:
   3549 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
   3550 	for {
   3551 		t := v.Type
   3552 		_ = v.Args[1]
   3553 		x := v.Args[0]
   3554 		y := v.Args[1]
   3555 		v.reset(OpS390XANDW)
   3556 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3557 		v0.AddArg(x)
   3558 		v0.AddArg(y)
   3559 		v.AddArg(v0)
   3560 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3561 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3562 		v2.AuxInt = 31
   3563 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3564 		v3.AddArg(y)
   3565 		v2.AddArg(v3)
   3566 		v1.AddArg(v2)
   3567 		v.AddArg(v1)
   3568 		return true
   3569 	}
   3570 }
   3571 func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
   3572 	b := v.Block
   3573 	_ = b
   3574 	typ := &b.Func.Config.Types
   3575 	_ = typ
   3576 	// match: (Lsh32x16 <t> x y)
   3577 	// cond:
   3578 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
   3579 	for {
   3580 		t := v.Type
   3581 		_ = v.Args[1]
   3582 		x := v.Args[0]
   3583 		y := v.Args[1]
   3584 		v.reset(OpS390XANDW)
   3585 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3586 		v0.AddArg(x)
   3587 		v0.AddArg(y)
   3588 		v.AddArg(v0)
   3589 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3590 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3591 		v2.AuxInt = 31
   3592 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3593 		v3.AddArg(y)
   3594 		v2.AddArg(v3)
   3595 		v1.AddArg(v2)
   3596 		v.AddArg(v1)
   3597 		return true
   3598 	}
   3599 }
   3600 func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
   3601 	b := v.Block
   3602 	_ = b
   3603 	// match: (Lsh32x32 <t> x y)
   3604 	// cond:
   3605 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst y [31])))
   3606 	for {
   3607 		t := v.Type
   3608 		_ = v.Args[1]
   3609 		x := v.Args[0]
   3610 		y := v.Args[1]
   3611 		v.reset(OpS390XANDW)
   3612 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3613 		v0.AddArg(x)
   3614 		v0.AddArg(y)
   3615 		v.AddArg(v0)
   3616 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3617 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3618 		v2.AuxInt = 31
   3619 		v2.AddArg(y)
   3620 		v1.AddArg(v2)
   3621 		v.AddArg(v1)
   3622 		return true
   3623 	}
   3624 }
   3625 func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
   3626 	b := v.Block
   3627 	_ = b
   3628 	// match: (Lsh32x64 <t> x y)
   3629 	// cond:
   3630 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPUconst y [31])))
   3631 	for {
   3632 		t := v.Type
   3633 		_ = v.Args[1]
   3634 		x := v.Args[0]
   3635 		y := v.Args[1]
   3636 		v.reset(OpS390XANDW)
   3637 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3638 		v0.AddArg(x)
   3639 		v0.AddArg(y)
   3640 		v.AddArg(v0)
   3641 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3642 		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   3643 		v2.AuxInt = 31
   3644 		v2.AddArg(y)
   3645 		v1.AddArg(v2)
   3646 		v.AddArg(v1)
   3647 		return true
   3648 	}
   3649 }
   3650 func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
   3651 	b := v.Block
   3652 	_ = b
   3653 	typ := &b.Func.Config.Types
   3654 	_ = typ
   3655 	// match: (Lsh32x8 <t> x y)
   3656 	// cond:
   3657 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
   3658 	for {
   3659 		t := v.Type
   3660 		_ = v.Args[1]
   3661 		x := v.Args[0]
   3662 		y := v.Args[1]
   3663 		v.reset(OpS390XANDW)
   3664 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3665 		v0.AddArg(x)
   3666 		v0.AddArg(y)
   3667 		v.AddArg(v0)
   3668 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3669 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3670 		v2.AuxInt = 31
   3671 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3672 		v3.AddArg(y)
   3673 		v2.AddArg(v3)
   3674 		v1.AddArg(v2)
   3675 		v.AddArg(v1)
   3676 		return true
   3677 	}
   3678 }
   3679 func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
   3680 	b := v.Block
   3681 	_ = b
   3682 	typ := &b.Func.Config.Types
   3683 	_ = typ
   3684 	// match: (Lsh64x16 <t> x y)
   3685 	// cond:
   3686 	// result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVHZreg y) [63])))
   3687 	for {
   3688 		t := v.Type
   3689 		_ = v.Args[1]
   3690 		x := v.Args[0]
   3691 		y := v.Args[1]
   3692 		v.reset(OpS390XAND)
   3693 		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
   3694 		v0.AddArg(x)
   3695 		v0.AddArg(y)
   3696 		v.AddArg(v0)
   3697 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   3698 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3699 		v2.AuxInt = 63
   3700 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3701 		v3.AddArg(y)
   3702 		v2.AddArg(v3)
   3703 		v1.AddArg(v2)
   3704 		v.AddArg(v1)
   3705 		return true
   3706 	}
   3707 }
   3708 func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
   3709 	b := v.Block
   3710 	_ = b
   3711 	// match: (Lsh64x32 <t> x y)
   3712 	// cond:
   3713 	// result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst y [63])))
   3714 	for {
   3715 		t := v.Type
   3716 		_ = v.Args[1]
   3717 		x := v.Args[0]
   3718 		y := v.Args[1]
   3719 		v.reset(OpS390XAND)
   3720 		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
   3721 		v0.AddArg(x)
   3722 		v0.AddArg(y)
   3723 		v.AddArg(v0)
   3724 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   3725 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3726 		v2.AuxInt = 63
   3727 		v2.AddArg(y)
   3728 		v1.AddArg(v2)
   3729 		v.AddArg(v1)
   3730 		return true
   3731 	}
   3732 }
   3733 func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
   3734 	b := v.Block
   3735 	_ = b
   3736 	// match: (Lsh64x64 <t> x y)
   3737 	// cond:
   3738 	// result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPUconst y [63])))
   3739 	for {
   3740 		t := v.Type
   3741 		_ = v.Args[1]
   3742 		x := v.Args[0]
   3743 		y := v.Args[1]
   3744 		v.reset(OpS390XAND)
   3745 		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
   3746 		v0.AddArg(x)
   3747 		v0.AddArg(y)
   3748 		v.AddArg(v0)
   3749 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   3750 		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   3751 		v2.AuxInt = 63
   3752 		v2.AddArg(y)
   3753 		v1.AddArg(v2)
   3754 		v.AddArg(v1)
   3755 		return true
   3756 	}
   3757 }
   3758 func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
   3759 	b := v.Block
   3760 	_ = b
   3761 	typ := &b.Func.Config.Types
   3762 	_ = typ
   3763 	// match: (Lsh64x8 <t> x y)
   3764 	// cond:
   3765 	// result: (AND (SLD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVBZreg y) [63])))
   3766 	for {
   3767 		t := v.Type
   3768 		_ = v.Args[1]
   3769 		x := v.Args[0]
   3770 		y := v.Args[1]
   3771 		v.reset(OpS390XAND)
   3772 		v0 := b.NewValue0(v.Pos, OpS390XSLD, t)
   3773 		v0.AddArg(x)
   3774 		v0.AddArg(y)
   3775 		v.AddArg(v0)
   3776 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   3777 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3778 		v2.AuxInt = 63
   3779 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3780 		v3.AddArg(y)
   3781 		v2.AddArg(v3)
   3782 		v1.AddArg(v2)
   3783 		v.AddArg(v1)
   3784 		return true
   3785 	}
   3786 }
   3787 func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
   3788 	b := v.Block
   3789 	_ = b
   3790 	typ := &b.Func.Config.Types
   3791 	_ = typ
   3792 	// match: (Lsh8x16 <t> x y)
   3793 	// cond:
   3794 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
   3795 	for {
   3796 		t := v.Type
   3797 		_ = v.Args[1]
   3798 		x := v.Args[0]
   3799 		y := v.Args[1]
   3800 		v.reset(OpS390XANDW)
   3801 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3802 		v0.AddArg(x)
   3803 		v0.AddArg(y)
   3804 		v.AddArg(v0)
   3805 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3806 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3807 		v2.AuxInt = 31
   3808 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3809 		v3.AddArg(y)
   3810 		v2.AddArg(v3)
   3811 		v1.AddArg(v2)
   3812 		v.AddArg(v1)
   3813 		return true
   3814 	}
   3815 }
   3816 func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
   3817 	b := v.Block
   3818 	_ = b
   3819 	// match: (Lsh8x32 <t> x y)
   3820 	// cond:
   3821 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst y [31])))
   3822 	for {
   3823 		t := v.Type
   3824 		_ = v.Args[1]
   3825 		x := v.Args[0]
   3826 		y := v.Args[1]
   3827 		v.reset(OpS390XANDW)
   3828 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3829 		v0.AddArg(x)
   3830 		v0.AddArg(y)
   3831 		v.AddArg(v0)
   3832 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3833 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3834 		v2.AuxInt = 31
   3835 		v2.AddArg(y)
   3836 		v1.AddArg(v2)
   3837 		v.AddArg(v1)
   3838 		return true
   3839 	}
   3840 }
   3841 func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
   3842 	b := v.Block
   3843 	_ = b
   3844 	// match: (Lsh8x64 <t> x y)
   3845 	// cond:
   3846 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPUconst y [31])))
   3847 	for {
   3848 		t := v.Type
   3849 		_ = v.Args[1]
   3850 		x := v.Args[0]
   3851 		y := v.Args[1]
   3852 		v.reset(OpS390XANDW)
   3853 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3854 		v0.AddArg(x)
   3855 		v0.AddArg(y)
   3856 		v.AddArg(v0)
   3857 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3858 		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   3859 		v2.AuxInt = 31
   3860 		v2.AddArg(y)
   3861 		v1.AddArg(v2)
   3862 		v.AddArg(v1)
   3863 		return true
   3864 	}
   3865 }
   3866 func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
   3867 	b := v.Block
   3868 	_ = b
   3869 	typ := &b.Func.Config.Types
   3870 	_ = typ
   3871 	// match: (Lsh8x8 <t> x y)
   3872 	// cond:
   3873 	// result: (ANDW (SLW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
   3874 	for {
   3875 		t := v.Type
   3876 		_ = v.Args[1]
   3877 		x := v.Args[0]
   3878 		y := v.Args[1]
   3879 		v.reset(OpS390XANDW)
   3880 		v0 := b.NewValue0(v.Pos, OpS390XSLW, t)
   3881 		v0.AddArg(x)
   3882 		v0.AddArg(y)
   3883 		v.AddArg(v0)
   3884 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   3885 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   3886 		v2.AuxInt = 31
   3887 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   3888 		v3.AddArg(y)
   3889 		v2.AddArg(v3)
   3890 		v1.AddArg(v2)
   3891 		v.AddArg(v1)
   3892 		return true
   3893 	}
   3894 }
   3895 func rewriteValueS390X_OpMod16_0(v *Value) bool {
   3896 	b := v.Block
   3897 	_ = b
   3898 	typ := &b.Func.Config.Types
   3899 	_ = typ
   3900 	// match: (Mod16 x y)
   3901 	// cond:
   3902 	// result: (MODW  (MOVHreg x) (MOVHreg y))
   3903 	for {
   3904 		_ = v.Args[1]
   3905 		x := v.Args[0]
   3906 		y := v.Args[1]
   3907 		v.reset(OpS390XMODW)
   3908 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   3909 		v0.AddArg(x)
   3910 		v.AddArg(v0)
   3911 		v1 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   3912 		v1.AddArg(y)
   3913 		v.AddArg(v1)
   3914 		return true
   3915 	}
   3916 }
   3917 func rewriteValueS390X_OpMod16u_0(v *Value) bool {
   3918 	b := v.Block
   3919 	_ = b
   3920 	typ := &b.Func.Config.Types
   3921 	_ = typ
   3922 	// match: (Mod16u x y)
   3923 	// cond:
   3924 	// result: (MODWU (MOVHZreg x) (MOVHZreg y))
   3925 	for {
   3926 		_ = v.Args[1]
   3927 		x := v.Args[0]
   3928 		y := v.Args[1]
   3929 		v.reset(OpS390XMODWU)
   3930 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3931 		v0.AddArg(x)
   3932 		v.AddArg(v0)
   3933 		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   3934 		v1.AddArg(y)
   3935 		v.AddArg(v1)
   3936 		return true
   3937 	}
   3938 }
   3939 func rewriteValueS390X_OpMod32_0(v *Value) bool {
   3940 	b := v.Block
   3941 	_ = b
   3942 	typ := &b.Func.Config.Types
   3943 	_ = typ
   3944 	// match: (Mod32 x y)
   3945 	// cond:
   3946 	// result: (MODW  (MOVWreg x) y)
   3947 	for {
   3948 		_ = v.Args[1]
   3949 		x := v.Args[0]
   3950 		y := v.Args[1]
   3951 		v.reset(OpS390XMODW)
   3952 		v0 := b.NewValue0(v.Pos, OpS390XMOVWreg, typ.Int64)
   3953 		v0.AddArg(x)
   3954 		v.AddArg(v0)
   3955 		v.AddArg(y)
   3956 		return true
   3957 	}
   3958 }
   3959 func rewriteValueS390X_OpMod32u_0(v *Value) bool {
   3960 	b := v.Block
   3961 	_ = b
   3962 	typ := &b.Func.Config.Types
   3963 	_ = typ
   3964 	// match: (Mod32u x y)
   3965 	// cond:
   3966 	// result: (MODWU (MOVWZreg x) y)
   3967 	for {
   3968 		_ = v.Args[1]
   3969 		x := v.Args[0]
   3970 		y := v.Args[1]
   3971 		v.reset(OpS390XMODWU)
   3972 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   3973 		v0.AddArg(x)
   3974 		v.AddArg(v0)
   3975 		v.AddArg(y)
   3976 		return true
   3977 	}
   3978 }
   3979 func rewriteValueS390X_OpMod64_0(v *Value) bool {
   3980 	// match: (Mod64 x y)
   3981 	// cond:
   3982 	// result: (MODD  x y)
   3983 	for {
   3984 		_ = v.Args[1]
   3985 		x := v.Args[0]
   3986 		y := v.Args[1]
   3987 		v.reset(OpS390XMODD)
   3988 		v.AddArg(x)
   3989 		v.AddArg(y)
   3990 		return true
   3991 	}
   3992 }
   3993 func rewriteValueS390X_OpMod64u_0(v *Value) bool {
   3994 	// match: (Mod64u x y)
   3995 	// cond:
   3996 	// result: (MODDU x y)
   3997 	for {
   3998 		_ = v.Args[1]
   3999 		x := v.Args[0]
   4000 		y := v.Args[1]
   4001 		v.reset(OpS390XMODDU)
   4002 		v.AddArg(x)
   4003 		v.AddArg(y)
   4004 		return true
   4005 	}
   4006 }
   4007 func rewriteValueS390X_OpMod8_0(v *Value) bool {
   4008 	b := v.Block
   4009 	_ = b
   4010 	typ := &b.Func.Config.Types
   4011 	_ = typ
   4012 	// match: (Mod8 x y)
   4013 	// cond:
   4014 	// result: (MODW  (MOVBreg x) (MOVBreg y))
   4015 	for {
   4016 		_ = v.Args[1]
   4017 		x := v.Args[0]
   4018 		y := v.Args[1]
   4019 		v.reset(OpS390XMODW)
   4020 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4021 		v0.AddArg(x)
   4022 		v.AddArg(v0)
   4023 		v1 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4024 		v1.AddArg(y)
   4025 		v.AddArg(v1)
   4026 		return true
   4027 	}
   4028 }
   4029 func rewriteValueS390X_OpMod8u_0(v *Value) bool {
   4030 	b := v.Block
   4031 	_ = b
   4032 	typ := &b.Func.Config.Types
   4033 	_ = typ
   4034 	// match: (Mod8u x y)
   4035 	// cond:
   4036 	// result: (MODWU (MOVBZreg x) (MOVBZreg y))
   4037 	for {
   4038 		_ = v.Args[1]
   4039 		x := v.Args[0]
   4040 		y := v.Args[1]
   4041 		v.reset(OpS390XMODWU)
   4042 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   4043 		v0.AddArg(x)
   4044 		v.AddArg(v0)
   4045 		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   4046 		v1.AddArg(y)
   4047 		v.AddArg(v1)
   4048 		return true
   4049 	}
   4050 }
   4051 func rewriteValueS390X_OpMove_0(v *Value) bool {
   4052 	b := v.Block
   4053 	_ = b
   4054 	typ := &b.Func.Config.Types
   4055 	_ = typ
   4056 	// match: (Move [0] _ _ mem)
   4057 	// cond:
   4058 	// result: mem
   4059 	for {
   4060 		if v.AuxInt != 0 {
   4061 			break
   4062 		}
   4063 		_ = v.Args[2]
   4064 		mem := v.Args[2]
   4065 		v.reset(OpCopy)
   4066 		v.Type = mem.Type
   4067 		v.AddArg(mem)
   4068 		return true
   4069 	}
   4070 	// match: (Move [1] dst src mem)
   4071 	// cond:
   4072 	// result: (MOVBstore dst (MOVBZload src mem) mem)
   4073 	for {
   4074 		if v.AuxInt != 1 {
   4075 			break
   4076 		}
   4077 		_ = v.Args[2]
   4078 		dst := v.Args[0]
   4079 		src := v.Args[1]
   4080 		mem := v.Args[2]
   4081 		v.reset(OpS390XMOVBstore)
   4082 		v.AddArg(dst)
   4083 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
   4084 		v0.AddArg(src)
   4085 		v0.AddArg(mem)
   4086 		v.AddArg(v0)
   4087 		v.AddArg(mem)
   4088 		return true
   4089 	}
   4090 	// match: (Move [2] dst src mem)
   4091 	// cond:
   4092 	// result: (MOVHstore dst (MOVHZload src mem) mem)
   4093 	for {
   4094 		if v.AuxInt != 2 {
   4095 			break
   4096 		}
   4097 		_ = v.Args[2]
   4098 		dst := v.Args[0]
   4099 		src := v.Args[1]
   4100 		mem := v.Args[2]
   4101 		v.reset(OpS390XMOVHstore)
   4102 		v.AddArg(dst)
   4103 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   4104 		v0.AddArg(src)
   4105 		v0.AddArg(mem)
   4106 		v.AddArg(v0)
   4107 		v.AddArg(mem)
   4108 		return true
   4109 	}
   4110 	// match: (Move [4] dst src mem)
   4111 	// cond:
   4112 	// result: (MOVWstore dst (MOVWZload src mem) mem)
   4113 	for {
   4114 		if v.AuxInt != 4 {
   4115 			break
   4116 		}
   4117 		_ = v.Args[2]
   4118 		dst := v.Args[0]
   4119 		src := v.Args[1]
   4120 		mem := v.Args[2]
   4121 		v.reset(OpS390XMOVWstore)
   4122 		v.AddArg(dst)
   4123 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   4124 		v0.AddArg(src)
   4125 		v0.AddArg(mem)
   4126 		v.AddArg(v0)
   4127 		v.AddArg(mem)
   4128 		return true
   4129 	}
   4130 	// match: (Move [8] dst src mem)
   4131 	// cond:
   4132 	// result: (MOVDstore dst (MOVDload src mem) mem)
   4133 	for {
   4134 		if v.AuxInt != 8 {
   4135 			break
   4136 		}
   4137 		_ = v.Args[2]
   4138 		dst := v.Args[0]
   4139 		src := v.Args[1]
   4140 		mem := v.Args[2]
   4141 		v.reset(OpS390XMOVDstore)
   4142 		v.AddArg(dst)
   4143 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   4144 		v0.AddArg(src)
   4145 		v0.AddArg(mem)
   4146 		v.AddArg(v0)
   4147 		v.AddArg(mem)
   4148 		return true
   4149 	}
   4150 	// match: (Move [16] dst src mem)
   4151 	// cond:
   4152 	// result: (MOVDstore [8] dst (MOVDload [8] src mem) 		(MOVDstore dst (MOVDload src mem) mem))
   4153 	for {
   4154 		if v.AuxInt != 16 {
   4155 			break
   4156 		}
   4157 		_ = v.Args[2]
   4158 		dst := v.Args[0]
   4159 		src := v.Args[1]
   4160 		mem := v.Args[2]
   4161 		v.reset(OpS390XMOVDstore)
   4162 		v.AuxInt = 8
   4163 		v.AddArg(dst)
   4164 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   4165 		v0.AuxInt = 8
   4166 		v0.AddArg(src)
   4167 		v0.AddArg(mem)
   4168 		v.AddArg(v0)
   4169 		v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
   4170 		v1.AddArg(dst)
   4171 		v2 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   4172 		v2.AddArg(src)
   4173 		v2.AddArg(mem)
   4174 		v1.AddArg(v2)
   4175 		v1.AddArg(mem)
   4176 		v.AddArg(v1)
   4177 		return true
   4178 	}
   4179 	// match: (Move [24] dst src mem)
   4180 	// cond:
   4181 	// result: (MOVDstore [16] dst (MOVDload [16] src mem) 	        (MOVDstore [8] dst (MOVDload [8] src mem)                 (MOVDstore dst (MOVDload src mem) mem)))
   4182 	for {
   4183 		if v.AuxInt != 24 {
   4184 			break
   4185 		}
   4186 		_ = v.Args[2]
   4187 		dst := v.Args[0]
   4188 		src := v.Args[1]
   4189 		mem := v.Args[2]
   4190 		v.reset(OpS390XMOVDstore)
   4191 		v.AuxInt = 16
   4192 		v.AddArg(dst)
   4193 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   4194 		v0.AuxInt = 16
   4195 		v0.AddArg(src)
   4196 		v0.AddArg(mem)
   4197 		v.AddArg(v0)
   4198 		v1 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
   4199 		v1.AuxInt = 8
   4200 		v1.AddArg(dst)
   4201 		v2 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   4202 		v2.AuxInt = 8
   4203 		v2.AddArg(src)
   4204 		v2.AddArg(mem)
   4205 		v1.AddArg(v2)
   4206 		v3 := b.NewValue0(v.Pos, OpS390XMOVDstore, types.TypeMem)
   4207 		v3.AddArg(dst)
   4208 		v4 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   4209 		v4.AddArg(src)
   4210 		v4.AddArg(mem)
   4211 		v3.AddArg(v4)
   4212 		v3.AddArg(mem)
   4213 		v1.AddArg(v3)
   4214 		v.AddArg(v1)
   4215 		return true
   4216 	}
   4217 	// match: (Move [3] dst src mem)
   4218 	// cond:
   4219 	// result: (MOVBstore [2] dst (MOVBZload [2] src mem) 		(MOVHstore dst (MOVHZload src mem) mem))
   4220 	for {
   4221 		if v.AuxInt != 3 {
   4222 			break
   4223 		}
   4224 		_ = v.Args[2]
   4225 		dst := v.Args[0]
   4226 		src := v.Args[1]
   4227 		mem := v.Args[2]
   4228 		v.reset(OpS390XMOVBstore)
   4229 		v.AuxInt = 2
   4230 		v.AddArg(dst)
   4231 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
   4232 		v0.AuxInt = 2
   4233 		v0.AddArg(src)
   4234 		v0.AddArg(mem)
   4235 		v.AddArg(v0)
   4236 		v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, types.TypeMem)
   4237 		v1.AddArg(dst)
   4238 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   4239 		v2.AddArg(src)
   4240 		v2.AddArg(mem)
   4241 		v1.AddArg(v2)
   4242 		v1.AddArg(mem)
   4243 		v.AddArg(v1)
   4244 		return true
   4245 	}
   4246 	// match: (Move [5] dst src mem)
   4247 	// cond:
   4248 	// result: (MOVBstore [4] dst (MOVBZload [4] src mem) 		(MOVWstore dst (MOVWZload src mem) mem))
   4249 	for {
   4250 		if v.AuxInt != 5 {
   4251 			break
   4252 		}
   4253 		_ = v.Args[2]
   4254 		dst := v.Args[0]
   4255 		src := v.Args[1]
   4256 		mem := v.Args[2]
   4257 		v.reset(OpS390XMOVBstore)
   4258 		v.AuxInt = 4
   4259 		v.AddArg(dst)
   4260 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
   4261 		v0.AuxInt = 4
   4262 		v0.AddArg(src)
   4263 		v0.AddArg(mem)
   4264 		v.AddArg(v0)
   4265 		v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
   4266 		v1.AddArg(dst)
   4267 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   4268 		v2.AddArg(src)
   4269 		v2.AddArg(mem)
   4270 		v1.AddArg(v2)
   4271 		v1.AddArg(mem)
   4272 		v.AddArg(v1)
   4273 		return true
   4274 	}
   4275 	// match: (Move [6] dst src mem)
   4276 	// cond:
   4277 	// result: (MOVHstore [4] dst (MOVHZload [4] src mem) 		(MOVWstore dst (MOVWZload src mem) mem))
   4278 	for {
   4279 		if v.AuxInt != 6 {
   4280 			break
   4281 		}
   4282 		_ = v.Args[2]
   4283 		dst := v.Args[0]
   4284 		src := v.Args[1]
   4285 		mem := v.Args[2]
   4286 		v.reset(OpS390XMOVHstore)
   4287 		v.AuxInt = 4
   4288 		v.AddArg(dst)
   4289 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   4290 		v0.AuxInt = 4
   4291 		v0.AddArg(src)
   4292 		v0.AddArg(mem)
   4293 		v.AddArg(v0)
   4294 		v1 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
   4295 		v1.AddArg(dst)
   4296 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   4297 		v2.AddArg(src)
   4298 		v2.AddArg(mem)
   4299 		v1.AddArg(v2)
   4300 		v1.AddArg(mem)
   4301 		v.AddArg(v1)
   4302 		return true
   4303 	}
   4304 	return false
   4305 }
   4306 func rewriteValueS390X_OpMove_10(v *Value) bool {
   4307 	b := v.Block
   4308 	_ = b
   4309 	typ := &b.Func.Config.Types
   4310 	_ = typ
   4311 	// match: (Move [7] dst src mem)
   4312 	// cond:
   4313 	// result: (MOVBstore [6] dst (MOVBZload [6] src mem) 		(MOVHstore [4] dst (MOVHZload [4] src mem) 			(MOVWstore dst (MOVWZload src mem) mem)))
   4314 	for {
   4315 		if v.AuxInt != 7 {
   4316 			break
   4317 		}
   4318 		_ = v.Args[2]
   4319 		dst := v.Args[0]
   4320 		src := v.Args[1]
   4321 		mem := v.Args[2]
   4322 		v.reset(OpS390XMOVBstore)
   4323 		v.AuxInt = 6
   4324 		v.AddArg(dst)
   4325 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, typ.UInt8)
   4326 		v0.AuxInt = 6
   4327 		v0.AddArg(src)
   4328 		v0.AddArg(mem)
   4329 		v.AddArg(v0)
   4330 		v1 := b.NewValue0(v.Pos, OpS390XMOVHstore, types.TypeMem)
   4331 		v1.AuxInt = 4
   4332 		v1.AddArg(dst)
   4333 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   4334 		v2.AuxInt = 4
   4335 		v2.AddArg(src)
   4336 		v2.AddArg(mem)
   4337 		v1.AddArg(v2)
   4338 		v3 := b.NewValue0(v.Pos, OpS390XMOVWstore, types.TypeMem)
   4339 		v3.AddArg(dst)
   4340 		v4 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   4341 		v4.AddArg(src)
   4342 		v4.AddArg(mem)
   4343 		v3.AddArg(v4)
   4344 		v3.AddArg(mem)
   4345 		v1.AddArg(v3)
   4346 		v.AddArg(v1)
   4347 		return true
   4348 	}
   4349 	// match: (Move [s] dst src mem)
   4350 	// cond: s > 0 && s <= 256
   4351 	// result: (MVC [makeValAndOff(s, 0)] dst src mem)
   4352 	for {
   4353 		s := v.AuxInt
   4354 		_ = v.Args[2]
   4355 		dst := v.Args[0]
   4356 		src := v.Args[1]
   4357 		mem := v.Args[2]
   4358 		if !(s > 0 && s <= 256) {
   4359 			break
   4360 		}
   4361 		v.reset(OpS390XMVC)
   4362 		v.AuxInt = makeValAndOff(s, 0)
   4363 		v.AddArg(dst)
   4364 		v.AddArg(src)
   4365 		v.AddArg(mem)
   4366 		return true
   4367 	}
   4368 	// match: (Move [s] dst src mem)
   4369 	// cond: s > 256 && s <= 512
   4370 	// result: (MVC [makeValAndOff(s-256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))
   4371 	for {
   4372 		s := v.AuxInt
   4373 		_ = v.Args[2]
   4374 		dst := v.Args[0]
   4375 		src := v.Args[1]
   4376 		mem := v.Args[2]
   4377 		if !(s > 256 && s <= 512) {
   4378 			break
   4379 		}
   4380 		v.reset(OpS390XMVC)
   4381 		v.AuxInt = makeValAndOff(s-256, 256)
   4382 		v.AddArg(dst)
   4383 		v.AddArg(src)
   4384 		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
   4385 		v0.AuxInt = makeValAndOff(256, 0)
   4386 		v0.AddArg(dst)
   4387 		v0.AddArg(src)
   4388 		v0.AddArg(mem)
   4389 		v.AddArg(v0)
   4390 		return true
   4391 	}
   4392 	// match: (Move [s] dst src mem)
   4393 	// cond: s > 512 && s <= 768
   4394 	// result: (MVC [makeValAndOff(s-512, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem)))
   4395 	for {
   4396 		s := v.AuxInt
   4397 		_ = v.Args[2]
   4398 		dst := v.Args[0]
   4399 		src := v.Args[1]
   4400 		mem := v.Args[2]
   4401 		if !(s > 512 && s <= 768) {
   4402 			break
   4403 		}
   4404 		v.reset(OpS390XMVC)
   4405 		v.AuxInt = makeValAndOff(s-512, 512)
   4406 		v.AddArg(dst)
   4407 		v.AddArg(src)
   4408 		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
   4409 		v0.AuxInt = makeValAndOff(256, 256)
   4410 		v0.AddArg(dst)
   4411 		v0.AddArg(src)
   4412 		v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
   4413 		v1.AuxInt = makeValAndOff(256, 0)
   4414 		v1.AddArg(dst)
   4415 		v1.AddArg(src)
   4416 		v1.AddArg(mem)
   4417 		v0.AddArg(v1)
   4418 		v.AddArg(v0)
   4419 		return true
   4420 	}
   4421 	// match: (Move [s] dst src mem)
   4422 	// cond: s > 768 && s <= 1024
   4423 	// result: (MVC [makeValAndOff(s-768, 768)] dst src (MVC [makeValAndOff(256, 512)] dst src (MVC [makeValAndOff(256, 256)] dst src (MVC [makeValAndOff(256, 0)] dst src mem))))
   4424 	for {
   4425 		s := v.AuxInt
   4426 		_ = v.Args[2]
   4427 		dst := v.Args[0]
   4428 		src := v.Args[1]
   4429 		mem := v.Args[2]
   4430 		if !(s > 768 && s <= 1024) {
   4431 			break
   4432 		}
   4433 		v.reset(OpS390XMVC)
   4434 		v.AuxInt = makeValAndOff(s-768, 768)
   4435 		v.AddArg(dst)
   4436 		v.AddArg(src)
   4437 		v0 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
   4438 		v0.AuxInt = makeValAndOff(256, 512)
   4439 		v0.AddArg(dst)
   4440 		v0.AddArg(src)
   4441 		v1 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
   4442 		v1.AuxInt = makeValAndOff(256, 256)
   4443 		v1.AddArg(dst)
   4444 		v1.AddArg(src)
   4445 		v2 := b.NewValue0(v.Pos, OpS390XMVC, types.TypeMem)
   4446 		v2.AuxInt = makeValAndOff(256, 0)
   4447 		v2.AddArg(dst)
   4448 		v2.AddArg(src)
   4449 		v2.AddArg(mem)
   4450 		v1.AddArg(v2)
   4451 		v0.AddArg(v1)
   4452 		v.AddArg(v0)
   4453 		return true
   4454 	}
   4455 	// match: (Move [s] dst src mem)
   4456 	// cond: s > 1024
   4457 	// result: (LoweredMove [s%256] dst src (ADDconst <src.Type> src [(s/256)*256]) mem)
   4458 	for {
   4459 		s := v.AuxInt
   4460 		_ = v.Args[2]
   4461 		dst := v.Args[0]
   4462 		src := v.Args[1]
   4463 		mem := v.Args[2]
   4464 		if !(s > 1024) {
   4465 			break
   4466 		}
   4467 		v.reset(OpS390XLoweredMove)
   4468 		v.AuxInt = s % 256
   4469 		v.AddArg(dst)
   4470 		v.AddArg(src)
   4471 		v0 := b.NewValue0(v.Pos, OpS390XADDconst, src.Type)
   4472 		v0.AuxInt = (s / 256) * 256
   4473 		v0.AddArg(src)
   4474 		v.AddArg(v0)
   4475 		v.AddArg(mem)
   4476 		return true
   4477 	}
   4478 	return false
   4479 }
   4480 func rewriteValueS390X_OpMul16_0(v *Value) bool {
   4481 	// match: (Mul16 x y)
   4482 	// cond:
   4483 	// result: (MULLW  x y)
   4484 	for {
   4485 		_ = v.Args[1]
   4486 		x := v.Args[0]
   4487 		y := v.Args[1]
   4488 		v.reset(OpS390XMULLW)
   4489 		v.AddArg(x)
   4490 		v.AddArg(y)
   4491 		return true
   4492 	}
   4493 }
   4494 func rewriteValueS390X_OpMul32_0(v *Value) bool {
   4495 	// match: (Mul32 x y)
   4496 	// cond:
   4497 	// result: (MULLW  x y)
   4498 	for {
   4499 		_ = v.Args[1]
   4500 		x := v.Args[0]
   4501 		y := v.Args[1]
   4502 		v.reset(OpS390XMULLW)
   4503 		v.AddArg(x)
   4504 		v.AddArg(y)
   4505 		return true
   4506 	}
   4507 }
   4508 func rewriteValueS390X_OpMul32F_0(v *Value) bool {
   4509 	// match: (Mul32F x y)
   4510 	// cond:
   4511 	// result: (FMULS x y)
   4512 	for {
   4513 		_ = v.Args[1]
   4514 		x := v.Args[0]
   4515 		y := v.Args[1]
   4516 		v.reset(OpS390XFMULS)
   4517 		v.AddArg(x)
   4518 		v.AddArg(y)
   4519 		return true
   4520 	}
   4521 }
   4522 func rewriteValueS390X_OpMul64_0(v *Value) bool {
   4523 	// match: (Mul64 x y)
   4524 	// cond:
   4525 	// result: (MULLD  x y)
   4526 	for {
   4527 		_ = v.Args[1]
   4528 		x := v.Args[0]
   4529 		y := v.Args[1]
   4530 		v.reset(OpS390XMULLD)
   4531 		v.AddArg(x)
   4532 		v.AddArg(y)
   4533 		return true
   4534 	}
   4535 }
   4536 func rewriteValueS390X_OpMul64F_0(v *Value) bool {
   4537 	// match: (Mul64F x y)
   4538 	// cond:
   4539 	// result: (FMUL x y)
   4540 	for {
   4541 		_ = v.Args[1]
   4542 		x := v.Args[0]
   4543 		y := v.Args[1]
   4544 		v.reset(OpS390XFMUL)
   4545 		v.AddArg(x)
   4546 		v.AddArg(y)
   4547 		return true
   4548 	}
   4549 }
   4550 func rewriteValueS390X_OpMul8_0(v *Value) bool {
   4551 	// match: (Mul8 x y)
   4552 	// cond:
   4553 	// result: (MULLW  x y)
   4554 	for {
   4555 		_ = v.Args[1]
   4556 		x := v.Args[0]
   4557 		y := v.Args[1]
   4558 		v.reset(OpS390XMULLW)
   4559 		v.AddArg(x)
   4560 		v.AddArg(y)
   4561 		return true
   4562 	}
   4563 }
   4564 func rewriteValueS390X_OpNeg16_0(v *Value) bool {
   4565 	b := v.Block
   4566 	_ = b
   4567 	typ := &b.Func.Config.Types
   4568 	_ = typ
   4569 	// match: (Neg16 x)
   4570 	// cond:
   4571 	// result: (NEGW (MOVHreg x))
   4572 	for {
   4573 		x := v.Args[0]
   4574 		v.reset(OpS390XNEGW)
   4575 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   4576 		v0.AddArg(x)
   4577 		v.AddArg(v0)
   4578 		return true
   4579 	}
   4580 }
   4581 func rewriteValueS390X_OpNeg32_0(v *Value) bool {
   4582 	// match: (Neg32 x)
   4583 	// cond:
   4584 	// result: (NEGW x)
   4585 	for {
   4586 		x := v.Args[0]
   4587 		v.reset(OpS390XNEGW)
   4588 		v.AddArg(x)
   4589 		return true
   4590 	}
   4591 }
   4592 func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
   4593 	// match: (Neg32F x)
   4594 	// cond:
   4595 	// result: (FNEGS x)
   4596 	for {
   4597 		x := v.Args[0]
   4598 		v.reset(OpS390XFNEGS)
   4599 		v.AddArg(x)
   4600 		return true
   4601 	}
   4602 }
   4603 func rewriteValueS390X_OpNeg64_0(v *Value) bool {
   4604 	// match: (Neg64 x)
   4605 	// cond:
   4606 	// result: (NEG x)
   4607 	for {
   4608 		x := v.Args[0]
   4609 		v.reset(OpS390XNEG)
   4610 		v.AddArg(x)
   4611 		return true
   4612 	}
   4613 }
   4614 func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
   4615 	// match: (Neg64F x)
   4616 	// cond:
   4617 	// result: (FNEG x)
   4618 	for {
   4619 		x := v.Args[0]
   4620 		v.reset(OpS390XFNEG)
   4621 		v.AddArg(x)
   4622 		return true
   4623 	}
   4624 }
   4625 func rewriteValueS390X_OpNeg8_0(v *Value) bool {
   4626 	b := v.Block
   4627 	_ = b
   4628 	typ := &b.Func.Config.Types
   4629 	_ = typ
   4630 	// match: (Neg8 x)
   4631 	// cond:
   4632 	// result: (NEGW (MOVBreg x))
   4633 	for {
   4634 		x := v.Args[0]
   4635 		v.reset(OpS390XNEGW)
   4636 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4637 		v0.AddArg(x)
   4638 		v.AddArg(v0)
   4639 		return true
   4640 	}
   4641 }
   4642 func rewriteValueS390X_OpNeq16_0(v *Value) bool {
   4643 	b := v.Block
   4644 	_ = b
   4645 	typ := &b.Func.Config.Types
   4646 	_ = typ
   4647 	// match: (Neq16 x y)
   4648 	// cond:
   4649 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVHreg x) (MOVHreg y)))
   4650 	for {
   4651 		_ = v.Args[1]
   4652 		x := v.Args[0]
   4653 		y := v.Args[1]
   4654 		v.reset(OpS390XMOVDNE)
   4655 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4656 		v0.AuxInt = 0
   4657 		v.AddArg(v0)
   4658 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4659 		v1.AuxInt = 1
   4660 		v.AddArg(v1)
   4661 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   4662 		v3 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   4663 		v3.AddArg(x)
   4664 		v2.AddArg(v3)
   4665 		v4 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   4666 		v4.AddArg(y)
   4667 		v2.AddArg(v4)
   4668 		v.AddArg(v2)
   4669 		return true
   4670 	}
   4671 }
   4672 func rewriteValueS390X_OpNeq32_0(v *Value) bool {
   4673 	b := v.Block
   4674 	_ = b
   4675 	typ := &b.Func.Config.Types
   4676 	_ = typ
   4677 	// match: (Neq32 x y)
   4678 	// cond:
   4679 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMPW x y))
   4680 	for {
   4681 		_ = v.Args[1]
   4682 		x := v.Args[0]
   4683 		y := v.Args[1]
   4684 		v.reset(OpS390XMOVDNE)
   4685 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4686 		v0.AuxInt = 0
   4687 		v.AddArg(v0)
   4688 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4689 		v1.AuxInt = 1
   4690 		v.AddArg(v1)
   4691 		v2 := b.NewValue0(v.Pos, OpS390XCMPW, types.TypeFlags)
   4692 		v2.AddArg(x)
   4693 		v2.AddArg(y)
   4694 		v.AddArg(v2)
   4695 		return true
   4696 	}
   4697 }
   4698 func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
   4699 	b := v.Block
   4700 	_ = b
   4701 	typ := &b.Func.Config.Types
   4702 	_ = typ
   4703 	// match: (Neq32F x y)
   4704 	// cond:
   4705 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMPS x y))
   4706 	for {
   4707 		_ = v.Args[1]
   4708 		x := v.Args[0]
   4709 		y := v.Args[1]
   4710 		v.reset(OpS390XMOVDNE)
   4711 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4712 		v0.AuxInt = 0
   4713 		v.AddArg(v0)
   4714 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4715 		v1.AuxInt = 1
   4716 		v.AddArg(v1)
   4717 		v2 := b.NewValue0(v.Pos, OpS390XFCMPS, types.TypeFlags)
   4718 		v2.AddArg(x)
   4719 		v2.AddArg(y)
   4720 		v.AddArg(v2)
   4721 		return true
   4722 	}
   4723 }
   4724 func rewriteValueS390X_OpNeq64_0(v *Value) bool {
   4725 	b := v.Block
   4726 	_ = b
   4727 	typ := &b.Func.Config.Types
   4728 	_ = typ
   4729 	// match: (Neq64 x y)
   4730 	// cond:
   4731 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   4732 	for {
   4733 		_ = v.Args[1]
   4734 		x := v.Args[0]
   4735 		y := v.Args[1]
   4736 		v.reset(OpS390XMOVDNE)
   4737 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4738 		v0.AuxInt = 0
   4739 		v.AddArg(v0)
   4740 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4741 		v1.AuxInt = 1
   4742 		v.AddArg(v1)
   4743 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   4744 		v2.AddArg(x)
   4745 		v2.AddArg(y)
   4746 		v.AddArg(v2)
   4747 		return true
   4748 	}
   4749 }
   4750 func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
   4751 	b := v.Block
   4752 	_ = b
   4753 	typ := &b.Func.Config.Types
   4754 	_ = typ
   4755 	// match: (Neq64F x y)
   4756 	// cond:
   4757 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (FCMP x y))
   4758 	for {
   4759 		_ = v.Args[1]
   4760 		x := v.Args[0]
   4761 		y := v.Args[1]
   4762 		v.reset(OpS390XMOVDNE)
   4763 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4764 		v0.AuxInt = 0
   4765 		v.AddArg(v0)
   4766 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4767 		v1.AuxInt = 1
   4768 		v.AddArg(v1)
   4769 		v2 := b.NewValue0(v.Pos, OpS390XFCMP, types.TypeFlags)
   4770 		v2.AddArg(x)
   4771 		v2.AddArg(y)
   4772 		v.AddArg(v2)
   4773 		return true
   4774 	}
   4775 }
   4776 func rewriteValueS390X_OpNeq8_0(v *Value) bool {
   4777 	b := v.Block
   4778 	_ = b
   4779 	typ := &b.Func.Config.Types
   4780 	_ = typ
   4781 	// match: (Neq8 x y)
   4782 	// cond:
   4783 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   4784 	for {
   4785 		_ = v.Args[1]
   4786 		x := v.Args[0]
   4787 		y := v.Args[1]
   4788 		v.reset(OpS390XMOVDNE)
   4789 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4790 		v0.AuxInt = 0
   4791 		v.AddArg(v0)
   4792 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4793 		v1.AuxInt = 1
   4794 		v.AddArg(v1)
   4795 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   4796 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4797 		v3.AddArg(x)
   4798 		v2.AddArg(v3)
   4799 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4800 		v4.AddArg(y)
   4801 		v2.AddArg(v4)
   4802 		v.AddArg(v2)
   4803 		return true
   4804 	}
   4805 }
   4806 func rewriteValueS390X_OpNeqB_0(v *Value) bool {
   4807 	b := v.Block
   4808 	_ = b
   4809 	typ := &b.Func.Config.Types
   4810 	_ = typ
   4811 	// match: (NeqB x y)
   4812 	// cond:
   4813 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP (MOVBreg x) (MOVBreg y)))
   4814 	for {
   4815 		_ = v.Args[1]
   4816 		x := v.Args[0]
   4817 		y := v.Args[1]
   4818 		v.reset(OpS390XMOVDNE)
   4819 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4820 		v0.AuxInt = 0
   4821 		v.AddArg(v0)
   4822 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4823 		v1.AuxInt = 1
   4824 		v.AddArg(v1)
   4825 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   4826 		v3 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4827 		v3.AddArg(x)
   4828 		v2.AddArg(v3)
   4829 		v4 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   4830 		v4.AddArg(y)
   4831 		v2.AddArg(v4)
   4832 		v.AddArg(v2)
   4833 		return true
   4834 	}
   4835 }
   4836 func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
   4837 	b := v.Block
   4838 	_ = b
   4839 	typ := &b.Func.Config.Types
   4840 	_ = typ
   4841 	// match: (NeqPtr x y)
   4842 	// cond:
   4843 	// result: (MOVDNE (MOVDconst [0]) (MOVDconst [1]) (CMP x y))
   4844 	for {
   4845 		_ = v.Args[1]
   4846 		x := v.Args[0]
   4847 		y := v.Args[1]
   4848 		v.reset(OpS390XMOVDNE)
   4849 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4850 		v0.AuxInt = 0
   4851 		v.AddArg(v0)
   4852 		v1 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4853 		v1.AuxInt = 1
   4854 		v.AddArg(v1)
   4855 		v2 := b.NewValue0(v.Pos, OpS390XCMP, types.TypeFlags)
   4856 		v2.AddArg(x)
   4857 		v2.AddArg(y)
   4858 		v.AddArg(v2)
   4859 		return true
   4860 	}
   4861 }
   4862 func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
   4863 	// match: (NilCheck ptr mem)
   4864 	// cond:
   4865 	// result: (LoweredNilCheck ptr mem)
   4866 	for {
   4867 		_ = v.Args[1]
   4868 		ptr := v.Args[0]
   4869 		mem := v.Args[1]
   4870 		v.reset(OpS390XLoweredNilCheck)
   4871 		v.AddArg(ptr)
   4872 		v.AddArg(mem)
   4873 		return true
   4874 	}
   4875 }
   4876 func rewriteValueS390X_OpNot_0(v *Value) bool {
   4877 	// match: (Not x)
   4878 	// cond:
   4879 	// result: (XORWconst [1] x)
   4880 	for {
   4881 		x := v.Args[0]
   4882 		v.reset(OpS390XXORWconst)
   4883 		v.AuxInt = 1
   4884 		v.AddArg(x)
   4885 		return true
   4886 	}
   4887 }
   4888 func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
   4889 	b := v.Block
   4890 	_ = b
   4891 	typ := &b.Func.Config.Types
   4892 	_ = typ
   4893 	// match: (OffPtr [off] ptr:(SP))
   4894 	// cond:
   4895 	// result: (MOVDaddr [off] ptr)
   4896 	for {
   4897 		off := v.AuxInt
   4898 		ptr := v.Args[0]
   4899 		if ptr.Op != OpSP {
   4900 			break
   4901 		}
   4902 		v.reset(OpS390XMOVDaddr)
   4903 		v.AuxInt = off
   4904 		v.AddArg(ptr)
   4905 		return true
   4906 	}
   4907 	// match: (OffPtr [off] ptr)
   4908 	// cond: is32Bit(off)
   4909 	// result: (ADDconst [off] ptr)
   4910 	for {
   4911 		off := v.AuxInt
   4912 		ptr := v.Args[0]
   4913 		if !(is32Bit(off)) {
   4914 			break
   4915 		}
   4916 		v.reset(OpS390XADDconst)
   4917 		v.AuxInt = off
   4918 		v.AddArg(ptr)
   4919 		return true
   4920 	}
   4921 	// match: (OffPtr [off] ptr)
   4922 	// cond:
   4923 	// result: (ADD (MOVDconst [off]) ptr)
   4924 	for {
   4925 		off := v.AuxInt
   4926 		ptr := v.Args[0]
   4927 		v.reset(OpS390XADD)
   4928 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   4929 		v0.AuxInt = off
   4930 		v.AddArg(v0)
   4931 		v.AddArg(ptr)
   4932 		return true
   4933 	}
   4934 }
   4935 func rewriteValueS390X_OpOr16_0(v *Value) bool {
   4936 	// match: (Or16 x y)
   4937 	// cond:
   4938 	// result: (ORW x y)
   4939 	for {
   4940 		_ = v.Args[1]
   4941 		x := v.Args[0]
   4942 		y := v.Args[1]
   4943 		v.reset(OpS390XORW)
   4944 		v.AddArg(x)
   4945 		v.AddArg(y)
   4946 		return true
   4947 	}
   4948 }
   4949 func rewriteValueS390X_OpOr32_0(v *Value) bool {
   4950 	// match: (Or32 x y)
   4951 	// cond:
   4952 	// result: (ORW x y)
   4953 	for {
   4954 		_ = v.Args[1]
   4955 		x := v.Args[0]
   4956 		y := v.Args[1]
   4957 		v.reset(OpS390XORW)
   4958 		v.AddArg(x)
   4959 		v.AddArg(y)
   4960 		return true
   4961 	}
   4962 }
   4963 func rewriteValueS390X_OpOr64_0(v *Value) bool {
   4964 	// match: (Or64 x y)
   4965 	// cond:
   4966 	// result: (OR x y)
   4967 	for {
   4968 		_ = v.Args[1]
   4969 		x := v.Args[0]
   4970 		y := v.Args[1]
   4971 		v.reset(OpS390XOR)
   4972 		v.AddArg(x)
   4973 		v.AddArg(y)
   4974 		return true
   4975 	}
   4976 }
   4977 func rewriteValueS390X_OpOr8_0(v *Value) bool {
   4978 	// match: (Or8 x y)
   4979 	// cond:
   4980 	// result: (ORW x y)
   4981 	for {
   4982 		_ = v.Args[1]
   4983 		x := v.Args[0]
   4984 		y := v.Args[1]
   4985 		v.reset(OpS390XORW)
   4986 		v.AddArg(x)
   4987 		v.AddArg(y)
   4988 		return true
   4989 	}
   4990 }
   4991 func rewriteValueS390X_OpOrB_0(v *Value) bool {
   4992 	// match: (OrB x y)
   4993 	// cond:
   4994 	// result: (ORW x y)
   4995 	for {
   4996 		_ = v.Args[1]
   4997 		x := v.Args[0]
   4998 		y := v.Args[1]
   4999 		v.reset(OpS390XORW)
   5000 		v.AddArg(x)
   5001 		v.AddArg(y)
   5002 		return true
   5003 	}
   5004 }
   5005 func rewriteValueS390X_OpRound_0(v *Value) bool {
   5006 	// match: (Round x)
   5007 	// cond:
   5008 	// result: (FIDBR [1] x)
   5009 	for {
   5010 		x := v.Args[0]
   5011 		v.reset(OpS390XFIDBR)
   5012 		v.AuxInt = 1
   5013 		v.AddArg(x)
   5014 		return true
   5015 	}
   5016 }
   5017 func rewriteValueS390X_OpRound32F_0(v *Value) bool {
   5018 	// match: (Round32F x)
   5019 	// cond:
   5020 	// result: (LoweredRound32F x)
   5021 	for {
   5022 		x := v.Args[0]
   5023 		v.reset(OpS390XLoweredRound32F)
   5024 		v.AddArg(x)
   5025 		return true
   5026 	}
   5027 }
   5028 func rewriteValueS390X_OpRound64F_0(v *Value) bool {
   5029 	// match: (Round64F x)
   5030 	// cond:
   5031 	// result: (LoweredRound64F x)
   5032 	for {
   5033 		x := v.Args[0]
   5034 		v.reset(OpS390XLoweredRound64F)
   5035 		v.AddArg(x)
   5036 		return true
   5037 	}
   5038 }
   5039 func rewriteValueS390X_OpRoundToEven_0(v *Value) bool {
   5040 	// match: (RoundToEven x)
   5041 	// cond:
   5042 	// result: (FIDBR [4] x)
   5043 	for {
   5044 		x := v.Args[0]
   5045 		v.reset(OpS390XFIDBR)
   5046 		v.AuxInt = 4
   5047 		v.AddArg(x)
   5048 		return true
   5049 	}
   5050 }
   5051 func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
   5052 	b := v.Block
   5053 	_ = b
   5054 	typ := &b.Func.Config.Types
   5055 	_ = typ
   5056 	// match: (Rsh16Ux16 <t> x y)
   5057 	// cond:
   5058 	// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [15])))
   5059 	for {
   5060 		t := v.Type
   5061 		_ = v.Args[1]
   5062 		x := v.Args[0]
   5063 		y := v.Args[1]
   5064 		v.reset(OpS390XANDW)
   5065 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5066 		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5067 		v1.AddArg(x)
   5068 		v0.AddArg(v1)
   5069 		v0.AddArg(y)
   5070 		v.AddArg(v0)
   5071 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5072 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5073 		v3.AuxInt = 15
   5074 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5075 		v4.AddArg(y)
   5076 		v3.AddArg(v4)
   5077 		v2.AddArg(v3)
   5078 		v.AddArg(v2)
   5079 		return true
   5080 	}
   5081 }
   5082 func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
   5083 	b := v.Block
   5084 	_ = b
   5085 	typ := &b.Func.Config.Types
   5086 	_ = typ
   5087 	// match: (Rsh16Ux32 <t> x y)
   5088 	// cond:
   5089 	// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst y [15])))
   5090 	for {
   5091 		t := v.Type
   5092 		_ = v.Args[1]
   5093 		x := v.Args[0]
   5094 		y := v.Args[1]
   5095 		v.reset(OpS390XANDW)
   5096 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5097 		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5098 		v1.AddArg(x)
   5099 		v0.AddArg(v1)
   5100 		v0.AddArg(y)
   5101 		v.AddArg(v0)
   5102 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5103 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5104 		v3.AuxInt = 15
   5105 		v3.AddArg(y)
   5106 		v2.AddArg(v3)
   5107 		v.AddArg(v2)
   5108 		return true
   5109 	}
   5110 }
   5111 func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
   5112 	b := v.Block
   5113 	_ = b
   5114 	typ := &b.Func.Config.Types
   5115 	_ = typ
   5116 	// match: (Rsh16Ux64 <t> x y)
   5117 	// cond:
   5118 	// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPUconst y [15])))
   5119 	for {
   5120 		t := v.Type
   5121 		_ = v.Args[1]
   5122 		x := v.Args[0]
   5123 		y := v.Args[1]
   5124 		v.reset(OpS390XANDW)
   5125 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5126 		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5127 		v1.AddArg(x)
   5128 		v0.AddArg(v1)
   5129 		v0.AddArg(y)
   5130 		v.AddArg(v0)
   5131 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5132 		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5133 		v3.AuxInt = 15
   5134 		v3.AddArg(y)
   5135 		v2.AddArg(v3)
   5136 		v.AddArg(v2)
   5137 		return true
   5138 	}
   5139 }
   5140 func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
   5141 	b := v.Block
   5142 	_ = b
   5143 	typ := &b.Func.Config.Types
   5144 	_ = typ
   5145 	// match: (Rsh16Ux8 <t> x y)
   5146 	// cond:
   5147 	// result: (ANDW (SRW <t> (MOVHZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [15])))
   5148 	for {
   5149 		t := v.Type
   5150 		_ = v.Args[1]
   5151 		x := v.Args[0]
   5152 		y := v.Args[1]
   5153 		v.reset(OpS390XANDW)
   5154 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5155 		v1 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5156 		v1.AddArg(x)
   5157 		v0.AddArg(v1)
   5158 		v0.AddArg(y)
   5159 		v.AddArg(v0)
   5160 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5161 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5162 		v3.AuxInt = 15
   5163 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5164 		v4.AddArg(y)
   5165 		v3.AddArg(v4)
   5166 		v2.AddArg(v3)
   5167 		v.AddArg(v2)
   5168 		return true
   5169 	}
   5170 }
   5171 func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
   5172 	b := v.Block
   5173 	_ = b
   5174 	typ := &b.Func.Config.Types
   5175 	_ = typ
   5176 	// match: (Rsh16x16 <t> x y)
   5177 	// cond:
   5178 	// result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [15])))))
   5179 	for {
   5180 		t := v.Type
   5181 		_ = v.Args[1]
   5182 		x := v.Args[0]
   5183 		y := v.Args[1]
   5184 		v.reset(OpS390XSRAW)
   5185 		v.Type = t
   5186 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   5187 		v0.AddArg(x)
   5188 		v.AddArg(v0)
   5189 		v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5190 		v1.AddArg(y)
   5191 		v2 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5192 		v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5193 		v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5194 		v4.AuxInt = 15
   5195 		v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5196 		v5.AddArg(y)
   5197 		v4.AddArg(v5)
   5198 		v3.AddArg(v4)
   5199 		v2.AddArg(v3)
   5200 		v1.AddArg(v2)
   5201 		v.AddArg(v1)
   5202 		return true
   5203 	}
   5204 }
   5205 func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
   5206 	b := v.Block
   5207 	_ = b
   5208 	typ := &b.Func.Config.Types
   5209 	_ = typ
   5210 	// match: (Rsh16x32 <t> x y)
   5211 	// cond:
   5212 	// result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [15])))))
   5213 	for {
   5214 		t := v.Type
   5215 		_ = v.Args[1]
   5216 		x := v.Args[0]
   5217 		y := v.Args[1]
   5218 		v.reset(OpS390XSRAW)
   5219 		v.Type = t
   5220 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   5221 		v0.AddArg(x)
   5222 		v.AddArg(v0)
   5223 		v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5224 		v1.AddArg(y)
   5225 		v2 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5226 		v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5227 		v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5228 		v4.AuxInt = 15
   5229 		v4.AddArg(y)
   5230 		v3.AddArg(v4)
   5231 		v2.AddArg(v3)
   5232 		v1.AddArg(v2)
   5233 		v.AddArg(v1)
   5234 		return true
   5235 	}
   5236 }
   5237 func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
   5238 	b := v.Block
   5239 	_ = b
   5240 	typ := &b.Func.Config.Types
   5241 	_ = typ
   5242 	// match: (Rsh16x64 <t> x y)
   5243 	// cond:
   5244 	// result: (SRAW <t> (MOVHreg x) (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [15])))))
   5245 	for {
   5246 		t := v.Type
   5247 		_ = v.Args[1]
   5248 		x := v.Args[0]
   5249 		y := v.Args[1]
   5250 		v.reset(OpS390XSRAW)
   5251 		v.Type = t
   5252 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   5253 		v0.AddArg(x)
   5254 		v.AddArg(v0)
   5255 		v1 := b.NewValue0(v.Pos, OpS390XOR, y.Type)
   5256 		v1.AddArg(y)
   5257 		v2 := b.NewValue0(v.Pos, OpS390XNOT, y.Type)
   5258 		v3 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, y.Type)
   5259 		v4 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5260 		v4.AuxInt = 15
   5261 		v4.AddArg(y)
   5262 		v3.AddArg(v4)
   5263 		v2.AddArg(v3)
   5264 		v1.AddArg(v2)
   5265 		v.AddArg(v1)
   5266 		return true
   5267 	}
   5268 }
   5269 func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
   5270 	b := v.Block
   5271 	_ = b
   5272 	typ := &b.Func.Config.Types
   5273 	_ = typ
   5274 	// match: (Rsh16x8 <t> x y)
   5275 	// cond:
   5276 	// result: (SRAW <t> (MOVHreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [15])))))
   5277 	for {
   5278 		t := v.Type
   5279 		_ = v.Args[1]
   5280 		x := v.Args[0]
   5281 		y := v.Args[1]
   5282 		v.reset(OpS390XSRAW)
   5283 		v.Type = t
   5284 		v0 := b.NewValue0(v.Pos, OpS390XMOVHreg, typ.Int64)
   5285 		v0.AddArg(x)
   5286 		v.AddArg(v0)
   5287 		v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5288 		v1.AddArg(y)
   5289 		v2 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5290 		v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5291 		v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5292 		v4.AuxInt = 15
   5293 		v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5294 		v5.AddArg(y)
   5295 		v4.AddArg(v5)
   5296 		v3.AddArg(v4)
   5297 		v2.AddArg(v3)
   5298 		v1.AddArg(v2)
   5299 		v.AddArg(v1)
   5300 		return true
   5301 	}
   5302 }
   5303 func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
   5304 	b := v.Block
   5305 	_ = b
   5306 	typ := &b.Func.Config.Types
   5307 	_ = typ
   5308 	// match: (Rsh32Ux16 <t> x y)
   5309 	// cond:
   5310 	// result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [31])))
   5311 	for {
   5312 		t := v.Type
   5313 		_ = v.Args[1]
   5314 		x := v.Args[0]
   5315 		y := v.Args[1]
   5316 		v.reset(OpS390XANDW)
   5317 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5318 		v0.AddArg(x)
   5319 		v0.AddArg(y)
   5320 		v.AddArg(v0)
   5321 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5322 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5323 		v2.AuxInt = 31
   5324 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5325 		v3.AddArg(y)
   5326 		v2.AddArg(v3)
   5327 		v1.AddArg(v2)
   5328 		v.AddArg(v1)
   5329 		return true
   5330 	}
   5331 }
   5332 func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
   5333 	b := v.Block
   5334 	_ = b
   5335 	// match: (Rsh32Ux32 <t> x y)
   5336 	// cond:
   5337 	// result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst y [31])))
   5338 	for {
   5339 		t := v.Type
   5340 		_ = v.Args[1]
   5341 		x := v.Args[0]
   5342 		y := v.Args[1]
   5343 		v.reset(OpS390XANDW)
   5344 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5345 		v0.AddArg(x)
   5346 		v0.AddArg(y)
   5347 		v.AddArg(v0)
   5348 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5349 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5350 		v2.AuxInt = 31
   5351 		v2.AddArg(y)
   5352 		v1.AddArg(v2)
   5353 		v.AddArg(v1)
   5354 		return true
   5355 	}
   5356 }
   5357 func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
   5358 	b := v.Block
   5359 	_ = b
   5360 	// match: (Rsh32Ux64 <t> x y)
   5361 	// cond:
   5362 	// result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPUconst y [31])))
   5363 	for {
   5364 		t := v.Type
   5365 		_ = v.Args[1]
   5366 		x := v.Args[0]
   5367 		y := v.Args[1]
   5368 		v.reset(OpS390XANDW)
   5369 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5370 		v0.AddArg(x)
   5371 		v0.AddArg(y)
   5372 		v.AddArg(v0)
   5373 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5374 		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5375 		v2.AuxInt = 31
   5376 		v2.AddArg(y)
   5377 		v1.AddArg(v2)
   5378 		v.AddArg(v1)
   5379 		return true
   5380 	}
   5381 }
   5382 func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
   5383 	b := v.Block
   5384 	_ = b
   5385 	typ := &b.Func.Config.Types
   5386 	_ = typ
   5387 	// match: (Rsh32Ux8 <t> x y)
   5388 	// cond:
   5389 	// result: (ANDW (SRW <t> x y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [31])))
   5390 	for {
   5391 		t := v.Type
   5392 		_ = v.Args[1]
   5393 		x := v.Args[0]
   5394 		y := v.Args[1]
   5395 		v.reset(OpS390XANDW)
   5396 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5397 		v0.AddArg(x)
   5398 		v0.AddArg(y)
   5399 		v.AddArg(v0)
   5400 		v1 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5401 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5402 		v2.AuxInt = 31
   5403 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5404 		v3.AddArg(y)
   5405 		v2.AddArg(v3)
   5406 		v1.AddArg(v2)
   5407 		v.AddArg(v1)
   5408 		return true
   5409 	}
   5410 }
   5411 func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
   5412 	b := v.Block
   5413 	_ = b
   5414 	typ := &b.Func.Config.Types
   5415 	_ = typ
   5416 	// match: (Rsh32x16 <t> x y)
   5417 	// cond:
   5418 	// result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [31])))))
   5419 	for {
   5420 		t := v.Type
   5421 		_ = v.Args[1]
   5422 		x := v.Args[0]
   5423 		y := v.Args[1]
   5424 		v.reset(OpS390XSRAW)
   5425 		v.Type = t
   5426 		v.AddArg(x)
   5427 		v0 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5428 		v0.AddArg(y)
   5429 		v1 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5430 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5431 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5432 		v3.AuxInt = 31
   5433 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5434 		v4.AddArg(y)
   5435 		v3.AddArg(v4)
   5436 		v2.AddArg(v3)
   5437 		v1.AddArg(v2)
   5438 		v0.AddArg(v1)
   5439 		v.AddArg(v0)
   5440 		return true
   5441 	}
   5442 }
   5443 func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
   5444 	b := v.Block
   5445 	_ = b
   5446 	// match: (Rsh32x32 <t> x y)
   5447 	// cond:
   5448 	// result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [31])))))
   5449 	for {
   5450 		t := v.Type
   5451 		_ = v.Args[1]
   5452 		x := v.Args[0]
   5453 		y := v.Args[1]
   5454 		v.reset(OpS390XSRAW)
   5455 		v.Type = t
   5456 		v.AddArg(x)
   5457 		v0 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5458 		v0.AddArg(y)
   5459 		v1 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5460 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5461 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5462 		v3.AuxInt = 31
   5463 		v3.AddArg(y)
   5464 		v2.AddArg(v3)
   5465 		v1.AddArg(v2)
   5466 		v0.AddArg(v1)
   5467 		v.AddArg(v0)
   5468 		return true
   5469 	}
   5470 }
   5471 func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
   5472 	b := v.Block
   5473 	_ = b
   5474 	// match: (Rsh32x64 <t> x y)
   5475 	// cond:
   5476 	// result: (SRAW <t> x (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [31])))))
   5477 	for {
   5478 		t := v.Type
   5479 		_ = v.Args[1]
   5480 		x := v.Args[0]
   5481 		y := v.Args[1]
   5482 		v.reset(OpS390XSRAW)
   5483 		v.Type = t
   5484 		v.AddArg(x)
   5485 		v0 := b.NewValue0(v.Pos, OpS390XOR, y.Type)
   5486 		v0.AddArg(y)
   5487 		v1 := b.NewValue0(v.Pos, OpS390XNOT, y.Type)
   5488 		v2 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, y.Type)
   5489 		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5490 		v3.AuxInt = 31
   5491 		v3.AddArg(y)
   5492 		v2.AddArg(v3)
   5493 		v1.AddArg(v2)
   5494 		v0.AddArg(v1)
   5495 		v.AddArg(v0)
   5496 		return true
   5497 	}
   5498 }
   5499 func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
   5500 	b := v.Block
   5501 	_ = b
   5502 	typ := &b.Func.Config.Types
   5503 	_ = typ
   5504 	// match: (Rsh32x8 <t> x y)
   5505 	// cond:
   5506 	// result: (SRAW <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [31])))))
   5507 	for {
   5508 		t := v.Type
   5509 		_ = v.Args[1]
   5510 		x := v.Args[0]
   5511 		y := v.Args[1]
   5512 		v.reset(OpS390XSRAW)
   5513 		v.Type = t
   5514 		v.AddArg(x)
   5515 		v0 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5516 		v0.AddArg(y)
   5517 		v1 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5518 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5519 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5520 		v3.AuxInt = 31
   5521 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5522 		v4.AddArg(y)
   5523 		v3.AddArg(v4)
   5524 		v2.AddArg(v3)
   5525 		v1.AddArg(v2)
   5526 		v0.AddArg(v1)
   5527 		v.AddArg(v0)
   5528 		return true
   5529 	}
   5530 }
   5531 func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
   5532 	b := v.Block
   5533 	_ = b
   5534 	typ := &b.Func.Config.Types
   5535 	_ = typ
   5536 	// match: (Rsh64Ux16 <t> x y)
   5537 	// cond:
   5538 	// result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVHZreg y) [63])))
   5539 	for {
   5540 		t := v.Type
   5541 		_ = v.Args[1]
   5542 		x := v.Args[0]
   5543 		y := v.Args[1]
   5544 		v.reset(OpS390XAND)
   5545 		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
   5546 		v0.AddArg(x)
   5547 		v0.AddArg(y)
   5548 		v.AddArg(v0)
   5549 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   5550 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5551 		v2.AuxInt = 63
   5552 		v3 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5553 		v3.AddArg(y)
   5554 		v2.AddArg(v3)
   5555 		v1.AddArg(v2)
   5556 		v.AddArg(v1)
   5557 		return true
   5558 	}
   5559 }
   5560 func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
   5561 	b := v.Block
   5562 	_ = b
   5563 	// match: (Rsh64Ux32 <t> x y)
   5564 	// cond:
   5565 	// result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst y [63])))
   5566 	for {
   5567 		t := v.Type
   5568 		_ = v.Args[1]
   5569 		x := v.Args[0]
   5570 		y := v.Args[1]
   5571 		v.reset(OpS390XAND)
   5572 		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
   5573 		v0.AddArg(x)
   5574 		v0.AddArg(y)
   5575 		v.AddArg(v0)
   5576 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   5577 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5578 		v2.AuxInt = 63
   5579 		v2.AddArg(y)
   5580 		v1.AddArg(v2)
   5581 		v.AddArg(v1)
   5582 		return true
   5583 	}
   5584 }
   5585 func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
   5586 	b := v.Block
   5587 	_ = b
   5588 	// match: (Rsh64Ux64 <t> x y)
   5589 	// cond:
   5590 	// result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPUconst y [63])))
   5591 	for {
   5592 		t := v.Type
   5593 		_ = v.Args[1]
   5594 		x := v.Args[0]
   5595 		y := v.Args[1]
   5596 		v.reset(OpS390XAND)
   5597 		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
   5598 		v0.AddArg(x)
   5599 		v0.AddArg(y)
   5600 		v.AddArg(v0)
   5601 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   5602 		v2 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5603 		v2.AuxInt = 63
   5604 		v2.AddArg(y)
   5605 		v1.AddArg(v2)
   5606 		v.AddArg(v1)
   5607 		return true
   5608 	}
   5609 }
   5610 func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
   5611 	b := v.Block
   5612 	_ = b
   5613 	typ := &b.Func.Config.Types
   5614 	_ = typ
   5615 	// match: (Rsh64Ux8 <t> x y)
   5616 	// cond:
   5617 	// result: (AND (SRD <t> x y) (SUBEcarrymask <t> (CMPWUconst (MOVBZreg y) [63])))
   5618 	for {
   5619 		t := v.Type
   5620 		_ = v.Args[1]
   5621 		x := v.Args[0]
   5622 		y := v.Args[1]
   5623 		v.reset(OpS390XAND)
   5624 		v0 := b.NewValue0(v.Pos, OpS390XSRD, t)
   5625 		v0.AddArg(x)
   5626 		v0.AddArg(y)
   5627 		v.AddArg(v0)
   5628 		v1 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, t)
   5629 		v2 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5630 		v2.AuxInt = 63
   5631 		v3 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5632 		v3.AddArg(y)
   5633 		v2.AddArg(v3)
   5634 		v1.AddArg(v2)
   5635 		v.AddArg(v1)
   5636 		return true
   5637 	}
   5638 }
   5639 func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
   5640 	b := v.Block
   5641 	_ = b
   5642 	typ := &b.Func.Config.Types
   5643 	_ = typ
   5644 	// match: (Rsh64x16 <t> x y)
   5645 	// cond:
   5646 	// result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [63])))))
   5647 	for {
   5648 		t := v.Type
   5649 		_ = v.Args[1]
   5650 		x := v.Args[0]
   5651 		y := v.Args[1]
   5652 		v.reset(OpS390XSRAD)
   5653 		v.Type = t
   5654 		v.AddArg(x)
   5655 		v0 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5656 		v0.AddArg(y)
   5657 		v1 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5658 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5659 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5660 		v3.AuxInt = 63
   5661 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5662 		v4.AddArg(y)
   5663 		v3.AddArg(v4)
   5664 		v2.AddArg(v3)
   5665 		v1.AddArg(v2)
   5666 		v0.AddArg(v1)
   5667 		v.AddArg(v0)
   5668 		return true
   5669 	}
   5670 }
   5671 func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
   5672 	b := v.Block
   5673 	_ = b
   5674 	// match: (Rsh64x32 <t> x y)
   5675 	// cond:
   5676 	// result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [63])))))
   5677 	for {
   5678 		t := v.Type
   5679 		_ = v.Args[1]
   5680 		x := v.Args[0]
   5681 		y := v.Args[1]
   5682 		v.reset(OpS390XSRAD)
   5683 		v.Type = t
   5684 		v.AddArg(x)
   5685 		v0 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5686 		v0.AddArg(y)
   5687 		v1 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5688 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5689 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5690 		v3.AuxInt = 63
   5691 		v3.AddArg(y)
   5692 		v2.AddArg(v3)
   5693 		v1.AddArg(v2)
   5694 		v0.AddArg(v1)
   5695 		v.AddArg(v0)
   5696 		return true
   5697 	}
   5698 }
   5699 func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
   5700 	b := v.Block
   5701 	_ = b
   5702 	// match: (Rsh64x64 <t> x y)
   5703 	// cond:
   5704 	// result: (SRAD <t> x (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [63])))))
   5705 	for {
   5706 		t := v.Type
   5707 		_ = v.Args[1]
   5708 		x := v.Args[0]
   5709 		y := v.Args[1]
   5710 		v.reset(OpS390XSRAD)
   5711 		v.Type = t
   5712 		v.AddArg(x)
   5713 		v0 := b.NewValue0(v.Pos, OpS390XOR, y.Type)
   5714 		v0.AddArg(y)
   5715 		v1 := b.NewValue0(v.Pos, OpS390XNOT, y.Type)
   5716 		v2 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, y.Type)
   5717 		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5718 		v3.AuxInt = 63
   5719 		v3.AddArg(y)
   5720 		v2.AddArg(v3)
   5721 		v1.AddArg(v2)
   5722 		v0.AddArg(v1)
   5723 		v.AddArg(v0)
   5724 		return true
   5725 	}
   5726 }
   5727 func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
   5728 	b := v.Block
   5729 	_ = b
   5730 	typ := &b.Func.Config.Types
   5731 	_ = typ
   5732 	// match: (Rsh64x8 <t> x y)
   5733 	// cond:
   5734 	// result: (SRAD <t> x (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [63])))))
   5735 	for {
   5736 		t := v.Type
   5737 		_ = v.Args[1]
   5738 		x := v.Args[0]
   5739 		y := v.Args[1]
   5740 		v.reset(OpS390XSRAD)
   5741 		v.Type = t
   5742 		v.AddArg(x)
   5743 		v0 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5744 		v0.AddArg(y)
   5745 		v1 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5746 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5747 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5748 		v3.AuxInt = 63
   5749 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5750 		v4.AddArg(y)
   5751 		v3.AddArg(v4)
   5752 		v2.AddArg(v3)
   5753 		v1.AddArg(v2)
   5754 		v0.AddArg(v1)
   5755 		v.AddArg(v0)
   5756 		return true
   5757 	}
   5758 }
   5759 func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
   5760 	b := v.Block
   5761 	_ = b
   5762 	typ := &b.Func.Config.Types
   5763 	_ = typ
   5764 	// match: (Rsh8Ux16 <t> x y)
   5765 	// cond:
   5766 	// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVHZreg y) [7])))
   5767 	for {
   5768 		t := v.Type
   5769 		_ = v.Args[1]
   5770 		x := v.Args[0]
   5771 		y := v.Args[1]
   5772 		v.reset(OpS390XANDW)
   5773 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5774 		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5775 		v1.AddArg(x)
   5776 		v0.AddArg(v1)
   5777 		v0.AddArg(y)
   5778 		v.AddArg(v0)
   5779 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5780 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5781 		v3.AuxInt = 7
   5782 		v4 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5783 		v4.AddArg(y)
   5784 		v3.AddArg(v4)
   5785 		v2.AddArg(v3)
   5786 		v.AddArg(v2)
   5787 		return true
   5788 	}
   5789 }
   5790 func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
   5791 	b := v.Block
   5792 	_ = b
   5793 	typ := &b.Func.Config.Types
   5794 	_ = typ
   5795 	// match: (Rsh8Ux32 <t> x y)
   5796 	// cond:
   5797 	// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst y [7])))
   5798 	for {
   5799 		t := v.Type
   5800 		_ = v.Args[1]
   5801 		x := v.Args[0]
   5802 		y := v.Args[1]
   5803 		v.reset(OpS390XANDW)
   5804 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5805 		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5806 		v1.AddArg(x)
   5807 		v0.AddArg(v1)
   5808 		v0.AddArg(y)
   5809 		v.AddArg(v0)
   5810 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5811 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5812 		v3.AuxInt = 7
   5813 		v3.AddArg(y)
   5814 		v2.AddArg(v3)
   5815 		v.AddArg(v2)
   5816 		return true
   5817 	}
   5818 }
   5819 func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
   5820 	b := v.Block
   5821 	_ = b
   5822 	typ := &b.Func.Config.Types
   5823 	_ = typ
   5824 	// match: (Rsh8Ux64 <t> x y)
   5825 	// cond:
   5826 	// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPUconst y [7])))
   5827 	for {
   5828 		t := v.Type
   5829 		_ = v.Args[1]
   5830 		x := v.Args[0]
   5831 		y := v.Args[1]
   5832 		v.reset(OpS390XANDW)
   5833 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5834 		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5835 		v1.AddArg(x)
   5836 		v0.AddArg(v1)
   5837 		v0.AddArg(y)
   5838 		v.AddArg(v0)
   5839 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5840 		v3 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5841 		v3.AuxInt = 7
   5842 		v3.AddArg(y)
   5843 		v2.AddArg(v3)
   5844 		v.AddArg(v2)
   5845 		return true
   5846 	}
   5847 }
   5848 func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
   5849 	b := v.Block
   5850 	_ = b
   5851 	typ := &b.Func.Config.Types
   5852 	_ = typ
   5853 	// match: (Rsh8Ux8 <t> x y)
   5854 	// cond:
   5855 	// result: (ANDW (SRW <t> (MOVBZreg x) y) (SUBEWcarrymask <t> (CMPWUconst (MOVBZreg y) [7])))
   5856 	for {
   5857 		t := v.Type
   5858 		_ = v.Args[1]
   5859 		x := v.Args[0]
   5860 		y := v.Args[1]
   5861 		v.reset(OpS390XANDW)
   5862 		v0 := b.NewValue0(v.Pos, OpS390XSRW, t)
   5863 		v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5864 		v1.AddArg(x)
   5865 		v0.AddArg(v1)
   5866 		v0.AddArg(y)
   5867 		v.AddArg(v0)
   5868 		v2 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, t)
   5869 		v3 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5870 		v3.AuxInt = 7
   5871 		v4 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   5872 		v4.AddArg(y)
   5873 		v3.AddArg(v4)
   5874 		v2.AddArg(v3)
   5875 		v.AddArg(v2)
   5876 		return true
   5877 	}
   5878 }
   5879 func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
   5880 	b := v.Block
   5881 	_ = b
   5882 	typ := &b.Func.Config.Types
   5883 	_ = typ
   5884 	// match: (Rsh8x16 <t> x y)
   5885 	// cond:
   5886 	// result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVHZreg y) [7])))))
   5887 	for {
   5888 		t := v.Type
   5889 		_ = v.Args[1]
   5890 		x := v.Args[0]
   5891 		y := v.Args[1]
   5892 		v.reset(OpS390XSRAW)
   5893 		v.Type = t
   5894 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   5895 		v0.AddArg(x)
   5896 		v.AddArg(v0)
   5897 		v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5898 		v1.AddArg(y)
   5899 		v2 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5900 		v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5901 		v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5902 		v4.AuxInt = 7
   5903 		v5 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   5904 		v5.AddArg(y)
   5905 		v4.AddArg(v5)
   5906 		v3.AddArg(v4)
   5907 		v2.AddArg(v3)
   5908 		v1.AddArg(v2)
   5909 		v.AddArg(v1)
   5910 		return true
   5911 	}
   5912 }
   5913 func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
   5914 	b := v.Block
   5915 	_ = b
   5916 	typ := &b.Func.Config.Types
   5917 	_ = typ
   5918 	// match: (Rsh8x32 <t> x y)
   5919 	// cond:
   5920 	// result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst y [7])))))
   5921 	for {
   5922 		t := v.Type
   5923 		_ = v.Args[1]
   5924 		x := v.Args[0]
   5925 		y := v.Args[1]
   5926 		v.reset(OpS390XSRAW)
   5927 		v.Type = t
   5928 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   5929 		v0.AddArg(x)
   5930 		v.AddArg(v0)
   5931 		v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5932 		v1.AddArg(y)
   5933 		v2 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5934 		v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5935 		v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   5936 		v4.AuxInt = 7
   5937 		v4.AddArg(y)
   5938 		v3.AddArg(v4)
   5939 		v2.AddArg(v3)
   5940 		v1.AddArg(v2)
   5941 		v.AddArg(v1)
   5942 		return true
   5943 	}
   5944 }
   5945 func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
   5946 	b := v.Block
   5947 	_ = b
   5948 	typ := &b.Func.Config.Types
   5949 	_ = typ
   5950 	// match: (Rsh8x64 <t> x y)
   5951 	// cond:
   5952 	// result: (SRAW <t> (MOVBreg x) (OR <y.Type> y (NOT <y.Type> (SUBEcarrymask <y.Type> (CMPUconst y [7])))))
   5953 	for {
   5954 		t := v.Type
   5955 		_ = v.Args[1]
   5956 		x := v.Args[0]
   5957 		y := v.Args[1]
   5958 		v.reset(OpS390XSRAW)
   5959 		v.Type = t
   5960 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   5961 		v0.AddArg(x)
   5962 		v.AddArg(v0)
   5963 		v1 := b.NewValue0(v.Pos, OpS390XOR, y.Type)
   5964 		v1.AddArg(y)
   5965 		v2 := b.NewValue0(v.Pos, OpS390XNOT, y.Type)
   5966 		v3 := b.NewValue0(v.Pos, OpS390XSUBEcarrymask, y.Type)
   5967 		v4 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   5968 		v4.AuxInt = 7
   5969 		v4.AddArg(y)
   5970 		v3.AddArg(v4)
   5971 		v2.AddArg(v3)
   5972 		v1.AddArg(v2)
   5973 		v.AddArg(v1)
   5974 		return true
   5975 	}
   5976 }
   5977 func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
   5978 	b := v.Block
   5979 	_ = b
   5980 	typ := &b.Func.Config.Types
   5981 	_ = typ
   5982 	// match: (Rsh8x8 <t> x y)
   5983 	// cond:
   5984 	// result: (SRAW <t> (MOVBreg x) (ORW <y.Type> y (NOTW <y.Type> (SUBEWcarrymask <y.Type> (CMPWUconst (MOVBZreg y) [7])))))
   5985 	for {
   5986 		t := v.Type
   5987 		_ = v.Args[1]
   5988 		x := v.Args[0]
   5989 		y := v.Args[1]
   5990 		v.reset(OpS390XSRAW)
   5991 		v.Type = t
   5992 		v0 := b.NewValue0(v.Pos, OpS390XMOVBreg, typ.Int64)
   5993 		v0.AddArg(x)
   5994 		v.AddArg(v0)
   5995 		v1 := b.NewValue0(v.Pos, OpS390XORW, y.Type)
   5996 		v1.AddArg(y)
   5997 		v2 := b.NewValue0(v.Pos, OpS390XNOTW, y.Type)
   5998 		v3 := b.NewValue0(v.Pos, OpS390XSUBEWcarrymask, y.Type)
   5999 		v4 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   6000 		v4.AuxInt = 7
   6001 		v5 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.UInt64)
   6002 		v5.AddArg(y)
   6003 		v4.AddArg(v5)
   6004 		v3.AddArg(v4)
   6005 		v2.AddArg(v3)
   6006 		v1.AddArg(v2)
   6007 		v.AddArg(v1)
   6008 		return true
   6009 	}
   6010 }
   6011 func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
   6012 	// match: (ADD x (MOVDconst [c]))
   6013 	// cond: is32Bit(c)
   6014 	// result: (ADDconst [c] x)
   6015 	for {
   6016 		_ = v.Args[1]
   6017 		x := v.Args[0]
   6018 		v_1 := v.Args[1]
   6019 		if v_1.Op != OpS390XMOVDconst {
   6020 			break
   6021 		}
   6022 		c := v_1.AuxInt
   6023 		if !(is32Bit(c)) {
   6024 			break
   6025 		}
   6026 		v.reset(OpS390XADDconst)
   6027 		v.AuxInt = c
   6028 		v.AddArg(x)
   6029 		return true
   6030 	}
   6031 	// match: (ADD (MOVDconst [c]) x)
   6032 	// cond: is32Bit(c)
   6033 	// result: (ADDconst [c] x)
   6034 	for {
   6035 		_ = v.Args[1]
   6036 		v_0 := v.Args[0]
   6037 		if v_0.Op != OpS390XMOVDconst {
   6038 			break
   6039 		}
   6040 		c := v_0.AuxInt
   6041 		x := v.Args[1]
   6042 		if !(is32Bit(c)) {
   6043 			break
   6044 		}
   6045 		v.reset(OpS390XADDconst)
   6046 		v.AuxInt = c
   6047 		v.AddArg(x)
   6048 		return true
   6049 	}
   6050 	// match: (ADD (SLDconst x [c]) (SRDconst x [d]))
   6051 	// cond: d == 64-c
   6052 	// result: (RLLGconst [c] x)
   6053 	for {
   6054 		_ = v.Args[1]
   6055 		v_0 := v.Args[0]
   6056 		if v_0.Op != OpS390XSLDconst {
   6057 			break
   6058 		}
   6059 		c := v_0.AuxInt
   6060 		x := v_0.Args[0]
   6061 		v_1 := v.Args[1]
   6062 		if v_1.Op != OpS390XSRDconst {
   6063 			break
   6064 		}
   6065 		d := v_1.AuxInt
   6066 		if x != v_1.Args[0] {
   6067 			break
   6068 		}
   6069 		if !(d == 64-c) {
   6070 			break
   6071 		}
   6072 		v.reset(OpS390XRLLGconst)
   6073 		v.AuxInt = c
   6074 		v.AddArg(x)
   6075 		return true
   6076 	}
   6077 	// match: (ADD (SRDconst x [d]) (SLDconst x [c]))
   6078 	// cond: d == 64-c
   6079 	// result: (RLLGconst [c] x)
   6080 	for {
   6081 		_ = v.Args[1]
   6082 		v_0 := v.Args[0]
   6083 		if v_0.Op != OpS390XSRDconst {
   6084 			break
   6085 		}
   6086 		d := v_0.AuxInt
   6087 		x := v_0.Args[0]
   6088 		v_1 := v.Args[1]
   6089 		if v_1.Op != OpS390XSLDconst {
   6090 			break
   6091 		}
   6092 		c := v_1.AuxInt
   6093 		if x != v_1.Args[0] {
   6094 			break
   6095 		}
   6096 		if !(d == 64-c) {
   6097 			break
   6098 		}
   6099 		v.reset(OpS390XRLLGconst)
   6100 		v.AuxInt = c
   6101 		v.AddArg(x)
   6102 		return true
   6103 	}
   6104 	// match: (ADD idx (MOVDaddr [c] {s} ptr))
   6105 	// cond: ptr.Op != OpSB && idx.Op != OpSB
   6106 	// result: (MOVDaddridx [c] {s} ptr idx)
   6107 	for {
   6108 		_ = v.Args[1]
   6109 		idx := v.Args[0]
   6110 		v_1 := v.Args[1]
   6111 		if v_1.Op != OpS390XMOVDaddr {
   6112 			break
   6113 		}
   6114 		c := v_1.AuxInt
   6115 		s := v_1.Aux
   6116 		ptr := v_1.Args[0]
   6117 		if !(ptr.Op != OpSB && idx.Op != OpSB) {
   6118 			break
   6119 		}
   6120 		v.reset(OpS390XMOVDaddridx)
   6121 		v.AuxInt = c
   6122 		v.Aux = s
   6123 		v.AddArg(ptr)
   6124 		v.AddArg(idx)
   6125 		return true
   6126 	}
   6127 	// match: (ADD (MOVDaddr [c] {s} ptr) idx)
   6128 	// cond: ptr.Op != OpSB && idx.Op != OpSB
   6129 	// result: (MOVDaddridx [c] {s} ptr idx)
   6130 	for {
   6131 		_ = v.Args[1]
   6132 		v_0 := v.Args[0]
   6133 		if v_0.Op != OpS390XMOVDaddr {
   6134 			break
   6135 		}
   6136 		c := v_0.AuxInt
   6137 		s := v_0.Aux
   6138 		ptr := v_0.Args[0]
   6139 		idx := v.Args[1]
   6140 		if !(ptr.Op != OpSB && idx.Op != OpSB) {
   6141 			break
   6142 		}
   6143 		v.reset(OpS390XMOVDaddridx)
   6144 		v.AuxInt = c
   6145 		v.Aux = s
   6146 		v.AddArg(ptr)
   6147 		v.AddArg(idx)
   6148 		return true
   6149 	}
   6150 	// match: (ADD x (NEG y))
   6151 	// cond:
   6152 	// result: (SUB x y)
   6153 	for {
   6154 		_ = v.Args[1]
   6155 		x := v.Args[0]
   6156 		v_1 := v.Args[1]
   6157 		if v_1.Op != OpS390XNEG {
   6158 			break
   6159 		}
   6160 		y := v_1.Args[0]
   6161 		v.reset(OpS390XSUB)
   6162 		v.AddArg(x)
   6163 		v.AddArg(y)
   6164 		return true
   6165 	}
   6166 	// match: (ADD (NEG y) x)
   6167 	// cond:
   6168 	// result: (SUB x y)
   6169 	for {
   6170 		_ = v.Args[1]
   6171 		v_0 := v.Args[0]
   6172 		if v_0.Op != OpS390XNEG {
   6173 			break
   6174 		}
   6175 		y := v_0.Args[0]
   6176 		x := v.Args[1]
   6177 		v.reset(OpS390XSUB)
   6178 		v.AddArg(x)
   6179 		v.AddArg(y)
   6180 		return true
   6181 	}
   6182 	// match: (ADD <t> x g:(MOVDload [off] {sym} ptr mem))
   6183 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6184 	// result: (ADDload <t> [off] {sym} x ptr mem)
   6185 	for {
   6186 		t := v.Type
   6187 		_ = v.Args[1]
   6188 		x := v.Args[0]
   6189 		g := v.Args[1]
   6190 		if g.Op != OpS390XMOVDload {
   6191 			break
   6192 		}
   6193 		off := g.AuxInt
   6194 		sym := g.Aux
   6195 		_ = g.Args[1]
   6196 		ptr := g.Args[0]
   6197 		mem := g.Args[1]
   6198 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6199 			break
   6200 		}
   6201 		v.reset(OpS390XADDload)
   6202 		v.Type = t
   6203 		v.AuxInt = off
   6204 		v.Aux = sym
   6205 		v.AddArg(x)
   6206 		v.AddArg(ptr)
   6207 		v.AddArg(mem)
   6208 		return true
   6209 	}
   6210 	// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
   6211 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6212 	// result: (ADDload <t> [off] {sym} x ptr mem)
   6213 	for {
   6214 		t := v.Type
   6215 		_ = v.Args[1]
   6216 		g := v.Args[0]
   6217 		if g.Op != OpS390XMOVDload {
   6218 			break
   6219 		}
   6220 		off := g.AuxInt
   6221 		sym := g.Aux
   6222 		_ = g.Args[1]
   6223 		ptr := g.Args[0]
   6224 		mem := g.Args[1]
   6225 		x := v.Args[1]
   6226 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6227 			break
   6228 		}
   6229 		v.reset(OpS390XADDload)
   6230 		v.Type = t
   6231 		v.AuxInt = off
   6232 		v.Aux = sym
   6233 		v.AddArg(x)
   6234 		v.AddArg(ptr)
   6235 		v.AddArg(mem)
   6236 		return true
   6237 	}
   6238 	return false
   6239 }
   6240 func rewriteValueS390X_OpS390XADD_10(v *Value) bool {
   6241 	// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
   6242 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6243 	// result: (ADDload <t> [off] {sym} x ptr mem)
   6244 	for {
   6245 		t := v.Type
   6246 		_ = v.Args[1]
   6247 		g := v.Args[0]
   6248 		if g.Op != OpS390XMOVDload {
   6249 			break
   6250 		}
   6251 		off := g.AuxInt
   6252 		sym := g.Aux
   6253 		_ = g.Args[1]
   6254 		ptr := g.Args[0]
   6255 		mem := g.Args[1]
   6256 		x := v.Args[1]
   6257 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6258 			break
   6259 		}
   6260 		v.reset(OpS390XADDload)
   6261 		v.Type = t
   6262 		v.AuxInt = off
   6263 		v.Aux = sym
   6264 		v.AddArg(x)
   6265 		v.AddArg(ptr)
   6266 		v.AddArg(mem)
   6267 		return true
   6268 	}
   6269 	// match: (ADD <t> x g:(MOVDload [off] {sym} ptr mem))
   6270 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6271 	// result: (ADDload <t> [off] {sym} x ptr mem)
   6272 	for {
   6273 		t := v.Type
   6274 		_ = v.Args[1]
   6275 		x := v.Args[0]
   6276 		g := v.Args[1]
   6277 		if g.Op != OpS390XMOVDload {
   6278 			break
   6279 		}
   6280 		off := g.AuxInt
   6281 		sym := g.Aux
   6282 		_ = g.Args[1]
   6283 		ptr := g.Args[0]
   6284 		mem := g.Args[1]
   6285 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6286 			break
   6287 		}
   6288 		v.reset(OpS390XADDload)
   6289 		v.Type = t
   6290 		v.AuxInt = off
   6291 		v.Aux = sym
   6292 		v.AddArg(x)
   6293 		v.AddArg(ptr)
   6294 		v.AddArg(mem)
   6295 		return true
   6296 	}
   6297 	return false
   6298 }
   6299 func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
   6300 	// match: (ADDW x (MOVDconst [c]))
   6301 	// cond:
   6302 	// result: (ADDWconst [int64(int32(c))] x)
   6303 	for {
   6304 		_ = v.Args[1]
   6305 		x := v.Args[0]
   6306 		v_1 := v.Args[1]
   6307 		if v_1.Op != OpS390XMOVDconst {
   6308 			break
   6309 		}
   6310 		c := v_1.AuxInt
   6311 		v.reset(OpS390XADDWconst)
   6312 		v.AuxInt = int64(int32(c))
   6313 		v.AddArg(x)
   6314 		return true
   6315 	}
   6316 	// match: (ADDW (MOVDconst [c]) x)
   6317 	// cond:
   6318 	// result: (ADDWconst [int64(int32(c))] x)
   6319 	for {
   6320 		_ = v.Args[1]
   6321 		v_0 := v.Args[0]
   6322 		if v_0.Op != OpS390XMOVDconst {
   6323 			break
   6324 		}
   6325 		c := v_0.AuxInt
   6326 		x := v.Args[1]
   6327 		v.reset(OpS390XADDWconst)
   6328 		v.AuxInt = int64(int32(c))
   6329 		v.AddArg(x)
   6330 		return true
   6331 	}
   6332 	// match: (ADDW (SLWconst x [c]) (SRWconst x [d]))
   6333 	// cond: d == 32-c
   6334 	// result: (RLLconst [c] x)
   6335 	for {
   6336 		_ = v.Args[1]
   6337 		v_0 := v.Args[0]
   6338 		if v_0.Op != OpS390XSLWconst {
   6339 			break
   6340 		}
   6341 		c := v_0.AuxInt
   6342 		x := v_0.Args[0]
   6343 		v_1 := v.Args[1]
   6344 		if v_1.Op != OpS390XSRWconst {
   6345 			break
   6346 		}
   6347 		d := v_1.AuxInt
   6348 		if x != v_1.Args[0] {
   6349 			break
   6350 		}
   6351 		if !(d == 32-c) {
   6352 			break
   6353 		}
   6354 		v.reset(OpS390XRLLconst)
   6355 		v.AuxInt = c
   6356 		v.AddArg(x)
   6357 		return true
   6358 	}
   6359 	// match: (ADDW (SRWconst x [d]) (SLWconst x [c]))
   6360 	// cond: d == 32-c
   6361 	// result: (RLLconst [c] x)
   6362 	for {
   6363 		_ = v.Args[1]
   6364 		v_0 := v.Args[0]
   6365 		if v_0.Op != OpS390XSRWconst {
   6366 			break
   6367 		}
   6368 		d := v_0.AuxInt
   6369 		x := v_0.Args[0]
   6370 		v_1 := v.Args[1]
   6371 		if v_1.Op != OpS390XSLWconst {
   6372 			break
   6373 		}
   6374 		c := v_1.AuxInt
   6375 		if x != v_1.Args[0] {
   6376 			break
   6377 		}
   6378 		if !(d == 32-c) {
   6379 			break
   6380 		}
   6381 		v.reset(OpS390XRLLconst)
   6382 		v.AuxInt = c
   6383 		v.AddArg(x)
   6384 		return true
   6385 	}
   6386 	// match: (ADDW x (NEGW y))
   6387 	// cond:
   6388 	// result: (SUBW x y)
   6389 	for {
   6390 		_ = v.Args[1]
   6391 		x := v.Args[0]
   6392 		v_1 := v.Args[1]
   6393 		if v_1.Op != OpS390XNEGW {
   6394 			break
   6395 		}
   6396 		y := v_1.Args[0]
   6397 		v.reset(OpS390XSUBW)
   6398 		v.AddArg(x)
   6399 		v.AddArg(y)
   6400 		return true
   6401 	}
   6402 	// match: (ADDW (NEGW y) x)
   6403 	// cond:
   6404 	// result: (SUBW x y)
   6405 	for {
   6406 		_ = v.Args[1]
   6407 		v_0 := v.Args[0]
   6408 		if v_0.Op != OpS390XNEGW {
   6409 			break
   6410 		}
   6411 		y := v_0.Args[0]
   6412 		x := v.Args[1]
   6413 		v.reset(OpS390XSUBW)
   6414 		v.AddArg(x)
   6415 		v.AddArg(y)
   6416 		return true
   6417 	}
   6418 	// match: (ADDW <t> x g:(MOVWload [off] {sym} ptr mem))
   6419 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6420 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6421 	for {
   6422 		t := v.Type
   6423 		_ = v.Args[1]
   6424 		x := v.Args[0]
   6425 		g := v.Args[1]
   6426 		if g.Op != OpS390XMOVWload {
   6427 			break
   6428 		}
   6429 		off := g.AuxInt
   6430 		sym := g.Aux
   6431 		_ = g.Args[1]
   6432 		ptr := g.Args[0]
   6433 		mem := g.Args[1]
   6434 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6435 			break
   6436 		}
   6437 		v.reset(OpS390XADDWload)
   6438 		v.Type = t
   6439 		v.AuxInt = off
   6440 		v.Aux = sym
   6441 		v.AddArg(x)
   6442 		v.AddArg(ptr)
   6443 		v.AddArg(mem)
   6444 		return true
   6445 	}
   6446 	// match: (ADDW <t> g:(MOVWload [off] {sym} ptr mem) x)
   6447 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6448 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6449 	for {
   6450 		t := v.Type
   6451 		_ = v.Args[1]
   6452 		g := v.Args[0]
   6453 		if g.Op != OpS390XMOVWload {
   6454 			break
   6455 		}
   6456 		off := g.AuxInt
   6457 		sym := g.Aux
   6458 		_ = g.Args[1]
   6459 		ptr := g.Args[0]
   6460 		mem := g.Args[1]
   6461 		x := v.Args[1]
   6462 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6463 			break
   6464 		}
   6465 		v.reset(OpS390XADDWload)
   6466 		v.Type = t
   6467 		v.AuxInt = off
   6468 		v.Aux = sym
   6469 		v.AddArg(x)
   6470 		v.AddArg(ptr)
   6471 		v.AddArg(mem)
   6472 		return true
   6473 	}
   6474 	// match: (ADDW <t> g:(MOVWload [off] {sym} ptr mem) x)
   6475 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6476 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6477 	for {
   6478 		t := v.Type
   6479 		_ = v.Args[1]
   6480 		g := v.Args[0]
   6481 		if g.Op != OpS390XMOVWload {
   6482 			break
   6483 		}
   6484 		off := g.AuxInt
   6485 		sym := g.Aux
   6486 		_ = g.Args[1]
   6487 		ptr := g.Args[0]
   6488 		mem := g.Args[1]
   6489 		x := v.Args[1]
   6490 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6491 			break
   6492 		}
   6493 		v.reset(OpS390XADDWload)
   6494 		v.Type = t
   6495 		v.AuxInt = off
   6496 		v.Aux = sym
   6497 		v.AddArg(x)
   6498 		v.AddArg(ptr)
   6499 		v.AddArg(mem)
   6500 		return true
   6501 	}
   6502 	// match: (ADDW <t> x g:(MOVWload [off] {sym} ptr mem))
   6503 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6504 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6505 	for {
   6506 		t := v.Type
   6507 		_ = v.Args[1]
   6508 		x := v.Args[0]
   6509 		g := v.Args[1]
   6510 		if g.Op != OpS390XMOVWload {
   6511 			break
   6512 		}
   6513 		off := g.AuxInt
   6514 		sym := g.Aux
   6515 		_ = g.Args[1]
   6516 		ptr := g.Args[0]
   6517 		mem := g.Args[1]
   6518 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6519 			break
   6520 		}
   6521 		v.reset(OpS390XADDWload)
   6522 		v.Type = t
   6523 		v.AuxInt = off
   6524 		v.Aux = sym
   6525 		v.AddArg(x)
   6526 		v.AddArg(ptr)
   6527 		v.AddArg(mem)
   6528 		return true
   6529 	}
   6530 	return false
   6531 }
   6532 func rewriteValueS390X_OpS390XADDW_10(v *Value) bool {
   6533 	// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
   6534 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6535 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6536 	for {
   6537 		t := v.Type
   6538 		_ = v.Args[1]
   6539 		x := v.Args[0]
   6540 		g := v.Args[1]
   6541 		if g.Op != OpS390XMOVWZload {
   6542 			break
   6543 		}
   6544 		off := g.AuxInt
   6545 		sym := g.Aux
   6546 		_ = g.Args[1]
   6547 		ptr := g.Args[0]
   6548 		mem := g.Args[1]
   6549 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6550 			break
   6551 		}
   6552 		v.reset(OpS390XADDWload)
   6553 		v.Type = t
   6554 		v.AuxInt = off
   6555 		v.Aux = sym
   6556 		v.AddArg(x)
   6557 		v.AddArg(ptr)
   6558 		v.AddArg(mem)
   6559 		return true
   6560 	}
   6561 	// match: (ADDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   6562 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6563 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6564 	for {
   6565 		t := v.Type
   6566 		_ = v.Args[1]
   6567 		g := v.Args[0]
   6568 		if g.Op != OpS390XMOVWZload {
   6569 			break
   6570 		}
   6571 		off := g.AuxInt
   6572 		sym := g.Aux
   6573 		_ = g.Args[1]
   6574 		ptr := g.Args[0]
   6575 		mem := g.Args[1]
   6576 		x := v.Args[1]
   6577 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6578 			break
   6579 		}
   6580 		v.reset(OpS390XADDWload)
   6581 		v.Type = t
   6582 		v.AuxInt = off
   6583 		v.Aux = sym
   6584 		v.AddArg(x)
   6585 		v.AddArg(ptr)
   6586 		v.AddArg(mem)
   6587 		return true
   6588 	}
   6589 	// match: (ADDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   6590 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6591 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6592 	for {
   6593 		t := v.Type
   6594 		_ = v.Args[1]
   6595 		g := v.Args[0]
   6596 		if g.Op != OpS390XMOVWZload {
   6597 			break
   6598 		}
   6599 		off := g.AuxInt
   6600 		sym := g.Aux
   6601 		_ = g.Args[1]
   6602 		ptr := g.Args[0]
   6603 		mem := g.Args[1]
   6604 		x := v.Args[1]
   6605 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6606 			break
   6607 		}
   6608 		v.reset(OpS390XADDWload)
   6609 		v.Type = t
   6610 		v.AuxInt = off
   6611 		v.Aux = sym
   6612 		v.AddArg(x)
   6613 		v.AddArg(ptr)
   6614 		v.AddArg(mem)
   6615 		return true
   6616 	}
   6617 	// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
   6618 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   6619 	// result: (ADDWload <t> [off] {sym} x ptr mem)
   6620 	for {
   6621 		t := v.Type
   6622 		_ = v.Args[1]
   6623 		x := v.Args[0]
   6624 		g := v.Args[1]
   6625 		if g.Op != OpS390XMOVWZload {
   6626 			break
   6627 		}
   6628 		off := g.AuxInt
   6629 		sym := g.Aux
   6630 		_ = g.Args[1]
   6631 		ptr := g.Args[0]
   6632 		mem := g.Args[1]
   6633 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   6634 			break
   6635 		}
   6636 		v.reset(OpS390XADDWload)
   6637 		v.Type = t
   6638 		v.AuxInt = off
   6639 		v.Aux = sym
   6640 		v.AddArg(x)
   6641 		v.AddArg(ptr)
   6642 		v.AddArg(mem)
   6643 		return true
   6644 	}
   6645 	return false
   6646 }
   6647 func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
   6648 	// match: (ADDWconst [c] x)
   6649 	// cond: int32(c)==0
   6650 	// result: x
   6651 	for {
   6652 		c := v.AuxInt
   6653 		x := v.Args[0]
   6654 		if !(int32(c) == 0) {
   6655 			break
   6656 		}
   6657 		v.reset(OpCopy)
   6658 		v.Type = x.Type
   6659 		v.AddArg(x)
   6660 		return true
   6661 	}
   6662 	// match: (ADDWconst [c] (MOVDconst [d]))
   6663 	// cond:
   6664 	// result: (MOVDconst [int64(int32(c+d))])
   6665 	for {
   6666 		c := v.AuxInt
   6667 		v_0 := v.Args[0]
   6668 		if v_0.Op != OpS390XMOVDconst {
   6669 			break
   6670 		}
   6671 		d := v_0.AuxInt
   6672 		v.reset(OpS390XMOVDconst)
   6673 		v.AuxInt = int64(int32(c + d))
   6674 		return true
   6675 	}
   6676 	// match: (ADDWconst [c] (ADDWconst [d] x))
   6677 	// cond:
   6678 	// result: (ADDWconst [int64(int32(c+d))] x)
   6679 	for {
   6680 		c := v.AuxInt
   6681 		v_0 := v.Args[0]
   6682 		if v_0.Op != OpS390XADDWconst {
   6683 			break
   6684 		}
   6685 		d := v_0.AuxInt
   6686 		x := v_0.Args[0]
   6687 		v.reset(OpS390XADDWconst)
   6688 		v.AuxInt = int64(int32(c + d))
   6689 		v.AddArg(x)
   6690 		return true
   6691 	}
   6692 	return false
   6693 }
   6694 func rewriteValueS390X_OpS390XADDWload_0(v *Value) bool {
   6695 	// match: (ADDWload [off1] {sym} x (ADDconst [off2] ptr) mem)
   6696 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   6697 	// result: (ADDWload  [off1+off2] {sym} x ptr mem)
   6698 	for {
   6699 		off1 := v.AuxInt
   6700 		sym := v.Aux
   6701 		_ = v.Args[2]
   6702 		x := v.Args[0]
   6703 		v_1 := v.Args[1]
   6704 		if v_1.Op != OpS390XADDconst {
   6705 			break
   6706 		}
   6707 		off2 := v_1.AuxInt
   6708 		ptr := v_1.Args[0]
   6709 		mem := v.Args[2]
   6710 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   6711 			break
   6712 		}
   6713 		v.reset(OpS390XADDWload)
   6714 		v.AuxInt = off1 + off2
   6715 		v.Aux = sym
   6716 		v.AddArg(x)
   6717 		v.AddArg(ptr)
   6718 		v.AddArg(mem)
   6719 		return true
   6720 	}
   6721 	// match: (ADDWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   6722 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   6723 	// result: (ADDWload  [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   6724 	for {
   6725 		o1 := v.AuxInt
   6726 		s1 := v.Aux
   6727 		_ = v.Args[2]
   6728 		x := v.Args[0]
   6729 		v_1 := v.Args[1]
   6730 		if v_1.Op != OpS390XMOVDaddr {
   6731 			break
   6732 		}
   6733 		o2 := v_1.AuxInt
   6734 		s2 := v_1.Aux
   6735 		ptr := v_1.Args[0]
   6736 		mem := v.Args[2]
   6737 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   6738 			break
   6739 		}
   6740 		v.reset(OpS390XADDWload)
   6741 		v.AuxInt = o1 + o2
   6742 		v.Aux = mergeSym(s1, s2)
   6743 		v.AddArg(x)
   6744 		v.AddArg(ptr)
   6745 		v.AddArg(mem)
   6746 		return true
   6747 	}
   6748 	return false
   6749 }
   6750 func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
   6751 	// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
   6752 	// cond: ((c+d)&1 == 0) && is32Bit(c+d)
   6753 	// result: (MOVDaddr [c+d] {s} x)
   6754 	for {
   6755 		c := v.AuxInt
   6756 		v_0 := v.Args[0]
   6757 		if v_0.Op != OpS390XMOVDaddr {
   6758 			break
   6759 		}
   6760 		d := v_0.AuxInt
   6761 		s := v_0.Aux
   6762 		x := v_0.Args[0]
   6763 		if x.Op != OpSB {
   6764 			break
   6765 		}
   6766 		if !(((c+d)&1 == 0) && is32Bit(c+d)) {
   6767 			break
   6768 		}
   6769 		v.reset(OpS390XMOVDaddr)
   6770 		v.AuxInt = c + d
   6771 		v.Aux = s
   6772 		v.AddArg(x)
   6773 		return true
   6774 	}
   6775 	// match: (ADDconst [c] (MOVDaddr [d] {s} x))
   6776 	// cond: x.Op != OpSB && is20Bit(c+d)
   6777 	// result: (MOVDaddr [c+d] {s} x)
   6778 	for {
   6779 		c := v.AuxInt
   6780 		v_0 := v.Args[0]
   6781 		if v_0.Op != OpS390XMOVDaddr {
   6782 			break
   6783 		}
   6784 		d := v_0.AuxInt
   6785 		s := v_0.Aux
   6786 		x := v_0.Args[0]
   6787 		if !(x.Op != OpSB && is20Bit(c+d)) {
   6788 			break
   6789 		}
   6790 		v.reset(OpS390XMOVDaddr)
   6791 		v.AuxInt = c + d
   6792 		v.Aux = s
   6793 		v.AddArg(x)
   6794 		return true
   6795 	}
   6796 	// match: (ADDconst [c] (MOVDaddridx [d] {s} x y))
   6797 	// cond: is20Bit(c+d)
   6798 	// result: (MOVDaddridx [c+d] {s} x y)
   6799 	for {
   6800 		c := v.AuxInt
   6801 		v_0 := v.Args[0]
   6802 		if v_0.Op != OpS390XMOVDaddridx {
   6803 			break
   6804 		}
   6805 		d := v_0.AuxInt
   6806 		s := v_0.Aux
   6807 		_ = v_0.Args[1]
   6808 		x := v_0.Args[0]
   6809 		y := v_0.Args[1]
   6810 		if !(is20Bit(c + d)) {
   6811 			break
   6812 		}
   6813 		v.reset(OpS390XMOVDaddridx)
   6814 		v.AuxInt = c + d
   6815 		v.Aux = s
   6816 		v.AddArg(x)
   6817 		v.AddArg(y)
   6818 		return true
   6819 	}
   6820 	// match: (ADDconst [0] x)
   6821 	// cond:
   6822 	// result: x
   6823 	for {
   6824 		if v.AuxInt != 0 {
   6825 			break
   6826 		}
   6827 		x := v.Args[0]
   6828 		v.reset(OpCopy)
   6829 		v.Type = x.Type
   6830 		v.AddArg(x)
   6831 		return true
   6832 	}
   6833 	// match: (ADDconst [c] (MOVDconst [d]))
   6834 	// cond:
   6835 	// result: (MOVDconst [c+d])
   6836 	for {
   6837 		c := v.AuxInt
   6838 		v_0 := v.Args[0]
   6839 		if v_0.Op != OpS390XMOVDconst {
   6840 			break
   6841 		}
   6842 		d := v_0.AuxInt
   6843 		v.reset(OpS390XMOVDconst)
   6844 		v.AuxInt = c + d
   6845 		return true
   6846 	}
   6847 	// match: (ADDconst [c] (ADDconst [d] x))
   6848 	// cond: is32Bit(c+d)
   6849 	// result: (ADDconst [c+d] x)
   6850 	for {
   6851 		c := v.AuxInt
   6852 		v_0 := v.Args[0]
   6853 		if v_0.Op != OpS390XADDconst {
   6854 			break
   6855 		}
   6856 		d := v_0.AuxInt
   6857 		x := v_0.Args[0]
   6858 		if !(is32Bit(c + d)) {
   6859 			break
   6860 		}
   6861 		v.reset(OpS390XADDconst)
   6862 		v.AuxInt = c + d
   6863 		v.AddArg(x)
   6864 		return true
   6865 	}
   6866 	return false
   6867 }
   6868 func rewriteValueS390X_OpS390XADDload_0(v *Value) bool {
   6869 	b := v.Block
   6870 	_ = b
   6871 	// match: (ADDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
   6872 	// cond: isSamePtr(ptr1, ptr2)
   6873 	// result: (ADD   x (LGDR <t> y))
   6874 	for {
   6875 		t := v.Type
   6876 		off := v.AuxInt
   6877 		sym := v.Aux
   6878 		_ = v.Args[2]
   6879 		x := v.Args[0]
   6880 		ptr1 := v.Args[1]
   6881 		v_2 := v.Args[2]
   6882 		if v_2.Op != OpS390XFMOVDstore {
   6883 			break
   6884 		}
   6885 		if v_2.AuxInt != off {
   6886 			break
   6887 		}
   6888 		if v_2.Aux != sym {
   6889 			break
   6890 		}
   6891 		_ = v_2.Args[2]
   6892 		ptr2 := v_2.Args[0]
   6893 		y := v_2.Args[1]
   6894 		if !(isSamePtr(ptr1, ptr2)) {
   6895 			break
   6896 		}
   6897 		v.reset(OpS390XADD)
   6898 		v.AddArg(x)
   6899 		v0 := b.NewValue0(v.Pos, OpS390XLGDR, t)
   6900 		v0.AddArg(y)
   6901 		v.AddArg(v0)
   6902 		return true
   6903 	}
   6904 	// match: (ADDload [off1] {sym} x (ADDconst [off2] ptr) mem)
   6905 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   6906 	// result: (ADDload   [off1+off2] {sym} x ptr mem)
   6907 	for {
   6908 		off1 := v.AuxInt
   6909 		sym := v.Aux
   6910 		_ = v.Args[2]
   6911 		x := v.Args[0]
   6912 		v_1 := v.Args[1]
   6913 		if v_1.Op != OpS390XADDconst {
   6914 			break
   6915 		}
   6916 		off2 := v_1.AuxInt
   6917 		ptr := v_1.Args[0]
   6918 		mem := v.Args[2]
   6919 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   6920 			break
   6921 		}
   6922 		v.reset(OpS390XADDload)
   6923 		v.AuxInt = off1 + off2
   6924 		v.Aux = sym
   6925 		v.AddArg(x)
   6926 		v.AddArg(ptr)
   6927 		v.AddArg(mem)
   6928 		return true
   6929 	}
   6930 	// match: (ADDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   6931 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   6932 	// result: (ADDload   [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   6933 	for {
   6934 		o1 := v.AuxInt
   6935 		s1 := v.Aux
   6936 		_ = v.Args[2]
   6937 		x := v.Args[0]
   6938 		v_1 := v.Args[1]
   6939 		if v_1.Op != OpS390XMOVDaddr {
   6940 			break
   6941 		}
   6942 		o2 := v_1.AuxInt
   6943 		s2 := v_1.Aux
   6944 		ptr := v_1.Args[0]
   6945 		mem := v.Args[2]
   6946 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   6947 			break
   6948 		}
   6949 		v.reset(OpS390XADDload)
   6950 		v.AuxInt = o1 + o2
   6951 		v.Aux = mergeSym(s1, s2)
   6952 		v.AddArg(x)
   6953 		v.AddArg(ptr)
   6954 		v.AddArg(mem)
   6955 		return true
   6956 	}
   6957 	return false
   6958 }
   6959 func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
   6960 	// match: (AND x (MOVDconst [c]))
   6961 	// cond: is32Bit(c) && c < 0
   6962 	// result: (ANDconst [c] x)
   6963 	for {
   6964 		_ = v.Args[1]
   6965 		x := v.Args[0]
   6966 		v_1 := v.Args[1]
   6967 		if v_1.Op != OpS390XMOVDconst {
   6968 			break
   6969 		}
   6970 		c := v_1.AuxInt
   6971 		if !(is32Bit(c) && c < 0) {
   6972 			break
   6973 		}
   6974 		v.reset(OpS390XANDconst)
   6975 		v.AuxInt = c
   6976 		v.AddArg(x)
   6977 		return true
   6978 	}
   6979 	// match: (AND (MOVDconst [c]) x)
   6980 	// cond: is32Bit(c) && c < 0
   6981 	// result: (ANDconst [c] x)
   6982 	for {
   6983 		_ = v.Args[1]
   6984 		v_0 := v.Args[0]
   6985 		if v_0.Op != OpS390XMOVDconst {
   6986 			break
   6987 		}
   6988 		c := v_0.AuxInt
   6989 		x := v.Args[1]
   6990 		if !(is32Bit(c) && c < 0) {
   6991 			break
   6992 		}
   6993 		v.reset(OpS390XANDconst)
   6994 		v.AuxInt = c
   6995 		v.AddArg(x)
   6996 		return true
   6997 	}
   6998 	// match: (AND x (MOVDconst [0xFF]))
   6999 	// cond:
   7000 	// result: (MOVBZreg x)
   7001 	for {
   7002 		_ = v.Args[1]
   7003 		x := v.Args[0]
   7004 		v_1 := v.Args[1]
   7005 		if v_1.Op != OpS390XMOVDconst {
   7006 			break
   7007 		}
   7008 		if v_1.AuxInt != 0xFF {
   7009 			break
   7010 		}
   7011 		v.reset(OpS390XMOVBZreg)
   7012 		v.AddArg(x)
   7013 		return true
   7014 	}
   7015 	// match: (AND (MOVDconst [0xFF]) x)
   7016 	// cond:
   7017 	// result: (MOVBZreg x)
   7018 	for {
   7019 		_ = v.Args[1]
   7020 		v_0 := v.Args[0]
   7021 		if v_0.Op != OpS390XMOVDconst {
   7022 			break
   7023 		}
   7024 		if v_0.AuxInt != 0xFF {
   7025 			break
   7026 		}
   7027 		x := v.Args[1]
   7028 		v.reset(OpS390XMOVBZreg)
   7029 		v.AddArg(x)
   7030 		return true
   7031 	}
   7032 	// match: (AND x (MOVDconst [0xFFFF]))
   7033 	// cond:
   7034 	// result: (MOVHZreg x)
   7035 	for {
   7036 		_ = v.Args[1]
   7037 		x := v.Args[0]
   7038 		v_1 := v.Args[1]
   7039 		if v_1.Op != OpS390XMOVDconst {
   7040 			break
   7041 		}
   7042 		if v_1.AuxInt != 0xFFFF {
   7043 			break
   7044 		}
   7045 		v.reset(OpS390XMOVHZreg)
   7046 		v.AddArg(x)
   7047 		return true
   7048 	}
   7049 	// match: (AND (MOVDconst [0xFFFF]) x)
   7050 	// cond:
   7051 	// result: (MOVHZreg x)
   7052 	for {
   7053 		_ = v.Args[1]
   7054 		v_0 := v.Args[0]
   7055 		if v_0.Op != OpS390XMOVDconst {
   7056 			break
   7057 		}
   7058 		if v_0.AuxInt != 0xFFFF {
   7059 			break
   7060 		}
   7061 		x := v.Args[1]
   7062 		v.reset(OpS390XMOVHZreg)
   7063 		v.AddArg(x)
   7064 		return true
   7065 	}
   7066 	// match: (AND x (MOVDconst [0xFFFFFFFF]))
   7067 	// cond:
   7068 	// result: (MOVWZreg x)
   7069 	for {
   7070 		_ = v.Args[1]
   7071 		x := v.Args[0]
   7072 		v_1 := v.Args[1]
   7073 		if v_1.Op != OpS390XMOVDconst {
   7074 			break
   7075 		}
   7076 		if v_1.AuxInt != 0xFFFFFFFF {
   7077 			break
   7078 		}
   7079 		v.reset(OpS390XMOVWZreg)
   7080 		v.AddArg(x)
   7081 		return true
   7082 	}
   7083 	// match: (AND (MOVDconst [0xFFFFFFFF]) x)
   7084 	// cond:
   7085 	// result: (MOVWZreg x)
   7086 	for {
   7087 		_ = v.Args[1]
   7088 		v_0 := v.Args[0]
   7089 		if v_0.Op != OpS390XMOVDconst {
   7090 			break
   7091 		}
   7092 		if v_0.AuxInt != 0xFFFFFFFF {
   7093 			break
   7094 		}
   7095 		x := v.Args[1]
   7096 		v.reset(OpS390XMOVWZreg)
   7097 		v.AddArg(x)
   7098 		return true
   7099 	}
   7100 	// match: (AND (MOVDconst [c]) (MOVDconst [d]))
   7101 	// cond:
   7102 	// result: (MOVDconst [c&d])
   7103 	for {
   7104 		_ = v.Args[1]
   7105 		v_0 := v.Args[0]
   7106 		if v_0.Op != OpS390XMOVDconst {
   7107 			break
   7108 		}
   7109 		c := v_0.AuxInt
   7110 		v_1 := v.Args[1]
   7111 		if v_1.Op != OpS390XMOVDconst {
   7112 			break
   7113 		}
   7114 		d := v_1.AuxInt
   7115 		v.reset(OpS390XMOVDconst)
   7116 		v.AuxInt = c & d
   7117 		return true
   7118 	}
   7119 	// match: (AND (MOVDconst [d]) (MOVDconst [c]))
   7120 	// cond:
   7121 	// result: (MOVDconst [c&d])
   7122 	for {
   7123 		_ = v.Args[1]
   7124 		v_0 := v.Args[0]
   7125 		if v_0.Op != OpS390XMOVDconst {
   7126 			break
   7127 		}
   7128 		d := v_0.AuxInt
   7129 		v_1 := v.Args[1]
   7130 		if v_1.Op != OpS390XMOVDconst {
   7131 			break
   7132 		}
   7133 		c := v_1.AuxInt
   7134 		v.reset(OpS390XMOVDconst)
   7135 		v.AuxInt = c & d
   7136 		return true
   7137 	}
   7138 	return false
   7139 }
   7140 func rewriteValueS390X_OpS390XAND_10(v *Value) bool {
   7141 	// match: (AND x x)
   7142 	// cond:
   7143 	// result: x
   7144 	for {
   7145 		_ = v.Args[1]
   7146 		x := v.Args[0]
   7147 		if x != v.Args[1] {
   7148 			break
   7149 		}
   7150 		v.reset(OpCopy)
   7151 		v.Type = x.Type
   7152 		v.AddArg(x)
   7153 		return true
   7154 	}
   7155 	// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
   7156 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7157 	// result: (ANDload <t> [off] {sym} x ptr mem)
   7158 	for {
   7159 		t := v.Type
   7160 		_ = v.Args[1]
   7161 		x := v.Args[0]
   7162 		g := v.Args[1]
   7163 		if g.Op != OpS390XMOVDload {
   7164 			break
   7165 		}
   7166 		off := g.AuxInt
   7167 		sym := g.Aux
   7168 		_ = g.Args[1]
   7169 		ptr := g.Args[0]
   7170 		mem := g.Args[1]
   7171 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7172 			break
   7173 		}
   7174 		v.reset(OpS390XANDload)
   7175 		v.Type = t
   7176 		v.AuxInt = off
   7177 		v.Aux = sym
   7178 		v.AddArg(x)
   7179 		v.AddArg(ptr)
   7180 		v.AddArg(mem)
   7181 		return true
   7182 	}
   7183 	// match: (AND <t> g:(MOVDload [off] {sym} ptr mem) x)
   7184 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7185 	// result: (ANDload <t> [off] {sym} x ptr mem)
   7186 	for {
   7187 		t := v.Type
   7188 		_ = v.Args[1]
   7189 		g := v.Args[0]
   7190 		if g.Op != OpS390XMOVDload {
   7191 			break
   7192 		}
   7193 		off := g.AuxInt
   7194 		sym := g.Aux
   7195 		_ = g.Args[1]
   7196 		ptr := g.Args[0]
   7197 		mem := g.Args[1]
   7198 		x := v.Args[1]
   7199 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7200 			break
   7201 		}
   7202 		v.reset(OpS390XANDload)
   7203 		v.Type = t
   7204 		v.AuxInt = off
   7205 		v.Aux = sym
   7206 		v.AddArg(x)
   7207 		v.AddArg(ptr)
   7208 		v.AddArg(mem)
   7209 		return true
   7210 	}
   7211 	// match: (AND <t> g:(MOVDload [off] {sym} ptr mem) x)
   7212 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7213 	// result: (ANDload <t> [off] {sym} x ptr mem)
   7214 	for {
   7215 		t := v.Type
   7216 		_ = v.Args[1]
   7217 		g := v.Args[0]
   7218 		if g.Op != OpS390XMOVDload {
   7219 			break
   7220 		}
   7221 		off := g.AuxInt
   7222 		sym := g.Aux
   7223 		_ = g.Args[1]
   7224 		ptr := g.Args[0]
   7225 		mem := g.Args[1]
   7226 		x := v.Args[1]
   7227 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7228 			break
   7229 		}
   7230 		v.reset(OpS390XANDload)
   7231 		v.Type = t
   7232 		v.AuxInt = off
   7233 		v.Aux = sym
   7234 		v.AddArg(x)
   7235 		v.AddArg(ptr)
   7236 		v.AddArg(mem)
   7237 		return true
   7238 	}
   7239 	// match: (AND <t> x g:(MOVDload [off] {sym} ptr mem))
   7240 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7241 	// result: (ANDload <t> [off] {sym} x ptr mem)
   7242 	for {
   7243 		t := v.Type
   7244 		_ = v.Args[1]
   7245 		x := v.Args[0]
   7246 		g := v.Args[1]
   7247 		if g.Op != OpS390XMOVDload {
   7248 			break
   7249 		}
   7250 		off := g.AuxInt
   7251 		sym := g.Aux
   7252 		_ = g.Args[1]
   7253 		ptr := g.Args[0]
   7254 		mem := g.Args[1]
   7255 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7256 			break
   7257 		}
   7258 		v.reset(OpS390XANDload)
   7259 		v.Type = t
   7260 		v.AuxInt = off
   7261 		v.Aux = sym
   7262 		v.AddArg(x)
   7263 		v.AddArg(ptr)
   7264 		v.AddArg(mem)
   7265 		return true
   7266 	}
   7267 	return false
   7268 }
   7269 func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
   7270 	// match: (ANDW x (MOVDconst [c]))
   7271 	// cond:
   7272 	// result: (ANDWconst [int64(int32(c))] x)
   7273 	for {
   7274 		_ = v.Args[1]
   7275 		x := v.Args[0]
   7276 		v_1 := v.Args[1]
   7277 		if v_1.Op != OpS390XMOVDconst {
   7278 			break
   7279 		}
   7280 		c := v_1.AuxInt
   7281 		v.reset(OpS390XANDWconst)
   7282 		v.AuxInt = int64(int32(c))
   7283 		v.AddArg(x)
   7284 		return true
   7285 	}
   7286 	// match: (ANDW (MOVDconst [c]) x)
   7287 	// cond:
   7288 	// result: (ANDWconst [int64(int32(c))] x)
   7289 	for {
   7290 		_ = v.Args[1]
   7291 		v_0 := v.Args[0]
   7292 		if v_0.Op != OpS390XMOVDconst {
   7293 			break
   7294 		}
   7295 		c := v_0.AuxInt
   7296 		x := v.Args[1]
   7297 		v.reset(OpS390XANDWconst)
   7298 		v.AuxInt = int64(int32(c))
   7299 		v.AddArg(x)
   7300 		return true
   7301 	}
   7302 	// match: (ANDW x x)
   7303 	// cond:
   7304 	// result: x
   7305 	for {
   7306 		_ = v.Args[1]
   7307 		x := v.Args[0]
   7308 		if x != v.Args[1] {
   7309 			break
   7310 		}
   7311 		v.reset(OpCopy)
   7312 		v.Type = x.Type
   7313 		v.AddArg(x)
   7314 		return true
   7315 	}
   7316 	// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
   7317 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7318 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7319 	for {
   7320 		t := v.Type
   7321 		_ = v.Args[1]
   7322 		x := v.Args[0]
   7323 		g := v.Args[1]
   7324 		if g.Op != OpS390XMOVWload {
   7325 			break
   7326 		}
   7327 		off := g.AuxInt
   7328 		sym := g.Aux
   7329 		_ = g.Args[1]
   7330 		ptr := g.Args[0]
   7331 		mem := g.Args[1]
   7332 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7333 			break
   7334 		}
   7335 		v.reset(OpS390XANDWload)
   7336 		v.Type = t
   7337 		v.AuxInt = off
   7338 		v.Aux = sym
   7339 		v.AddArg(x)
   7340 		v.AddArg(ptr)
   7341 		v.AddArg(mem)
   7342 		return true
   7343 	}
   7344 	// match: (ANDW <t> g:(MOVWload [off] {sym} ptr mem) x)
   7345 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7346 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7347 	for {
   7348 		t := v.Type
   7349 		_ = v.Args[1]
   7350 		g := v.Args[0]
   7351 		if g.Op != OpS390XMOVWload {
   7352 			break
   7353 		}
   7354 		off := g.AuxInt
   7355 		sym := g.Aux
   7356 		_ = g.Args[1]
   7357 		ptr := g.Args[0]
   7358 		mem := g.Args[1]
   7359 		x := v.Args[1]
   7360 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7361 			break
   7362 		}
   7363 		v.reset(OpS390XANDWload)
   7364 		v.Type = t
   7365 		v.AuxInt = off
   7366 		v.Aux = sym
   7367 		v.AddArg(x)
   7368 		v.AddArg(ptr)
   7369 		v.AddArg(mem)
   7370 		return true
   7371 	}
   7372 	// match: (ANDW <t> g:(MOVWload [off] {sym} ptr mem) x)
   7373 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7374 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7375 	for {
   7376 		t := v.Type
   7377 		_ = v.Args[1]
   7378 		g := v.Args[0]
   7379 		if g.Op != OpS390XMOVWload {
   7380 			break
   7381 		}
   7382 		off := g.AuxInt
   7383 		sym := g.Aux
   7384 		_ = g.Args[1]
   7385 		ptr := g.Args[0]
   7386 		mem := g.Args[1]
   7387 		x := v.Args[1]
   7388 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7389 			break
   7390 		}
   7391 		v.reset(OpS390XANDWload)
   7392 		v.Type = t
   7393 		v.AuxInt = off
   7394 		v.Aux = sym
   7395 		v.AddArg(x)
   7396 		v.AddArg(ptr)
   7397 		v.AddArg(mem)
   7398 		return true
   7399 	}
   7400 	// match: (ANDW <t> x g:(MOVWload [off] {sym} ptr mem))
   7401 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7402 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7403 	for {
   7404 		t := v.Type
   7405 		_ = v.Args[1]
   7406 		x := v.Args[0]
   7407 		g := v.Args[1]
   7408 		if g.Op != OpS390XMOVWload {
   7409 			break
   7410 		}
   7411 		off := g.AuxInt
   7412 		sym := g.Aux
   7413 		_ = g.Args[1]
   7414 		ptr := g.Args[0]
   7415 		mem := g.Args[1]
   7416 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7417 			break
   7418 		}
   7419 		v.reset(OpS390XANDWload)
   7420 		v.Type = t
   7421 		v.AuxInt = off
   7422 		v.Aux = sym
   7423 		v.AddArg(x)
   7424 		v.AddArg(ptr)
   7425 		v.AddArg(mem)
   7426 		return true
   7427 	}
   7428 	// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
   7429 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7430 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7431 	for {
   7432 		t := v.Type
   7433 		_ = v.Args[1]
   7434 		x := v.Args[0]
   7435 		g := v.Args[1]
   7436 		if g.Op != OpS390XMOVWZload {
   7437 			break
   7438 		}
   7439 		off := g.AuxInt
   7440 		sym := g.Aux
   7441 		_ = g.Args[1]
   7442 		ptr := g.Args[0]
   7443 		mem := g.Args[1]
   7444 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7445 			break
   7446 		}
   7447 		v.reset(OpS390XANDWload)
   7448 		v.Type = t
   7449 		v.AuxInt = off
   7450 		v.Aux = sym
   7451 		v.AddArg(x)
   7452 		v.AddArg(ptr)
   7453 		v.AddArg(mem)
   7454 		return true
   7455 	}
   7456 	// match: (ANDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   7457 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7458 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7459 	for {
   7460 		t := v.Type
   7461 		_ = v.Args[1]
   7462 		g := v.Args[0]
   7463 		if g.Op != OpS390XMOVWZload {
   7464 			break
   7465 		}
   7466 		off := g.AuxInt
   7467 		sym := g.Aux
   7468 		_ = g.Args[1]
   7469 		ptr := g.Args[0]
   7470 		mem := g.Args[1]
   7471 		x := v.Args[1]
   7472 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7473 			break
   7474 		}
   7475 		v.reset(OpS390XANDWload)
   7476 		v.Type = t
   7477 		v.AuxInt = off
   7478 		v.Aux = sym
   7479 		v.AddArg(x)
   7480 		v.AddArg(ptr)
   7481 		v.AddArg(mem)
   7482 		return true
   7483 	}
   7484 	// match: (ANDW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   7485 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7486 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7487 	for {
   7488 		t := v.Type
   7489 		_ = v.Args[1]
   7490 		g := v.Args[0]
   7491 		if g.Op != OpS390XMOVWZload {
   7492 			break
   7493 		}
   7494 		off := g.AuxInt
   7495 		sym := g.Aux
   7496 		_ = g.Args[1]
   7497 		ptr := g.Args[0]
   7498 		mem := g.Args[1]
   7499 		x := v.Args[1]
   7500 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7501 			break
   7502 		}
   7503 		v.reset(OpS390XANDWload)
   7504 		v.Type = t
   7505 		v.AuxInt = off
   7506 		v.Aux = sym
   7507 		v.AddArg(x)
   7508 		v.AddArg(ptr)
   7509 		v.AddArg(mem)
   7510 		return true
   7511 	}
   7512 	return false
   7513 }
   7514 func rewriteValueS390X_OpS390XANDW_10(v *Value) bool {
   7515 	// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
   7516 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   7517 	// result: (ANDWload <t> [off] {sym} x ptr mem)
   7518 	for {
   7519 		t := v.Type
   7520 		_ = v.Args[1]
   7521 		x := v.Args[0]
   7522 		g := v.Args[1]
   7523 		if g.Op != OpS390XMOVWZload {
   7524 			break
   7525 		}
   7526 		off := g.AuxInt
   7527 		sym := g.Aux
   7528 		_ = g.Args[1]
   7529 		ptr := g.Args[0]
   7530 		mem := g.Args[1]
   7531 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   7532 			break
   7533 		}
   7534 		v.reset(OpS390XANDWload)
   7535 		v.Type = t
   7536 		v.AuxInt = off
   7537 		v.Aux = sym
   7538 		v.AddArg(x)
   7539 		v.AddArg(ptr)
   7540 		v.AddArg(mem)
   7541 		return true
   7542 	}
   7543 	return false
   7544 }
   7545 func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
   7546 	// match: (ANDWconst [c] (ANDWconst [d] x))
   7547 	// cond:
   7548 	// result: (ANDWconst [c & d] x)
   7549 	for {
   7550 		c := v.AuxInt
   7551 		v_0 := v.Args[0]
   7552 		if v_0.Op != OpS390XANDWconst {
   7553 			break
   7554 		}
   7555 		d := v_0.AuxInt
   7556 		x := v_0.Args[0]
   7557 		v.reset(OpS390XANDWconst)
   7558 		v.AuxInt = c & d
   7559 		v.AddArg(x)
   7560 		return true
   7561 	}
   7562 	// match: (ANDWconst [0xFF] x)
   7563 	// cond:
   7564 	// result: (MOVBZreg x)
   7565 	for {
   7566 		if v.AuxInt != 0xFF {
   7567 			break
   7568 		}
   7569 		x := v.Args[0]
   7570 		v.reset(OpS390XMOVBZreg)
   7571 		v.AddArg(x)
   7572 		return true
   7573 	}
   7574 	// match: (ANDWconst [0xFFFF] x)
   7575 	// cond:
   7576 	// result: (MOVHZreg x)
   7577 	for {
   7578 		if v.AuxInt != 0xFFFF {
   7579 			break
   7580 		}
   7581 		x := v.Args[0]
   7582 		v.reset(OpS390XMOVHZreg)
   7583 		v.AddArg(x)
   7584 		return true
   7585 	}
   7586 	// match: (ANDWconst [c] _)
   7587 	// cond: int32(c)==0
   7588 	// result: (MOVDconst [0])
   7589 	for {
   7590 		c := v.AuxInt
   7591 		if !(int32(c) == 0) {
   7592 			break
   7593 		}
   7594 		v.reset(OpS390XMOVDconst)
   7595 		v.AuxInt = 0
   7596 		return true
   7597 	}
   7598 	// match: (ANDWconst [c] x)
   7599 	// cond: int32(c)==-1
   7600 	// result: x
   7601 	for {
   7602 		c := v.AuxInt
   7603 		x := v.Args[0]
   7604 		if !(int32(c) == -1) {
   7605 			break
   7606 		}
   7607 		v.reset(OpCopy)
   7608 		v.Type = x.Type
   7609 		v.AddArg(x)
   7610 		return true
   7611 	}
   7612 	// match: (ANDWconst [c] (MOVDconst [d]))
   7613 	// cond:
   7614 	// result: (MOVDconst [c&d])
   7615 	for {
   7616 		c := v.AuxInt
   7617 		v_0 := v.Args[0]
   7618 		if v_0.Op != OpS390XMOVDconst {
   7619 			break
   7620 		}
   7621 		d := v_0.AuxInt
   7622 		v.reset(OpS390XMOVDconst)
   7623 		v.AuxInt = c & d
   7624 		return true
   7625 	}
   7626 	return false
   7627 }
   7628 func rewriteValueS390X_OpS390XANDWload_0(v *Value) bool {
   7629 	// match: (ANDWload [off1] {sym} x (ADDconst [off2] ptr) mem)
   7630 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   7631 	// result: (ANDWload  [off1+off2] {sym} x ptr mem)
   7632 	for {
   7633 		off1 := v.AuxInt
   7634 		sym := v.Aux
   7635 		_ = v.Args[2]
   7636 		x := v.Args[0]
   7637 		v_1 := v.Args[1]
   7638 		if v_1.Op != OpS390XADDconst {
   7639 			break
   7640 		}
   7641 		off2 := v_1.AuxInt
   7642 		ptr := v_1.Args[0]
   7643 		mem := v.Args[2]
   7644 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   7645 			break
   7646 		}
   7647 		v.reset(OpS390XANDWload)
   7648 		v.AuxInt = off1 + off2
   7649 		v.Aux = sym
   7650 		v.AddArg(x)
   7651 		v.AddArg(ptr)
   7652 		v.AddArg(mem)
   7653 		return true
   7654 	}
   7655 	// match: (ANDWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   7656 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   7657 	// result: (ANDWload  [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   7658 	for {
   7659 		o1 := v.AuxInt
   7660 		s1 := v.Aux
   7661 		_ = v.Args[2]
   7662 		x := v.Args[0]
   7663 		v_1 := v.Args[1]
   7664 		if v_1.Op != OpS390XMOVDaddr {
   7665 			break
   7666 		}
   7667 		o2 := v_1.AuxInt
   7668 		s2 := v_1.Aux
   7669 		ptr := v_1.Args[0]
   7670 		mem := v.Args[2]
   7671 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   7672 			break
   7673 		}
   7674 		v.reset(OpS390XANDWload)
   7675 		v.AuxInt = o1 + o2
   7676 		v.Aux = mergeSym(s1, s2)
   7677 		v.AddArg(x)
   7678 		v.AddArg(ptr)
   7679 		v.AddArg(mem)
   7680 		return true
   7681 	}
   7682 	return false
   7683 }
   7684 func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
   7685 	// match: (ANDconst [c] (ANDconst [d] x))
   7686 	// cond:
   7687 	// result: (ANDconst [c & d] x)
   7688 	for {
   7689 		c := v.AuxInt
   7690 		v_0 := v.Args[0]
   7691 		if v_0.Op != OpS390XANDconst {
   7692 			break
   7693 		}
   7694 		d := v_0.AuxInt
   7695 		x := v_0.Args[0]
   7696 		v.reset(OpS390XANDconst)
   7697 		v.AuxInt = c & d
   7698 		v.AddArg(x)
   7699 		return true
   7700 	}
   7701 	// match: (ANDconst [0] _)
   7702 	// cond:
   7703 	// result: (MOVDconst [0])
   7704 	for {
   7705 		if v.AuxInt != 0 {
   7706 			break
   7707 		}
   7708 		v.reset(OpS390XMOVDconst)
   7709 		v.AuxInt = 0
   7710 		return true
   7711 	}
   7712 	// match: (ANDconst [-1] x)
   7713 	// cond:
   7714 	// result: x
   7715 	for {
   7716 		if v.AuxInt != -1 {
   7717 			break
   7718 		}
   7719 		x := v.Args[0]
   7720 		v.reset(OpCopy)
   7721 		v.Type = x.Type
   7722 		v.AddArg(x)
   7723 		return true
   7724 	}
   7725 	// match: (ANDconst [c] (MOVDconst [d]))
   7726 	// cond:
   7727 	// result: (MOVDconst [c&d])
   7728 	for {
   7729 		c := v.AuxInt
   7730 		v_0 := v.Args[0]
   7731 		if v_0.Op != OpS390XMOVDconst {
   7732 			break
   7733 		}
   7734 		d := v_0.AuxInt
   7735 		v.reset(OpS390XMOVDconst)
   7736 		v.AuxInt = c & d
   7737 		return true
   7738 	}
   7739 	return false
   7740 }
   7741 func rewriteValueS390X_OpS390XANDload_0(v *Value) bool {
   7742 	b := v.Block
   7743 	_ = b
   7744 	// match: (ANDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
   7745 	// cond: isSamePtr(ptr1, ptr2)
   7746 	// result: (AND   x (LGDR <t> y))
   7747 	for {
   7748 		t := v.Type
   7749 		off := v.AuxInt
   7750 		sym := v.Aux
   7751 		_ = v.Args[2]
   7752 		x := v.Args[0]
   7753 		ptr1 := v.Args[1]
   7754 		v_2 := v.Args[2]
   7755 		if v_2.Op != OpS390XFMOVDstore {
   7756 			break
   7757 		}
   7758 		if v_2.AuxInt != off {
   7759 			break
   7760 		}
   7761 		if v_2.Aux != sym {
   7762 			break
   7763 		}
   7764 		_ = v_2.Args[2]
   7765 		ptr2 := v_2.Args[0]
   7766 		y := v_2.Args[1]
   7767 		if !(isSamePtr(ptr1, ptr2)) {
   7768 			break
   7769 		}
   7770 		v.reset(OpS390XAND)
   7771 		v.AddArg(x)
   7772 		v0 := b.NewValue0(v.Pos, OpS390XLGDR, t)
   7773 		v0.AddArg(y)
   7774 		v.AddArg(v0)
   7775 		return true
   7776 	}
   7777 	// match: (ANDload [off1] {sym} x (ADDconst [off2] ptr) mem)
   7778 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   7779 	// result: (ANDload   [off1+off2] {sym} x ptr mem)
   7780 	for {
   7781 		off1 := v.AuxInt
   7782 		sym := v.Aux
   7783 		_ = v.Args[2]
   7784 		x := v.Args[0]
   7785 		v_1 := v.Args[1]
   7786 		if v_1.Op != OpS390XADDconst {
   7787 			break
   7788 		}
   7789 		off2 := v_1.AuxInt
   7790 		ptr := v_1.Args[0]
   7791 		mem := v.Args[2]
   7792 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   7793 			break
   7794 		}
   7795 		v.reset(OpS390XANDload)
   7796 		v.AuxInt = off1 + off2
   7797 		v.Aux = sym
   7798 		v.AddArg(x)
   7799 		v.AddArg(ptr)
   7800 		v.AddArg(mem)
   7801 		return true
   7802 	}
   7803 	// match: (ANDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   7804 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   7805 	// result: (ANDload   [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   7806 	for {
   7807 		o1 := v.AuxInt
   7808 		s1 := v.Aux
   7809 		_ = v.Args[2]
   7810 		x := v.Args[0]
   7811 		v_1 := v.Args[1]
   7812 		if v_1.Op != OpS390XMOVDaddr {
   7813 			break
   7814 		}
   7815 		o2 := v_1.AuxInt
   7816 		s2 := v_1.Aux
   7817 		ptr := v_1.Args[0]
   7818 		mem := v.Args[2]
   7819 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   7820 			break
   7821 		}
   7822 		v.reset(OpS390XANDload)
   7823 		v.AuxInt = o1 + o2
   7824 		v.Aux = mergeSym(s1, s2)
   7825 		v.AddArg(x)
   7826 		v.AddArg(ptr)
   7827 		v.AddArg(mem)
   7828 		return true
   7829 	}
   7830 	return false
   7831 }
   7832 func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
   7833 	b := v.Block
   7834 	_ = b
   7835 	// match: (CMP x (MOVDconst [c]))
   7836 	// cond: is32Bit(c)
   7837 	// result: (CMPconst x [c])
   7838 	for {
   7839 		_ = v.Args[1]
   7840 		x := v.Args[0]
   7841 		v_1 := v.Args[1]
   7842 		if v_1.Op != OpS390XMOVDconst {
   7843 			break
   7844 		}
   7845 		c := v_1.AuxInt
   7846 		if !(is32Bit(c)) {
   7847 			break
   7848 		}
   7849 		v.reset(OpS390XCMPconst)
   7850 		v.AuxInt = c
   7851 		v.AddArg(x)
   7852 		return true
   7853 	}
   7854 	// match: (CMP (MOVDconst [c]) x)
   7855 	// cond: is32Bit(c)
   7856 	// result: (InvertFlags (CMPconst x [c]))
   7857 	for {
   7858 		_ = v.Args[1]
   7859 		v_0 := v.Args[0]
   7860 		if v_0.Op != OpS390XMOVDconst {
   7861 			break
   7862 		}
   7863 		c := v_0.AuxInt
   7864 		x := v.Args[1]
   7865 		if !(is32Bit(c)) {
   7866 			break
   7867 		}
   7868 		v.reset(OpS390XInvertFlags)
   7869 		v0 := b.NewValue0(v.Pos, OpS390XCMPconst, types.TypeFlags)
   7870 		v0.AuxInt = c
   7871 		v0.AddArg(x)
   7872 		v.AddArg(v0)
   7873 		return true
   7874 	}
   7875 	return false
   7876 }
   7877 func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
   7878 	b := v.Block
   7879 	_ = b
   7880 	// match: (CMPU x (MOVDconst [c]))
   7881 	// cond: isU32Bit(c)
   7882 	// result: (CMPUconst x [int64(int32(c))])
   7883 	for {
   7884 		_ = v.Args[1]
   7885 		x := v.Args[0]
   7886 		v_1 := v.Args[1]
   7887 		if v_1.Op != OpS390XMOVDconst {
   7888 			break
   7889 		}
   7890 		c := v_1.AuxInt
   7891 		if !(isU32Bit(c)) {
   7892 			break
   7893 		}
   7894 		v.reset(OpS390XCMPUconst)
   7895 		v.AuxInt = int64(int32(c))
   7896 		v.AddArg(x)
   7897 		return true
   7898 	}
   7899 	// match: (CMPU (MOVDconst [c]) x)
   7900 	// cond: isU32Bit(c)
   7901 	// result: (InvertFlags (CMPUconst x [int64(int32(c))]))
   7902 	for {
   7903 		_ = v.Args[1]
   7904 		v_0 := v.Args[0]
   7905 		if v_0.Op != OpS390XMOVDconst {
   7906 			break
   7907 		}
   7908 		c := v_0.AuxInt
   7909 		x := v.Args[1]
   7910 		if !(isU32Bit(c)) {
   7911 			break
   7912 		}
   7913 		v.reset(OpS390XInvertFlags)
   7914 		v0 := b.NewValue0(v.Pos, OpS390XCMPUconst, types.TypeFlags)
   7915 		v0.AuxInt = int64(int32(c))
   7916 		v0.AddArg(x)
   7917 		v.AddArg(v0)
   7918 		return true
   7919 	}
   7920 	return false
   7921 }
   7922 func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
   7923 	// match: (CMPUconst (MOVDconst [x]) [y])
   7924 	// cond: uint64(x)==uint64(y)
   7925 	// result: (FlagEQ)
   7926 	for {
   7927 		y := v.AuxInt
   7928 		v_0 := v.Args[0]
   7929 		if v_0.Op != OpS390XMOVDconst {
   7930 			break
   7931 		}
   7932 		x := v_0.AuxInt
   7933 		if !(uint64(x) == uint64(y)) {
   7934 			break
   7935 		}
   7936 		v.reset(OpS390XFlagEQ)
   7937 		return true
   7938 	}
   7939 	// match: (CMPUconst (MOVDconst [x]) [y])
   7940 	// cond: uint64(x)<uint64(y)
   7941 	// result: (FlagLT)
   7942 	for {
   7943 		y := v.AuxInt
   7944 		v_0 := v.Args[0]
   7945 		if v_0.Op != OpS390XMOVDconst {
   7946 			break
   7947 		}
   7948 		x := v_0.AuxInt
   7949 		if !(uint64(x) < uint64(y)) {
   7950 			break
   7951 		}
   7952 		v.reset(OpS390XFlagLT)
   7953 		return true
   7954 	}
   7955 	// match: (CMPUconst (MOVDconst [x]) [y])
   7956 	// cond: uint64(x)>uint64(y)
   7957 	// result: (FlagGT)
   7958 	for {
   7959 		y := v.AuxInt
   7960 		v_0 := v.Args[0]
   7961 		if v_0.Op != OpS390XMOVDconst {
   7962 			break
   7963 		}
   7964 		x := v_0.AuxInt
   7965 		if !(uint64(x) > uint64(y)) {
   7966 			break
   7967 		}
   7968 		v.reset(OpS390XFlagGT)
   7969 		return true
   7970 	}
   7971 	return false
   7972 }
   7973 func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
   7974 	b := v.Block
   7975 	_ = b
   7976 	// match: (CMPW x (MOVDconst [c]))
   7977 	// cond:
   7978 	// result: (CMPWconst x [int64(int32(c))])
   7979 	for {
   7980 		_ = v.Args[1]
   7981 		x := v.Args[0]
   7982 		v_1 := v.Args[1]
   7983 		if v_1.Op != OpS390XMOVDconst {
   7984 			break
   7985 		}
   7986 		c := v_1.AuxInt
   7987 		v.reset(OpS390XCMPWconst)
   7988 		v.AuxInt = int64(int32(c))
   7989 		v.AddArg(x)
   7990 		return true
   7991 	}
   7992 	// match: (CMPW (MOVDconst [c]) x)
   7993 	// cond:
   7994 	// result: (InvertFlags (CMPWconst x [int64(int32(c))]))
   7995 	for {
   7996 		_ = v.Args[1]
   7997 		v_0 := v.Args[0]
   7998 		if v_0.Op != OpS390XMOVDconst {
   7999 			break
   8000 		}
   8001 		c := v_0.AuxInt
   8002 		x := v.Args[1]
   8003 		v.reset(OpS390XInvertFlags)
   8004 		v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, types.TypeFlags)
   8005 		v0.AuxInt = int64(int32(c))
   8006 		v0.AddArg(x)
   8007 		v.AddArg(v0)
   8008 		return true
   8009 	}
   8010 	return false
   8011 }
   8012 func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
   8013 	b := v.Block
   8014 	_ = b
   8015 	// match: (CMPWU x (MOVDconst [c]))
   8016 	// cond:
   8017 	// result: (CMPWUconst x [int64(int32(c))])
   8018 	for {
   8019 		_ = v.Args[1]
   8020 		x := v.Args[0]
   8021 		v_1 := v.Args[1]
   8022 		if v_1.Op != OpS390XMOVDconst {
   8023 			break
   8024 		}
   8025 		c := v_1.AuxInt
   8026 		v.reset(OpS390XCMPWUconst)
   8027 		v.AuxInt = int64(int32(c))
   8028 		v.AddArg(x)
   8029 		return true
   8030 	}
   8031 	// match: (CMPWU (MOVDconst [c]) x)
   8032 	// cond:
   8033 	// result: (InvertFlags (CMPWUconst x [int64(int32(c))]))
   8034 	for {
   8035 		_ = v.Args[1]
   8036 		v_0 := v.Args[0]
   8037 		if v_0.Op != OpS390XMOVDconst {
   8038 			break
   8039 		}
   8040 		c := v_0.AuxInt
   8041 		x := v.Args[1]
   8042 		v.reset(OpS390XInvertFlags)
   8043 		v0 := b.NewValue0(v.Pos, OpS390XCMPWUconst, types.TypeFlags)
   8044 		v0.AuxInt = int64(int32(c))
   8045 		v0.AddArg(x)
   8046 		v.AddArg(v0)
   8047 		return true
   8048 	}
   8049 	return false
   8050 }
   8051 func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
   8052 	// match: (CMPWUconst (MOVDconst [x]) [y])
   8053 	// cond: uint32(x)==uint32(y)
   8054 	// result: (FlagEQ)
   8055 	for {
   8056 		y := v.AuxInt
   8057 		v_0 := v.Args[0]
   8058 		if v_0.Op != OpS390XMOVDconst {
   8059 			break
   8060 		}
   8061 		x := v_0.AuxInt
   8062 		if !(uint32(x) == uint32(y)) {
   8063 			break
   8064 		}
   8065 		v.reset(OpS390XFlagEQ)
   8066 		return true
   8067 	}
   8068 	// match: (CMPWUconst (MOVDconst [x]) [y])
   8069 	// cond: uint32(x)<uint32(y)
   8070 	// result: (FlagLT)
   8071 	for {
   8072 		y := v.AuxInt
   8073 		v_0 := v.Args[0]
   8074 		if v_0.Op != OpS390XMOVDconst {
   8075 			break
   8076 		}
   8077 		x := v_0.AuxInt
   8078 		if !(uint32(x) < uint32(y)) {
   8079 			break
   8080 		}
   8081 		v.reset(OpS390XFlagLT)
   8082 		return true
   8083 	}
   8084 	// match: (CMPWUconst (MOVDconst [x]) [y])
   8085 	// cond: uint32(x)>uint32(y)
   8086 	// result: (FlagGT)
   8087 	for {
   8088 		y := v.AuxInt
   8089 		v_0 := v.Args[0]
   8090 		if v_0.Op != OpS390XMOVDconst {
   8091 			break
   8092 		}
   8093 		x := v_0.AuxInt
   8094 		if !(uint32(x) > uint32(y)) {
   8095 			break
   8096 		}
   8097 		v.reset(OpS390XFlagGT)
   8098 		return true
   8099 	}
   8100 	return false
   8101 }
   8102 func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
   8103 	// match: (CMPWconst (MOVDconst [x]) [y])
   8104 	// cond: int32(x)==int32(y)
   8105 	// result: (FlagEQ)
   8106 	for {
   8107 		y := v.AuxInt
   8108 		v_0 := v.Args[0]
   8109 		if v_0.Op != OpS390XMOVDconst {
   8110 			break
   8111 		}
   8112 		x := v_0.AuxInt
   8113 		if !(int32(x) == int32(y)) {
   8114 			break
   8115 		}
   8116 		v.reset(OpS390XFlagEQ)
   8117 		return true
   8118 	}
   8119 	// match: (CMPWconst (MOVDconst [x]) [y])
   8120 	// cond: int32(x)<int32(y)
   8121 	// result: (FlagLT)
   8122 	for {
   8123 		y := v.AuxInt
   8124 		v_0 := v.Args[0]
   8125 		if v_0.Op != OpS390XMOVDconst {
   8126 			break
   8127 		}
   8128 		x := v_0.AuxInt
   8129 		if !(int32(x) < int32(y)) {
   8130 			break
   8131 		}
   8132 		v.reset(OpS390XFlagLT)
   8133 		return true
   8134 	}
   8135 	// match: (CMPWconst (MOVDconst [x]) [y])
   8136 	// cond: int32(x)>int32(y)
   8137 	// result: (FlagGT)
   8138 	for {
   8139 		y := v.AuxInt
   8140 		v_0 := v.Args[0]
   8141 		if v_0.Op != OpS390XMOVDconst {
   8142 			break
   8143 		}
   8144 		x := v_0.AuxInt
   8145 		if !(int32(x) > int32(y)) {
   8146 			break
   8147 		}
   8148 		v.reset(OpS390XFlagGT)
   8149 		return true
   8150 	}
   8151 	// match: (CMPWconst (SRWconst _ [c]) [n])
   8152 	// cond: 0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n)
   8153 	// result: (FlagLT)
   8154 	for {
   8155 		n := v.AuxInt
   8156 		v_0 := v.Args[0]
   8157 		if v_0.Op != OpS390XSRWconst {
   8158 			break
   8159 		}
   8160 		c := v_0.AuxInt
   8161 		if !(0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n)) {
   8162 			break
   8163 		}
   8164 		v.reset(OpS390XFlagLT)
   8165 		return true
   8166 	}
   8167 	// match: (CMPWconst (ANDWconst _ [m]) [n])
   8168 	// cond: 0 <= int32(m) && int32(m) < int32(n)
   8169 	// result: (FlagLT)
   8170 	for {
   8171 		n := v.AuxInt
   8172 		v_0 := v.Args[0]
   8173 		if v_0.Op != OpS390XANDWconst {
   8174 			break
   8175 		}
   8176 		m := v_0.AuxInt
   8177 		if !(0 <= int32(m) && int32(m) < int32(n)) {
   8178 			break
   8179 		}
   8180 		v.reset(OpS390XFlagLT)
   8181 		return true
   8182 	}
   8183 	return false
   8184 }
   8185 func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
   8186 	// match: (CMPconst (MOVDconst [x]) [y])
   8187 	// cond: x==y
   8188 	// result: (FlagEQ)
   8189 	for {
   8190 		y := v.AuxInt
   8191 		v_0 := v.Args[0]
   8192 		if v_0.Op != OpS390XMOVDconst {
   8193 			break
   8194 		}
   8195 		x := v_0.AuxInt
   8196 		if !(x == y) {
   8197 			break
   8198 		}
   8199 		v.reset(OpS390XFlagEQ)
   8200 		return true
   8201 	}
   8202 	// match: (CMPconst (MOVDconst [x]) [y])
   8203 	// cond: x<y
   8204 	// result: (FlagLT)
   8205 	for {
   8206 		y := v.AuxInt
   8207 		v_0 := v.Args[0]
   8208 		if v_0.Op != OpS390XMOVDconst {
   8209 			break
   8210 		}
   8211 		x := v_0.AuxInt
   8212 		if !(x < y) {
   8213 			break
   8214 		}
   8215 		v.reset(OpS390XFlagLT)
   8216 		return true
   8217 	}
   8218 	// match: (CMPconst (MOVDconst [x]) [y])
   8219 	// cond: x>y
   8220 	// result: (FlagGT)
   8221 	for {
   8222 		y := v.AuxInt
   8223 		v_0 := v.Args[0]
   8224 		if v_0.Op != OpS390XMOVDconst {
   8225 			break
   8226 		}
   8227 		x := v_0.AuxInt
   8228 		if !(x > y) {
   8229 			break
   8230 		}
   8231 		v.reset(OpS390XFlagGT)
   8232 		return true
   8233 	}
   8234 	// match: (CMPconst (MOVBZreg _) [c])
   8235 	// cond: 0xFF < c
   8236 	// result: (FlagLT)
   8237 	for {
   8238 		c := v.AuxInt
   8239 		v_0 := v.Args[0]
   8240 		if v_0.Op != OpS390XMOVBZreg {
   8241 			break
   8242 		}
   8243 		if !(0xFF < c) {
   8244 			break
   8245 		}
   8246 		v.reset(OpS390XFlagLT)
   8247 		return true
   8248 	}
   8249 	// match: (CMPconst (MOVHZreg _) [c])
   8250 	// cond: 0xFFFF < c
   8251 	// result: (FlagLT)
   8252 	for {
   8253 		c := v.AuxInt
   8254 		v_0 := v.Args[0]
   8255 		if v_0.Op != OpS390XMOVHZreg {
   8256 			break
   8257 		}
   8258 		if !(0xFFFF < c) {
   8259 			break
   8260 		}
   8261 		v.reset(OpS390XFlagLT)
   8262 		return true
   8263 	}
   8264 	// match: (CMPconst (MOVWZreg _) [c])
   8265 	// cond: 0xFFFFFFFF < c
   8266 	// result: (FlagLT)
   8267 	for {
   8268 		c := v.AuxInt
   8269 		v_0 := v.Args[0]
   8270 		if v_0.Op != OpS390XMOVWZreg {
   8271 			break
   8272 		}
   8273 		if !(0xFFFFFFFF < c) {
   8274 			break
   8275 		}
   8276 		v.reset(OpS390XFlagLT)
   8277 		return true
   8278 	}
   8279 	// match: (CMPconst (SRDconst _ [c]) [n])
   8280 	// cond: 0 <= n && 0 < c && c <= 64 && (1<<uint64(64-c)) <= uint64(n)
   8281 	// result: (FlagLT)
   8282 	for {
   8283 		n := v.AuxInt
   8284 		v_0 := v.Args[0]
   8285 		if v_0.Op != OpS390XSRDconst {
   8286 			break
   8287 		}
   8288 		c := v_0.AuxInt
   8289 		if !(0 <= n && 0 < c && c <= 64 && (1<<uint64(64-c)) <= uint64(n)) {
   8290 			break
   8291 		}
   8292 		v.reset(OpS390XFlagLT)
   8293 		return true
   8294 	}
   8295 	// match: (CMPconst (ANDconst _ [m]) [n])
   8296 	// cond: 0 <= m && m < n
   8297 	// result: (FlagLT)
   8298 	for {
   8299 		n := v.AuxInt
   8300 		v_0 := v.Args[0]
   8301 		if v_0.Op != OpS390XANDconst {
   8302 			break
   8303 		}
   8304 		m := v_0.AuxInt
   8305 		if !(0 <= m && m < n) {
   8306 			break
   8307 		}
   8308 		v.reset(OpS390XFlagLT)
   8309 		return true
   8310 	}
   8311 	return false
   8312 }
   8313 func rewriteValueS390X_OpS390XCPSDR_0(v *Value) bool {
   8314 	// match: (CPSDR y (FMOVDconst [c]))
   8315 	// cond: c & -1<<63 == 0
   8316 	// result: (LPDFR y)
   8317 	for {
   8318 		_ = v.Args[1]
   8319 		y := v.Args[0]
   8320 		v_1 := v.Args[1]
   8321 		if v_1.Op != OpS390XFMOVDconst {
   8322 			break
   8323 		}
   8324 		c := v_1.AuxInt
   8325 		if !(c&-1<<63 == 0) {
   8326 			break
   8327 		}
   8328 		v.reset(OpS390XLPDFR)
   8329 		v.AddArg(y)
   8330 		return true
   8331 	}
   8332 	// match: (CPSDR y (FMOVDconst [c]))
   8333 	// cond: c & -1<<63 != 0
   8334 	// result: (LNDFR y)
   8335 	for {
   8336 		_ = v.Args[1]
   8337 		y := v.Args[0]
   8338 		v_1 := v.Args[1]
   8339 		if v_1.Op != OpS390XFMOVDconst {
   8340 			break
   8341 		}
   8342 		c := v_1.AuxInt
   8343 		if !(c&-1<<63 != 0) {
   8344 			break
   8345 		}
   8346 		v.reset(OpS390XLNDFR)
   8347 		v.AddArg(y)
   8348 		return true
   8349 	}
   8350 	return false
   8351 }
   8352 func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
   8353 	// match: (FADD (FMUL y z) x)
   8354 	// cond:
   8355 	// result: (FMADD x y z)
   8356 	for {
   8357 		_ = v.Args[1]
   8358 		v_0 := v.Args[0]
   8359 		if v_0.Op != OpS390XFMUL {
   8360 			break
   8361 		}
   8362 		_ = v_0.Args[1]
   8363 		y := v_0.Args[0]
   8364 		z := v_0.Args[1]
   8365 		x := v.Args[1]
   8366 		v.reset(OpS390XFMADD)
   8367 		v.AddArg(x)
   8368 		v.AddArg(y)
   8369 		v.AddArg(z)
   8370 		return true
   8371 	}
   8372 	// match: (FADD x (FMUL y z))
   8373 	// cond:
   8374 	// result: (FMADD x y z)
   8375 	for {
   8376 		_ = v.Args[1]
   8377 		x := v.Args[0]
   8378 		v_1 := v.Args[1]
   8379 		if v_1.Op != OpS390XFMUL {
   8380 			break
   8381 		}
   8382 		_ = v_1.Args[1]
   8383 		y := v_1.Args[0]
   8384 		z := v_1.Args[1]
   8385 		v.reset(OpS390XFMADD)
   8386 		v.AddArg(x)
   8387 		v.AddArg(y)
   8388 		v.AddArg(z)
   8389 		return true
   8390 	}
   8391 	return false
   8392 }
   8393 func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
   8394 	// match: (FADDS (FMULS y z) x)
   8395 	// cond:
   8396 	// result: (FMADDS x y z)
   8397 	for {
   8398 		_ = v.Args[1]
   8399 		v_0 := v.Args[0]
   8400 		if v_0.Op != OpS390XFMULS {
   8401 			break
   8402 		}
   8403 		_ = v_0.Args[1]
   8404 		y := v_0.Args[0]
   8405 		z := v_0.Args[1]
   8406 		x := v.Args[1]
   8407 		v.reset(OpS390XFMADDS)
   8408 		v.AddArg(x)
   8409 		v.AddArg(y)
   8410 		v.AddArg(z)
   8411 		return true
   8412 	}
   8413 	// match: (FADDS x (FMULS y z))
   8414 	// cond:
   8415 	// result: (FMADDS x y z)
   8416 	for {
   8417 		_ = v.Args[1]
   8418 		x := v.Args[0]
   8419 		v_1 := v.Args[1]
   8420 		if v_1.Op != OpS390XFMULS {
   8421 			break
   8422 		}
   8423 		_ = v_1.Args[1]
   8424 		y := v_1.Args[0]
   8425 		z := v_1.Args[1]
   8426 		v.reset(OpS390XFMADDS)
   8427 		v.AddArg(x)
   8428 		v.AddArg(y)
   8429 		v.AddArg(z)
   8430 		return true
   8431 	}
   8432 	return false
   8433 }
   8434 func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
   8435 	// match: (FMOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
   8436 	// cond: isSamePtr(ptr1, ptr2)
   8437 	// result: (LDGR x)
   8438 	for {
   8439 		off := v.AuxInt
   8440 		sym := v.Aux
   8441 		_ = v.Args[1]
   8442 		ptr1 := v.Args[0]
   8443 		v_1 := v.Args[1]
   8444 		if v_1.Op != OpS390XMOVDstore {
   8445 			break
   8446 		}
   8447 		if v_1.AuxInt != off {
   8448 			break
   8449 		}
   8450 		if v_1.Aux != sym {
   8451 			break
   8452 		}
   8453 		_ = v_1.Args[2]
   8454 		ptr2 := v_1.Args[0]
   8455 		x := v_1.Args[1]
   8456 		if !(isSamePtr(ptr1, ptr2)) {
   8457 			break
   8458 		}
   8459 		v.reset(OpS390XLDGR)
   8460 		v.AddArg(x)
   8461 		return true
   8462 	}
   8463 	// match: (FMOVDload [off] {sym} ptr1 (FMOVDstore [off] {sym} ptr2 x _))
   8464 	// cond: isSamePtr(ptr1, ptr2)
   8465 	// result: x
   8466 	for {
   8467 		off := v.AuxInt
   8468 		sym := v.Aux
   8469 		_ = v.Args[1]
   8470 		ptr1 := v.Args[0]
   8471 		v_1 := v.Args[1]
   8472 		if v_1.Op != OpS390XFMOVDstore {
   8473 			break
   8474 		}
   8475 		if v_1.AuxInt != off {
   8476 			break
   8477 		}
   8478 		if v_1.Aux != sym {
   8479 			break
   8480 		}
   8481 		_ = v_1.Args[2]
   8482 		ptr2 := v_1.Args[0]
   8483 		x := v_1.Args[1]
   8484 		if !(isSamePtr(ptr1, ptr2)) {
   8485 			break
   8486 		}
   8487 		v.reset(OpCopy)
   8488 		v.Type = x.Type
   8489 		v.AddArg(x)
   8490 		return true
   8491 	}
   8492 	// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
   8493 	// cond: is20Bit(off1+off2)
   8494 	// result: (FMOVDload [off1+off2] {sym} ptr mem)
   8495 	for {
   8496 		off1 := v.AuxInt
   8497 		sym := v.Aux
   8498 		_ = v.Args[1]
   8499 		v_0 := v.Args[0]
   8500 		if v_0.Op != OpS390XADDconst {
   8501 			break
   8502 		}
   8503 		off2 := v_0.AuxInt
   8504 		ptr := v_0.Args[0]
   8505 		mem := v.Args[1]
   8506 		if !(is20Bit(off1 + off2)) {
   8507 			break
   8508 		}
   8509 		v.reset(OpS390XFMOVDload)
   8510 		v.AuxInt = off1 + off2
   8511 		v.Aux = sym
   8512 		v.AddArg(ptr)
   8513 		v.AddArg(mem)
   8514 		return true
   8515 	}
   8516 	// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
   8517 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   8518 	// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   8519 	for {
   8520 		off1 := v.AuxInt
   8521 		sym1 := v.Aux
   8522 		_ = v.Args[1]
   8523 		v_0 := v.Args[0]
   8524 		if v_0.Op != OpS390XMOVDaddr {
   8525 			break
   8526 		}
   8527 		off2 := v_0.AuxInt
   8528 		sym2 := v_0.Aux
   8529 		base := v_0.Args[0]
   8530 		mem := v.Args[1]
   8531 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   8532 			break
   8533 		}
   8534 		v.reset(OpS390XFMOVDload)
   8535 		v.AuxInt = off1 + off2
   8536 		v.Aux = mergeSym(sym1, sym2)
   8537 		v.AddArg(base)
   8538 		v.AddArg(mem)
   8539 		return true
   8540 	}
   8541 	// match: (FMOVDload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   8542 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   8543 	// result: (FMOVDloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   8544 	for {
   8545 		off1 := v.AuxInt
   8546 		sym1 := v.Aux
   8547 		_ = v.Args[1]
   8548 		v_0 := v.Args[0]
   8549 		if v_0.Op != OpS390XMOVDaddridx {
   8550 			break
   8551 		}
   8552 		off2 := v_0.AuxInt
   8553 		sym2 := v_0.Aux
   8554 		_ = v_0.Args[1]
   8555 		ptr := v_0.Args[0]
   8556 		idx := v_0.Args[1]
   8557 		mem := v.Args[1]
   8558 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   8559 			break
   8560 		}
   8561 		v.reset(OpS390XFMOVDloadidx)
   8562 		v.AuxInt = off1 + off2
   8563 		v.Aux = mergeSym(sym1, sym2)
   8564 		v.AddArg(ptr)
   8565 		v.AddArg(idx)
   8566 		v.AddArg(mem)
   8567 		return true
   8568 	}
   8569 	// match: (FMOVDload [off] {sym} (ADD ptr idx) mem)
   8570 	// cond: ptr.Op != OpSB
   8571 	// result: (FMOVDloadidx [off] {sym} ptr idx mem)
   8572 	for {
   8573 		off := v.AuxInt
   8574 		sym := v.Aux
   8575 		_ = v.Args[1]
   8576 		v_0 := v.Args[0]
   8577 		if v_0.Op != OpS390XADD {
   8578 			break
   8579 		}
   8580 		_ = v_0.Args[1]
   8581 		ptr := v_0.Args[0]
   8582 		idx := v_0.Args[1]
   8583 		mem := v.Args[1]
   8584 		if !(ptr.Op != OpSB) {
   8585 			break
   8586 		}
   8587 		v.reset(OpS390XFMOVDloadidx)
   8588 		v.AuxInt = off
   8589 		v.Aux = sym
   8590 		v.AddArg(ptr)
   8591 		v.AddArg(idx)
   8592 		v.AddArg(mem)
   8593 		return true
   8594 	}
   8595 	return false
   8596 }
   8597 func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
   8598 	// match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   8599 	// cond: is20Bit(c+d)
   8600 	// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
   8601 	for {
   8602 		c := v.AuxInt
   8603 		sym := v.Aux
   8604 		_ = v.Args[2]
   8605 		v_0 := v.Args[0]
   8606 		if v_0.Op != OpS390XADDconst {
   8607 			break
   8608 		}
   8609 		d := v_0.AuxInt
   8610 		ptr := v_0.Args[0]
   8611 		idx := v.Args[1]
   8612 		mem := v.Args[2]
   8613 		if !(is20Bit(c + d)) {
   8614 			break
   8615 		}
   8616 		v.reset(OpS390XFMOVDloadidx)
   8617 		v.AuxInt = c + d
   8618 		v.Aux = sym
   8619 		v.AddArg(ptr)
   8620 		v.AddArg(idx)
   8621 		v.AddArg(mem)
   8622 		return true
   8623 	}
   8624 	// match: (FMOVDloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   8625 	// cond: is20Bit(c+d)
   8626 	// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
   8627 	for {
   8628 		c := v.AuxInt
   8629 		sym := v.Aux
   8630 		_ = v.Args[2]
   8631 		ptr := v.Args[0]
   8632 		v_1 := v.Args[1]
   8633 		if v_1.Op != OpS390XADDconst {
   8634 			break
   8635 		}
   8636 		d := v_1.AuxInt
   8637 		idx := v_1.Args[0]
   8638 		mem := v.Args[2]
   8639 		if !(is20Bit(c + d)) {
   8640 			break
   8641 		}
   8642 		v.reset(OpS390XFMOVDloadidx)
   8643 		v.AuxInt = c + d
   8644 		v.Aux = sym
   8645 		v.AddArg(ptr)
   8646 		v.AddArg(idx)
   8647 		v.AddArg(mem)
   8648 		return true
   8649 	}
   8650 	return false
   8651 }
   8652 func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
   8653 	// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
   8654 	// cond: is20Bit(off1+off2)
   8655 	// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
   8656 	for {
   8657 		off1 := v.AuxInt
   8658 		sym := v.Aux
   8659 		_ = v.Args[2]
   8660 		v_0 := v.Args[0]
   8661 		if v_0.Op != OpS390XADDconst {
   8662 			break
   8663 		}
   8664 		off2 := v_0.AuxInt
   8665 		ptr := v_0.Args[0]
   8666 		val := v.Args[1]
   8667 		mem := v.Args[2]
   8668 		if !(is20Bit(off1 + off2)) {
   8669 			break
   8670 		}
   8671 		v.reset(OpS390XFMOVDstore)
   8672 		v.AuxInt = off1 + off2
   8673 		v.Aux = sym
   8674 		v.AddArg(ptr)
   8675 		v.AddArg(val)
   8676 		v.AddArg(mem)
   8677 		return true
   8678 	}
   8679 	// match: (FMOVDstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
   8680 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   8681 	// result: (FMOVDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   8682 	for {
   8683 		off1 := v.AuxInt
   8684 		sym1 := v.Aux
   8685 		_ = v.Args[2]
   8686 		v_0 := v.Args[0]
   8687 		if v_0.Op != OpS390XMOVDaddr {
   8688 			break
   8689 		}
   8690 		off2 := v_0.AuxInt
   8691 		sym2 := v_0.Aux
   8692 		base := v_0.Args[0]
   8693 		val := v.Args[1]
   8694 		mem := v.Args[2]
   8695 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   8696 			break
   8697 		}
   8698 		v.reset(OpS390XFMOVDstore)
   8699 		v.AuxInt = off1 + off2
   8700 		v.Aux = mergeSym(sym1, sym2)
   8701 		v.AddArg(base)
   8702 		v.AddArg(val)
   8703 		v.AddArg(mem)
   8704 		return true
   8705 	}
   8706 	// match: (FMOVDstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
   8707 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   8708 	// result: (FMOVDstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   8709 	for {
   8710 		off1 := v.AuxInt
   8711 		sym1 := v.Aux
   8712 		_ = v.Args[2]
   8713 		v_0 := v.Args[0]
   8714 		if v_0.Op != OpS390XMOVDaddridx {
   8715 			break
   8716 		}
   8717 		off2 := v_0.AuxInt
   8718 		sym2 := v_0.Aux
   8719 		_ = v_0.Args[1]
   8720 		ptr := v_0.Args[0]
   8721 		idx := v_0.Args[1]
   8722 		val := v.Args[1]
   8723 		mem := v.Args[2]
   8724 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   8725 			break
   8726 		}
   8727 		v.reset(OpS390XFMOVDstoreidx)
   8728 		v.AuxInt = off1 + off2
   8729 		v.Aux = mergeSym(sym1, sym2)
   8730 		v.AddArg(ptr)
   8731 		v.AddArg(idx)
   8732 		v.AddArg(val)
   8733 		v.AddArg(mem)
   8734 		return true
   8735 	}
   8736 	// match: (FMOVDstore [off] {sym} (ADD ptr idx) val mem)
   8737 	// cond: ptr.Op != OpSB
   8738 	// result: (FMOVDstoreidx [off] {sym} ptr idx val mem)
   8739 	for {
   8740 		off := v.AuxInt
   8741 		sym := v.Aux
   8742 		_ = v.Args[2]
   8743 		v_0 := v.Args[0]
   8744 		if v_0.Op != OpS390XADD {
   8745 			break
   8746 		}
   8747 		_ = v_0.Args[1]
   8748 		ptr := v_0.Args[0]
   8749 		idx := v_0.Args[1]
   8750 		val := v.Args[1]
   8751 		mem := v.Args[2]
   8752 		if !(ptr.Op != OpSB) {
   8753 			break
   8754 		}
   8755 		v.reset(OpS390XFMOVDstoreidx)
   8756 		v.AuxInt = off
   8757 		v.Aux = sym
   8758 		v.AddArg(ptr)
   8759 		v.AddArg(idx)
   8760 		v.AddArg(val)
   8761 		v.AddArg(mem)
   8762 		return true
   8763 	}
   8764 	return false
   8765 }
   8766 func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
   8767 	// match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
   8768 	// cond: is20Bit(c+d)
   8769 	// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
   8770 	for {
   8771 		c := v.AuxInt
   8772 		sym := v.Aux
   8773 		_ = v.Args[3]
   8774 		v_0 := v.Args[0]
   8775 		if v_0.Op != OpS390XADDconst {
   8776 			break
   8777 		}
   8778 		d := v_0.AuxInt
   8779 		ptr := v_0.Args[0]
   8780 		idx := v.Args[1]
   8781 		val := v.Args[2]
   8782 		mem := v.Args[3]
   8783 		if !(is20Bit(c + d)) {
   8784 			break
   8785 		}
   8786 		v.reset(OpS390XFMOVDstoreidx)
   8787 		v.AuxInt = c + d
   8788 		v.Aux = sym
   8789 		v.AddArg(ptr)
   8790 		v.AddArg(idx)
   8791 		v.AddArg(val)
   8792 		v.AddArg(mem)
   8793 		return true
   8794 	}
   8795 	// match: (FMOVDstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
   8796 	// cond: is20Bit(c+d)
   8797 	// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
   8798 	for {
   8799 		c := v.AuxInt
   8800 		sym := v.Aux
   8801 		_ = v.Args[3]
   8802 		ptr := v.Args[0]
   8803 		v_1 := v.Args[1]
   8804 		if v_1.Op != OpS390XADDconst {
   8805 			break
   8806 		}
   8807 		d := v_1.AuxInt
   8808 		idx := v_1.Args[0]
   8809 		val := v.Args[2]
   8810 		mem := v.Args[3]
   8811 		if !(is20Bit(c + d)) {
   8812 			break
   8813 		}
   8814 		v.reset(OpS390XFMOVDstoreidx)
   8815 		v.AuxInt = c + d
   8816 		v.Aux = sym
   8817 		v.AddArg(ptr)
   8818 		v.AddArg(idx)
   8819 		v.AddArg(val)
   8820 		v.AddArg(mem)
   8821 		return true
   8822 	}
   8823 	return false
   8824 }
   8825 func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
   8826 	// match: (FMOVSload [off] {sym} ptr1 (FMOVSstore [off] {sym} ptr2 x _))
   8827 	// cond: isSamePtr(ptr1, ptr2)
   8828 	// result: x
   8829 	for {
   8830 		off := v.AuxInt
   8831 		sym := v.Aux
   8832 		_ = v.Args[1]
   8833 		ptr1 := v.Args[0]
   8834 		v_1 := v.Args[1]
   8835 		if v_1.Op != OpS390XFMOVSstore {
   8836 			break
   8837 		}
   8838 		if v_1.AuxInt != off {
   8839 			break
   8840 		}
   8841 		if v_1.Aux != sym {
   8842 			break
   8843 		}
   8844 		_ = v_1.Args[2]
   8845 		ptr2 := v_1.Args[0]
   8846 		x := v_1.Args[1]
   8847 		if !(isSamePtr(ptr1, ptr2)) {
   8848 			break
   8849 		}
   8850 		v.reset(OpCopy)
   8851 		v.Type = x.Type
   8852 		v.AddArg(x)
   8853 		return true
   8854 	}
   8855 	// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
   8856 	// cond: is20Bit(off1+off2)
   8857 	// result: (FMOVSload [off1+off2] {sym} ptr mem)
   8858 	for {
   8859 		off1 := v.AuxInt
   8860 		sym := v.Aux
   8861 		_ = v.Args[1]
   8862 		v_0 := v.Args[0]
   8863 		if v_0.Op != OpS390XADDconst {
   8864 			break
   8865 		}
   8866 		off2 := v_0.AuxInt
   8867 		ptr := v_0.Args[0]
   8868 		mem := v.Args[1]
   8869 		if !(is20Bit(off1 + off2)) {
   8870 			break
   8871 		}
   8872 		v.reset(OpS390XFMOVSload)
   8873 		v.AuxInt = off1 + off2
   8874 		v.Aux = sym
   8875 		v.AddArg(ptr)
   8876 		v.AddArg(mem)
   8877 		return true
   8878 	}
   8879 	// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
   8880 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   8881 	// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   8882 	for {
   8883 		off1 := v.AuxInt
   8884 		sym1 := v.Aux
   8885 		_ = v.Args[1]
   8886 		v_0 := v.Args[0]
   8887 		if v_0.Op != OpS390XMOVDaddr {
   8888 			break
   8889 		}
   8890 		off2 := v_0.AuxInt
   8891 		sym2 := v_0.Aux
   8892 		base := v_0.Args[0]
   8893 		mem := v.Args[1]
   8894 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   8895 			break
   8896 		}
   8897 		v.reset(OpS390XFMOVSload)
   8898 		v.AuxInt = off1 + off2
   8899 		v.Aux = mergeSym(sym1, sym2)
   8900 		v.AddArg(base)
   8901 		v.AddArg(mem)
   8902 		return true
   8903 	}
   8904 	// match: (FMOVSload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   8905 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   8906 	// result: (FMOVSloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   8907 	for {
   8908 		off1 := v.AuxInt
   8909 		sym1 := v.Aux
   8910 		_ = v.Args[1]
   8911 		v_0 := v.Args[0]
   8912 		if v_0.Op != OpS390XMOVDaddridx {
   8913 			break
   8914 		}
   8915 		off2 := v_0.AuxInt
   8916 		sym2 := v_0.Aux
   8917 		_ = v_0.Args[1]
   8918 		ptr := v_0.Args[0]
   8919 		idx := v_0.Args[1]
   8920 		mem := v.Args[1]
   8921 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   8922 			break
   8923 		}
   8924 		v.reset(OpS390XFMOVSloadidx)
   8925 		v.AuxInt = off1 + off2
   8926 		v.Aux = mergeSym(sym1, sym2)
   8927 		v.AddArg(ptr)
   8928 		v.AddArg(idx)
   8929 		v.AddArg(mem)
   8930 		return true
   8931 	}
   8932 	// match: (FMOVSload [off] {sym} (ADD ptr idx) mem)
   8933 	// cond: ptr.Op != OpSB
   8934 	// result: (FMOVSloadidx [off] {sym} ptr idx mem)
   8935 	for {
   8936 		off := v.AuxInt
   8937 		sym := v.Aux
   8938 		_ = v.Args[1]
   8939 		v_0 := v.Args[0]
   8940 		if v_0.Op != OpS390XADD {
   8941 			break
   8942 		}
   8943 		_ = v_0.Args[1]
   8944 		ptr := v_0.Args[0]
   8945 		idx := v_0.Args[1]
   8946 		mem := v.Args[1]
   8947 		if !(ptr.Op != OpSB) {
   8948 			break
   8949 		}
   8950 		v.reset(OpS390XFMOVSloadidx)
   8951 		v.AuxInt = off
   8952 		v.Aux = sym
   8953 		v.AddArg(ptr)
   8954 		v.AddArg(idx)
   8955 		v.AddArg(mem)
   8956 		return true
   8957 	}
   8958 	return false
   8959 }
   8960 func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
   8961 	// match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   8962 	// cond: is20Bit(c+d)
   8963 	// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
   8964 	for {
   8965 		c := v.AuxInt
   8966 		sym := v.Aux
   8967 		_ = v.Args[2]
   8968 		v_0 := v.Args[0]
   8969 		if v_0.Op != OpS390XADDconst {
   8970 			break
   8971 		}
   8972 		d := v_0.AuxInt
   8973 		ptr := v_0.Args[0]
   8974 		idx := v.Args[1]
   8975 		mem := v.Args[2]
   8976 		if !(is20Bit(c + d)) {
   8977 			break
   8978 		}
   8979 		v.reset(OpS390XFMOVSloadidx)
   8980 		v.AuxInt = c + d
   8981 		v.Aux = sym
   8982 		v.AddArg(ptr)
   8983 		v.AddArg(idx)
   8984 		v.AddArg(mem)
   8985 		return true
   8986 	}
   8987 	// match: (FMOVSloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   8988 	// cond: is20Bit(c+d)
   8989 	// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
   8990 	for {
   8991 		c := v.AuxInt
   8992 		sym := v.Aux
   8993 		_ = v.Args[2]
   8994 		ptr := v.Args[0]
   8995 		v_1 := v.Args[1]
   8996 		if v_1.Op != OpS390XADDconst {
   8997 			break
   8998 		}
   8999 		d := v_1.AuxInt
   9000 		idx := v_1.Args[0]
   9001 		mem := v.Args[2]
   9002 		if !(is20Bit(c + d)) {
   9003 			break
   9004 		}
   9005 		v.reset(OpS390XFMOVSloadidx)
   9006 		v.AuxInt = c + d
   9007 		v.Aux = sym
   9008 		v.AddArg(ptr)
   9009 		v.AddArg(idx)
   9010 		v.AddArg(mem)
   9011 		return true
   9012 	}
   9013 	return false
   9014 }
   9015 func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
   9016 	// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
   9017 	// cond: is20Bit(off1+off2)
   9018 	// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
   9019 	for {
   9020 		off1 := v.AuxInt
   9021 		sym := v.Aux
   9022 		_ = v.Args[2]
   9023 		v_0 := v.Args[0]
   9024 		if v_0.Op != OpS390XADDconst {
   9025 			break
   9026 		}
   9027 		off2 := v_0.AuxInt
   9028 		ptr := v_0.Args[0]
   9029 		val := v.Args[1]
   9030 		mem := v.Args[2]
   9031 		if !(is20Bit(off1 + off2)) {
   9032 			break
   9033 		}
   9034 		v.reset(OpS390XFMOVSstore)
   9035 		v.AuxInt = off1 + off2
   9036 		v.Aux = sym
   9037 		v.AddArg(ptr)
   9038 		v.AddArg(val)
   9039 		v.AddArg(mem)
   9040 		return true
   9041 	}
   9042 	// match: (FMOVSstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
   9043 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   9044 	// result: (FMOVSstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   9045 	for {
   9046 		off1 := v.AuxInt
   9047 		sym1 := v.Aux
   9048 		_ = v.Args[2]
   9049 		v_0 := v.Args[0]
   9050 		if v_0.Op != OpS390XMOVDaddr {
   9051 			break
   9052 		}
   9053 		off2 := v_0.AuxInt
   9054 		sym2 := v_0.Aux
   9055 		base := v_0.Args[0]
   9056 		val := v.Args[1]
   9057 		mem := v.Args[2]
   9058 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   9059 			break
   9060 		}
   9061 		v.reset(OpS390XFMOVSstore)
   9062 		v.AuxInt = off1 + off2
   9063 		v.Aux = mergeSym(sym1, sym2)
   9064 		v.AddArg(base)
   9065 		v.AddArg(val)
   9066 		v.AddArg(mem)
   9067 		return true
   9068 	}
   9069 	// match: (FMOVSstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
   9070 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   9071 	// result: (FMOVSstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   9072 	for {
   9073 		off1 := v.AuxInt
   9074 		sym1 := v.Aux
   9075 		_ = v.Args[2]
   9076 		v_0 := v.Args[0]
   9077 		if v_0.Op != OpS390XMOVDaddridx {
   9078 			break
   9079 		}
   9080 		off2 := v_0.AuxInt
   9081 		sym2 := v_0.Aux
   9082 		_ = v_0.Args[1]
   9083 		ptr := v_0.Args[0]
   9084 		idx := v_0.Args[1]
   9085 		val := v.Args[1]
   9086 		mem := v.Args[2]
   9087 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   9088 			break
   9089 		}
   9090 		v.reset(OpS390XFMOVSstoreidx)
   9091 		v.AuxInt = off1 + off2
   9092 		v.Aux = mergeSym(sym1, sym2)
   9093 		v.AddArg(ptr)
   9094 		v.AddArg(idx)
   9095 		v.AddArg(val)
   9096 		v.AddArg(mem)
   9097 		return true
   9098 	}
   9099 	// match: (FMOVSstore [off] {sym} (ADD ptr idx) val mem)
   9100 	// cond: ptr.Op != OpSB
   9101 	// result: (FMOVSstoreidx [off] {sym} ptr idx val mem)
   9102 	for {
   9103 		off := v.AuxInt
   9104 		sym := v.Aux
   9105 		_ = v.Args[2]
   9106 		v_0 := v.Args[0]
   9107 		if v_0.Op != OpS390XADD {
   9108 			break
   9109 		}
   9110 		_ = v_0.Args[1]
   9111 		ptr := v_0.Args[0]
   9112 		idx := v_0.Args[1]
   9113 		val := v.Args[1]
   9114 		mem := v.Args[2]
   9115 		if !(ptr.Op != OpSB) {
   9116 			break
   9117 		}
   9118 		v.reset(OpS390XFMOVSstoreidx)
   9119 		v.AuxInt = off
   9120 		v.Aux = sym
   9121 		v.AddArg(ptr)
   9122 		v.AddArg(idx)
   9123 		v.AddArg(val)
   9124 		v.AddArg(mem)
   9125 		return true
   9126 	}
   9127 	return false
   9128 }
   9129 func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
   9130 	// match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
   9131 	// cond: is20Bit(c+d)
   9132 	// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
   9133 	for {
   9134 		c := v.AuxInt
   9135 		sym := v.Aux
   9136 		_ = v.Args[3]
   9137 		v_0 := v.Args[0]
   9138 		if v_0.Op != OpS390XADDconst {
   9139 			break
   9140 		}
   9141 		d := v_0.AuxInt
   9142 		ptr := v_0.Args[0]
   9143 		idx := v.Args[1]
   9144 		val := v.Args[2]
   9145 		mem := v.Args[3]
   9146 		if !(is20Bit(c + d)) {
   9147 			break
   9148 		}
   9149 		v.reset(OpS390XFMOVSstoreidx)
   9150 		v.AuxInt = c + d
   9151 		v.Aux = sym
   9152 		v.AddArg(ptr)
   9153 		v.AddArg(idx)
   9154 		v.AddArg(val)
   9155 		v.AddArg(mem)
   9156 		return true
   9157 	}
   9158 	// match: (FMOVSstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
   9159 	// cond: is20Bit(c+d)
   9160 	// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
   9161 	for {
   9162 		c := v.AuxInt
   9163 		sym := v.Aux
   9164 		_ = v.Args[3]
   9165 		ptr := v.Args[0]
   9166 		v_1 := v.Args[1]
   9167 		if v_1.Op != OpS390XADDconst {
   9168 			break
   9169 		}
   9170 		d := v_1.AuxInt
   9171 		idx := v_1.Args[0]
   9172 		val := v.Args[2]
   9173 		mem := v.Args[3]
   9174 		if !(is20Bit(c + d)) {
   9175 			break
   9176 		}
   9177 		v.reset(OpS390XFMOVSstoreidx)
   9178 		v.AuxInt = c + d
   9179 		v.Aux = sym
   9180 		v.AddArg(ptr)
   9181 		v.AddArg(idx)
   9182 		v.AddArg(val)
   9183 		v.AddArg(mem)
   9184 		return true
   9185 	}
   9186 	return false
   9187 }
   9188 func rewriteValueS390X_OpS390XFNEG_0(v *Value) bool {
   9189 	// match: (FNEG (LPDFR x))
   9190 	// cond:
   9191 	// result: (LNDFR x)
   9192 	for {
   9193 		v_0 := v.Args[0]
   9194 		if v_0.Op != OpS390XLPDFR {
   9195 			break
   9196 		}
   9197 		x := v_0.Args[0]
   9198 		v.reset(OpS390XLNDFR)
   9199 		v.AddArg(x)
   9200 		return true
   9201 	}
   9202 	// match: (FNEG (LNDFR x))
   9203 	// cond:
   9204 	// result: (LPDFR x)
   9205 	for {
   9206 		v_0 := v.Args[0]
   9207 		if v_0.Op != OpS390XLNDFR {
   9208 			break
   9209 		}
   9210 		x := v_0.Args[0]
   9211 		v.reset(OpS390XLPDFR)
   9212 		v.AddArg(x)
   9213 		return true
   9214 	}
   9215 	return false
   9216 }
   9217 func rewriteValueS390X_OpS390XFNEGS_0(v *Value) bool {
   9218 	// match: (FNEGS (LPDFR x))
   9219 	// cond:
   9220 	// result: (LNDFR x)
   9221 	for {
   9222 		v_0 := v.Args[0]
   9223 		if v_0.Op != OpS390XLPDFR {
   9224 			break
   9225 		}
   9226 		x := v_0.Args[0]
   9227 		v.reset(OpS390XLNDFR)
   9228 		v.AddArg(x)
   9229 		return true
   9230 	}
   9231 	// match: (FNEGS (LNDFR x))
   9232 	// cond:
   9233 	// result: (LPDFR x)
   9234 	for {
   9235 		v_0 := v.Args[0]
   9236 		if v_0.Op != OpS390XLNDFR {
   9237 			break
   9238 		}
   9239 		x := v_0.Args[0]
   9240 		v.reset(OpS390XLPDFR)
   9241 		v.AddArg(x)
   9242 		return true
   9243 	}
   9244 	return false
   9245 }
   9246 func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
   9247 	// match: (FSUB (FMUL y z) x)
   9248 	// cond:
   9249 	// result: (FMSUB x y z)
   9250 	for {
   9251 		_ = v.Args[1]
   9252 		v_0 := v.Args[0]
   9253 		if v_0.Op != OpS390XFMUL {
   9254 			break
   9255 		}
   9256 		_ = v_0.Args[1]
   9257 		y := v_0.Args[0]
   9258 		z := v_0.Args[1]
   9259 		x := v.Args[1]
   9260 		v.reset(OpS390XFMSUB)
   9261 		v.AddArg(x)
   9262 		v.AddArg(y)
   9263 		v.AddArg(z)
   9264 		return true
   9265 	}
   9266 	return false
   9267 }
   9268 func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
   9269 	// match: (FSUBS (FMULS y z) x)
   9270 	// cond:
   9271 	// result: (FMSUBS x y z)
   9272 	for {
   9273 		_ = v.Args[1]
   9274 		v_0 := v.Args[0]
   9275 		if v_0.Op != OpS390XFMULS {
   9276 			break
   9277 		}
   9278 		_ = v_0.Args[1]
   9279 		y := v_0.Args[0]
   9280 		z := v_0.Args[1]
   9281 		x := v.Args[1]
   9282 		v.reset(OpS390XFMSUBS)
   9283 		v.AddArg(x)
   9284 		v.AddArg(y)
   9285 		v.AddArg(z)
   9286 		return true
   9287 	}
   9288 	return false
   9289 }
   9290 func rewriteValueS390X_OpS390XLDGR_0(v *Value) bool {
   9291 	b := v.Block
   9292 	_ = b
   9293 	// match: (LDGR <t> (SRDconst [1] (SLDconst [1] x)))
   9294 	// cond:
   9295 	// result: (LPDFR (LDGR <t> x))
   9296 	for {
   9297 		t := v.Type
   9298 		v_0 := v.Args[0]
   9299 		if v_0.Op != OpS390XSRDconst {
   9300 			break
   9301 		}
   9302 		if v_0.AuxInt != 1 {
   9303 			break
   9304 		}
   9305 		v_0_0 := v_0.Args[0]
   9306 		if v_0_0.Op != OpS390XSLDconst {
   9307 			break
   9308 		}
   9309 		if v_0_0.AuxInt != 1 {
   9310 			break
   9311 		}
   9312 		x := v_0_0.Args[0]
   9313 		v.reset(OpS390XLPDFR)
   9314 		v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
   9315 		v0.AddArg(x)
   9316 		v.AddArg(v0)
   9317 		return true
   9318 	}
   9319 	// match: (LDGR <t> (OR (MOVDconst [-1<<63]) x))
   9320 	// cond:
   9321 	// result: (LNDFR (LDGR <t> x))
   9322 	for {
   9323 		t := v.Type
   9324 		v_0 := v.Args[0]
   9325 		if v_0.Op != OpS390XOR {
   9326 			break
   9327 		}
   9328 		_ = v_0.Args[1]
   9329 		v_0_0 := v_0.Args[0]
   9330 		if v_0_0.Op != OpS390XMOVDconst {
   9331 			break
   9332 		}
   9333 		if v_0_0.AuxInt != -1<<63 {
   9334 			break
   9335 		}
   9336 		x := v_0.Args[1]
   9337 		v.reset(OpS390XLNDFR)
   9338 		v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
   9339 		v0.AddArg(x)
   9340 		v.AddArg(v0)
   9341 		return true
   9342 	}
   9343 	// match: (LDGR <t> (OR x (MOVDconst [-1<<63])))
   9344 	// cond:
   9345 	// result: (LNDFR (LDGR <t> x))
   9346 	for {
   9347 		t := v.Type
   9348 		v_0 := v.Args[0]
   9349 		if v_0.Op != OpS390XOR {
   9350 			break
   9351 		}
   9352 		_ = v_0.Args[1]
   9353 		x := v_0.Args[0]
   9354 		v_0_1 := v_0.Args[1]
   9355 		if v_0_1.Op != OpS390XMOVDconst {
   9356 			break
   9357 		}
   9358 		if v_0_1.AuxInt != -1<<63 {
   9359 			break
   9360 		}
   9361 		v.reset(OpS390XLNDFR)
   9362 		v0 := b.NewValue0(v.Pos, OpS390XLDGR, t)
   9363 		v0.AddArg(x)
   9364 		v.AddArg(v0)
   9365 		return true
   9366 	}
   9367 	// match: (LDGR <t> x:(ORload <t1> [off] {sym} (MOVDconst [-1<<63]) ptr mem))
   9368 	// cond: x.Uses == 1 && clobber(x)
   9369 	// result: @x.Block (LNDFR <t> (LDGR <t> (MOVDload <t1> [off] {sym} ptr mem)))
   9370 	for {
   9371 		t := v.Type
   9372 		x := v.Args[0]
   9373 		if x.Op != OpS390XORload {
   9374 			break
   9375 		}
   9376 		t1 := x.Type
   9377 		off := x.AuxInt
   9378 		sym := x.Aux
   9379 		_ = x.Args[2]
   9380 		x_0 := x.Args[0]
   9381 		if x_0.Op != OpS390XMOVDconst {
   9382 			break
   9383 		}
   9384 		if x_0.AuxInt != -1<<63 {
   9385 			break
   9386 		}
   9387 		ptr := x.Args[1]
   9388 		mem := x.Args[2]
   9389 		if !(x.Uses == 1 && clobber(x)) {
   9390 			break
   9391 		}
   9392 		b = x.Block
   9393 		v0 := b.NewValue0(v.Pos, OpS390XLNDFR, t)
   9394 		v.reset(OpCopy)
   9395 		v.AddArg(v0)
   9396 		v1 := b.NewValue0(v.Pos, OpS390XLDGR, t)
   9397 		v2 := b.NewValue0(v.Pos, OpS390XMOVDload, t1)
   9398 		v2.AuxInt = off
   9399 		v2.Aux = sym
   9400 		v2.AddArg(ptr)
   9401 		v2.AddArg(mem)
   9402 		v1.AddArg(v2)
   9403 		v0.AddArg(v1)
   9404 		return true
   9405 	}
   9406 	// match: (LDGR (LGDR x))
   9407 	// cond:
   9408 	// result: x
   9409 	for {
   9410 		v_0 := v.Args[0]
   9411 		if v_0.Op != OpS390XLGDR {
   9412 			break
   9413 		}
   9414 		x := v_0.Args[0]
   9415 		v.reset(OpCopy)
   9416 		v.Type = x.Type
   9417 		v.AddArg(x)
   9418 		return true
   9419 	}
   9420 	return false
   9421 }
   9422 func rewriteValueS390X_OpS390XLEDBR_0(v *Value) bool {
   9423 	// match: (LEDBR (LPDFR (LDEBR x)))
   9424 	// cond:
   9425 	// result: (LPDFR x)
   9426 	for {
   9427 		v_0 := v.Args[0]
   9428 		if v_0.Op != OpS390XLPDFR {
   9429 			break
   9430 		}
   9431 		v_0_0 := v_0.Args[0]
   9432 		if v_0_0.Op != OpS390XLDEBR {
   9433 			break
   9434 		}
   9435 		x := v_0_0.Args[0]
   9436 		v.reset(OpS390XLPDFR)
   9437 		v.AddArg(x)
   9438 		return true
   9439 	}
   9440 	// match: (LEDBR (LNDFR (LDEBR x)))
   9441 	// cond:
   9442 	// result: (LNDFR x)
   9443 	for {
   9444 		v_0 := v.Args[0]
   9445 		if v_0.Op != OpS390XLNDFR {
   9446 			break
   9447 		}
   9448 		v_0_0 := v_0.Args[0]
   9449 		if v_0_0.Op != OpS390XLDEBR {
   9450 			break
   9451 		}
   9452 		x := v_0_0.Args[0]
   9453 		v.reset(OpS390XLNDFR)
   9454 		v.AddArg(x)
   9455 		return true
   9456 	}
   9457 	return false
   9458 }
   9459 func rewriteValueS390X_OpS390XLGDR_0(v *Value) bool {
   9460 	// match: (LGDR (LDGR x))
   9461 	// cond:
   9462 	// result: (MOVDreg x)
   9463 	for {
   9464 		v_0 := v.Args[0]
   9465 		if v_0.Op != OpS390XLDGR {
   9466 			break
   9467 		}
   9468 		x := v_0.Args[0]
   9469 		v.reset(OpS390XMOVDreg)
   9470 		v.AddArg(x)
   9471 		return true
   9472 	}
   9473 	return false
   9474 }
   9475 func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
   9476 	// match: (LoweredRound32F x:(FMOVSconst))
   9477 	// cond:
   9478 	// result: x
   9479 	for {
   9480 		x := v.Args[0]
   9481 		if x.Op != OpS390XFMOVSconst {
   9482 			break
   9483 		}
   9484 		v.reset(OpCopy)
   9485 		v.Type = x.Type
   9486 		v.AddArg(x)
   9487 		return true
   9488 	}
   9489 	return false
   9490 }
   9491 func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
   9492 	// match: (LoweredRound64F x:(FMOVDconst))
   9493 	// cond:
   9494 	// result: x
   9495 	for {
   9496 		x := v.Args[0]
   9497 		if x.Op != OpS390XFMOVDconst {
   9498 			break
   9499 		}
   9500 		v.reset(OpCopy)
   9501 		v.Type = x.Type
   9502 		v.AddArg(x)
   9503 		return true
   9504 	}
   9505 	return false
   9506 }
   9507 func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
   9508 	// match: (MOVBZload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
   9509 	// cond: isSamePtr(ptr1, ptr2)
   9510 	// result: (MOVBZreg x)
   9511 	for {
   9512 		off := v.AuxInt
   9513 		sym := v.Aux
   9514 		_ = v.Args[1]
   9515 		ptr1 := v.Args[0]
   9516 		v_1 := v.Args[1]
   9517 		if v_1.Op != OpS390XMOVBstore {
   9518 			break
   9519 		}
   9520 		if v_1.AuxInt != off {
   9521 			break
   9522 		}
   9523 		if v_1.Aux != sym {
   9524 			break
   9525 		}
   9526 		_ = v_1.Args[2]
   9527 		ptr2 := v_1.Args[0]
   9528 		x := v_1.Args[1]
   9529 		if !(isSamePtr(ptr1, ptr2)) {
   9530 			break
   9531 		}
   9532 		v.reset(OpS390XMOVBZreg)
   9533 		v.AddArg(x)
   9534 		return true
   9535 	}
   9536 	// match: (MOVBZload [off1] {sym} (ADDconst [off2] ptr) mem)
   9537 	// cond: is20Bit(off1+off2)
   9538 	// result: (MOVBZload [off1+off2] {sym} ptr mem)
   9539 	for {
   9540 		off1 := v.AuxInt
   9541 		sym := v.Aux
   9542 		_ = v.Args[1]
   9543 		v_0 := v.Args[0]
   9544 		if v_0.Op != OpS390XADDconst {
   9545 			break
   9546 		}
   9547 		off2 := v_0.AuxInt
   9548 		ptr := v_0.Args[0]
   9549 		mem := v.Args[1]
   9550 		if !(is20Bit(off1 + off2)) {
   9551 			break
   9552 		}
   9553 		v.reset(OpS390XMOVBZload)
   9554 		v.AuxInt = off1 + off2
   9555 		v.Aux = sym
   9556 		v.AddArg(ptr)
   9557 		v.AddArg(mem)
   9558 		return true
   9559 	}
   9560 	// match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
   9561 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   9562 	// result: (MOVBZload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   9563 	for {
   9564 		off1 := v.AuxInt
   9565 		sym1 := v.Aux
   9566 		_ = v.Args[1]
   9567 		v_0 := v.Args[0]
   9568 		if v_0.Op != OpS390XMOVDaddr {
   9569 			break
   9570 		}
   9571 		off2 := v_0.AuxInt
   9572 		sym2 := v_0.Aux
   9573 		base := v_0.Args[0]
   9574 		mem := v.Args[1]
   9575 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   9576 			break
   9577 		}
   9578 		v.reset(OpS390XMOVBZload)
   9579 		v.AuxInt = off1 + off2
   9580 		v.Aux = mergeSym(sym1, sym2)
   9581 		v.AddArg(base)
   9582 		v.AddArg(mem)
   9583 		return true
   9584 	}
   9585 	// match: (MOVBZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   9586 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   9587 	// result: (MOVBZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   9588 	for {
   9589 		off1 := v.AuxInt
   9590 		sym1 := v.Aux
   9591 		_ = v.Args[1]
   9592 		v_0 := v.Args[0]
   9593 		if v_0.Op != OpS390XMOVDaddridx {
   9594 			break
   9595 		}
   9596 		off2 := v_0.AuxInt
   9597 		sym2 := v_0.Aux
   9598 		_ = v_0.Args[1]
   9599 		ptr := v_0.Args[0]
   9600 		idx := v_0.Args[1]
   9601 		mem := v.Args[1]
   9602 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   9603 			break
   9604 		}
   9605 		v.reset(OpS390XMOVBZloadidx)
   9606 		v.AuxInt = off1 + off2
   9607 		v.Aux = mergeSym(sym1, sym2)
   9608 		v.AddArg(ptr)
   9609 		v.AddArg(idx)
   9610 		v.AddArg(mem)
   9611 		return true
   9612 	}
   9613 	// match: (MOVBZload [off] {sym} (ADD ptr idx) mem)
   9614 	// cond: ptr.Op != OpSB
   9615 	// result: (MOVBZloadidx [off] {sym} ptr idx mem)
   9616 	for {
   9617 		off := v.AuxInt
   9618 		sym := v.Aux
   9619 		_ = v.Args[1]
   9620 		v_0 := v.Args[0]
   9621 		if v_0.Op != OpS390XADD {
   9622 			break
   9623 		}
   9624 		_ = v_0.Args[1]
   9625 		ptr := v_0.Args[0]
   9626 		idx := v_0.Args[1]
   9627 		mem := v.Args[1]
   9628 		if !(ptr.Op != OpSB) {
   9629 			break
   9630 		}
   9631 		v.reset(OpS390XMOVBZloadidx)
   9632 		v.AuxInt = off
   9633 		v.Aux = sym
   9634 		v.AddArg(ptr)
   9635 		v.AddArg(idx)
   9636 		v.AddArg(mem)
   9637 		return true
   9638 	}
   9639 	return false
   9640 }
   9641 func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
   9642 	// match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   9643 	// cond: is20Bit(c+d)
   9644 	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
   9645 	for {
   9646 		c := v.AuxInt
   9647 		sym := v.Aux
   9648 		_ = v.Args[2]
   9649 		v_0 := v.Args[0]
   9650 		if v_0.Op != OpS390XADDconst {
   9651 			break
   9652 		}
   9653 		d := v_0.AuxInt
   9654 		ptr := v_0.Args[0]
   9655 		idx := v.Args[1]
   9656 		mem := v.Args[2]
   9657 		if !(is20Bit(c + d)) {
   9658 			break
   9659 		}
   9660 		v.reset(OpS390XMOVBZloadidx)
   9661 		v.AuxInt = c + d
   9662 		v.Aux = sym
   9663 		v.AddArg(ptr)
   9664 		v.AddArg(idx)
   9665 		v.AddArg(mem)
   9666 		return true
   9667 	}
   9668 	// match: (MOVBZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   9669 	// cond: is20Bit(c+d)
   9670 	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
   9671 	for {
   9672 		c := v.AuxInt
   9673 		sym := v.Aux
   9674 		_ = v.Args[2]
   9675 		idx := v.Args[0]
   9676 		v_1 := v.Args[1]
   9677 		if v_1.Op != OpS390XADDconst {
   9678 			break
   9679 		}
   9680 		d := v_1.AuxInt
   9681 		ptr := v_1.Args[0]
   9682 		mem := v.Args[2]
   9683 		if !(is20Bit(c + d)) {
   9684 			break
   9685 		}
   9686 		v.reset(OpS390XMOVBZloadidx)
   9687 		v.AuxInt = c + d
   9688 		v.Aux = sym
   9689 		v.AddArg(ptr)
   9690 		v.AddArg(idx)
   9691 		v.AddArg(mem)
   9692 		return true
   9693 	}
   9694 	// match: (MOVBZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   9695 	// cond: is20Bit(c+d)
   9696 	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
   9697 	for {
   9698 		c := v.AuxInt
   9699 		sym := v.Aux
   9700 		_ = v.Args[2]
   9701 		ptr := v.Args[0]
   9702 		v_1 := v.Args[1]
   9703 		if v_1.Op != OpS390XADDconst {
   9704 			break
   9705 		}
   9706 		d := v_1.AuxInt
   9707 		idx := v_1.Args[0]
   9708 		mem := v.Args[2]
   9709 		if !(is20Bit(c + d)) {
   9710 			break
   9711 		}
   9712 		v.reset(OpS390XMOVBZloadidx)
   9713 		v.AuxInt = c + d
   9714 		v.Aux = sym
   9715 		v.AddArg(ptr)
   9716 		v.AddArg(idx)
   9717 		v.AddArg(mem)
   9718 		return true
   9719 	}
   9720 	// match: (MOVBZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   9721 	// cond: is20Bit(c+d)
   9722 	// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
   9723 	for {
   9724 		c := v.AuxInt
   9725 		sym := v.Aux
   9726 		_ = v.Args[2]
   9727 		v_0 := v.Args[0]
   9728 		if v_0.Op != OpS390XADDconst {
   9729 			break
   9730 		}
   9731 		d := v_0.AuxInt
   9732 		idx := v_0.Args[0]
   9733 		ptr := v.Args[1]
   9734 		mem := v.Args[2]
   9735 		if !(is20Bit(c + d)) {
   9736 			break
   9737 		}
   9738 		v.reset(OpS390XMOVBZloadidx)
   9739 		v.AuxInt = c + d
   9740 		v.Aux = sym
   9741 		v.AddArg(ptr)
   9742 		v.AddArg(idx)
   9743 		v.AddArg(mem)
   9744 		return true
   9745 	}
   9746 	return false
   9747 }
   9748 func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
   9749 	// match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _))
   9750 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9751 	// result: (MOVDreg x)
   9752 	for {
   9753 		x := v.Args[0]
   9754 		if x.Op != OpS390XMOVDLT {
   9755 			break
   9756 		}
   9757 		_ = x.Args[2]
   9758 		x_0 := x.Args[0]
   9759 		if x_0.Op != OpS390XMOVDconst {
   9760 			break
   9761 		}
   9762 		c := x_0.AuxInt
   9763 		x_1 := x.Args[1]
   9764 		if x_1.Op != OpS390XMOVDconst {
   9765 			break
   9766 		}
   9767 		d := x_1.AuxInt
   9768 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9769 			break
   9770 		}
   9771 		v.reset(OpS390XMOVDreg)
   9772 		v.AddArg(x)
   9773 		return true
   9774 	}
   9775 	// match: (MOVBZreg x:(MOVDLE (MOVDconst [c]) (MOVDconst [d]) _))
   9776 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9777 	// result: (MOVDreg x)
   9778 	for {
   9779 		x := v.Args[0]
   9780 		if x.Op != OpS390XMOVDLE {
   9781 			break
   9782 		}
   9783 		_ = x.Args[2]
   9784 		x_0 := x.Args[0]
   9785 		if x_0.Op != OpS390XMOVDconst {
   9786 			break
   9787 		}
   9788 		c := x_0.AuxInt
   9789 		x_1 := x.Args[1]
   9790 		if x_1.Op != OpS390XMOVDconst {
   9791 			break
   9792 		}
   9793 		d := x_1.AuxInt
   9794 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9795 			break
   9796 		}
   9797 		v.reset(OpS390XMOVDreg)
   9798 		v.AddArg(x)
   9799 		return true
   9800 	}
   9801 	// match: (MOVBZreg x:(MOVDGT (MOVDconst [c]) (MOVDconst [d]) _))
   9802 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9803 	// result: (MOVDreg x)
   9804 	for {
   9805 		x := v.Args[0]
   9806 		if x.Op != OpS390XMOVDGT {
   9807 			break
   9808 		}
   9809 		_ = x.Args[2]
   9810 		x_0 := x.Args[0]
   9811 		if x_0.Op != OpS390XMOVDconst {
   9812 			break
   9813 		}
   9814 		c := x_0.AuxInt
   9815 		x_1 := x.Args[1]
   9816 		if x_1.Op != OpS390XMOVDconst {
   9817 			break
   9818 		}
   9819 		d := x_1.AuxInt
   9820 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9821 			break
   9822 		}
   9823 		v.reset(OpS390XMOVDreg)
   9824 		v.AddArg(x)
   9825 		return true
   9826 	}
   9827 	// match: (MOVBZreg x:(MOVDGE (MOVDconst [c]) (MOVDconst [d]) _))
   9828 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9829 	// result: (MOVDreg x)
   9830 	for {
   9831 		x := v.Args[0]
   9832 		if x.Op != OpS390XMOVDGE {
   9833 			break
   9834 		}
   9835 		_ = x.Args[2]
   9836 		x_0 := x.Args[0]
   9837 		if x_0.Op != OpS390XMOVDconst {
   9838 			break
   9839 		}
   9840 		c := x_0.AuxInt
   9841 		x_1 := x.Args[1]
   9842 		if x_1.Op != OpS390XMOVDconst {
   9843 			break
   9844 		}
   9845 		d := x_1.AuxInt
   9846 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9847 			break
   9848 		}
   9849 		v.reset(OpS390XMOVDreg)
   9850 		v.AddArg(x)
   9851 		return true
   9852 	}
   9853 	// match: (MOVBZreg x:(MOVDEQ (MOVDconst [c]) (MOVDconst [d]) _))
   9854 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9855 	// result: (MOVDreg x)
   9856 	for {
   9857 		x := v.Args[0]
   9858 		if x.Op != OpS390XMOVDEQ {
   9859 			break
   9860 		}
   9861 		_ = x.Args[2]
   9862 		x_0 := x.Args[0]
   9863 		if x_0.Op != OpS390XMOVDconst {
   9864 			break
   9865 		}
   9866 		c := x_0.AuxInt
   9867 		x_1 := x.Args[1]
   9868 		if x_1.Op != OpS390XMOVDconst {
   9869 			break
   9870 		}
   9871 		d := x_1.AuxInt
   9872 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9873 			break
   9874 		}
   9875 		v.reset(OpS390XMOVDreg)
   9876 		v.AddArg(x)
   9877 		return true
   9878 	}
   9879 	// match: (MOVBZreg x:(MOVDNE (MOVDconst [c]) (MOVDconst [d]) _))
   9880 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9881 	// result: (MOVDreg x)
   9882 	for {
   9883 		x := v.Args[0]
   9884 		if x.Op != OpS390XMOVDNE {
   9885 			break
   9886 		}
   9887 		_ = x.Args[2]
   9888 		x_0 := x.Args[0]
   9889 		if x_0.Op != OpS390XMOVDconst {
   9890 			break
   9891 		}
   9892 		c := x_0.AuxInt
   9893 		x_1 := x.Args[1]
   9894 		if x_1.Op != OpS390XMOVDconst {
   9895 			break
   9896 		}
   9897 		d := x_1.AuxInt
   9898 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9899 			break
   9900 		}
   9901 		v.reset(OpS390XMOVDreg)
   9902 		v.AddArg(x)
   9903 		return true
   9904 	}
   9905 	// match: (MOVBZreg x:(MOVDGTnoinv (MOVDconst [c]) (MOVDconst [d]) _))
   9906 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9907 	// result: (MOVDreg x)
   9908 	for {
   9909 		x := v.Args[0]
   9910 		if x.Op != OpS390XMOVDGTnoinv {
   9911 			break
   9912 		}
   9913 		_ = x.Args[2]
   9914 		x_0 := x.Args[0]
   9915 		if x_0.Op != OpS390XMOVDconst {
   9916 			break
   9917 		}
   9918 		c := x_0.AuxInt
   9919 		x_1 := x.Args[1]
   9920 		if x_1.Op != OpS390XMOVDconst {
   9921 			break
   9922 		}
   9923 		d := x_1.AuxInt
   9924 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9925 			break
   9926 		}
   9927 		v.reset(OpS390XMOVDreg)
   9928 		v.AddArg(x)
   9929 		return true
   9930 	}
   9931 	// match: (MOVBZreg x:(MOVDGEnoinv (MOVDconst [c]) (MOVDconst [d]) _))
   9932 	// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
   9933 	// result: (MOVDreg x)
   9934 	for {
   9935 		x := v.Args[0]
   9936 		if x.Op != OpS390XMOVDGEnoinv {
   9937 			break
   9938 		}
   9939 		_ = x.Args[2]
   9940 		x_0 := x.Args[0]
   9941 		if x_0.Op != OpS390XMOVDconst {
   9942 			break
   9943 		}
   9944 		c := x_0.AuxInt
   9945 		x_1 := x.Args[1]
   9946 		if x_1.Op != OpS390XMOVDconst {
   9947 			break
   9948 		}
   9949 		d := x_1.AuxInt
   9950 		if !(int64(uint8(c)) == c && int64(uint8(d)) == d) {
   9951 			break
   9952 		}
   9953 		v.reset(OpS390XMOVDreg)
   9954 		v.AddArg(x)
   9955 		return true
   9956 	}
   9957 	// match: (MOVBZreg x:(MOVBZload _ _))
   9958 	// cond:
   9959 	// result: (MOVDreg x)
   9960 	for {
   9961 		x := v.Args[0]
   9962 		if x.Op != OpS390XMOVBZload {
   9963 			break
   9964 		}
   9965 		_ = x.Args[1]
   9966 		v.reset(OpS390XMOVDreg)
   9967 		v.AddArg(x)
   9968 		return true
   9969 	}
   9970 	// match: (MOVBZreg x:(Arg <t>))
   9971 	// cond: is8BitInt(t) && !isSigned(t)
   9972 	// result: (MOVDreg x)
   9973 	for {
   9974 		x := v.Args[0]
   9975 		if x.Op != OpArg {
   9976 			break
   9977 		}
   9978 		t := x.Type
   9979 		if !(is8BitInt(t) && !isSigned(t)) {
   9980 			break
   9981 		}
   9982 		v.reset(OpS390XMOVDreg)
   9983 		v.AddArg(x)
   9984 		return true
   9985 	}
   9986 	return false
   9987 }
   9988 func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
   9989 	b := v.Block
   9990 	_ = b
   9991 	// match: (MOVBZreg x:(MOVBZreg _))
   9992 	// cond:
   9993 	// result: (MOVDreg x)
   9994 	for {
   9995 		x := v.Args[0]
   9996 		if x.Op != OpS390XMOVBZreg {
   9997 			break
   9998 		}
   9999 		v.reset(OpS390XMOVDreg)
   10000 		v.AddArg(x)
   10001 		return true
   10002 	}
   10003 	// match: (MOVBZreg (MOVDconst [c]))
   10004 	// cond:
   10005 	// result: (MOVDconst [int64(uint8(c))])
   10006 	for {
   10007 		v_0 := v.Args[0]
   10008 		if v_0.Op != OpS390XMOVDconst {
   10009 			break
   10010 		}
   10011 		c := v_0.AuxInt
   10012 		v.reset(OpS390XMOVDconst)
   10013 		v.AuxInt = int64(uint8(c))
   10014 		return true
   10015 	}
   10016 	// match: (MOVBZreg x:(MOVBZload [off] {sym} ptr mem))
   10017 	// cond: x.Uses == 1 && clobber(x)
   10018 	// result: @x.Block (MOVBZload <v.Type> [off] {sym} ptr mem)
   10019 	for {
   10020 		x := v.Args[0]
   10021 		if x.Op != OpS390XMOVBZload {
   10022 			break
   10023 		}
   10024 		off := x.AuxInt
   10025 		sym := x.Aux
   10026 		_ = x.Args[1]
   10027 		ptr := x.Args[0]
   10028 		mem := x.Args[1]
   10029 		if !(x.Uses == 1 && clobber(x)) {
   10030 			break
   10031 		}
   10032 		b = x.Block
   10033 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, v.Type)
   10034 		v.reset(OpCopy)
   10035 		v.AddArg(v0)
   10036 		v0.AuxInt = off
   10037 		v0.Aux = sym
   10038 		v0.AddArg(ptr)
   10039 		v0.AddArg(mem)
   10040 		return true
   10041 	}
   10042 	// match: (MOVBZreg x:(MOVBload [off] {sym} ptr mem))
   10043 	// cond: x.Uses == 1 && clobber(x)
   10044 	// result: @x.Block (MOVBZload <v.Type> [off] {sym} ptr mem)
   10045 	for {
   10046 		x := v.Args[0]
   10047 		if x.Op != OpS390XMOVBload {
   10048 			break
   10049 		}
   10050 		off := x.AuxInt
   10051 		sym := x.Aux
   10052 		_ = x.Args[1]
   10053 		ptr := x.Args[0]
   10054 		mem := x.Args[1]
   10055 		if !(x.Uses == 1 && clobber(x)) {
   10056 			break
   10057 		}
   10058 		b = x.Block
   10059 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, v.Type)
   10060 		v.reset(OpCopy)
   10061 		v.AddArg(v0)
   10062 		v0.AuxInt = off
   10063 		v0.Aux = sym
   10064 		v0.AddArg(ptr)
   10065 		v0.AddArg(mem)
   10066 		return true
   10067 	}
   10068 	// match: (MOVBZreg x:(MOVBZloadidx [off] {sym} ptr idx mem))
   10069 	// cond: x.Uses == 1 && clobber(x)
   10070 	// result: @x.Block (MOVBZloadidx <v.Type> [off] {sym} ptr idx mem)
   10071 	for {
   10072 		x := v.Args[0]
   10073 		if x.Op != OpS390XMOVBZloadidx {
   10074 			break
   10075 		}
   10076 		off := x.AuxInt
   10077 		sym := x.Aux
   10078 		_ = x.Args[2]
   10079 		ptr := x.Args[0]
   10080 		idx := x.Args[1]
   10081 		mem := x.Args[2]
   10082 		if !(x.Uses == 1 && clobber(x)) {
   10083 			break
   10084 		}
   10085 		b = x.Block
   10086 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, v.Type)
   10087 		v.reset(OpCopy)
   10088 		v.AddArg(v0)
   10089 		v0.AuxInt = off
   10090 		v0.Aux = sym
   10091 		v0.AddArg(ptr)
   10092 		v0.AddArg(idx)
   10093 		v0.AddArg(mem)
   10094 		return true
   10095 	}
   10096 	// match: (MOVBZreg x:(MOVBloadidx [off] {sym} ptr idx mem))
   10097 	// cond: x.Uses == 1 && clobber(x)
   10098 	// result: @x.Block (MOVBZloadidx <v.Type> [off] {sym} ptr idx mem)
   10099 	for {
   10100 		x := v.Args[0]
   10101 		if x.Op != OpS390XMOVBloadidx {
   10102 			break
   10103 		}
   10104 		off := x.AuxInt
   10105 		sym := x.Aux
   10106 		_ = x.Args[2]
   10107 		ptr := x.Args[0]
   10108 		idx := x.Args[1]
   10109 		mem := x.Args[2]
   10110 		if !(x.Uses == 1 && clobber(x)) {
   10111 			break
   10112 		}
   10113 		b = x.Block
   10114 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, v.Type)
   10115 		v.reset(OpCopy)
   10116 		v.AddArg(v0)
   10117 		v0.AuxInt = off
   10118 		v0.Aux = sym
   10119 		v0.AddArg(ptr)
   10120 		v0.AddArg(idx)
   10121 		v0.AddArg(mem)
   10122 		return true
   10123 	}
   10124 	return false
   10125 }
   10126 func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
   10127 	// match: (MOVBload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
   10128 	// cond: isSamePtr(ptr1, ptr2)
   10129 	// result: (MOVBreg x)
   10130 	for {
   10131 		off := v.AuxInt
   10132 		sym := v.Aux
   10133 		_ = v.Args[1]
   10134 		ptr1 := v.Args[0]
   10135 		v_1 := v.Args[1]
   10136 		if v_1.Op != OpS390XMOVBstore {
   10137 			break
   10138 		}
   10139 		if v_1.AuxInt != off {
   10140 			break
   10141 		}
   10142 		if v_1.Aux != sym {
   10143 			break
   10144 		}
   10145 		_ = v_1.Args[2]
   10146 		ptr2 := v_1.Args[0]
   10147 		x := v_1.Args[1]
   10148 		if !(isSamePtr(ptr1, ptr2)) {
   10149 			break
   10150 		}
   10151 		v.reset(OpS390XMOVBreg)
   10152 		v.AddArg(x)
   10153 		return true
   10154 	}
   10155 	// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
   10156 	// cond: is20Bit(off1+off2)
   10157 	// result: (MOVBload  [off1+off2] {sym} ptr mem)
   10158 	for {
   10159 		off1 := v.AuxInt
   10160 		sym := v.Aux
   10161 		_ = v.Args[1]
   10162 		v_0 := v.Args[0]
   10163 		if v_0.Op != OpS390XADDconst {
   10164 			break
   10165 		}
   10166 		off2 := v_0.AuxInt
   10167 		ptr := v_0.Args[0]
   10168 		mem := v.Args[1]
   10169 		if !(is20Bit(off1 + off2)) {
   10170 			break
   10171 		}
   10172 		v.reset(OpS390XMOVBload)
   10173 		v.AuxInt = off1 + off2
   10174 		v.Aux = sym
   10175 		v.AddArg(ptr)
   10176 		v.AddArg(mem)
   10177 		return true
   10178 	}
   10179 	// match: (MOVBload [off1] {sym1} (MOVDaddr [off2] {sym2} base) mem)
   10180 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   10181 	// result: (MOVBload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   10182 	for {
   10183 		off1 := v.AuxInt
   10184 		sym1 := v.Aux
   10185 		_ = v.Args[1]
   10186 		v_0 := v.Args[0]
   10187 		if v_0.Op != OpS390XMOVDaddr {
   10188 			break
   10189 		}
   10190 		off2 := v_0.AuxInt
   10191 		sym2 := v_0.Aux
   10192 		base := v_0.Args[0]
   10193 		mem := v.Args[1]
   10194 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   10195 			break
   10196 		}
   10197 		v.reset(OpS390XMOVBload)
   10198 		v.AuxInt = off1 + off2
   10199 		v.Aux = mergeSym(sym1, sym2)
   10200 		v.AddArg(base)
   10201 		v.AddArg(mem)
   10202 		return true
   10203 	}
   10204 	// match: (MOVBload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   10205 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   10206 	// result: (MOVBloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   10207 	for {
   10208 		off1 := v.AuxInt
   10209 		sym1 := v.Aux
   10210 		_ = v.Args[1]
   10211 		v_0 := v.Args[0]
   10212 		if v_0.Op != OpS390XMOVDaddridx {
   10213 			break
   10214 		}
   10215 		off2 := v_0.AuxInt
   10216 		sym2 := v_0.Aux
   10217 		_ = v_0.Args[1]
   10218 		ptr := v_0.Args[0]
   10219 		idx := v_0.Args[1]
   10220 		mem := v.Args[1]
   10221 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   10222 			break
   10223 		}
   10224 		v.reset(OpS390XMOVBloadidx)
   10225 		v.AuxInt = off1 + off2
   10226 		v.Aux = mergeSym(sym1, sym2)
   10227 		v.AddArg(ptr)
   10228 		v.AddArg(idx)
   10229 		v.AddArg(mem)
   10230 		return true
   10231 	}
   10232 	// match: (MOVBload [off] {sym} (ADD ptr idx) mem)
   10233 	// cond: ptr.Op != OpSB
   10234 	// result: (MOVBloadidx  [off] {sym} ptr idx mem)
   10235 	for {
   10236 		off := v.AuxInt
   10237 		sym := v.Aux
   10238 		_ = v.Args[1]
   10239 		v_0 := v.Args[0]
   10240 		if v_0.Op != OpS390XADD {
   10241 			break
   10242 		}
   10243 		_ = v_0.Args[1]
   10244 		ptr := v_0.Args[0]
   10245 		idx := v_0.Args[1]
   10246 		mem := v.Args[1]
   10247 		if !(ptr.Op != OpSB) {
   10248 			break
   10249 		}
   10250 		v.reset(OpS390XMOVBloadidx)
   10251 		v.AuxInt = off
   10252 		v.Aux = sym
   10253 		v.AddArg(ptr)
   10254 		v.AddArg(idx)
   10255 		v.AddArg(mem)
   10256 		return true
   10257 	}
   10258 	return false
   10259 }
   10260 func rewriteValueS390X_OpS390XMOVBloadidx_0(v *Value) bool {
   10261 	// match: (MOVBloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   10262 	// cond: is20Bit(c+d)
   10263 	// result: (MOVBloadidx  [c+d] {sym} ptr idx mem)
   10264 	for {
   10265 		c := v.AuxInt
   10266 		sym := v.Aux
   10267 		_ = v.Args[2]
   10268 		v_0 := v.Args[0]
   10269 		if v_0.Op != OpS390XADDconst {
   10270 			break
   10271 		}
   10272 		d := v_0.AuxInt
   10273 		ptr := v_0.Args[0]
   10274 		idx := v.Args[1]
   10275 		mem := v.Args[2]
   10276 		if !(is20Bit(c + d)) {
   10277 			break
   10278 		}
   10279 		v.reset(OpS390XMOVBloadidx)
   10280 		v.AuxInt = c + d
   10281 		v.Aux = sym
   10282 		v.AddArg(ptr)
   10283 		v.AddArg(idx)
   10284 		v.AddArg(mem)
   10285 		return true
   10286 	}
   10287 	// match: (MOVBloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   10288 	// cond: is20Bit(c+d)
   10289 	// result: (MOVBloadidx  [c+d] {sym} ptr idx mem)
   10290 	for {
   10291 		c := v.AuxInt
   10292 		sym := v.Aux
   10293 		_ = v.Args[2]
   10294 		idx := v.Args[0]
   10295 		v_1 := v.Args[1]
   10296 		if v_1.Op != OpS390XADDconst {
   10297 			break
   10298 		}
   10299 		d := v_1.AuxInt
   10300 		ptr := v_1.Args[0]
   10301 		mem := v.Args[2]
   10302 		if !(is20Bit(c + d)) {
   10303 			break
   10304 		}
   10305 		v.reset(OpS390XMOVBloadidx)
   10306 		v.AuxInt = c + d
   10307 		v.Aux = sym
   10308 		v.AddArg(ptr)
   10309 		v.AddArg(idx)
   10310 		v.AddArg(mem)
   10311 		return true
   10312 	}
   10313 	// match: (MOVBloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   10314 	// cond: is20Bit(c+d)
   10315 	// result: (MOVBloadidx  [c+d] {sym} ptr idx mem)
   10316 	for {
   10317 		c := v.AuxInt
   10318 		sym := v.Aux
   10319 		_ = v.Args[2]
   10320 		ptr := v.Args[0]
   10321 		v_1 := v.Args[1]
   10322 		if v_1.Op != OpS390XADDconst {
   10323 			break
   10324 		}
   10325 		d := v_1.AuxInt
   10326 		idx := v_1.Args[0]
   10327 		mem := v.Args[2]
   10328 		if !(is20Bit(c + d)) {
   10329 			break
   10330 		}
   10331 		v.reset(OpS390XMOVBloadidx)
   10332 		v.AuxInt = c + d
   10333 		v.Aux = sym
   10334 		v.AddArg(ptr)
   10335 		v.AddArg(idx)
   10336 		v.AddArg(mem)
   10337 		return true
   10338 	}
   10339 	// match: (MOVBloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   10340 	// cond: is20Bit(c+d)
   10341 	// result: (MOVBloadidx  [c+d] {sym} ptr idx mem)
   10342 	for {
   10343 		c := v.AuxInt
   10344 		sym := v.Aux
   10345 		_ = v.Args[2]
   10346 		v_0 := v.Args[0]
   10347 		if v_0.Op != OpS390XADDconst {
   10348 			break
   10349 		}
   10350 		d := v_0.AuxInt
   10351 		idx := v_0.Args[0]
   10352 		ptr := v.Args[1]
   10353 		mem := v.Args[2]
   10354 		if !(is20Bit(c + d)) {
   10355 			break
   10356 		}
   10357 		v.reset(OpS390XMOVBloadidx)
   10358 		v.AuxInt = c + d
   10359 		v.Aux = sym
   10360 		v.AddArg(ptr)
   10361 		v.AddArg(idx)
   10362 		v.AddArg(mem)
   10363 		return true
   10364 	}
   10365 	return false
   10366 }
   10367 func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
   10368 	b := v.Block
   10369 	_ = b
   10370 	// match: (MOVBreg x:(MOVBload _ _))
   10371 	// cond:
   10372 	// result: (MOVDreg x)
   10373 	for {
   10374 		x := v.Args[0]
   10375 		if x.Op != OpS390XMOVBload {
   10376 			break
   10377 		}
   10378 		_ = x.Args[1]
   10379 		v.reset(OpS390XMOVDreg)
   10380 		v.AddArg(x)
   10381 		return true
   10382 	}
   10383 	// match: (MOVBreg x:(Arg <t>))
   10384 	// cond: is8BitInt(t) && isSigned(t)
   10385 	// result: (MOVDreg x)
   10386 	for {
   10387 		x := v.Args[0]
   10388 		if x.Op != OpArg {
   10389 			break
   10390 		}
   10391 		t := x.Type
   10392 		if !(is8BitInt(t) && isSigned(t)) {
   10393 			break
   10394 		}
   10395 		v.reset(OpS390XMOVDreg)
   10396 		v.AddArg(x)
   10397 		return true
   10398 	}
   10399 	// match: (MOVBreg x:(MOVBreg _))
   10400 	// cond:
   10401 	// result: (MOVDreg x)
   10402 	for {
   10403 		x := v.Args[0]
   10404 		if x.Op != OpS390XMOVBreg {
   10405 			break
   10406 		}
   10407 		v.reset(OpS390XMOVDreg)
   10408 		v.AddArg(x)
   10409 		return true
   10410 	}
   10411 	// match: (MOVBreg (MOVDconst [c]))
   10412 	// cond:
   10413 	// result: (MOVDconst [int64(int8(c))])
   10414 	for {
   10415 		v_0 := v.Args[0]
   10416 		if v_0.Op != OpS390XMOVDconst {
   10417 			break
   10418 		}
   10419 		c := v_0.AuxInt
   10420 		v.reset(OpS390XMOVDconst)
   10421 		v.AuxInt = int64(int8(c))
   10422 		return true
   10423 	}
   10424 	// match: (MOVBreg x:(MOVBZload [off] {sym} ptr mem))
   10425 	// cond: x.Uses == 1 && clobber(x)
   10426 	// result: @x.Block (MOVBload  <v.Type> [off] {sym} ptr mem)
   10427 	for {
   10428 		x := v.Args[0]
   10429 		if x.Op != OpS390XMOVBZload {
   10430 			break
   10431 		}
   10432 		off := x.AuxInt
   10433 		sym := x.Aux
   10434 		_ = x.Args[1]
   10435 		ptr := x.Args[0]
   10436 		mem := x.Args[1]
   10437 		if !(x.Uses == 1 && clobber(x)) {
   10438 			break
   10439 		}
   10440 		b = x.Block
   10441 		v0 := b.NewValue0(v.Pos, OpS390XMOVBload, v.Type)
   10442 		v.reset(OpCopy)
   10443 		v.AddArg(v0)
   10444 		v0.AuxInt = off
   10445 		v0.Aux = sym
   10446 		v0.AddArg(ptr)
   10447 		v0.AddArg(mem)
   10448 		return true
   10449 	}
   10450 	// match: (MOVBreg x:(MOVBload [off] {sym} ptr mem))
   10451 	// cond: x.Uses == 1 && clobber(x)
   10452 	// result: @x.Block (MOVBload  <v.Type> [off] {sym} ptr mem)
   10453 	for {
   10454 		x := v.Args[0]
   10455 		if x.Op != OpS390XMOVBload {
   10456 			break
   10457 		}
   10458 		off := x.AuxInt
   10459 		sym := x.Aux
   10460 		_ = x.Args[1]
   10461 		ptr := x.Args[0]
   10462 		mem := x.Args[1]
   10463 		if !(x.Uses == 1 && clobber(x)) {
   10464 			break
   10465 		}
   10466 		b = x.Block
   10467 		v0 := b.NewValue0(v.Pos, OpS390XMOVBload, v.Type)
   10468 		v.reset(OpCopy)
   10469 		v.AddArg(v0)
   10470 		v0.AuxInt = off
   10471 		v0.Aux = sym
   10472 		v0.AddArg(ptr)
   10473 		v0.AddArg(mem)
   10474 		return true
   10475 	}
   10476 	// match: (MOVBreg x:(MOVBZloadidx [off] {sym} ptr idx mem))
   10477 	// cond: x.Uses == 1 && clobber(x)
   10478 	// result: @x.Block (MOVBloadidx  <v.Type> [off] {sym} ptr idx mem)
   10479 	for {
   10480 		x := v.Args[0]
   10481 		if x.Op != OpS390XMOVBZloadidx {
   10482 			break
   10483 		}
   10484 		off := x.AuxInt
   10485 		sym := x.Aux
   10486 		_ = x.Args[2]
   10487 		ptr := x.Args[0]
   10488 		idx := x.Args[1]
   10489 		mem := x.Args[2]
   10490 		if !(x.Uses == 1 && clobber(x)) {
   10491 			break
   10492 		}
   10493 		b = x.Block
   10494 		v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, v.Type)
   10495 		v.reset(OpCopy)
   10496 		v.AddArg(v0)
   10497 		v0.AuxInt = off
   10498 		v0.Aux = sym
   10499 		v0.AddArg(ptr)
   10500 		v0.AddArg(idx)
   10501 		v0.AddArg(mem)
   10502 		return true
   10503 	}
   10504 	// match: (MOVBreg x:(MOVBloadidx [off] {sym} ptr idx mem))
   10505 	// cond: x.Uses == 1 && clobber(x)
   10506 	// result: @x.Block (MOVBloadidx  <v.Type> [off] {sym} ptr idx mem)
   10507 	for {
   10508 		x := v.Args[0]
   10509 		if x.Op != OpS390XMOVBloadidx {
   10510 			break
   10511 		}
   10512 		off := x.AuxInt
   10513 		sym := x.Aux
   10514 		_ = x.Args[2]
   10515 		ptr := x.Args[0]
   10516 		idx := x.Args[1]
   10517 		mem := x.Args[2]
   10518 		if !(x.Uses == 1 && clobber(x)) {
   10519 			break
   10520 		}
   10521 		b = x.Block
   10522 		v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, v.Type)
   10523 		v.reset(OpCopy)
   10524 		v.AddArg(v0)
   10525 		v0.AuxInt = off
   10526 		v0.Aux = sym
   10527 		v0.AddArg(ptr)
   10528 		v0.AddArg(idx)
   10529 		v0.AddArg(mem)
   10530 		return true
   10531 	}
   10532 	return false
   10533 }
   10534 func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
   10535 	// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
   10536 	// cond:
   10537 	// result: (MOVBstore [off] {sym} ptr x mem)
   10538 	for {
   10539 		off := v.AuxInt
   10540 		sym := v.Aux
   10541 		_ = v.Args[2]
   10542 		ptr := v.Args[0]
   10543 		v_1 := v.Args[1]
   10544 		if v_1.Op != OpS390XMOVBreg {
   10545 			break
   10546 		}
   10547 		x := v_1.Args[0]
   10548 		mem := v.Args[2]
   10549 		v.reset(OpS390XMOVBstore)
   10550 		v.AuxInt = off
   10551 		v.Aux = sym
   10552 		v.AddArg(ptr)
   10553 		v.AddArg(x)
   10554 		v.AddArg(mem)
   10555 		return true
   10556 	}
   10557 	// match: (MOVBstore [off] {sym} ptr (MOVBZreg x) mem)
   10558 	// cond:
   10559 	// result: (MOVBstore [off] {sym} ptr x mem)
   10560 	for {
   10561 		off := v.AuxInt
   10562 		sym := v.Aux
   10563 		_ = v.Args[2]
   10564 		ptr := v.Args[0]
   10565 		v_1 := v.Args[1]
   10566 		if v_1.Op != OpS390XMOVBZreg {
   10567 			break
   10568 		}
   10569 		x := v_1.Args[0]
   10570 		mem := v.Args[2]
   10571 		v.reset(OpS390XMOVBstore)
   10572 		v.AuxInt = off
   10573 		v.Aux = sym
   10574 		v.AddArg(ptr)
   10575 		v.AddArg(x)
   10576 		v.AddArg(mem)
   10577 		return true
   10578 	}
   10579 	// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
   10580 	// cond: is20Bit(off1+off2)
   10581 	// result: (MOVBstore  [off1+off2] {sym} ptr val mem)
   10582 	for {
   10583 		off1 := v.AuxInt
   10584 		sym := v.Aux
   10585 		_ = v.Args[2]
   10586 		v_0 := v.Args[0]
   10587 		if v_0.Op != OpS390XADDconst {
   10588 			break
   10589 		}
   10590 		off2 := v_0.AuxInt
   10591 		ptr := v_0.Args[0]
   10592 		val := v.Args[1]
   10593 		mem := v.Args[2]
   10594 		if !(is20Bit(off1 + off2)) {
   10595 			break
   10596 		}
   10597 		v.reset(OpS390XMOVBstore)
   10598 		v.AuxInt = off1 + off2
   10599 		v.Aux = sym
   10600 		v.AddArg(ptr)
   10601 		v.AddArg(val)
   10602 		v.AddArg(mem)
   10603 		return true
   10604 	}
   10605 	// match: (MOVBstore [off] {sym} ptr (MOVDconst [c]) mem)
   10606 	// cond: is20Bit(off) && ptr.Op != OpSB
   10607 	// result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
   10608 	for {
   10609 		off := v.AuxInt
   10610 		sym := v.Aux
   10611 		_ = v.Args[2]
   10612 		ptr := v.Args[0]
   10613 		v_1 := v.Args[1]
   10614 		if v_1.Op != OpS390XMOVDconst {
   10615 			break
   10616 		}
   10617 		c := v_1.AuxInt
   10618 		mem := v.Args[2]
   10619 		if !(is20Bit(off) && ptr.Op != OpSB) {
   10620 			break
   10621 		}
   10622 		v.reset(OpS390XMOVBstoreconst)
   10623 		v.AuxInt = makeValAndOff(int64(int8(c)), off)
   10624 		v.Aux = sym
   10625 		v.AddArg(ptr)
   10626 		v.AddArg(mem)
   10627 		return true
   10628 	}
   10629 	// match: (MOVBstore [off1] {sym1} (MOVDaddr [off2] {sym2} base) val mem)
   10630 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   10631 	// result: (MOVBstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   10632 	for {
   10633 		off1 := v.AuxInt
   10634 		sym1 := v.Aux
   10635 		_ = v.Args[2]
   10636 		v_0 := v.Args[0]
   10637 		if v_0.Op != OpS390XMOVDaddr {
   10638 			break
   10639 		}
   10640 		off2 := v_0.AuxInt
   10641 		sym2 := v_0.Aux
   10642 		base := v_0.Args[0]
   10643 		val := v.Args[1]
   10644 		mem := v.Args[2]
   10645 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   10646 			break
   10647 		}
   10648 		v.reset(OpS390XMOVBstore)
   10649 		v.AuxInt = off1 + off2
   10650 		v.Aux = mergeSym(sym1, sym2)
   10651 		v.AddArg(base)
   10652 		v.AddArg(val)
   10653 		v.AddArg(mem)
   10654 		return true
   10655 	}
   10656 	// match: (MOVBstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
   10657 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   10658 	// result: (MOVBstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   10659 	for {
   10660 		off1 := v.AuxInt
   10661 		sym1 := v.Aux
   10662 		_ = v.Args[2]
   10663 		v_0 := v.Args[0]
   10664 		if v_0.Op != OpS390XMOVDaddridx {
   10665 			break
   10666 		}
   10667 		off2 := v_0.AuxInt
   10668 		sym2 := v_0.Aux
   10669 		_ = v_0.Args[1]
   10670 		ptr := v_0.Args[0]
   10671 		idx := v_0.Args[1]
   10672 		val := v.Args[1]
   10673 		mem := v.Args[2]
   10674 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   10675 			break
   10676 		}
   10677 		v.reset(OpS390XMOVBstoreidx)
   10678 		v.AuxInt = off1 + off2
   10679 		v.Aux = mergeSym(sym1, sym2)
   10680 		v.AddArg(ptr)
   10681 		v.AddArg(idx)
   10682 		v.AddArg(val)
   10683 		v.AddArg(mem)
   10684 		return true
   10685 	}
   10686 	// match: (MOVBstore [off] {sym} (ADD ptr idx) val mem)
   10687 	// cond: ptr.Op != OpSB
   10688 	// result: (MOVBstoreidx  [off] {sym} ptr idx val mem)
   10689 	for {
   10690 		off := v.AuxInt
   10691 		sym := v.Aux
   10692 		_ = v.Args[2]
   10693 		v_0 := v.Args[0]
   10694 		if v_0.Op != OpS390XADD {
   10695 			break
   10696 		}
   10697 		_ = v_0.Args[1]
   10698 		ptr := v_0.Args[0]
   10699 		idx := v_0.Args[1]
   10700 		val := v.Args[1]
   10701 		mem := v.Args[2]
   10702 		if !(ptr.Op != OpSB) {
   10703 			break
   10704 		}
   10705 		v.reset(OpS390XMOVBstoreidx)
   10706 		v.AuxInt = off
   10707 		v.Aux = sym
   10708 		v.AddArg(ptr)
   10709 		v.AddArg(idx)
   10710 		v.AddArg(val)
   10711 		v.AddArg(mem)
   10712 		return true
   10713 	}
   10714 	// match: (MOVBstore [i] {s} p w x:(MOVBstore [i-1] {s} p (SRDconst [8] w) mem))
   10715 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   10716 	// result: (MOVHstore [i-1] {s} p w mem)
   10717 	for {
   10718 		i := v.AuxInt
   10719 		s := v.Aux
   10720 		_ = v.Args[2]
   10721 		p := v.Args[0]
   10722 		w := v.Args[1]
   10723 		x := v.Args[2]
   10724 		if x.Op != OpS390XMOVBstore {
   10725 			break
   10726 		}
   10727 		if x.AuxInt != i-1 {
   10728 			break
   10729 		}
   10730 		if x.Aux != s {
   10731 			break
   10732 		}
   10733 		_ = x.Args[2]
   10734 		if p != x.Args[0] {
   10735 			break
   10736 		}
   10737 		x_1 := x.Args[1]
   10738 		if x_1.Op != OpS390XSRDconst {
   10739 			break
   10740 		}
   10741 		if x_1.AuxInt != 8 {
   10742 			break
   10743 		}
   10744 		if w != x_1.Args[0] {
   10745 			break
   10746 		}
   10747 		mem := x.Args[2]
   10748 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   10749 			break
   10750 		}
   10751 		v.reset(OpS390XMOVHstore)
   10752 		v.AuxInt = i - 1
   10753 		v.Aux = s
   10754 		v.AddArg(p)
   10755 		v.AddArg(w)
   10756 		v.AddArg(mem)
   10757 		return true
   10758 	}
   10759 	// match: (MOVBstore [i] {s} p w0:(SRDconst [j] w) x:(MOVBstore [i-1] {s} p (SRDconst [j+8] w) mem))
   10760 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   10761 	// result: (MOVHstore [i-1] {s} p w0 mem)
   10762 	for {
   10763 		i := v.AuxInt
   10764 		s := v.Aux
   10765 		_ = v.Args[2]
   10766 		p := v.Args[0]
   10767 		w0 := v.Args[1]
   10768 		if w0.Op != OpS390XSRDconst {
   10769 			break
   10770 		}
   10771 		j := w0.AuxInt
   10772 		w := w0.Args[0]
   10773 		x := v.Args[2]
   10774 		if x.Op != OpS390XMOVBstore {
   10775 			break
   10776 		}
   10777 		if x.AuxInt != i-1 {
   10778 			break
   10779 		}
   10780 		if x.Aux != s {
   10781 			break
   10782 		}
   10783 		_ = x.Args[2]
   10784 		if p != x.Args[0] {
   10785 			break
   10786 		}
   10787 		x_1 := x.Args[1]
   10788 		if x_1.Op != OpS390XSRDconst {
   10789 			break
   10790 		}
   10791 		if x_1.AuxInt != j+8 {
   10792 			break
   10793 		}
   10794 		if w != x_1.Args[0] {
   10795 			break
   10796 		}
   10797 		mem := x.Args[2]
   10798 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   10799 			break
   10800 		}
   10801 		v.reset(OpS390XMOVHstore)
   10802 		v.AuxInt = i - 1
   10803 		v.Aux = s
   10804 		v.AddArg(p)
   10805 		v.AddArg(w0)
   10806 		v.AddArg(mem)
   10807 		return true
   10808 	}
   10809 	// match: (MOVBstore [i] {s} p w x:(MOVBstore [i-1] {s} p (SRWconst [8] w) mem))
   10810 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   10811 	// result: (MOVHstore [i-1] {s} p w mem)
   10812 	for {
   10813 		i := v.AuxInt
   10814 		s := v.Aux
   10815 		_ = v.Args[2]
   10816 		p := v.Args[0]
   10817 		w := v.Args[1]
   10818 		x := v.Args[2]
   10819 		if x.Op != OpS390XMOVBstore {
   10820 			break
   10821 		}
   10822 		if x.AuxInt != i-1 {
   10823 			break
   10824 		}
   10825 		if x.Aux != s {
   10826 			break
   10827 		}
   10828 		_ = x.Args[2]
   10829 		if p != x.Args[0] {
   10830 			break
   10831 		}
   10832 		x_1 := x.Args[1]
   10833 		if x_1.Op != OpS390XSRWconst {
   10834 			break
   10835 		}
   10836 		if x_1.AuxInt != 8 {
   10837 			break
   10838 		}
   10839 		if w != x_1.Args[0] {
   10840 			break
   10841 		}
   10842 		mem := x.Args[2]
   10843 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   10844 			break
   10845 		}
   10846 		v.reset(OpS390XMOVHstore)
   10847 		v.AuxInt = i - 1
   10848 		v.Aux = s
   10849 		v.AddArg(p)
   10850 		v.AddArg(w)
   10851 		v.AddArg(mem)
   10852 		return true
   10853 	}
   10854 	return false
   10855 }
   10856 func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
   10857 	// match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem))
   10858 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   10859 	// result: (MOVHstore [i-1] {s} p w0 mem)
   10860 	for {
   10861 		i := v.AuxInt
   10862 		s := v.Aux
   10863 		_ = v.Args[2]
   10864 		p := v.Args[0]
   10865 		w0 := v.Args[1]
   10866 		if w0.Op != OpS390XSRWconst {
   10867 			break
   10868 		}
   10869 		j := w0.AuxInt
   10870 		w := w0.Args[0]
   10871 		x := v.Args[2]
   10872 		if x.Op != OpS390XMOVBstore {
   10873 			break
   10874 		}
   10875 		if x.AuxInt != i-1 {
   10876 			break
   10877 		}
   10878 		if x.Aux != s {
   10879 			break
   10880 		}
   10881 		_ = x.Args[2]
   10882 		if p != x.Args[0] {
   10883 			break
   10884 		}
   10885 		x_1 := x.Args[1]
   10886 		if x_1.Op != OpS390XSRWconst {
   10887 			break
   10888 		}
   10889 		if x_1.AuxInt != j+8 {
   10890 			break
   10891 		}
   10892 		if w != x_1.Args[0] {
   10893 			break
   10894 		}
   10895 		mem := x.Args[2]
   10896 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   10897 			break
   10898 		}
   10899 		v.reset(OpS390XMOVHstore)
   10900 		v.AuxInt = i - 1
   10901 		v.Aux = s
   10902 		v.AddArg(p)
   10903 		v.AddArg(w0)
   10904 		v.AddArg(mem)
   10905 		return true
   10906 	}
   10907 	// match: (MOVBstore [i] {s} p (SRDconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
   10908 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   10909 	// result: (MOVHBRstore [i-1] {s} p w mem)
   10910 	for {
   10911 		i := v.AuxInt
   10912 		s := v.Aux
   10913 		_ = v.Args[2]
   10914 		p := v.Args[0]
   10915 		v_1 := v.Args[1]
   10916 		if v_1.Op != OpS390XSRDconst {
   10917 			break
   10918 		}
   10919 		if v_1.AuxInt != 8 {
   10920 			break
   10921 		}
   10922 		w := v_1.Args[0]
   10923 		x := v.Args[2]
   10924 		if x.Op != OpS390XMOVBstore {
   10925 			break
   10926 		}
   10927 		if x.AuxInt != i-1 {
   10928 			break
   10929 		}
   10930 		if x.Aux != s {
   10931 			break
   10932 		}
   10933 		_ = x.Args[2]
   10934 		if p != x.Args[0] {
   10935 			break
   10936 		}
   10937 		if w != x.Args[1] {
   10938 			break
   10939 		}
   10940 		mem := x.Args[2]
   10941 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   10942 			break
   10943 		}
   10944 		v.reset(OpS390XMOVHBRstore)
   10945 		v.AuxInt = i - 1
   10946 		v.Aux = s
   10947 		v.AddArg(p)
   10948 		v.AddArg(w)
   10949 		v.AddArg(mem)
   10950 		return true
   10951 	}
   10952 	// match: (MOVBstore [i] {s} p (SRDconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SRDconst [j-8] w) mem))
   10953 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   10954 	// result: (MOVHBRstore [i-1] {s} p w0 mem)
   10955 	for {
   10956 		i := v.AuxInt
   10957 		s := v.Aux
   10958 		_ = v.Args[2]
   10959 		p := v.Args[0]
   10960 		v_1 := v.Args[1]
   10961 		if v_1.Op != OpS390XSRDconst {
   10962 			break
   10963 		}
   10964 		j := v_1.AuxInt
   10965 		w := v_1.Args[0]
   10966 		x := v.Args[2]
   10967 		if x.Op != OpS390XMOVBstore {
   10968 			break
   10969 		}
   10970 		if x.AuxInt != i-1 {
   10971 			break
   10972 		}
   10973 		if x.Aux != s {
   10974 			break
   10975 		}
   10976 		_ = x.Args[2]
   10977 		if p != x.Args[0] {
   10978 			break
   10979 		}
   10980 		w0 := x.Args[1]
   10981 		if w0.Op != OpS390XSRDconst {
   10982 			break
   10983 		}
   10984 		if w0.AuxInt != j-8 {
   10985 			break
   10986 		}
   10987 		if w != w0.Args[0] {
   10988 			break
   10989 		}
   10990 		mem := x.Args[2]
   10991 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   10992 			break
   10993 		}
   10994 		v.reset(OpS390XMOVHBRstore)
   10995 		v.AuxInt = i - 1
   10996 		v.Aux = s
   10997 		v.AddArg(p)
   10998 		v.AddArg(w0)
   10999 		v.AddArg(mem)
   11000 		return true
   11001 	}
   11002 	// match: (MOVBstore [i] {s} p (SRWconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
   11003 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   11004 	// result: (MOVHBRstore [i-1] {s} p w mem)
   11005 	for {
   11006 		i := v.AuxInt
   11007 		s := v.Aux
   11008 		_ = v.Args[2]
   11009 		p := v.Args[0]
   11010 		v_1 := v.Args[1]
   11011 		if v_1.Op != OpS390XSRWconst {
   11012 			break
   11013 		}
   11014 		if v_1.AuxInt != 8 {
   11015 			break
   11016 		}
   11017 		w := v_1.Args[0]
   11018 		x := v.Args[2]
   11019 		if x.Op != OpS390XMOVBstore {
   11020 			break
   11021 		}
   11022 		if x.AuxInt != i-1 {
   11023 			break
   11024 		}
   11025 		if x.Aux != s {
   11026 			break
   11027 		}
   11028 		_ = x.Args[2]
   11029 		if p != x.Args[0] {
   11030 			break
   11031 		}
   11032 		if w != x.Args[1] {
   11033 			break
   11034 		}
   11035 		mem := x.Args[2]
   11036 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   11037 			break
   11038 		}
   11039 		v.reset(OpS390XMOVHBRstore)
   11040 		v.AuxInt = i - 1
   11041 		v.Aux = s
   11042 		v.AddArg(p)
   11043 		v.AddArg(w)
   11044 		v.AddArg(mem)
   11045 		return true
   11046 	}
   11047 	// match: (MOVBstore [i] {s} p (SRWconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SRWconst [j-8] w) mem))
   11048 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   11049 	// result: (MOVHBRstore [i-1] {s} p w0 mem)
   11050 	for {
   11051 		i := v.AuxInt
   11052 		s := v.Aux
   11053 		_ = v.Args[2]
   11054 		p := v.Args[0]
   11055 		v_1 := v.Args[1]
   11056 		if v_1.Op != OpS390XSRWconst {
   11057 			break
   11058 		}
   11059 		j := v_1.AuxInt
   11060 		w := v_1.Args[0]
   11061 		x := v.Args[2]
   11062 		if x.Op != OpS390XMOVBstore {
   11063 			break
   11064 		}
   11065 		if x.AuxInt != i-1 {
   11066 			break
   11067 		}
   11068 		if x.Aux != s {
   11069 			break
   11070 		}
   11071 		_ = x.Args[2]
   11072 		if p != x.Args[0] {
   11073 			break
   11074 		}
   11075 		w0 := x.Args[1]
   11076 		if w0.Op != OpS390XSRWconst {
   11077 			break
   11078 		}
   11079 		if w0.AuxInt != j-8 {
   11080 			break
   11081 		}
   11082 		if w != w0.Args[0] {
   11083 			break
   11084 		}
   11085 		mem := x.Args[2]
   11086 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   11087 			break
   11088 		}
   11089 		v.reset(OpS390XMOVHBRstore)
   11090 		v.AuxInt = i - 1
   11091 		v.Aux = s
   11092 		v.AddArg(p)
   11093 		v.AddArg(w0)
   11094 		v.AddArg(mem)
   11095 		return true
   11096 	}
   11097 	return false
   11098 }
   11099 func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
   11100 	// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
   11101 	// cond: is20Bit(ValAndOff(sc).Off()+off)
   11102 	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   11103 	for {
   11104 		sc := v.AuxInt
   11105 		s := v.Aux
   11106 		_ = v.Args[1]
   11107 		v_0 := v.Args[0]
   11108 		if v_0.Op != OpS390XADDconst {
   11109 			break
   11110 		}
   11111 		off := v_0.AuxInt
   11112 		ptr := v_0.Args[0]
   11113 		mem := v.Args[1]
   11114 		if !(is20Bit(ValAndOff(sc).Off() + off)) {
   11115 			break
   11116 		}
   11117 		v.reset(OpS390XMOVBstoreconst)
   11118 		v.AuxInt = ValAndOff(sc).add(off)
   11119 		v.Aux = s
   11120 		v.AddArg(ptr)
   11121 		v.AddArg(mem)
   11122 		return true
   11123 	}
   11124 	// match: (MOVBstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
   11125 	// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
   11126 	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   11127 	for {
   11128 		sc := v.AuxInt
   11129 		sym1 := v.Aux
   11130 		_ = v.Args[1]
   11131 		v_0 := v.Args[0]
   11132 		if v_0.Op != OpS390XMOVDaddr {
   11133 			break
   11134 		}
   11135 		off := v_0.AuxInt
   11136 		sym2 := v_0.Aux
   11137 		ptr := v_0.Args[0]
   11138 		mem := v.Args[1]
   11139 		if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
   11140 			break
   11141 		}
   11142 		v.reset(OpS390XMOVBstoreconst)
   11143 		v.AuxInt = ValAndOff(sc).add(off)
   11144 		v.Aux = mergeSym(sym1, sym2)
   11145 		v.AddArg(ptr)
   11146 		v.AddArg(mem)
   11147 		return true
   11148 	}
   11149 	// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
   11150 	// cond: p.Op != OpSB   && x.Uses == 1   && ValAndOff(a).Off() + 1 == ValAndOff(c).Off()   && clobber(x)
   11151 	// result: (MOVHstoreconst [makeValAndOff(ValAndOff(c).Val()&0xff | ValAndOff(a).Val()<<8, ValAndOff(a).Off())] {s} p mem)
   11152 	for {
   11153 		c := v.AuxInt
   11154 		s := v.Aux
   11155 		_ = v.Args[1]
   11156 		p := v.Args[0]
   11157 		x := v.Args[1]
   11158 		if x.Op != OpS390XMOVBstoreconst {
   11159 			break
   11160 		}
   11161 		a := x.AuxInt
   11162 		if x.Aux != s {
   11163 			break
   11164 		}
   11165 		_ = x.Args[1]
   11166 		if p != x.Args[0] {
   11167 			break
   11168 		}
   11169 		mem := x.Args[1]
   11170 		if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
   11171 			break
   11172 		}
   11173 		v.reset(OpS390XMOVHstoreconst)
   11174 		v.AuxInt = makeValAndOff(ValAndOff(c).Val()&0xff|ValAndOff(a).Val()<<8, ValAndOff(a).Off())
   11175 		v.Aux = s
   11176 		v.AddArg(p)
   11177 		v.AddArg(mem)
   11178 		return true
   11179 	}
   11180 	return false
   11181 }
   11182 func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
   11183 	// match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
   11184 	// cond: is20Bit(c+d)
   11185 	// result: (MOVBstoreidx  [c+d] {sym} ptr idx val mem)
   11186 	for {
   11187 		c := v.AuxInt
   11188 		sym := v.Aux
   11189 		_ = v.Args[3]
   11190 		v_0 := v.Args[0]
   11191 		if v_0.Op != OpS390XADDconst {
   11192 			break
   11193 		}
   11194 		d := v_0.AuxInt
   11195 		ptr := v_0.Args[0]
   11196 		idx := v.Args[1]
   11197 		val := v.Args[2]
   11198 		mem := v.Args[3]
   11199 		if !(is20Bit(c + d)) {
   11200 			break
   11201 		}
   11202 		v.reset(OpS390XMOVBstoreidx)
   11203 		v.AuxInt = c + d
   11204 		v.Aux = sym
   11205 		v.AddArg(ptr)
   11206 		v.AddArg(idx)
   11207 		v.AddArg(val)
   11208 		v.AddArg(mem)
   11209 		return true
   11210 	}
   11211 	// match: (MOVBstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
   11212 	// cond: is20Bit(c+d)
   11213 	// result: (MOVBstoreidx  [c+d] {sym} ptr idx val mem)
   11214 	for {
   11215 		c := v.AuxInt
   11216 		sym := v.Aux
   11217 		_ = v.Args[3]
   11218 		idx := v.Args[0]
   11219 		v_1 := v.Args[1]
   11220 		if v_1.Op != OpS390XADDconst {
   11221 			break
   11222 		}
   11223 		d := v_1.AuxInt
   11224 		ptr := v_1.Args[0]
   11225 		val := v.Args[2]
   11226 		mem := v.Args[3]
   11227 		if !(is20Bit(c + d)) {
   11228 			break
   11229 		}
   11230 		v.reset(OpS390XMOVBstoreidx)
   11231 		v.AuxInt = c + d
   11232 		v.Aux = sym
   11233 		v.AddArg(ptr)
   11234 		v.AddArg(idx)
   11235 		v.AddArg(val)
   11236 		v.AddArg(mem)
   11237 		return true
   11238 	}
   11239 	// match: (MOVBstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
   11240 	// cond: is20Bit(c+d)
   11241 	// result: (MOVBstoreidx  [c+d] {sym} ptr idx val mem)
   11242 	for {
   11243 		c := v.AuxInt
   11244 		sym := v.Aux
   11245 		_ = v.Args[3]
   11246 		ptr := v.Args[0]
   11247 		v_1 := v.Args[1]
   11248 		if v_1.Op != OpS390XADDconst {
   11249 			break
   11250 		}
   11251 		d := v_1.AuxInt
   11252 		idx := v_1.Args[0]
   11253 		val := v.Args[2]
   11254 		mem := v.Args[3]
   11255 		if !(is20Bit(c + d)) {
   11256 			break
   11257 		}
   11258 		v.reset(OpS390XMOVBstoreidx)
   11259 		v.AuxInt = c + d
   11260 		v.Aux = sym
   11261 		v.AddArg(ptr)
   11262 		v.AddArg(idx)
   11263 		v.AddArg(val)
   11264 		v.AddArg(mem)
   11265 		return true
   11266 	}
   11267 	// match: (MOVBstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
   11268 	// cond: is20Bit(c+d)
   11269 	// result: (MOVBstoreidx  [c+d] {sym} ptr idx val mem)
   11270 	for {
   11271 		c := v.AuxInt
   11272 		sym := v.Aux
   11273 		_ = v.Args[3]
   11274 		v_0 := v.Args[0]
   11275 		if v_0.Op != OpS390XADDconst {
   11276 			break
   11277 		}
   11278 		d := v_0.AuxInt
   11279 		idx := v_0.Args[0]
   11280 		ptr := v.Args[1]
   11281 		val := v.Args[2]
   11282 		mem := v.Args[3]
   11283 		if !(is20Bit(c + d)) {
   11284 			break
   11285 		}
   11286 		v.reset(OpS390XMOVBstoreidx)
   11287 		v.AuxInt = c + d
   11288 		v.Aux = sym
   11289 		v.AddArg(ptr)
   11290 		v.AddArg(idx)
   11291 		v.AddArg(val)
   11292 		v.AddArg(mem)
   11293 		return true
   11294 	}
   11295 	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [8] w) mem))
   11296 	// cond: x.Uses == 1   && clobber(x)
   11297 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11298 	for {
   11299 		i := v.AuxInt
   11300 		s := v.Aux
   11301 		_ = v.Args[3]
   11302 		p := v.Args[0]
   11303 		idx := v.Args[1]
   11304 		w := v.Args[2]
   11305 		x := v.Args[3]
   11306 		if x.Op != OpS390XMOVBstoreidx {
   11307 			break
   11308 		}
   11309 		if x.AuxInt != i-1 {
   11310 			break
   11311 		}
   11312 		if x.Aux != s {
   11313 			break
   11314 		}
   11315 		_ = x.Args[3]
   11316 		if p != x.Args[0] {
   11317 			break
   11318 		}
   11319 		if idx != x.Args[1] {
   11320 			break
   11321 		}
   11322 		x_2 := x.Args[2]
   11323 		if x_2.Op != OpS390XSRDconst {
   11324 			break
   11325 		}
   11326 		if x_2.AuxInt != 8 {
   11327 			break
   11328 		}
   11329 		if w != x_2.Args[0] {
   11330 			break
   11331 		}
   11332 		mem := x.Args[3]
   11333 		if !(x.Uses == 1 && clobber(x)) {
   11334 			break
   11335 		}
   11336 		v.reset(OpS390XMOVHstoreidx)
   11337 		v.AuxInt = i - 1
   11338 		v.Aux = s
   11339 		v.AddArg(p)
   11340 		v.AddArg(idx)
   11341 		v.AddArg(w)
   11342 		v.AddArg(mem)
   11343 		return true
   11344 	}
   11345 	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [8] w) mem))
   11346 	// cond: x.Uses == 1   && clobber(x)
   11347 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11348 	for {
   11349 		i := v.AuxInt
   11350 		s := v.Aux
   11351 		_ = v.Args[3]
   11352 		p := v.Args[0]
   11353 		idx := v.Args[1]
   11354 		w := v.Args[2]
   11355 		x := v.Args[3]
   11356 		if x.Op != OpS390XMOVBstoreidx {
   11357 			break
   11358 		}
   11359 		if x.AuxInt != i-1 {
   11360 			break
   11361 		}
   11362 		if x.Aux != s {
   11363 			break
   11364 		}
   11365 		_ = x.Args[3]
   11366 		if idx != x.Args[0] {
   11367 			break
   11368 		}
   11369 		if p != x.Args[1] {
   11370 			break
   11371 		}
   11372 		x_2 := x.Args[2]
   11373 		if x_2.Op != OpS390XSRDconst {
   11374 			break
   11375 		}
   11376 		if x_2.AuxInt != 8 {
   11377 			break
   11378 		}
   11379 		if w != x_2.Args[0] {
   11380 			break
   11381 		}
   11382 		mem := x.Args[3]
   11383 		if !(x.Uses == 1 && clobber(x)) {
   11384 			break
   11385 		}
   11386 		v.reset(OpS390XMOVHstoreidx)
   11387 		v.AuxInt = i - 1
   11388 		v.Aux = s
   11389 		v.AddArg(p)
   11390 		v.AddArg(idx)
   11391 		v.AddArg(w)
   11392 		v.AddArg(mem)
   11393 		return true
   11394 	}
   11395 	// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [8] w) mem))
   11396 	// cond: x.Uses == 1   && clobber(x)
   11397 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11398 	for {
   11399 		i := v.AuxInt
   11400 		s := v.Aux
   11401 		_ = v.Args[3]
   11402 		idx := v.Args[0]
   11403 		p := v.Args[1]
   11404 		w := v.Args[2]
   11405 		x := v.Args[3]
   11406 		if x.Op != OpS390XMOVBstoreidx {
   11407 			break
   11408 		}
   11409 		if x.AuxInt != i-1 {
   11410 			break
   11411 		}
   11412 		if x.Aux != s {
   11413 			break
   11414 		}
   11415 		_ = x.Args[3]
   11416 		if p != x.Args[0] {
   11417 			break
   11418 		}
   11419 		if idx != x.Args[1] {
   11420 			break
   11421 		}
   11422 		x_2 := x.Args[2]
   11423 		if x_2.Op != OpS390XSRDconst {
   11424 			break
   11425 		}
   11426 		if x_2.AuxInt != 8 {
   11427 			break
   11428 		}
   11429 		if w != x_2.Args[0] {
   11430 			break
   11431 		}
   11432 		mem := x.Args[3]
   11433 		if !(x.Uses == 1 && clobber(x)) {
   11434 			break
   11435 		}
   11436 		v.reset(OpS390XMOVHstoreidx)
   11437 		v.AuxInt = i - 1
   11438 		v.Aux = s
   11439 		v.AddArg(p)
   11440 		v.AddArg(idx)
   11441 		v.AddArg(w)
   11442 		v.AddArg(mem)
   11443 		return true
   11444 	}
   11445 	// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [8] w) mem))
   11446 	// cond: x.Uses == 1   && clobber(x)
   11447 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11448 	for {
   11449 		i := v.AuxInt
   11450 		s := v.Aux
   11451 		_ = v.Args[3]
   11452 		idx := v.Args[0]
   11453 		p := v.Args[1]
   11454 		w := v.Args[2]
   11455 		x := v.Args[3]
   11456 		if x.Op != OpS390XMOVBstoreidx {
   11457 			break
   11458 		}
   11459 		if x.AuxInt != i-1 {
   11460 			break
   11461 		}
   11462 		if x.Aux != s {
   11463 			break
   11464 		}
   11465 		_ = x.Args[3]
   11466 		if idx != x.Args[0] {
   11467 			break
   11468 		}
   11469 		if p != x.Args[1] {
   11470 			break
   11471 		}
   11472 		x_2 := x.Args[2]
   11473 		if x_2.Op != OpS390XSRDconst {
   11474 			break
   11475 		}
   11476 		if x_2.AuxInt != 8 {
   11477 			break
   11478 		}
   11479 		if w != x_2.Args[0] {
   11480 			break
   11481 		}
   11482 		mem := x.Args[3]
   11483 		if !(x.Uses == 1 && clobber(x)) {
   11484 			break
   11485 		}
   11486 		v.reset(OpS390XMOVHstoreidx)
   11487 		v.AuxInt = i - 1
   11488 		v.Aux = s
   11489 		v.AddArg(p)
   11490 		v.AddArg(idx)
   11491 		v.AddArg(w)
   11492 		v.AddArg(mem)
   11493 		return true
   11494 	}
   11495 	// match: (MOVBstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
   11496 	// cond: x.Uses == 1   && clobber(x)
   11497 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   11498 	for {
   11499 		i := v.AuxInt
   11500 		s := v.Aux
   11501 		_ = v.Args[3]
   11502 		p := v.Args[0]
   11503 		idx := v.Args[1]
   11504 		w0 := v.Args[2]
   11505 		if w0.Op != OpS390XSRDconst {
   11506 			break
   11507 		}
   11508 		j := w0.AuxInt
   11509 		w := w0.Args[0]
   11510 		x := v.Args[3]
   11511 		if x.Op != OpS390XMOVBstoreidx {
   11512 			break
   11513 		}
   11514 		if x.AuxInt != i-1 {
   11515 			break
   11516 		}
   11517 		if x.Aux != s {
   11518 			break
   11519 		}
   11520 		_ = x.Args[3]
   11521 		if p != x.Args[0] {
   11522 			break
   11523 		}
   11524 		if idx != x.Args[1] {
   11525 			break
   11526 		}
   11527 		x_2 := x.Args[2]
   11528 		if x_2.Op != OpS390XSRDconst {
   11529 			break
   11530 		}
   11531 		if x_2.AuxInt != j+8 {
   11532 			break
   11533 		}
   11534 		if w != x_2.Args[0] {
   11535 			break
   11536 		}
   11537 		mem := x.Args[3]
   11538 		if !(x.Uses == 1 && clobber(x)) {
   11539 			break
   11540 		}
   11541 		v.reset(OpS390XMOVHstoreidx)
   11542 		v.AuxInt = i - 1
   11543 		v.Aux = s
   11544 		v.AddArg(p)
   11545 		v.AddArg(idx)
   11546 		v.AddArg(w0)
   11547 		v.AddArg(mem)
   11548 		return true
   11549 	}
   11550 	// match: (MOVBstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [j+8] w) mem))
   11551 	// cond: x.Uses == 1   && clobber(x)
   11552 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   11553 	for {
   11554 		i := v.AuxInt
   11555 		s := v.Aux
   11556 		_ = v.Args[3]
   11557 		p := v.Args[0]
   11558 		idx := v.Args[1]
   11559 		w0 := v.Args[2]
   11560 		if w0.Op != OpS390XSRDconst {
   11561 			break
   11562 		}
   11563 		j := w0.AuxInt
   11564 		w := w0.Args[0]
   11565 		x := v.Args[3]
   11566 		if x.Op != OpS390XMOVBstoreidx {
   11567 			break
   11568 		}
   11569 		if x.AuxInt != i-1 {
   11570 			break
   11571 		}
   11572 		if x.Aux != s {
   11573 			break
   11574 		}
   11575 		_ = x.Args[3]
   11576 		if idx != x.Args[0] {
   11577 			break
   11578 		}
   11579 		if p != x.Args[1] {
   11580 			break
   11581 		}
   11582 		x_2 := x.Args[2]
   11583 		if x_2.Op != OpS390XSRDconst {
   11584 			break
   11585 		}
   11586 		if x_2.AuxInt != j+8 {
   11587 			break
   11588 		}
   11589 		if w != x_2.Args[0] {
   11590 			break
   11591 		}
   11592 		mem := x.Args[3]
   11593 		if !(x.Uses == 1 && clobber(x)) {
   11594 			break
   11595 		}
   11596 		v.reset(OpS390XMOVHstoreidx)
   11597 		v.AuxInt = i - 1
   11598 		v.Aux = s
   11599 		v.AddArg(p)
   11600 		v.AddArg(idx)
   11601 		v.AddArg(w0)
   11602 		v.AddArg(mem)
   11603 		return true
   11604 	}
   11605 	return false
   11606 }
   11607 func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool {
   11608 	// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
   11609 	// cond: x.Uses == 1   && clobber(x)
   11610 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   11611 	for {
   11612 		i := v.AuxInt
   11613 		s := v.Aux
   11614 		_ = v.Args[3]
   11615 		idx := v.Args[0]
   11616 		p := v.Args[1]
   11617 		w0 := v.Args[2]
   11618 		if w0.Op != OpS390XSRDconst {
   11619 			break
   11620 		}
   11621 		j := w0.AuxInt
   11622 		w := w0.Args[0]
   11623 		x := v.Args[3]
   11624 		if x.Op != OpS390XMOVBstoreidx {
   11625 			break
   11626 		}
   11627 		if x.AuxInt != i-1 {
   11628 			break
   11629 		}
   11630 		if x.Aux != s {
   11631 			break
   11632 		}
   11633 		_ = x.Args[3]
   11634 		if p != x.Args[0] {
   11635 			break
   11636 		}
   11637 		if idx != x.Args[1] {
   11638 			break
   11639 		}
   11640 		x_2 := x.Args[2]
   11641 		if x_2.Op != OpS390XSRDconst {
   11642 			break
   11643 		}
   11644 		if x_2.AuxInt != j+8 {
   11645 			break
   11646 		}
   11647 		if w != x_2.Args[0] {
   11648 			break
   11649 		}
   11650 		mem := x.Args[3]
   11651 		if !(x.Uses == 1 && clobber(x)) {
   11652 			break
   11653 		}
   11654 		v.reset(OpS390XMOVHstoreidx)
   11655 		v.AuxInt = i - 1
   11656 		v.Aux = s
   11657 		v.AddArg(p)
   11658 		v.AddArg(idx)
   11659 		v.AddArg(w0)
   11660 		v.AddArg(mem)
   11661 		return true
   11662 	}
   11663 	// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRDconst [j+8] w) mem))
   11664 	// cond: x.Uses == 1   && clobber(x)
   11665 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   11666 	for {
   11667 		i := v.AuxInt
   11668 		s := v.Aux
   11669 		_ = v.Args[3]
   11670 		idx := v.Args[0]
   11671 		p := v.Args[1]
   11672 		w0 := v.Args[2]
   11673 		if w0.Op != OpS390XSRDconst {
   11674 			break
   11675 		}
   11676 		j := w0.AuxInt
   11677 		w := w0.Args[0]
   11678 		x := v.Args[3]
   11679 		if x.Op != OpS390XMOVBstoreidx {
   11680 			break
   11681 		}
   11682 		if x.AuxInt != i-1 {
   11683 			break
   11684 		}
   11685 		if x.Aux != s {
   11686 			break
   11687 		}
   11688 		_ = x.Args[3]
   11689 		if idx != x.Args[0] {
   11690 			break
   11691 		}
   11692 		if p != x.Args[1] {
   11693 			break
   11694 		}
   11695 		x_2 := x.Args[2]
   11696 		if x_2.Op != OpS390XSRDconst {
   11697 			break
   11698 		}
   11699 		if x_2.AuxInt != j+8 {
   11700 			break
   11701 		}
   11702 		if w != x_2.Args[0] {
   11703 			break
   11704 		}
   11705 		mem := x.Args[3]
   11706 		if !(x.Uses == 1 && clobber(x)) {
   11707 			break
   11708 		}
   11709 		v.reset(OpS390XMOVHstoreidx)
   11710 		v.AuxInt = i - 1
   11711 		v.Aux = s
   11712 		v.AddArg(p)
   11713 		v.AddArg(idx)
   11714 		v.AddArg(w0)
   11715 		v.AddArg(mem)
   11716 		return true
   11717 	}
   11718 	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [8] w) mem))
   11719 	// cond: x.Uses == 1   && clobber(x)
   11720 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11721 	for {
   11722 		i := v.AuxInt
   11723 		s := v.Aux
   11724 		_ = v.Args[3]
   11725 		p := v.Args[0]
   11726 		idx := v.Args[1]
   11727 		w := v.Args[2]
   11728 		x := v.Args[3]
   11729 		if x.Op != OpS390XMOVBstoreidx {
   11730 			break
   11731 		}
   11732 		if x.AuxInt != i-1 {
   11733 			break
   11734 		}
   11735 		if x.Aux != s {
   11736 			break
   11737 		}
   11738 		_ = x.Args[3]
   11739 		if p != x.Args[0] {
   11740 			break
   11741 		}
   11742 		if idx != x.Args[1] {
   11743 			break
   11744 		}
   11745 		x_2 := x.Args[2]
   11746 		if x_2.Op != OpS390XSRWconst {
   11747 			break
   11748 		}
   11749 		if x_2.AuxInt != 8 {
   11750 			break
   11751 		}
   11752 		if w != x_2.Args[0] {
   11753 			break
   11754 		}
   11755 		mem := x.Args[3]
   11756 		if !(x.Uses == 1 && clobber(x)) {
   11757 			break
   11758 		}
   11759 		v.reset(OpS390XMOVHstoreidx)
   11760 		v.AuxInt = i - 1
   11761 		v.Aux = s
   11762 		v.AddArg(p)
   11763 		v.AddArg(idx)
   11764 		v.AddArg(w)
   11765 		v.AddArg(mem)
   11766 		return true
   11767 	}
   11768 	// match: (MOVBstoreidx [i] {s} p idx w x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [8] w) mem))
   11769 	// cond: x.Uses == 1   && clobber(x)
   11770 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11771 	for {
   11772 		i := v.AuxInt
   11773 		s := v.Aux
   11774 		_ = v.Args[3]
   11775 		p := v.Args[0]
   11776 		idx := v.Args[1]
   11777 		w := v.Args[2]
   11778 		x := v.Args[3]
   11779 		if x.Op != OpS390XMOVBstoreidx {
   11780 			break
   11781 		}
   11782 		if x.AuxInt != i-1 {
   11783 			break
   11784 		}
   11785 		if x.Aux != s {
   11786 			break
   11787 		}
   11788 		_ = x.Args[3]
   11789 		if idx != x.Args[0] {
   11790 			break
   11791 		}
   11792 		if p != x.Args[1] {
   11793 			break
   11794 		}
   11795 		x_2 := x.Args[2]
   11796 		if x_2.Op != OpS390XSRWconst {
   11797 			break
   11798 		}
   11799 		if x_2.AuxInt != 8 {
   11800 			break
   11801 		}
   11802 		if w != x_2.Args[0] {
   11803 			break
   11804 		}
   11805 		mem := x.Args[3]
   11806 		if !(x.Uses == 1 && clobber(x)) {
   11807 			break
   11808 		}
   11809 		v.reset(OpS390XMOVHstoreidx)
   11810 		v.AuxInt = i - 1
   11811 		v.Aux = s
   11812 		v.AddArg(p)
   11813 		v.AddArg(idx)
   11814 		v.AddArg(w)
   11815 		v.AddArg(mem)
   11816 		return true
   11817 	}
   11818 	// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [8] w) mem))
   11819 	// cond: x.Uses == 1   && clobber(x)
   11820 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11821 	for {
   11822 		i := v.AuxInt
   11823 		s := v.Aux
   11824 		_ = v.Args[3]
   11825 		idx := v.Args[0]
   11826 		p := v.Args[1]
   11827 		w := v.Args[2]
   11828 		x := v.Args[3]
   11829 		if x.Op != OpS390XMOVBstoreidx {
   11830 			break
   11831 		}
   11832 		if x.AuxInt != i-1 {
   11833 			break
   11834 		}
   11835 		if x.Aux != s {
   11836 			break
   11837 		}
   11838 		_ = x.Args[3]
   11839 		if p != x.Args[0] {
   11840 			break
   11841 		}
   11842 		if idx != x.Args[1] {
   11843 			break
   11844 		}
   11845 		x_2 := x.Args[2]
   11846 		if x_2.Op != OpS390XSRWconst {
   11847 			break
   11848 		}
   11849 		if x_2.AuxInt != 8 {
   11850 			break
   11851 		}
   11852 		if w != x_2.Args[0] {
   11853 			break
   11854 		}
   11855 		mem := x.Args[3]
   11856 		if !(x.Uses == 1 && clobber(x)) {
   11857 			break
   11858 		}
   11859 		v.reset(OpS390XMOVHstoreidx)
   11860 		v.AuxInt = i - 1
   11861 		v.Aux = s
   11862 		v.AddArg(p)
   11863 		v.AddArg(idx)
   11864 		v.AddArg(w)
   11865 		v.AddArg(mem)
   11866 		return true
   11867 	}
   11868 	// match: (MOVBstoreidx [i] {s} idx p w x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [8] w) mem))
   11869 	// cond: x.Uses == 1   && clobber(x)
   11870 	// result: (MOVHstoreidx [i-1] {s} p idx w mem)
   11871 	for {
   11872 		i := v.AuxInt
   11873 		s := v.Aux
   11874 		_ = v.Args[3]
   11875 		idx := v.Args[0]
   11876 		p := v.Args[1]
   11877 		w := v.Args[2]
   11878 		x := v.Args[3]
   11879 		if x.Op != OpS390XMOVBstoreidx {
   11880 			break
   11881 		}
   11882 		if x.AuxInt != i-1 {
   11883 			break
   11884 		}
   11885 		if x.Aux != s {
   11886 			break
   11887 		}
   11888 		_ = x.Args[3]
   11889 		if idx != x.Args[0] {
   11890 			break
   11891 		}
   11892 		if p != x.Args[1] {
   11893 			break
   11894 		}
   11895 		x_2 := x.Args[2]
   11896 		if x_2.Op != OpS390XSRWconst {
   11897 			break
   11898 		}
   11899 		if x_2.AuxInt != 8 {
   11900 			break
   11901 		}
   11902 		if w != x_2.Args[0] {
   11903 			break
   11904 		}
   11905 		mem := x.Args[3]
   11906 		if !(x.Uses == 1 && clobber(x)) {
   11907 			break
   11908 		}
   11909 		v.reset(OpS390XMOVHstoreidx)
   11910 		v.AuxInt = i - 1
   11911 		v.Aux = s
   11912 		v.AddArg(p)
   11913 		v.AddArg(idx)
   11914 		v.AddArg(w)
   11915 		v.AddArg(mem)
   11916 		return true
   11917 	}
   11918 	// match: (MOVBstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [j+8] w) mem))
   11919 	// cond: x.Uses == 1   && clobber(x)
   11920 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   11921 	for {
   11922 		i := v.AuxInt
   11923 		s := v.Aux
   11924 		_ = v.Args[3]
   11925 		p := v.Args[0]
   11926 		idx := v.Args[1]
   11927 		w0 := v.Args[2]
   11928 		if w0.Op != OpS390XSRWconst {
   11929 			break
   11930 		}
   11931 		j := w0.AuxInt
   11932 		w := w0.Args[0]
   11933 		x := v.Args[3]
   11934 		if x.Op != OpS390XMOVBstoreidx {
   11935 			break
   11936 		}
   11937 		if x.AuxInt != i-1 {
   11938 			break
   11939 		}
   11940 		if x.Aux != s {
   11941 			break
   11942 		}
   11943 		_ = x.Args[3]
   11944 		if p != x.Args[0] {
   11945 			break
   11946 		}
   11947 		if idx != x.Args[1] {
   11948 			break
   11949 		}
   11950 		x_2 := x.Args[2]
   11951 		if x_2.Op != OpS390XSRWconst {
   11952 			break
   11953 		}
   11954 		if x_2.AuxInt != j+8 {
   11955 			break
   11956 		}
   11957 		if w != x_2.Args[0] {
   11958 			break
   11959 		}
   11960 		mem := x.Args[3]
   11961 		if !(x.Uses == 1 && clobber(x)) {
   11962 			break
   11963 		}
   11964 		v.reset(OpS390XMOVHstoreidx)
   11965 		v.AuxInt = i - 1
   11966 		v.Aux = s
   11967 		v.AddArg(p)
   11968 		v.AddArg(idx)
   11969 		v.AddArg(w0)
   11970 		v.AddArg(mem)
   11971 		return true
   11972 	}
   11973 	// match: (MOVBstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [j+8] w) mem))
   11974 	// cond: x.Uses == 1   && clobber(x)
   11975 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   11976 	for {
   11977 		i := v.AuxInt
   11978 		s := v.Aux
   11979 		_ = v.Args[3]
   11980 		p := v.Args[0]
   11981 		idx := v.Args[1]
   11982 		w0 := v.Args[2]
   11983 		if w0.Op != OpS390XSRWconst {
   11984 			break
   11985 		}
   11986 		j := w0.AuxInt
   11987 		w := w0.Args[0]
   11988 		x := v.Args[3]
   11989 		if x.Op != OpS390XMOVBstoreidx {
   11990 			break
   11991 		}
   11992 		if x.AuxInt != i-1 {
   11993 			break
   11994 		}
   11995 		if x.Aux != s {
   11996 			break
   11997 		}
   11998 		_ = x.Args[3]
   11999 		if idx != x.Args[0] {
   12000 			break
   12001 		}
   12002 		if p != x.Args[1] {
   12003 			break
   12004 		}
   12005 		x_2 := x.Args[2]
   12006 		if x_2.Op != OpS390XSRWconst {
   12007 			break
   12008 		}
   12009 		if x_2.AuxInt != j+8 {
   12010 			break
   12011 		}
   12012 		if w != x_2.Args[0] {
   12013 			break
   12014 		}
   12015 		mem := x.Args[3]
   12016 		if !(x.Uses == 1 && clobber(x)) {
   12017 			break
   12018 		}
   12019 		v.reset(OpS390XMOVHstoreidx)
   12020 		v.AuxInt = i - 1
   12021 		v.Aux = s
   12022 		v.AddArg(p)
   12023 		v.AddArg(idx)
   12024 		v.AddArg(w0)
   12025 		v.AddArg(mem)
   12026 		return true
   12027 	}
   12028 	// match: (MOVBstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRWconst [j+8] w) mem))
   12029 	// cond: x.Uses == 1   && clobber(x)
   12030 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   12031 	for {
   12032 		i := v.AuxInt
   12033 		s := v.Aux
   12034 		_ = v.Args[3]
   12035 		idx := v.Args[0]
   12036 		p := v.Args[1]
   12037 		w0 := v.Args[2]
   12038 		if w0.Op != OpS390XSRWconst {
   12039 			break
   12040 		}
   12041 		j := w0.AuxInt
   12042 		w := w0.Args[0]
   12043 		x := v.Args[3]
   12044 		if x.Op != OpS390XMOVBstoreidx {
   12045 			break
   12046 		}
   12047 		if x.AuxInt != i-1 {
   12048 			break
   12049 		}
   12050 		if x.Aux != s {
   12051 			break
   12052 		}
   12053 		_ = x.Args[3]
   12054 		if p != x.Args[0] {
   12055 			break
   12056 		}
   12057 		if idx != x.Args[1] {
   12058 			break
   12059 		}
   12060 		x_2 := x.Args[2]
   12061 		if x_2.Op != OpS390XSRWconst {
   12062 			break
   12063 		}
   12064 		if x_2.AuxInt != j+8 {
   12065 			break
   12066 		}
   12067 		if w != x_2.Args[0] {
   12068 			break
   12069 		}
   12070 		mem := x.Args[3]
   12071 		if !(x.Uses == 1 && clobber(x)) {
   12072 			break
   12073 		}
   12074 		v.reset(OpS390XMOVHstoreidx)
   12075 		v.AuxInt = i - 1
   12076 		v.Aux = s
   12077 		v.AddArg(p)
   12078 		v.AddArg(idx)
   12079 		v.AddArg(w0)
   12080 		v.AddArg(mem)
   12081 		return true
   12082 	}
   12083 	// match: (MOVBstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p (SRWconst [j+8] w) mem))
   12084 	// cond: x.Uses == 1   && clobber(x)
   12085 	// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
   12086 	for {
   12087 		i := v.AuxInt
   12088 		s := v.Aux
   12089 		_ = v.Args[3]
   12090 		idx := v.Args[0]
   12091 		p := v.Args[1]
   12092 		w0 := v.Args[2]
   12093 		if w0.Op != OpS390XSRWconst {
   12094 			break
   12095 		}
   12096 		j := w0.AuxInt
   12097 		w := w0.Args[0]
   12098 		x := v.Args[3]
   12099 		if x.Op != OpS390XMOVBstoreidx {
   12100 			break
   12101 		}
   12102 		if x.AuxInt != i-1 {
   12103 			break
   12104 		}
   12105 		if x.Aux != s {
   12106 			break
   12107 		}
   12108 		_ = x.Args[3]
   12109 		if idx != x.Args[0] {
   12110 			break
   12111 		}
   12112 		if p != x.Args[1] {
   12113 			break
   12114 		}
   12115 		x_2 := x.Args[2]
   12116 		if x_2.Op != OpS390XSRWconst {
   12117 			break
   12118 		}
   12119 		if x_2.AuxInt != j+8 {
   12120 			break
   12121 		}
   12122 		if w != x_2.Args[0] {
   12123 			break
   12124 		}
   12125 		mem := x.Args[3]
   12126 		if !(x.Uses == 1 && clobber(x)) {
   12127 			break
   12128 		}
   12129 		v.reset(OpS390XMOVHstoreidx)
   12130 		v.AuxInt = i - 1
   12131 		v.Aux = s
   12132 		v.AddArg(p)
   12133 		v.AddArg(idx)
   12134 		v.AddArg(w0)
   12135 		v.AddArg(mem)
   12136 		return true
   12137 	}
   12138 	return false
   12139 }
   12140 func rewriteValueS390X_OpS390XMOVBstoreidx_20(v *Value) bool {
   12141 	// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
   12142 	// cond: x.Uses == 1   && clobber(x)
   12143 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12144 	for {
   12145 		i := v.AuxInt
   12146 		s := v.Aux
   12147 		_ = v.Args[3]
   12148 		p := v.Args[0]
   12149 		idx := v.Args[1]
   12150 		v_2 := v.Args[2]
   12151 		if v_2.Op != OpS390XSRDconst {
   12152 			break
   12153 		}
   12154 		if v_2.AuxInt != 8 {
   12155 			break
   12156 		}
   12157 		w := v_2.Args[0]
   12158 		x := v.Args[3]
   12159 		if x.Op != OpS390XMOVBstoreidx {
   12160 			break
   12161 		}
   12162 		if x.AuxInt != i-1 {
   12163 			break
   12164 		}
   12165 		if x.Aux != s {
   12166 			break
   12167 		}
   12168 		_ = x.Args[3]
   12169 		if p != x.Args[0] {
   12170 			break
   12171 		}
   12172 		if idx != x.Args[1] {
   12173 			break
   12174 		}
   12175 		if w != x.Args[2] {
   12176 			break
   12177 		}
   12178 		mem := x.Args[3]
   12179 		if !(x.Uses == 1 && clobber(x)) {
   12180 			break
   12181 		}
   12182 		v.reset(OpS390XMOVHBRstoreidx)
   12183 		v.AuxInt = i - 1
   12184 		v.Aux = s
   12185 		v.AddArg(p)
   12186 		v.AddArg(idx)
   12187 		v.AddArg(w)
   12188 		v.AddArg(mem)
   12189 		return true
   12190 	}
   12191 	// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
   12192 	// cond: x.Uses == 1   && clobber(x)
   12193 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12194 	for {
   12195 		i := v.AuxInt
   12196 		s := v.Aux
   12197 		_ = v.Args[3]
   12198 		p := v.Args[0]
   12199 		idx := v.Args[1]
   12200 		v_2 := v.Args[2]
   12201 		if v_2.Op != OpS390XSRDconst {
   12202 			break
   12203 		}
   12204 		if v_2.AuxInt != 8 {
   12205 			break
   12206 		}
   12207 		w := v_2.Args[0]
   12208 		x := v.Args[3]
   12209 		if x.Op != OpS390XMOVBstoreidx {
   12210 			break
   12211 		}
   12212 		if x.AuxInt != i-1 {
   12213 			break
   12214 		}
   12215 		if x.Aux != s {
   12216 			break
   12217 		}
   12218 		_ = x.Args[3]
   12219 		if idx != x.Args[0] {
   12220 			break
   12221 		}
   12222 		if p != x.Args[1] {
   12223 			break
   12224 		}
   12225 		if w != x.Args[2] {
   12226 			break
   12227 		}
   12228 		mem := x.Args[3]
   12229 		if !(x.Uses == 1 && clobber(x)) {
   12230 			break
   12231 		}
   12232 		v.reset(OpS390XMOVHBRstoreidx)
   12233 		v.AuxInt = i - 1
   12234 		v.Aux = s
   12235 		v.AddArg(p)
   12236 		v.AddArg(idx)
   12237 		v.AddArg(w)
   12238 		v.AddArg(mem)
   12239 		return true
   12240 	}
   12241 	// match: (MOVBstoreidx [i] {s} idx p (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
   12242 	// cond: x.Uses == 1   && clobber(x)
   12243 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12244 	for {
   12245 		i := v.AuxInt
   12246 		s := v.Aux
   12247 		_ = v.Args[3]
   12248 		idx := v.Args[0]
   12249 		p := v.Args[1]
   12250 		v_2 := v.Args[2]
   12251 		if v_2.Op != OpS390XSRDconst {
   12252 			break
   12253 		}
   12254 		if v_2.AuxInt != 8 {
   12255 			break
   12256 		}
   12257 		w := v_2.Args[0]
   12258 		x := v.Args[3]
   12259 		if x.Op != OpS390XMOVBstoreidx {
   12260 			break
   12261 		}
   12262 		if x.AuxInt != i-1 {
   12263 			break
   12264 		}
   12265 		if x.Aux != s {
   12266 			break
   12267 		}
   12268 		_ = x.Args[3]
   12269 		if p != x.Args[0] {
   12270 			break
   12271 		}
   12272 		if idx != x.Args[1] {
   12273 			break
   12274 		}
   12275 		if w != x.Args[2] {
   12276 			break
   12277 		}
   12278 		mem := x.Args[3]
   12279 		if !(x.Uses == 1 && clobber(x)) {
   12280 			break
   12281 		}
   12282 		v.reset(OpS390XMOVHBRstoreidx)
   12283 		v.AuxInt = i - 1
   12284 		v.Aux = s
   12285 		v.AddArg(p)
   12286 		v.AddArg(idx)
   12287 		v.AddArg(w)
   12288 		v.AddArg(mem)
   12289 		return true
   12290 	}
   12291 	// match: (MOVBstoreidx [i] {s} idx p (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
   12292 	// cond: x.Uses == 1   && clobber(x)
   12293 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12294 	for {
   12295 		i := v.AuxInt
   12296 		s := v.Aux
   12297 		_ = v.Args[3]
   12298 		idx := v.Args[0]
   12299 		p := v.Args[1]
   12300 		v_2 := v.Args[2]
   12301 		if v_2.Op != OpS390XSRDconst {
   12302 			break
   12303 		}
   12304 		if v_2.AuxInt != 8 {
   12305 			break
   12306 		}
   12307 		w := v_2.Args[0]
   12308 		x := v.Args[3]
   12309 		if x.Op != OpS390XMOVBstoreidx {
   12310 			break
   12311 		}
   12312 		if x.AuxInt != i-1 {
   12313 			break
   12314 		}
   12315 		if x.Aux != s {
   12316 			break
   12317 		}
   12318 		_ = x.Args[3]
   12319 		if idx != x.Args[0] {
   12320 			break
   12321 		}
   12322 		if p != x.Args[1] {
   12323 			break
   12324 		}
   12325 		if w != x.Args[2] {
   12326 			break
   12327 		}
   12328 		mem := x.Args[3]
   12329 		if !(x.Uses == 1 && clobber(x)) {
   12330 			break
   12331 		}
   12332 		v.reset(OpS390XMOVHBRstoreidx)
   12333 		v.AuxInt = i - 1
   12334 		v.Aux = s
   12335 		v.AddArg(p)
   12336 		v.AddArg(idx)
   12337 		v.AddArg(w)
   12338 		v.AddArg(mem)
   12339 		return true
   12340 	}
   12341 	// match: (MOVBstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRDconst [j-8] w) mem))
   12342 	// cond: x.Uses == 1   && clobber(x)
   12343 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12344 	for {
   12345 		i := v.AuxInt
   12346 		s := v.Aux
   12347 		_ = v.Args[3]
   12348 		p := v.Args[0]
   12349 		idx := v.Args[1]
   12350 		v_2 := v.Args[2]
   12351 		if v_2.Op != OpS390XSRDconst {
   12352 			break
   12353 		}
   12354 		j := v_2.AuxInt
   12355 		w := v_2.Args[0]
   12356 		x := v.Args[3]
   12357 		if x.Op != OpS390XMOVBstoreidx {
   12358 			break
   12359 		}
   12360 		if x.AuxInt != i-1 {
   12361 			break
   12362 		}
   12363 		if x.Aux != s {
   12364 			break
   12365 		}
   12366 		_ = x.Args[3]
   12367 		if p != x.Args[0] {
   12368 			break
   12369 		}
   12370 		if idx != x.Args[1] {
   12371 			break
   12372 		}
   12373 		w0 := x.Args[2]
   12374 		if w0.Op != OpS390XSRDconst {
   12375 			break
   12376 		}
   12377 		if w0.AuxInt != j-8 {
   12378 			break
   12379 		}
   12380 		if w != w0.Args[0] {
   12381 			break
   12382 		}
   12383 		mem := x.Args[3]
   12384 		if !(x.Uses == 1 && clobber(x)) {
   12385 			break
   12386 		}
   12387 		v.reset(OpS390XMOVHBRstoreidx)
   12388 		v.AuxInt = i - 1
   12389 		v.Aux = s
   12390 		v.AddArg(p)
   12391 		v.AddArg(idx)
   12392 		v.AddArg(w0)
   12393 		v.AddArg(mem)
   12394 		return true
   12395 	}
   12396 	// match: (MOVBstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRDconst [j-8] w) mem))
   12397 	// cond: x.Uses == 1   && clobber(x)
   12398 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12399 	for {
   12400 		i := v.AuxInt
   12401 		s := v.Aux
   12402 		_ = v.Args[3]
   12403 		p := v.Args[0]
   12404 		idx := v.Args[1]
   12405 		v_2 := v.Args[2]
   12406 		if v_2.Op != OpS390XSRDconst {
   12407 			break
   12408 		}
   12409 		j := v_2.AuxInt
   12410 		w := v_2.Args[0]
   12411 		x := v.Args[3]
   12412 		if x.Op != OpS390XMOVBstoreidx {
   12413 			break
   12414 		}
   12415 		if x.AuxInt != i-1 {
   12416 			break
   12417 		}
   12418 		if x.Aux != s {
   12419 			break
   12420 		}
   12421 		_ = x.Args[3]
   12422 		if idx != x.Args[0] {
   12423 			break
   12424 		}
   12425 		if p != x.Args[1] {
   12426 			break
   12427 		}
   12428 		w0 := x.Args[2]
   12429 		if w0.Op != OpS390XSRDconst {
   12430 			break
   12431 		}
   12432 		if w0.AuxInt != j-8 {
   12433 			break
   12434 		}
   12435 		if w != w0.Args[0] {
   12436 			break
   12437 		}
   12438 		mem := x.Args[3]
   12439 		if !(x.Uses == 1 && clobber(x)) {
   12440 			break
   12441 		}
   12442 		v.reset(OpS390XMOVHBRstoreidx)
   12443 		v.AuxInt = i - 1
   12444 		v.Aux = s
   12445 		v.AddArg(p)
   12446 		v.AddArg(idx)
   12447 		v.AddArg(w0)
   12448 		v.AddArg(mem)
   12449 		return true
   12450 	}
   12451 	// match: (MOVBstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRDconst [j-8] w) mem))
   12452 	// cond: x.Uses == 1   && clobber(x)
   12453 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12454 	for {
   12455 		i := v.AuxInt
   12456 		s := v.Aux
   12457 		_ = v.Args[3]
   12458 		idx := v.Args[0]
   12459 		p := v.Args[1]
   12460 		v_2 := v.Args[2]
   12461 		if v_2.Op != OpS390XSRDconst {
   12462 			break
   12463 		}
   12464 		j := v_2.AuxInt
   12465 		w := v_2.Args[0]
   12466 		x := v.Args[3]
   12467 		if x.Op != OpS390XMOVBstoreidx {
   12468 			break
   12469 		}
   12470 		if x.AuxInt != i-1 {
   12471 			break
   12472 		}
   12473 		if x.Aux != s {
   12474 			break
   12475 		}
   12476 		_ = x.Args[3]
   12477 		if p != x.Args[0] {
   12478 			break
   12479 		}
   12480 		if idx != x.Args[1] {
   12481 			break
   12482 		}
   12483 		w0 := x.Args[2]
   12484 		if w0.Op != OpS390XSRDconst {
   12485 			break
   12486 		}
   12487 		if w0.AuxInt != j-8 {
   12488 			break
   12489 		}
   12490 		if w != w0.Args[0] {
   12491 			break
   12492 		}
   12493 		mem := x.Args[3]
   12494 		if !(x.Uses == 1 && clobber(x)) {
   12495 			break
   12496 		}
   12497 		v.reset(OpS390XMOVHBRstoreidx)
   12498 		v.AuxInt = i - 1
   12499 		v.Aux = s
   12500 		v.AddArg(p)
   12501 		v.AddArg(idx)
   12502 		v.AddArg(w0)
   12503 		v.AddArg(mem)
   12504 		return true
   12505 	}
   12506 	// match: (MOVBstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRDconst [j-8] w) mem))
   12507 	// cond: x.Uses == 1   && clobber(x)
   12508 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12509 	for {
   12510 		i := v.AuxInt
   12511 		s := v.Aux
   12512 		_ = v.Args[3]
   12513 		idx := v.Args[0]
   12514 		p := v.Args[1]
   12515 		v_2 := v.Args[2]
   12516 		if v_2.Op != OpS390XSRDconst {
   12517 			break
   12518 		}
   12519 		j := v_2.AuxInt
   12520 		w := v_2.Args[0]
   12521 		x := v.Args[3]
   12522 		if x.Op != OpS390XMOVBstoreidx {
   12523 			break
   12524 		}
   12525 		if x.AuxInt != i-1 {
   12526 			break
   12527 		}
   12528 		if x.Aux != s {
   12529 			break
   12530 		}
   12531 		_ = x.Args[3]
   12532 		if idx != x.Args[0] {
   12533 			break
   12534 		}
   12535 		if p != x.Args[1] {
   12536 			break
   12537 		}
   12538 		w0 := x.Args[2]
   12539 		if w0.Op != OpS390XSRDconst {
   12540 			break
   12541 		}
   12542 		if w0.AuxInt != j-8 {
   12543 			break
   12544 		}
   12545 		if w != w0.Args[0] {
   12546 			break
   12547 		}
   12548 		mem := x.Args[3]
   12549 		if !(x.Uses == 1 && clobber(x)) {
   12550 			break
   12551 		}
   12552 		v.reset(OpS390XMOVHBRstoreidx)
   12553 		v.AuxInt = i - 1
   12554 		v.Aux = s
   12555 		v.AddArg(p)
   12556 		v.AddArg(idx)
   12557 		v.AddArg(w0)
   12558 		v.AddArg(mem)
   12559 		return true
   12560 	}
   12561 	// match: (MOVBstoreidx [i] {s} p idx (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
   12562 	// cond: x.Uses == 1   && clobber(x)
   12563 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12564 	for {
   12565 		i := v.AuxInt
   12566 		s := v.Aux
   12567 		_ = v.Args[3]
   12568 		p := v.Args[0]
   12569 		idx := v.Args[1]
   12570 		v_2 := v.Args[2]
   12571 		if v_2.Op != OpS390XSRWconst {
   12572 			break
   12573 		}
   12574 		if v_2.AuxInt != 8 {
   12575 			break
   12576 		}
   12577 		w := v_2.Args[0]
   12578 		x := v.Args[3]
   12579 		if x.Op != OpS390XMOVBstoreidx {
   12580 			break
   12581 		}
   12582 		if x.AuxInt != i-1 {
   12583 			break
   12584 		}
   12585 		if x.Aux != s {
   12586 			break
   12587 		}
   12588 		_ = x.Args[3]
   12589 		if p != x.Args[0] {
   12590 			break
   12591 		}
   12592 		if idx != x.Args[1] {
   12593 			break
   12594 		}
   12595 		if w != x.Args[2] {
   12596 			break
   12597 		}
   12598 		mem := x.Args[3]
   12599 		if !(x.Uses == 1 && clobber(x)) {
   12600 			break
   12601 		}
   12602 		v.reset(OpS390XMOVHBRstoreidx)
   12603 		v.AuxInt = i - 1
   12604 		v.Aux = s
   12605 		v.AddArg(p)
   12606 		v.AddArg(idx)
   12607 		v.AddArg(w)
   12608 		v.AddArg(mem)
   12609 		return true
   12610 	}
   12611 	// match: (MOVBstoreidx [i] {s} p idx (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
   12612 	// cond: x.Uses == 1   && clobber(x)
   12613 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12614 	for {
   12615 		i := v.AuxInt
   12616 		s := v.Aux
   12617 		_ = v.Args[3]
   12618 		p := v.Args[0]
   12619 		idx := v.Args[1]
   12620 		v_2 := v.Args[2]
   12621 		if v_2.Op != OpS390XSRWconst {
   12622 			break
   12623 		}
   12624 		if v_2.AuxInt != 8 {
   12625 			break
   12626 		}
   12627 		w := v_2.Args[0]
   12628 		x := v.Args[3]
   12629 		if x.Op != OpS390XMOVBstoreidx {
   12630 			break
   12631 		}
   12632 		if x.AuxInt != i-1 {
   12633 			break
   12634 		}
   12635 		if x.Aux != s {
   12636 			break
   12637 		}
   12638 		_ = x.Args[3]
   12639 		if idx != x.Args[0] {
   12640 			break
   12641 		}
   12642 		if p != x.Args[1] {
   12643 			break
   12644 		}
   12645 		if w != x.Args[2] {
   12646 			break
   12647 		}
   12648 		mem := x.Args[3]
   12649 		if !(x.Uses == 1 && clobber(x)) {
   12650 			break
   12651 		}
   12652 		v.reset(OpS390XMOVHBRstoreidx)
   12653 		v.AuxInt = i - 1
   12654 		v.Aux = s
   12655 		v.AddArg(p)
   12656 		v.AddArg(idx)
   12657 		v.AddArg(w)
   12658 		v.AddArg(mem)
   12659 		return true
   12660 	}
   12661 	return false
   12662 }
   12663 func rewriteValueS390X_OpS390XMOVBstoreidx_30(v *Value) bool {
   12664 	// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
   12665 	// cond: x.Uses == 1   && clobber(x)
   12666 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12667 	for {
   12668 		i := v.AuxInt
   12669 		s := v.Aux
   12670 		_ = v.Args[3]
   12671 		idx := v.Args[0]
   12672 		p := v.Args[1]
   12673 		v_2 := v.Args[2]
   12674 		if v_2.Op != OpS390XSRWconst {
   12675 			break
   12676 		}
   12677 		if v_2.AuxInt != 8 {
   12678 			break
   12679 		}
   12680 		w := v_2.Args[0]
   12681 		x := v.Args[3]
   12682 		if x.Op != OpS390XMOVBstoreidx {
   12683 			break
   12684 		}
   12685 		if x.AuxInt != i-1 {
   12686 			break
   12687 		}
   12688 		if x.Aux != s {
   12689 			break
   12690 		}
   12691 		_ = x.Args[3]
   12692 		if p != x.Args[0] {
   12693 			break
   12694 		}
   12695 		if idx != x.Args[1] {
   12696 			break
   12697 		}
   12698 		if w != x.Args[2] {
   12699 			break
   12700 		}
   12701 		mem := x.Args[3]
   12702 		if !(x.Uses == 1 && clobber(x)) {
   12703 			break
   12704 		}
   12705 		v.reset(OpS390XMOVHBRstoreidx)
   12706 		v.AuxInt = i - 1
   12707 		v.Aux = s
   12708 		v.AddArg(p)
   12709 		v.AddArg(idx)
   12710 		v.AddArg(w)
   12711 		v.AddArg(mem)
   12712 		return true
   12713 	}
   12714 	// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} idx p w mem))
   12715 	// cond: x.Uses == 1   && clobber(x)
   12716 	// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
   12717 	for {
   12718 		i := v.AuxInt
   12719 		s := v.Aux
   12720 		_ = v.Args[3]
   12721 		idx := v.Args[0]
   12722 		p := v.Args[1]
   12723 		v_2 := v.Args[2]
   12724 		if v_2.Op != OpS390XSRWconst {
   12725 			break
   12726 		}
   12727 		if v_2.AuxInt != 8 {
   12728 			break
   12729 		}
   12730 		w := v_2.Args[0]
   12731 		x := v.Args[3]
   12732 		if x.Op != OpS390XMOVBstoreidx {
   12733 			break
   12734 		}
   12735 		if x.AuxInt != i-1 {
   12736 			break
   12737 		}
   12738 		if x.Aux != s {
   12739 			break
   12740 		}
   12741 		_ = x.Args[3]
   12742 		if idx != x.Args[0] {
   12743 			break
   12744 		}
   12745 		if p != x.Args[1] {
   12746 			break
   12747 		}
   12748 		if w != x.Args[2] {
   12749 			break
   12750 		}
   12751 		mem := x.Args[3]
   12752 		if !(x.Uses == 1 && clobber(x)) {
   12753 			break
   12754 		}
   12755 		v.reset(OpS390XMOVHBRstoreidx)
   12756 		v.AuxInt = i - 1
   12757 		v.Aux = s
   12758 		v.AddArg(p)
   12759 		v.AddArg(idx)
   12760 		v.AddArg(w)
   12761 		v.AddArg(mem)
   12762 		return true
   12763 	}
   12764 	// match: (MOVBstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRWconst [j-8] w) mem))
   12765 	// cond: x.Uses == 1   && clobber(x)
   12766 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12767 	for {
   12768 		i := v.AuxInt
   12769 		s := v.Aux
   12770 		_ = v.Args[3]
   12771 		p := v.Args[0]
   12772 		idx := v.Args[1]
   12773 		v_2 := v.Args[2]
   12774 		if v_2.Op != OpS390XSRWconst {
   12775 			break
   12776 		}
   12777 		j := v_2.AuxInt
   12778 		w := v_2.Args[0]
   12779 		x := v.Args[3]
   12780 		if x.Op != OpS390XMOVBstoreidx {
   12781 			break
   12782 		}
   12783 		if x.AuxInt != i-1 {
   12784 			break
   12785 		}
   12786 		if x.Aux != s {
   12787 			break
   12788 		}
   12789 		_ = x.Args[3]
   12790 		if p != x.Args[0] {
   12791 			break
   12792 		}
   12793 		if idx != x.Args[1] {
   12794 			break
   12795 		}
   12796 		w0 := x.Args[2]
   12797 		if w0.Op != OpS390XSRWconst {
   12798 			break
   12799 		}
   12800 		if w0.AuxInt != j-8 {
   12801 			break
   12802 		}
   12803 		if w != w0.Args[0] {
   12804 			break
   12805 		}
   12806 		mem := x.Args[3]
   12807 		if !(x.Uses == 1 && clobber(x)) {
   12808 			break
   12809 		}
   12810 		v.reset(OpS390XMOVHBRstoreidx)
   12811 		v.AuxInt = i - 1
   12812 		v.Aux = s
   12813 		v.AddArg(p)
   12814 		v.AddArg(idx)
   12815 		v.AddArg(w0)
   12816 		v.AddArg(mem)
   12817 		return true
   12818 	}
   12819 	// match: (MOVBstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRWconst [j-8] w) mem))
   12820 	// cond: x.Uses == 1   && clobber(x)
   12821 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12822 	for {
   12823 		i := v.AuxInt
   12824 		s := v.Aux
   12825 		_ = v.Args[3]
   12826 		p := v.Args[0]
   12827 		idx := v.Args[1]
   12828 		v_2 := v.Args[2]
   12829 		if v_2.Op != OpS390XSRWconst {
   12830 			break
   12831 		}
   12832 		j := v_2.AuxInt
   12833 		w := v_2.Args[0]
   12834 		x := v.Args[3]
   12835 		if x.Op != OpS390XMOVBstoreidx {
   12836 			break
   12837 		}
   12838 		if x.AuxInt != i-1 {
   12839 			break
   12840 		}
   12841 		if x.Aux != s {
   12842 			break
   12843 		}
   12844 		_ = x.Args[3]
   12845 		if idx != x.Args[0] {
   12846 			break
   12847 		}
   12848 		if p != x.Args[1] {
   12849 			break
   12850 		}
   12851 		w0 := x.Args[2]
   12852 		if w0.Op != OpS390XSRWconst {
   12853 			break
   12854 		}
   12855 		if w0.AuxInt != j-8 {
   12856 			break
   12857 		}
   12858 		if w != w0.Args[0] {
   12859 			break
   12860 		}
   12861 		mem := x.Args[3]
   12862 		if !(x.Uses == 1 && clobber(x)) {
   12863 			break
   12864 		}
   12865 		v.reset(OpS390XMOVHBRstoreidx)
   12866 		v.AuxInt = i - 1
   12867 		v.Aux = s
   12868 		v.AddArg(p)
   12869 		v.AddArg(idx)
   12870 		v.AddArg(w0)
   12871 		v.AddArg(mem)
   12872 		return true
   12873 	}
   12874 	// match: (MOVBstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx w0:(SRWconst [j-8] w) mem))
   12875 	// cond: x.Uses == 1   && clobber(x)
   12876 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12877 	for {
   12878 		i := v.AuxInt
   12879 		s := v.Aux
   12880 		_ = v.Args[3]
   12881 		idx := v.Args[0]
   12882 		p := v.Args[1]
   12883 		v_2 := v.Args[2]
   12884 		if v_2.Op != OpS390XSRWconst {
   12885 			break
   12886 		}
   12887 		j := v_2.AuxInt
   12888 		w := v_2.Args[0]
   12889 		x := v.Args[3]
   12890 		if x.Op != OpS390XMOVBstoreidx {
   12891 			break
   12892 		}
   12893 		if x.AuxInt != i-1 {
   12894 			break
   12895 		}
   12896 		if x.Aux != s {
   12897 			break
   12898 		}
   12899 		_ = x.Args[3]
   12900 		if p != x.Args[0] {
   12901 			break
   12902 		}
   12903 		if idx != x.Args[1] {
   12904 			break
   12905 		}
   12906 		w0 := x.Args[2]
   12907 		if w0.Op != OpS390XSRWconst {
   12908 			break
   12909 		}
   12910 		if w0.AuxInt != j-8 {
   12911 			break
   12912 		}
   12913 		if w != w0.Args[0] {
   12914 			break
   12915 		}
   12916 		mem := x.Args[3]
   12917 		if !(x.Uses == 1 && clobber(x)) {
   12918 			break
   12919 		}
   12920 		v.reset(OpS390XMOVHBRstoreidx)
   12921 		v.AuxInt = i - 1
   12922 		v.Aux = s
   12923 		v.AddArg(p)
   12924 		v.AddArg(idx)
   12925 		v.AddArg(w0)
   12926 		v.AddArg(mem)
   12927 		return true
   12928 	}
   12929 	// match: (MOVBstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVBstoreidx [i-1] {s} idx p w0:(SRWconst [j-8] w) mem))
   12930 	// cond: x.Uses == 1   && clobber(x)
   12931 	// result: (MOVHBRstoreidx [i-1] {s} p idx w0 mem)
   12932 	for {
   12933 		i := v.AuxInt
   12934 		s := v.Aux
   12935 		_ = v.Args[3]
   12936 		idx := v.Args[0]
   12937 		p := v.Args[1]
   12938 		v_2 := v.Args[2]
   12939 		if v_2.Op != OpS390XSRWconst {
   12940 			break
   12941 		}
   12942 		j := v_2.AuxInt
   12943 		w := v_2.Args[0]
   12944 		x := v.Args[3]
   12945 		if x.Op != OpS390XMOVBstoreidx {
   12946 			break
   12947 		}
   12948 		if x.AuxInt != i-1 {
   12949 			break
   12950 		}
   12951 		if x.Aux != s {
   12952 			break
   12953 		}
   12954 		_ = x.Args[3]
   12955 		if idx != x.Args[0] {
   12956 			break
   12957 		}
   12958 		if p != x.Args[1] {
   12959 			break
   12960 		}
   12961 		w0 := x.Args[2]
   12962 		if w0.Op != OpS390XSRWconst {
   12963 			break
   12964 		}
   12965 		if w0.AuxInt != j-8 {
   12966 			break
   12967 		}
   12968 		if w != w0.Args[0] {
   12969 			break
   12970 		}
   12971 		mem := x.Args[3]
   12972 		if !(x.Uses == 1 && clobber(x)) {
   12973 			break
   12974 		}
   12975 		v.reset(OpS390XMOVHBRstoreidx)
   12976 		v.AuxInt = i - 1
   12977 		v.Aux = s
   12978 		v.AddArg(p)
   12979 		v.AddArg(idx)
   12980 		v.AddArg(w0)
   12981 		v.AddArg(mem)
   12982 		return true
   12983 	}
   12984 	return false
   12985 }
   12986 func rewriteValueS390X_OpS390XMOVDEQ_0(v *Value) bool {
   12987 	// match: (MOVDEQ x y (InvertFlags cmp))
   12988 	// cond:
   12989 	// result: (MOVDEQ x y cmp)
   12990 	for {
   12991 		_ = v.Args[2]
   12992 		x := v.Args[0]
   12993 		y := v.Args[1]
   12994 		v_2 := v.Args[2]
   12995 		if v_2.Op != OpS390XInvertFlags {
   12996 			break
   12997 		}
   12998 		cmp := v_2.Args[0]
   12999 		v.reset(OpS390XMOVDEQ)
   13000 		v.AddArg(x)
   13001 		v.AddArg(y)
   13002 		v.AddArg(cmp)
   13003 		return true
   13004 	}
   13005 	// match: (MOVDEQ _ x (FlagEQ))
   13006 	// cond:
   13007 	// result: x
   13008 	for {
   13009 		_ = v.Args[2]
   13010 		x := v.Args[1]
   13011 		v_2 := v.Args[2]
   13012 		if v_2.Op != OpS390XFlagEQ {
   13013 			break
   13014 		}
   13015 		v.reset(OpCopy)
   13016 		v.Type = x.Type
   13017 		v.AddArg(x)
   13018 		return true
   13019 	}
   13020 	// match: (MOVDEQ y _ (FlagLT))
   13021 	// cond:
   13022 	// result: y
   13023 	for {
   13024 		_ = v.Args[2]
   13025 		y := v.Args[0]
   13026 		v_2 := v.Args[2]
   13027 		if v_2.Op != OpS390XFlagLT {
   13028 			break
   13029 		}
   13030 		v.reset(OpCopy)
   13031 		v.Type = y.Type
   13032 		v.AddArg(y)
   13033 		return true
   13034 	}
   13035 	// match: (MOVDEQ y _ (FlagGT))
   13036 	// cond:
   13037 	// result: y
   13038 	for {
   13039 		_ = v.Args[2]
   13040 		y := v.Args[0]
   13041 		v_2 := v.Args[2]
   13042 		if v_2.Op != OpS390XFlagGT {
   13043 			break
   13044 		}
   13045 		v.reset(OpCopy)
   13046 		v.Type = y.Type
   13047 		v.AddArg(y)
   13048 		return true
   13049 	}
   13050 	return false
   13051 }
   13052 func rewriteValueS390X_OpS390XMOVDGE_0(v *Value) bool {
   13053 	// match: (MOVDGE x y (InvertFlags cmp))
   13054 	// cond:
   13055 	// result: (MOVDLE x y cmp)
   13056 	for {
   13057 		_ = v.Args[2]
   13058 		x := v.Args[0]
   13059 		y := v.Args[1]
   13060 		v_2 := v.Args[2]
   13061 		if v_2.Op != OpS390XInvertFlags {
   13062 			break
   13063 		}
   13064 		cmp := v_2.Args[0]
   13065 		v.reset(OpS390XMOVDLE)
   13066 		v.AddArg(x)
   13067 		v.AddArg(y)
   13068 		v.AddArg(cmp)
   13069 		return true
   13070 	}
   13071 	// match: (MOVDGE _ x (FlagEQ))
   13072 	// cond:
   13073 	// result: x
   13074 	for {
   13075 		_ = v.Args[2]
   13076 		x := v.Args[1]
   13077 		v_2 := v.Args[2]
   13078 		if v_2.Op != OpS390XFlagEQ {
   13079 			break
   13080 		}
   13081 		v.reset(OpCopy)
   13082 		v.Type = x.Type
   13083 		v.AddArg(x)
   13084 		return true
   13085 	}
   13086 	// match: (MOVDGE y _ (FlagLT))
   13087 	// cond:
   13088 	// result: y
   13089 	for {
   13090 		_ = v.Args[2]
   13091 		y := v.Args[0]
   13092 		v_2 := v.Args[2]
   13093 		if v_2.Op != OpS390XFlagLT {
   13094 			break
   13095 		}
   13096 		v.reset(OpCopy)
   13097 		v.Type = y.Type
   13098 		v.AddArg(y)
   13099 		return true
   13100 	}
   13101 	// match: (MOVDGE _ x (FlagGT))
   13102 	// cond:
   13103 	// result: x
   13104 	for {
   13105 		_ = v.Args[2]
   13106 		x := v.Args[1]
   13107 		v_2 := v.Args[2]
   13108 		if v_2.Op != OpS390XFlagGT {
   13109 			break
   13110 		}
   13111 		v.reset(OpCopy)
   13112 		v.Type = x.Type
   13113 		v.AddArg(x)
   13114 		return true
   13115 	}
   13116 	return false
   13117 }
   13118 func rewriteValueS390X_OpS390XMOVDGT_0(v *Value) bool {
   13119 	// match: (MOVDGT x y (InvertFlags cmp))
   13120 	// cond:
   13121 	// result: (MOVDLT x y cmp)
   13122 	for {
   13123 		_ = v.Args[2]
   13124 		x := v.Args[0]
   13125 		y := v.Args[1]
   13126 		v_2 := v.Args[2]
   13127 		if v_2.Op != OpS390XInvertFlags {
   13128 			break
   13129 		}
   13130 		cmp := v_2.Args[0]
   13131 		v.reset(OpS390XMOVDLT)
   13132 		v.AddArg(x)
   13133 		v.AddArg(y)
   13134 		v.AddArg(cmp)
   13135 		return true
   13136 	}
   13137 	// match: (MOVDGT y _ (FlagEQ))
   13138 	// cond:
   13139 	// result: y
   13140 	for {
   13141 		_ = v.Args[2]
   13142 		y := v.Args[0]
   13143 		v_2 := v.Args[2]
   13144 		if v_2.Op != OpS390XFlagEQ {
   13145 			break
   13146 		}
   13147 		v.reset(OpCopy)
   13148 		v.Type = y.Type
   13149 		v.AddArg(y)
   13150 		return true
   13151 	}
   13152 	// match: (MOVDGT y _ (FlagLT))
   13153 	// cond:
   13154 	// result: y
   13155 	for {
   13156 		_ = v.Args[2]
   13157 		y := v.Args[0]
   13158 		v_2 := v.Args[2]
   13159 		if v_2.Op != OpS390XFlagLT {
   13160 			break
   13161 		}
   13162 		v.reset(OpCopy)
   13163 		v.Type = y.Type
   13164 		v.AddArg(y)
   13165 		return true
   13166 	}
   13167 	// match: (MOVDGT _ x (FlagGT))
   13168 	// cond:
   13169 	// result: x
   13170 	for {
   13171 		_ = v.Args[2]
   13172 		x := v.Args[1]
   13173 		v_2 := v.Args[2]
   13174 		if v_2.Op != OpS390XFlagGT {
   13175 			break
   13176 		}
   13177 		v.reset(OpCopy)
   13178 		v.Type = x.Type
   13179 		v.AddArg(x)
   13180 		return true
   13181 	}
   13182 	return false
   13183 }
   13184 func rewriteValueS390X_OpS390XMOVDLE_0(v *Value) bool {
   13185 	// match: (MOVDLE x y (InvertFlags cmp))
   13186 	// cond:
   13187 	// result: (MOVDGE x y cmp)
   13188 	for {
   13189 		_ = v.Args[2]
   13190 		x := v.Args[0]
   13191 		y := v.Args[1]
   13192 		v_2 := v.Args[2]
   13193 		if v_2.Op != OpS390XInvertFlags {
   13194 			break
   13195 		}
   13196 		cmp := v_2.Args[0]
   13197 		v.reset(OpS390XMOVDGE)
   13198 		v.AddArg(x)
   13199 		v.AddArg(y)
   13200 		v.AddArg(cmp)
   13201 		return true
   13202 	}
   13203 	// match: (MOVDLE _ x (FlagEQ))
   13204 	// cond:
   13205 	// result: x
   13206 	for {
   13207 		_ = v.Args[2]
   13208 		x := v.Args[1]
   13209 		v_2 := v.Args[2]
   13210 		if v_2.Op != OpS390XFlagEQ {
   13211 			break
   13212 		}
   13213 		v.reset(OpCopy)
   13214 		v.Type = x.Type
   13215 		v.AddArg(x)
   13216 		return true
   13217 	}
   13218 	// match: (MOVDLE _ x (FlagLT))
   13219 	// cond:
   13220 	// result: x
   13221 	for {
   13222 		_ = v.Args[2]
   13223 		x := v.Args[1]
   13224 		v_2 := v.Args[2]
   13225 		if v_2.Op != OpS390XFlagLT {
   13226 			break
   13227 		}
   13228 		v.reset(OpCopy)
   13229 		v.Type = x.Type
   13230 		v.AddArg(x)
   13231 		return true
   13232 	}
   13233 	// match: (MOVDLE y _ (FlagGT))
   13234 	// cond:
   13235 	// result: y
   13236 	for {
   13237 		_ = v.Args[2]
   13238 		y := v.Args[0]
   13239 		v_2 := v.Args[2]
   13240 		if v_2.Op != OpS390XFlagGT {
   13241 			break
   13242 		}
   13243 		v.reset(OpCopy)
   13244 		v.Type = y.Type
   13245 		v.AddArg(y)
   13246 		return true
   13247 	}
   13248 	return false
   13249 }
   13250 func rewriteValueS390X_OpS390XMOVDLT_0(v *Value) bool {
   13251 	// match: (MOVDLT x y (InvertFlags cmp))
   13252 	// cond:
   13253 	// result: (MOVDGT x y cmp)
   13254 	for {
   13255 		_ = v.Args[2]
   13256 		x := v.Args[0]
   13257 		y := v.Args[1]
   13258 		v_2 := v.Args[2]
   13259 		if v_2.Op != OpS390XInvertFlags {
   13260 			break
   13261 		}
   13262 		cmp := v_2.Args[0]
   13263 		v.reset(OpS390XMOVDGT)
   13264 		v.AddArg(x)
   13265 		v.AddArg(y)
   13266 		v.AddArg(cmp)
   13267 		return true
   13268 	}
   13269 	// match: (MOVDLT y _ (FlagEQ))
   13270 	// cond:
   13271 	// result: y
   13272 	for {
   13273 		_ = v.Args[2]
   13274 		y := v.Args[0]
   13275 		v_2 := v.Args[2]
   13276 		if v_2.Op != OpS390XFlagEQ {
   13277 			break
   13278 		}
   13279 		v.reset(OpCopy)
   13280 		v.Type = y.Type
   13281 		v.AddArg(y)
   13282 		return true
   13283 	}
   13284 	// match: (MOVDLT _ x (FlagLT))
   13285 	// cond:
   13286 	// result: x
   13287 	for {
   13288 		_ = v.Args[2]
   13289 		x := v.Args[1]
   13290 		v_2 := v.Args[2]
   13291 		if v_2.Op != OpS390XFlagLT {
   13292 			break
   13293 		}
   13294 		v.reset(OpCopy)
   13295 		v.Type = x.Type
   13296 		v.AddArg(x)
   13297 		return true
   13298 	}
   13299 	// match: (MOVDLT y _ (FlagGT))
   13300 	// cond:
   13301 	// result: y
   13302 	for {
   13303 		_ = v.Args[2]
   13304 		y := v.Args[0]
   13305 		v_2 := v.Args[2]
   13306 		if v_2.Op != OpS390XFlagGT {
   13307 			break
   13308 		}
   13309 		v.reset(OpCopy)
   13310 		v.Type = y.Type
   13311 		v.AddArg(y)
   13312 		return true
   13313 	}
   13314 	return false
   13315 }
   13316 func rewriteValueS390X_OpS390XMOVDNE_0(v *Value) bool {
   13317 	// match: (MOVDNE x y (InvertFlags cmp))
   13318 	// cond:
   13319 	// result: (MOVDNE x y cmp)
   13320 	for {
   13321 		_ = v.Args[2]
   13322 		x := v.Args[0]
   13323 		y := v.Args[1]
   13324 		v_2 := v.Args[2]
   13325 		if v_2.Op != OpS390XInvertFlags {
   13326 			break
   13327 		}
   13328 		cmp := v_2.Args[0]
   13329 		v.reset(OpS390XMOVDNE)
   13330 		v.AddArg(x)
   13331 		v.AddArg(y)
   13332 		v.AddArg(cmp)
   13333 		return true
   13334 	}
   13335 	// match: (MOVDNE y _ (FlagEQ))
   13336 	// cond:
   13337 	// result: y
   13338 	for {
   13339 		_ = v.Args[2]
   13340 		y := v.Args[0]
   13341 		v_2 := v.Args[2]
   13342 		if v_2.Op != OpS390XFlagEQ {
   13343 			break
   13344 		}
   13345 		v.reset(OpCopy)
   13346 		v.Type = y.Type
   13347 		v.AddArg(y)
   13348 		return true
   13349 	}
   13350 	// match: (MOVDNE _ x (FlagLT))
   13351 	// cond:
   13352 	// result: x
   13353 	for {
   13354 		_ = v.Args[2]
   13355 		x := v.Args[1]
   13356 		v_2 := v.Args[2]
   13357 		if v_2.Op != OpS390XFlagLT {
   13358 			break
   13359 		}
   13360 		v.reset(OpCopy)
   13361 		v.Type = x.Type
   13362 		v.AddArg(x)
   13363 		return true
   13364 	}
   13365 	// match: (MOVDNE _ x (FlagGT))
   13366 	// cond:
   13367 	// result: x
   13368 	for {
   13369 		_ = v.Args[2]
   13370 		x := v.Args[1]
   13371 		v_2 := v.Args[2]
   13372 		if v_2.Op != OpS390XFlagGT {
   13373 			break
   13374 		}
   13375 		v.reset(OpCopy)
   13376 		v.Type = x.Type
   13377 		v.AddArg(x)
   13378 		return true
   13379 	}
   13380 	return false
   13381 }
   13382 func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool {
   13383 	// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
   13384 	// cond: is20Bit(c+d) && x.Op != OpSB
   13385 	// result: (MOVDaddridx [c+d] {s} x y)
   13386 	for {
   13387 		c := v.AuxInt
   13388 		s := v.Aux
   13389 		_ = v.Args[1]
   13390 		v_0 := v.Args[0]
   13391 		if v_0.Op != OpS390XADDconst {
   13392 			break
   13393 		}
   13394 		d := v_0.AuxInt
   13395 		x := v_0.Args[0]
   13396 		y := v.Args[1]
   13397 		if !(is20Bit(c+d) && x.Op != OpSB) {
   13398 			break
   13399 		}
   13400 		v.reset(OpS390XMOVDaddridx)
   13401 		v.AuxInt = c + d
   13402 		v.Aux = s
   13403 		v.AddArg(x)
   13404 		v.AddArg(y)
   13405 		return true
   13406 	}
   13407 	// match: (MOVDaddridx [c] {s} x (ADDconst [d] y))
   13408 	// cond: is20Bit(c+d) && y.Op != OpSB
   13409 	// result: (MOVDaddridx [c+d] {s} x y)
   13410 	for {
   13411 		c := v.AuxInt
   13412 		s := v.Aux
   13413 		_ = v.Args[1]
   13414 		x := v.Args[0]
   13415 		v_1 := v.Args[1]
   13416 		if v_1.Op != OpS390XADDconst {
   13417 			break
   13418 		}
   13419 		d := v_1.AuxInt
   13420 		y := v_1.Args[0]
   13421 		if !(is20Bit(c+d) && y.Op != OpSB) {
   13422 			break
   13423 		}
   13424 		v.reset(OpS390XMOVDaddridx)
   13425 		v.AuxInt = c + d
   13426 		v.Aux = s
   13427 		v.AddArg(x)
   13428 		v.AddArg(y)
   13429 		return true
   13430 	}
   13431 	// match: (MOVDaddridx [off1] {sym1} (MOVDaddr [off2] {sym2} x) y)
   13432 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
   13433 	// result: (MOVDaddridx [off1+off2] {mergeSym(sym1,sym2)} x y)
   13434 	for {
   13435 		off1 := v.AuxInt
   13436 		sym1 := v.Aux
   13437 		_ = v.Args[1]
   13438 		v_0 := v.Args[0]
   13439 		if v_0.Op != OpS390XMOVDaddr {
   13440 			break
   13441 		}
   13442 		off2 := v_0.AuxInt
   13443 		sym2 := v_0.Aux
   13444 		x := v_0.Args[0]
   13445 		y := v.Args[1]
   13446 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
   13447 			break
   13448 		}
   13449 		v.reset(OpS390XMOVDaddridx)
   13450 		v.AuxInt = off1 + off2
   13451 		v.Aux = mergeSym(sym1, sym2)
   13452 		v.AddArg(x)
   13453 		v.AddArg(y)
   13454 		return true
   13455 	}
   13456 	// match: (MOVDaddridx [off1] {sym1} x (MOVDaddr [off2] {sym2} y))
   13457 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && y.Op != OpSB
   13458 	// result: (MOVDaddridx [off1+off2] {mergeSym(sym1,sym2)} x y)
   13459 	for {
   13460 		off1 := v.AuxInt
   13461 		sym1 := v.Aux
   13462 		_ = v.Args[1]
   13463 		x := v.Args[0]
   13464 		v_1 := v.Args[1]
   13465 		if v_1.Op != OpS390XMOVDaddr {
   13466 			break
   13467 		}
   13468 		off2 := v_1.AuxInt
   13469 		sym2 := v_1.Aux
   13470 		y := v_1.Args[0]
   13471 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && y.Op != OpSB) {
   13472 			break
   13473 		}
   13474 		v.reset(OpS390XMOVDaddridx)
   13475 		v.AuxInt = off1 + off2
   13476 		v.Aux = mergeSym(sym1, sym2)
   13477 		v.AddArg(x)
   13478 		v.AddArg(y)
   13479 		return true
   13480 	}
   13481 	return false
   13482 }
   13483 func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool {
   13484 	// match: (MOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
   13485 	// cond: isSamePtr(ptr1, ptr2)
   13486 	// result: (MOVDreg x)
   13487 	for {
   13488 		off := v.AuxInt
   13489 		sym := v.Aux
   13490 		_ = v.Args[1]
   13491 		ptr1 := v.Args[0]
   13492 		v_1 := v.Args[1]
   13493 		if v_1.Op != OpS390XMOVDstore {
   13494 			break
   13495 		}
   13496 		if v_1.AuxInt != off {
   13497 			break
   13498 		}
   13499 		if v_1.Aux != sym {
   13500 			break
   13501 		}
   13502 		_ = v_1.Args[2]
   13503 		ptr2 := v_1.Args[0]
   13504 		x := v_1.Args[1]
   13505 		if !(isSamePtr(ptr1, ptr2)) {
   13506 			break
   13507 		}
   13508 		v.reset(OpS390XMOVDreg)
   13509 		v.AddArg(x)
   13510 		return true
   13511 	}
   13512 	// match: (MOVDload [off] {sym} ptr1 (FMOVDstore [off] {sym} ptr2 x _))
   13513 	// cond: isSamePtr(ptr1, ptr2)
   13514 	// result: (LGDR x)
   13515 	for {
   13516 		off := v.AuxInt
   13517 		sym := v.Aux
   13518 		_ = v.Args[1]
   13519 		ptr1 := v.Args[0]
   13520 		v_1 := v.Args[1]
   13521 		if v_1.Op != OpS390XFMOVDstore {
   13522 			break
   13523 		}
   13524 		if v_1.AuxInt != off {
   13525 			break
   13526 		}
   13527 		if v_1.Aux != sym {
   13528 			break
   13529 		}
   13530 		_ = v_1.Args[2]
   13531 		ptr2 := v_1.Args[0]
   13532 		x := v_1.Args[1]
   13533 		if !(isSamePtr(ptr1, ptr2)) {
   13534 			break
   13535 		}
   13536 		v.reset(OpS390XLGDR)
   13537 		v.AddArg(x)
   13538 		return true
   13539 	}
   13540 	// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
   13541 	// cond: is20Bit(off1+off2)
   13542 	// result: (MOVDload  [off1+off2] {sym} ptr mem)
   13543 	for {
   13544 		off1 := v.AuxInt
   13545 		sym := v.Aux
   13546 		_ = v.Args[1]
   13547 		v_0 := v.Args[0]
   13548 		if v_0.Op != OpS390XADDconst {
   13549 			break
   13550 		}
   13551 		off2 := v_0.AuxInt
   13552 		ptr := v_0.Args[0]
   13553 		mem := v.Args[1]
   13554 		if !(is20Bit(off1 + off2)) {
   13555 			break
   13556 		}
   13557 		v.reset(OpS390XMOVDload)
   13558 		v.AuxInt = off1 + off2
   13559 		v.Aux = sym
   13560 		v.AddArg(ptr)
   13561 		v.AddArg(mem)
   13562 		return true
   13563 	}
   13564 	// match: (MOVDload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
   13565 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%8 == 0 && (off1+off2)%8 == 0))
   13566 	// result: (MOVDload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   13567 	for {
   13568 		off1 := v.AuxInt
   13569 		sym1 := v.Aux
   13570 		_ = v.Args[1]
   13571 		v_0 := v.Args[0]
   13572 		if v_0.Op != OpS390XMOVDaddr {
   13573 			break
   13574 		}
   13575 		t := v_0.Type
   13576 		off2 := v_0.AuxInt
   13577 		sym2 := v_0.Aux
   13578 		base := v_0.Args[0]
   13579 		mem := v.Args[1]
   13580 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%8 == 0 && (off1+off2)%8 == 0))) {
   13581 			break
   13582 		}
   13583 		v.reset(OpS390XMOVDload)
   13584 		v.AuxInt = off1 + off2
   13585 		v.Aux = mergeSym(sym1, sym2)
   13586 		v.AddArg(base)
   13587 		v.AddArg(mem)
   13588 		return true
   13589 	}
   13590 	// match: (MOVDload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   13591 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   13592 	// result: (MOVDloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   13593 	for {
   13594 		off1 := v.AuxInt
   13595 		sym1 := v.Aux
   13596 		_ = v.Args[1]
   13597 		v_0 := v.Args[0]
   13598 		if v_0.Op != OpS390XMOVDaddridx {
   13599 			break
   13600 		}
   13601 		off2 := v_0.AuxInt
   13602 		sym2 := v_0.Aux
   13603 		_ = v_0.Args[1]
   13604 		ptr := v_0.Args[0]
   13605 		idx := v_0.Args[1]
   13606 		mem := v.Args[1]
   13607 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   13608 			break
   13609 		}
   13610 		v.reset(OpS390XMOVDloadidx)
   13611 		v.AuxInt = off1 + off2
   13612 		v.Aux = mergeSym(sym1, sym2)
   13613 		v.AddArg(ptr)
   13614 		v.AddArg(idx)
   13615 		v.AddArg(mem)
   13616 		return true
   13617 	}
   13618 	// match: (MOVDload [off] {sym} (ADD ptr idx) mem)
   13619 	// cond: ptr.Op != OpSB
   13620 	// result: (MOVDloadidx  [off] {sym} ptr idx mem)
   13621 	for {
   13622 		off := v.AuxInt
   13623 		sym := v.Aux
   13624 		_ = v.Args[1]
   13625 		v_0 := v.Args[0]
   13626 		if v_0.Op != OpS390XADD {
   13627 			break
   13628 		}
   13629 		_ = v_0.Args[1]
   13630 		ptr := v_0.Args[0]
   13631 		idx := v_0.Args[1]
   13632 		mem := v.Args[1]
   13633 		if !(ptr.Op != OpSB) {
   13634 			break
   13635 		}
   13636 		v.reset(OpS390XMOVDloadidx)
   13637 		v.AuxInt = off
   13638 		v.Aux = sym
   13639 		v.AddArg(ptr)
   13640 		v.AddArg(idx)
   13641 		v.AddArg(mem)
   13642 		return true
   13643 	}
   13644 	return false
   13645 }
   13646 func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool {
   13647 	// match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   13648 	// cond: is20Bit(c+d)
   13649 	// result: (MOVDloadidx  [c+d] {sym} ptr idx mem)
   13650 	for {
   13651 		c := v.AuxInt
   13652 		sym := v.Aux
   13653 		_ = v.Args[2]
   13654 		v_0 := v.Args[0]
   13655 		if v_0.Op != OpS390XADDconst {
   13656 			break
   13657 		}
   13658 		d := v_0.AuxInt
   13659 		ptr := v_0.Args[0]
   13660 		idx := v.Args[1]
   13661 		mem := v.Args[2]
   13662 		if !(is20Bit(c + d)) {
   13663 			break
   13664 		}
   13665 		v.reset(OpS390XMOVDloadidx)
   13666 		v.AuxInt = c + d
   13667 		v.Aux = sym
   13668 		v.AddArg(ptr)
   13669 		v.AddArg(idx)
   13670 		v.AddArg(mem)
   13671 		return true
   13672 	}
   13673 	// match: (MOVDloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   13674 	// cond: is20Bit(c+d)
   13675 	// result: (MOVDloadidx  [c+d] {sym} ptr idx mem)
   13676 	for {
   13677 		c := v.AuxInt
   13678 		sym := v.Aux
   13679 		_ = v.Args[2]
   13680 		idx := v.Args[0]
   13681 		v_1 := v.Args[1]
   13682 		if v_1.Op != OpS390XADDconst {
   13683 			break
   13684 		}
   13685 		d := v_1.AuxInt
   13686 		ptr := v_1.Args[0]
   13687 		mem := v.Args[2]
   13688 		if !(is20Bit(c + d)) {
   13689 			break
   13690 		}
   13691 		v.reset(OpS390XMOVDloadidx)
   13692 		v.AuxInt = c + d
   13693 		v.Aux = sym
   13694 		v.AddArg(ptr)
   13695 		v.AddArg(idx)
   13696 		v.AddArg(mem)
   13697 		return true
   13698 	}
   13699 	// match: (MOVDloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   13700 	// cond: is20Bit(c+d)
   13701 	// result: (MOVDloadidx  [c+d] {sym} ptr idx mem)
   13702 	for {
   13703 		c := v.AuxInt
   13704 		sym := v.Aux
   13705 		_ = v.Args[2]
   13706 		ptr := v.Args[0]
   13707 		v_1 := v.Args[1]
   13708 		if v_1.Op != OpS390XADDconst {
   13709 			break
   13710 		}
   13711 		d := v_1.AuxInt
   13712 		idx := v_1.Args[0]
   13713 		mem := v.Args[2]
   13714 		if !(is20Bit(c + d)) {
   13715 			break
   13716 		}
   13717 		v.reset(OpS390XMOVDloadidx)
   13718 		v.AuxInt = c + d
   13719 		v.Aux = sym
   13720 		v.AddArg(ptr)
   13721 		v.AddArg(idx)
   13722 		v.AddArg(mem)
   13723 		return true
   13724 	}
   13725 	// match: (MOVDloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   13726 	// cond: is20Bit(c+d)
   13727 	// result: (MOVDloadidx  [c+d] {sym} ptr idx mem)
   13728 	for {
   13729 		c := v.AuxInt
   13730 		sym := v.Aux
   13731 		_ = v.Args[2]
   13732 		v_0 := v.Args[0]
   13733 		if v_0.Op != OpS390XADDconst {
   13734 			break
   13735 		}
   13736 		d := v_0.AuxInt
   13737 		idx := v_0.Args[0]
   13738 		ptr := v.Args[1]
   13739 		mem := v.Args[2]
   13740 		if !(is20Bit(c + d)) {
   13741 			break
   13742 		}
   13743 		v.reset(OpS390XMOVDloadidx)
   13744 		v.AuxInt = c + d
   13745 		v.Aux = sym
   13746 		v.AddArg(ptr)
   13747 		v.AddArg(idx)
   13748 		v.AddArg(mem)
   13749 		return true
   13750 	}
   13751 	return false
   13752 }
   13753 func rewriteValueS390X_OpS390XMOVDnop_0(v *Value) bool {
   13754 	b := v.Block
   13755 	_ = b
   13756 	// match: (MOVDnop <t> x)
   13757 	// cond: t.Compare(x.Type) == types.CMPeq
   13758 	// result: x
   13759 	for {
   13760 		t := v.Type
   13761 		x := v.Args[0]
   13762 		if !(t.Compare(x.Type) == types.CMPeq) {
   13763 			break
   13764 		}
   13765 		v.reset(OpCopy)
   13766 		v.Type = x.Type
   13767 		v.AddArg(x)
   13768 		return true
   13769 	}
   13770 	// match: (MOVDnop (MOVDconst [c]))
   13771 	// cond:
   13772 	// result: (MOVDconst [c])
   13773 	for {
   13774 		v_0 := v.Args[0]
   13775 		if v_0.Op != OpS390XMOVDconst {
   13776 			break
   13777 		}
   13778 		c := v_0.AuxInt
   13779 		v.reset(OpS390XMOVDconst)
   13780 		v.AuxInt = c
   13781 		return true
   13782 	}
   13783 	// match: (MOVDnop <t> x:(MOVBZload [off] {sym} ptr mem))
   13784 	// cond: x.Uses == 1 && clobber(x)
   13785 	// result: @x.Block (MOVBZload <t> [off] {sym} ptr mem)
   13786 	for {
   13787 		t := v.Type
   13788 		x := v.Args[0]
   13789 		if x.Op != OpS390XMOVBZload {
   13790 			break
   13791 		}
   13792 		off := x.AuxInt
   13793 		sym := x.Aux
   13794 		_ = x.Args[1]
   13795 		ptr := x.Args[0]
   13796 		mem := x.Args[1]
   13797 		if !(x.Uses == 1 && clobber(x)) {
   13798 			break
   13799 		}
   13800 		b = x.Block
   13801 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, t)
   13802 		v.reset(OpCopy)
   13803 		v.AddArg(v0)
   13804 		v0.AuxInt = off
   13805 		v0.Aux = sym
   13806 		v0.AddArg(ptr)
   13807 		v0.AddArg(mem)
   13808 		return true
   13809 	}
   13810 	// match: (MOVDnop <t> x:(MOVBload [off] {sym} ptr mem))
   13811 	// cond: x.Uses == 1 && clobber(x)
   13812 	// result: @x.Block (MOVBload  <t> [off] {sym} ptr mem)
   13813 	for {
   13814 		t := v.Type
   13815 		x := v.Args[0]
   13816 		if x.Op != OpS390XMOVBload {
   13817 			break
   13818 		}
   13819 		off := x.AuxInt
   13820 		sym := x.Aux
   13821 		_ = x.Args[1]
   13822 		ptr := x.Args[0]
   13823 		mem := x.Args[1]
   13824 		if !(x.Uses == 1 && clobber(x)) {
   13825 			break
   13826 		}
   13827 		b = x.Block
   13828 		v0 := b.NewValue0(v.Pos, OpS390XMOVBload, t)
   13829 		v.reset(OpCopy)
   13830 		v.AddArg(v0)
   13831 		v0.AuxInt = off
   13832 		v0.Aux = sym
   13833 		v0.AddArg(ptr)
   13834 		v0.AddArg(mem)
   13835 		return true
   13836 	}
   13837 	// match: (MOVDnop <t> x:(MOVHZload [off] {sym} ptr mem))
   13838 	// cond: x.Uses == 1 && clobber(x)
   13839 	// result: @x.Block (MOVHZload <t> [off] {sym} ptr mem)
   13840 	for {
   13841 		t := v.Type
   13842 		x := v.Args[0]
   13843 		if x.Op != OpS390XMOVHZload {
   13844 			break
   13845 		}
   13846 		off := x.AuxInt
   13847 		sym := x.Aux
   13848 		_ = x.Args[1]
   13849 		ptr := x.Args[0]
   13850 		mem := x.Args[1]
   13851 		if !(x.Uses == 1 && clobber(x)) {
   13852 			break
   13853 		}
   13854 		b = x.Block
   13855 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, t)
   13856 		v.reset(OpCopy)
   13857 		v.AddArg(v0)
   13858 		v0.AuxInt = off
   13859 		v0.Aux = sym
   13860 		v0.AddArg(ptr)
   13861 		v0.AddArg(mem)
   13862 		return true
   13863 	}
   13864 	// match: (MOVDnop <t> x:(MOVHload [off] {sym} ptr mem))
   13865 	// cond: x.Uses == 1 && clobber(x)
   13866 	// result: @x.Block (MOVHload  <t> [off] {sym} ptr mem)
   13867 	for {
   13868 		t := v.Type
   13869 		x := v.Args[0]
   13870 		if x.Op != OpS390XMOVHload {
   13871 			break
   13872 		}
   13873 		off := x.AuxInt
   13874 		sym := x.Aux
   13875 		_ = x.Args[1]
   13876 		ptr := x.Args[0]
   13877 		mem := x.Args[1]
   13878 		if !(x.Uses == 1 && clobber(x)) {
   13879 			break
   13880 		}
   13881 		b = x.Block
   13882 		v0 := b.NewValue0(v.Pos, OpS390XMOVHload, t)
   13883 		v.reset(OpCopy)
   13884 		v.AddArg(v0)
   13885 		v0.AuxInt = off
   13886 		v0.Aux = sym
   13887 		v0.AddArg(ptr)
   13888 		v0.AddArg(mem)
   13889 		return true
   13890 	}
   13891 	// match: (MOVDnop <t> x:(MOVWZload [off] {sym} ptr mem))
   13892 	// cond: x.Uses == 1 && clobber(x)
   13893 	// result: @x.Block (MOVWZload <t> [off] {sym} ptr mem)
   13894 	for {
   13895 		t := v.Type
   13896 		x := v.Args[0]
   13897 		if x.Op != OpS390XMOVWZload {
   13898 			break
   13899 		}
   13900 		off := x.AuxInt
   13901 		sym := x.Aux
   13902 		_ = x.Args[1]
   13903 		ptr := x.Args[0]
   13904 		mem := x.Args[1]
   13905 		if !(x.Uses == 1 && clobber(x)) {
   13906 			break
   13907 		}
   13908 		b = x.Block
   13909 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, t)
   13910 		v.reset(OpCopy)
   13911 		v.AddArg(v0)
   13912 		v0.AuxInt = off
   13913 		v0.Aux = sym
   13914 		v0.AddArg(ptr)
   13915 		v0.AddArg(mem)
   13916 		return true
   13917 	}
   13918 	// match: (MOVDnop <t> x:(MOVWload [off] {sym} ptr mem))
   13919 	// cond: x.Uses == 1 && clobber(x)
   13920 	// result: @x.Block (MOVWload  <t> [off] {sym} ptr mem)
   13921 	for {
   13922 		t := v.Type
   13923 		x := v.Args[0]
   13924 		if x.Op != OpS390XMOVWload {
   13925 			break
   13926 		}
   13927 		off := x.AuxInt
   13928 		sym := x.Aux
   13929 		_ = x.Args[1]
   13930 		ptr := x.Args[0]
   13931 		mem := x.Args[1]
   13932 		if !(x.Uses == 1 && clobber(x)) {
   13933 			break
   13934 		}
   13935 		b = x.Block
   13936 		v0 := b.NewValue0(v.Pos, OpS390XMOVWload, t)
   13937 		v.reset(OpCopy)
   13938 		v.AddArg(v0)
   13939 		v0.AuxInt = off
   13940 		v0.Aux = sym
   13941 		v0.AddArg(ptr)
   13942 		v0.AddArg(mem)
   13943 		return true
   13944 	}
   13945 	// match: (MOVDnop <t> x:(MOVDload [off] {sym} ptr mem))
   13946 	// cond: x.Uses == 1 && clobber(x)
   13947 	// result: @x.Block (MOVDload  <t> [off] {sym} ptr mem)
   13948 	for {
   13949 		t := v.Type
   13950 		x := v.Args[0]
   13951 		if x.Op != OpS390XMOVDload {
   13952 			break
   13953 		}
   13954 		off := x.AuxInt
   13955 		sym := x.Aux
   13956 		_ = x.Args[1]
   13957 		ptr := x.Args[0]
   13958 		mem := x.Args[1]
   13959 		if !(x.Uses == 1 && clobber(x)) {
   13960 			break
   13961 		}
   13962 		b = x.Block
   13963 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, t)
   13964 		v.reset(OpCopy)
   13965 		v.AddArg(v0)
   13966 		v0.AuxInt = off
   13967 		v0.Aux = sym
   13968 		v0.AddArg(ptr)
   13969 		v0.AddArg(mem)
   13970 		return true
   13971 	}
   13972 	// match: (MOVDnop <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
   13973 	// cond: x.Uses == 1 && clobber(x)
   13974 	// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
   13975 	for {
   13976 		t := v.Type
   13977 		x := v.Args[0]
   13978 		if x.Op != OpS390XMOVBZloadidx {
   13979 			break
   13980 		}
   13981 		off := x.AuxInt
   13982 		sym := x.Aux
   13983 		_ = x.Args[2]
   13984 		ptr := x.Args[0]
   13985 		idx := x.Args[1]
   13986 		mem := x.Args[2]
   13987 		if !(x.Uses == 1 && clobber(x)) {
   13988 			break
   13989 		}
   13990 		b = x.Block
   13991 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, t)
   13992 		v.reset(OpCopy)
   13993 		v.AddArg(v0)
   13994 		v0.AuxInt = off
   13995 		v0.Aux = sym
   13996 		v0.AddArg(ptr)
   13997 		v0.AddArg(idx)
   13998 		v0.AddArg(mem)
   13999 		return true
   14000 	}
   14001 	return false
   14002 }
   14003 func rewriteValueS390X_OpS390XMOVDnop_10(v *Value) bool {
   14004 	b := v.Block
   14005 	_ = b
   14006 	// match: (MOVDnop <t> x:(MOVBloadidx [off] {sym} ptr idx mem))
   14007 	// cond: x.Uses == 1 && clobber(x)
   14008 	// result: @x.Block (MOVBloadidx  <t> [off] {sym} ptr idx mem)
   14009 	for {
   14010 		t := v.Type
   14011 		x := v.Args[0]
   14012 		if x.Op != OpS390XMOVBloadidx {
   14013 			break
   14014 		}
   14015 		off := x.AuxInt
   14016 		sym := x.Aux
   14017 		_ = x.Args[2]
   14018 		ptr := x.Args[0]
   14019 		idx := x.Args[1]
   14020 		mem := x.Args[2]
   14021 		if !(x.Uses == 1 && clobber(x)) {
   14022 			break
   14023 		}
   14024 		b = x.Block
   14025 		v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, t)
   14026 		v.reset(OpCopy)
   14027 		v.AddArg(v0)
   14028 		v0.AuxInt = off
   14029 		v0.Aux = sym
   14030 		v0.AddArg(ptr)
   14031 		v0.AddArg(idx)
   14032 		v0.AddArg(mem)
   14033 		return true
   14034 	}
   14035 	// match: (MOVDnop <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
   14036 	// cond: x.Uses == 1 && clobber(x)
   14037 	// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
   14038 	for {
   14039 		t := v.Type
   14040 		x := v.Args[0]
   14041 		if x.Op != OpS390XMOVHZloadidx {
   14042 			break
   14043 		}
   14044 		off := x.AuxInt
   14045 		sym := x.Aux
   14046 		_ = x.Args[2]
   14047 		ptr := x.Args[0]
   14048 		idx := x.Args[1]
   14049 		mem := x.Args[2]
   14050 		if !(x.Uses == 1 && clobber(x)) {
   14051 			break
   14052 		}
   14053 		b = x.Block
   14054 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, t)
   14055 		v.reset(OpCopy)
   14056 		v.AddArg(v0)
   14057 		v0.AuxInt = off
   14058 		v0.Aux = sym
   14059 		v0.AddArg(ptr)
   14060 		v0.AddArg(idx)
   14061 		v0.AddArg(mem)
   14062 		return true
   14063 	}
   14064 	// match: (MOVDnop <t> x:(MOVHloadidx [off] {sym} ptr idx mem))
   14065 	// cond: x.Uses == 1 && clobber(x)
   14066 	// result: @x.Block (MOVHloadidx  <t> [off] {sym} ptr idx mem)
   14067 	for {
   14068 		t := v.Type
   14069 		x := v.Args[0]
   14070 		if x.Op != OpS390XMOVHloadidx {
   14071 			break
   14072 		}
   14073 		off := x.AuxInt
   14074 		sym := x.Aux
   14075 		_ = x.Args[2]
   14076 		ptr := x.Args[0]
   14077 		idx := x.Args[1]
   14078 		mem := x.Args[2]
   14079 		if !(x.Uses == 1 && clobber(x)) {
   14080 			break
   14081 		}
   14082 		b = x.Block
   14083 		v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, t)
   14084 		v.reset(OpCopy)
   14085 		v.AddArg(v0)
   14086 		v0.AuxInt = off
   14087 		v0.Aux = sym
   14088 		v0.AddArg(ptr)
   14089 		v0.AddArg(idx)
   14090 		v0.AddArg(mem)
   14091 		return true
   14092 	}
   14093 	// match: (MOVDnop <t> x:(MOVWZloadidx [off] {sym} ptr idx mem))
   14094 	// cond: x.Uses == 1 && clobber(x)
   14095 	// result: @x.Block (MOVWZloadidx <t> [off] {sym} ptr idx mem)
   14096 	for {
   14097 		t := v.Type
   14098 		x := v.Args[0]
   14099 		if x.Op != OpS390XMOVWZloadidx {
   14100 			break
   14101 		}
   14102 		off := x.AuxInt
   14103 		sym := x.Aux
   14104 		_ = x.Args[2]
   14105 		ptr := x.Args[0]
   14106 		idx := x.Args[1]
   14107 		mem := x.Args[2]
   14108 		if !(x.Uses == 1 && clobber(x)) {
   14109 			break
   14110 		}
   14111 		b = x.Block
   14112 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, t)
   14113 		v.reset(OpCopy)
   14114 		v.AddArg(v0)
   14115 		v0.AuxInt = off
   14116 		v0.Aux = sym
   14117 		v0.AddArg(ptr)
   14118 		v0.AddArg(idx)
   14119 		v0.AddArg(mem)
   14120 		return true
   14121 	}
   14122 	// match: (MOVDnop <t> x:(MOVWloadidx [off] {sym} ptr idx mem))
   14123 	// cond: x.Uses == 1 && clobber(x)
   14124 	// result: @x.Block (MOVWloadidx  <t> [off] {sym} ptr idx mem)
   14125 	for {
   14126 		t := v.Type
   14127 		x := v.Args[0]
   14128 		if x.Op != OpS390XMOVWloadidx {
   14129 			break
   14130 		}
   14131 		off := x.AuxInt
   14132 		sym := x.Aux
   14133 		_ = x.Args[2]
   14134 		ptr := x.Args[0]
   14135 		idx := x.Args[1]
   14136 		mem := x.Args[2]
   14137 		if !(x.Uses == 1 && clobber(x)) {
   14138 			break
   14139 		}
   14140 		b = x.Block
   14141 		v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, t)
   14142 		v.reset(OpCopy)
   14143 		v.AddArg(v0)
   14144 		v0.AuxInt = off
   14145 		v0.Aux = sym
   14146 		v0.AddArg(ptr)
   14147 		v0.AddArg(idx)
   14148 		v0.AddArg(mem)
   14149 		return true
   14150 	}
   14151 	// match: (MOVDnop <t> x:(MOVDloadidx [off] {sym} ptr idx mem))
   14152 	// cond: x.Uses == 1 && clobber(x)
   14153 	// result: @x.Block (MOVDloadidx  <t> [off] {sym} ptr idx mem)
   14154 	for {
   14155 		t := v.Type
   14156 		x := v.Args[0]
   14157 		if x.Op != OpS390XMOVDloadidx {
   14158 			break
   14159 		}
   14160 		off := x.AuxInt
   14161 		sym := x.Aux
   14162 		_ = x.Args[2]
   14163 		ptr := x.Args[0]
   14164 		idx := x.Args[1]
   14165 		mem := x.Args[2]
   14166 		if !(x.Uses == 1 && clobber(x)) {
   14167 			break
   14168 		}
   14169 		b = x.Block
   14170 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, t)
   14171 		v.reset(OpCopy)
   14172 		v.AddArg(v0)
   14173 		v0.AuxInt = off
   14174 		v0.Aux = sym
   14175 		v0.AddArg(ptr)
   14176 		v0.AddArg(idx)
   14177 		v0.AddArg(mem)
   14178 		return true
   14179 	}
   14180 	return false
   14181 }
   14182 func rewriteValueS390X_OpS390XMOVDreg_0(v *Value) bool {
   14183 	b := v.Block
   14184 	_ = b
   14185 	// match: (MOVDreg <t> x)
   14186 	// cond: t.Compare(x.Type) == types.CMPeq
   14187 	// result: x
   14188 	for {
   14189 		t := v.Type
   14190 		x := v.Args[0]
   14191 		if !(t.Compare(x.Type) == types.CMPeq) {
   14192 			break
   14193 		}
   14194 		v.reset(OpCopy)
   14195 		v.Type = x.Type
   14196 		v.AddArg(x)
   14197 		return true
   14198 	}
   14199 	// match: (MOVDreg (MOVDconst [c]))
   14200 	// cond:
   14201 	// result: (MOVDconst [c])
   14202 	for {
   14203 		v_0 := v.Args[0]
   14204 		if v_0.Op != OpS390XMOVDconst {
   14205 			break
   14206 		}
   14207 		c := v_0.AuxInt
   14208 		v.reset(OpS390XMOVDconst)
   14209 		v.AuxInt = c
   14210 		return true
   14211 	}
   14212 	// match: (MOVDreg x)
   14213 	// cond: x.Uses == 1
   14214 	// result: (MOVDnop x)
   14215 	for {
   14216 		x := v.Args[0]
   14217 		if !(x.Uses == 1) {
   14218 			break
   14219 		}
   14220 		v.reset(OpS390XMOVDnop)
   14221 		v.AddArg(x)
   14222 		return true
   14223 	}
   14224 	// match: (MOVDreg <t> x:(MOVBZload [off] {sym} ptr mem))
   14225 	// cond: x.Uses == 1 && clobber(x)
   14226 	// result: @x.Block (MOVBZload <t> [off] {sym} ptr mem)
   14227 	for {
   14228 		t := v.Type
   14229 		x := v.Args[0]
   14230 		if x.Op != OpS390XMOVBZload {
   14231 			break
   14232 		}
   14233 		off := x.AuxInt
   14234 		sym := x.Aux
   14235 		_ = x.Args[1]
   14236 		ptr := x.Args[0]
   14237 		mem := x.Args[1]
   14238 		if !(x.Uses == 1 && clobber(x)) {
   14239 			break
   14240 		}
   14241 		b = x.Block
   14242 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZload, t)
   14243 		v.reset(OpCopy)
   14244 		v.AddArg(v0)
   14245 		v0.AuxInt = off
   14246 		v0.Aux = sym
   14247 		v0.AddArg(ptr)
   14248 		v0.AddArg(mem)
   14249 		return true
   14250 	}
   14251 	// match: (MOVDreg <t> x:(MOVBload [off] {sym} ptr mem))
   14252 	// cond: x.Uses == 1 && clobber(x)
   14253 	// result: @x.Block (MOVBload  <t> [off] {sym} ptr mem)
   14254 	for {
   14255 		t := v.Type
   14256 		x := v.Args[0]
   14257 		if x.Op != OpS390XMOVBload {
   14258 			break
   14259 		}
   14260 		off := x.AuxInt
   14261 		sym := x.Aux
   14262 		_ = x.Args[1]
   14263 		ptr := x.Args[0]
   14264 		mem := x.Args[1]
   14265 		if !(x.Uses == 1 && clobber(x)) {
   14266 			break
   14267 		}
   14268 		b = x.Block
   14269 		v0 := b.NewValue0(v.Pos, OpS390XMOVBload, t)
   14270 		v.reset(OpCopy)
   14271 		v.AddArg(v0)
   14272 		v0.AuxInt = off
   14273 		v0.Aux = sym
   14274 		v0.AddArg(ptr)
   14275 		v0.AddArg(mem)
   14276 		return true
   14277 	}
   14278 	// match: (MOVDreg <t> x:(MOVHZload [off] {sym} ptr mem))
   14279 	// cond: x.Uses == 1 && clobber(x)
   14280 	// result: @x.Block (MOVHZload <t> [off] {sym} ptr mem)
   14281 	for {
   14282 		t := v.Type
   14283 		x := v.Args[0]
   14284 		if x.Op != OpS390XMOVHZload {
   14285 			break
   14286 		}
   14287 		off := x.AuxInt
   14288 		sym := x.Aux
   14289 		_ = x.Args[1]
   14290 		ptr := x.Args[0]
   14291 		mem := x.Args[1]
   14292 		if !(x.Uses == 1 && clobber(x)) {
   14293 			break
   14294 		}
   14295 		b = x.Block
   14296 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, t)
   14297 		v.reset(OpCopy)
   14298 		v.AddArg(v0)
   14299 		v0.AuxInt = off
   14300 		v0.Aux = sym
   14301 		v0.AddArg(ptr)
   14302 		v0.AddArg(mem)
   14303 		return true
   14304 	}
   14305 	// match: (MOVDreg <t> x:(MOVHload [off] {sym} ptr mem))
   14306 	// cond: x.Uses == 1 && clobber(x)
   14307 	// result: @x.Block (MOVHload  <t> [off] {sym} ptr mem)
   14308 	for {
   14309 		t := v.Type
   14310 		x := v.Args[0]
   14311 		if x.Op != OpS390XMOVHload {
   14312 			break
   14313 		}
   14314 		off := x.AuxInt
   14315 		sym := x.Aux
   14316 		_ = x.Args[1]
   14317 		ptr := x.Args[0]
   14318 		mem := x.Args[1]
   14319 		if !(x.Uses == 1 && clobber(x)) {
   14320 			break
   14321 		}
   14322 		b = x.Block
   14323 		v0 := b.NewValue0(v.Pos, OpS390XMOVHload, t)
   14324 		v.reset(OpCopy)
   14325 		v.AddArg(v0)
   14326 		v0.AuxInt = off
   14327 		v0.Aux = sym
   14328 		v0.AddArg(ptr)
   14329 		v0.AddArg(mem)
   14330 		return true
   14331 	}
   14332 	// match: (MOVDreg <t> x:(MOVWZload [off] {sym} ptr mem))
   14333 	// cond: x.Uses == 1 && clobber(x)
   14334 	// result: @x.Block (MOVWZload <t> [off] {sym} ptr mem)
   14335 	for {
   14336 		t := v.Type
   14337 		x := v.Args[0]
   14338 		if x.Op != OpS390XMOVWZload {
   14339 			break
   14340 		}
   14341 		off := x.AuxInt
   14342 		sym := x.Aux
   14343 		_ = x.Args[1]
   14344 		ptr := x.Args[0]
   14345 		mem := x.Args[1]
   14346 		if !(x.Uses == 1 && clobber(x)) {
   14347 			break
   14348 		}
   14349 		b = x.Block
   14350 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, t)
   14351 		v.reset(OpCopy)
   14352 		v.AddArg(v0)
   14353 		v0.AuxInt = off
   14354 		v0.Aux = sym
   14355 		v0.AddArg(ptr)
   14356 		v0.AddArg(mem)
   14357 		return true
   14358 	}
   14359 	// match: (MOVDreg <t> x:(MOVWload [off] {sym} ptr mem))
   14360 	// cond: x.Uses == 1 && clobber(x)
   14361 	// result: @x.Block (MOVWload  <t> [off] {sym} ptr mem)
   14362 	for {
   14363 		t := v.Type
   14364 		x := v.Args[0]
   14365 		if x.Op != OpS390XMOVWload {
   14366 			break
   14367 		}
   14368 		off := x.AuxInt
   14369 		sym := x.Aux
   14370 		_ = x.Args[1]
   14371 		ptr := x.Args[0]
   14372 		mem := x.Args[1]
   14373 		if !(x.Uses == 1 && clobber(x)) {
   14374 			break
   14375 		}
   14376 		b = x.Block
   14377 		v0 := b.NewValue0(v.Pos, OpS390XMOVWload, t)
   14378 		v.reset(OpCopy)
   14379 		v.AddArg(v0)
   14380 		v0.AuxInt = off
   14381 		v0.Aux = sym
   14382 		v0.AddArg(ptr)
   14383 		v0.AddArg(mem)
   14384 		return true
   14385 	}
   14386 	// match: (MOVDreg <t> x:(MOVDload [off] {sym} ptr mem))
   14387 	// cond: x.Uses == 1 && clobber(x)
   14388 	// result: @x.Block (MOVDload  <t> [off] {sym} ptr mem)
   14389 	for {
   14390 		t := v.Type
   14391 		x := v.Args[0]
   14392 		if x.Op != OpS390XMOVDload {
   14393 			break
   14394 		}
   14395 		off := x.AuxInt
   14396 		sym := x.Aux
   14397 		_ = x.Args[1]
   14398 		ptr := x.Args[0]
   14399 		mem := x.Args[1]
   14400 		if !(x.Uses == 1 && clobber(x)) {
   14401 			break
   14402 		}
   14403 		b = x.Block
   14404 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, t)
   14405 		v.reset(OpCopy)
   14406 		v.AddArg(v0)
   14407 		v0.AuxInt = off
   14408 		v0.Aux = sym
   14409 		v0.AddArg(ptr)
   14410 		v0.AddArg(mem)
   14411 		return true
   14412 	}
   14413 	return false
   14414 }
   14415 func rewriteValueS390X_OpS390XMOVDreg_10(v *Value) bool {
   14416 	b := v.Block
   14417 	_ = b
   14418 	// match: (MOVDreg <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
   14419 	// cond: x.Uses == 1 && clobber(x)
   14420 	// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
   14421 	for {
   14422 		t := v.Type
   14423 		x := v.Args[0]
   14424 		if x.Op != OpS390XMOVBZloadidx {
   14425 			break
   14426 		}
   14427 		off := x.AuxInt
   14428 		sym := x.Aux
   14429 		_ = x.Args[2]
   14430 		ptr := x.Args[0]
   14431 		idx := x.Args[1]
   14432 		mem := x.Args[2]
   14433 		if !(x.Uses == 1 && clobber(x)) {
   14434 			break
   14435 		}
   14436 		b = x.Block
   14437 		v0 := b.NewValue0(v.Pos, OpS390XMOVBZloadidx, t)
   14438 		v.reset(OpCopy)
   14439 		v.AddArg(v0)
   14440 		v0.AuxInt = off
   14441 		v0.Aux = sym
   14442 		v0.AddArg(ptr)
   14443 		v0.AddArg(idx)
   14444 		v0.AddArg(mem)
   14445 		return true
   14446 	}
   14447 	// match: (MOVDreg <t> x:(MOVBloadidx [off] {sym} ptr idx mem))
   14448 	// cond: x.Uses == 1 && clobber(x)
   14449 	// result: @x.Block (MOVBloadidx  <t> [off] {sym} ptr idx mem)
   14450 	for {
   14451 		t := v.Type
   14452 		x := v.Args[0]
   14453 		if x.Op != OpS390XMOVBloadidx {
   14454 			break
   14455 		}
   14456 		off := x.AuxInt
   14457 		sym := x.Aux
   14458 		_ = x.Args[2]
   14459 		ptr := x.Args[0]
   14460 		idx := x.Args[1]
   14461 		mem := x.Args[2]
   14462 		if !(x.Uses == 1 && clobber(x)) {
   14463 			break
   14464 		}
   14465 		b = x.Block
   14466 		v0 := b.NewValue0(v.Pos, OpS390XMOVBloadidx, t)
   14467 		v.reset(OpCopy)
   14468 		v.AddArg(v0)
   14469 		v0.AuxInt = off
   14470 		v0.Aux = sym
   14471 		v0.AddArg(ptr)
   14472 		v0.AddArg(idx)
   14473 		v0.AddArg(mem)
   14474 		return true
   14475 	}
   14476 	// match: (MOVDreg <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
   14477 	// cond: x.Uses == 1 && clobber(x)
   14478 	// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
   14479 	for {
   14480 		t := v.Type
   14481 		x := v.Args[0]
   14482 		if x.Op != OpS390XMOVHZloadidx {
   14483 			break
   14484 		}
   14485 		off := x.AuxInt
   14486 		sym := x.Aux
   14487 		_ = x.Args[2]
   14488 		ptr := x.Args[0]
   14489 		idx := x.Args[1]
   14490 		mem := x.Args[2]
   14491 		if !(x.Uses == 1 && clobber(x)) {
   14492 			break
   14493 		}
   14494 		b = x.Block
   14495 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, t)
   14496 		v.reset(OpCopy)
   14497 		v.AddArg(v0)
   14498 		v0.AuxInt = off
   14499 		v0.Aux = sym
   14500 		v0.AddArg(ptr)
   14501 		v0.AddArg(idx)
   14502 		v0.AddArg(mem)
   14503 		return true
   14504 	}
   14505 	// match: (MOVDreg <t> x:(MOVHloadidx [off] {sym} ptr idx mem))
   14506 	// cond: x.Uses == 1 && clobber(x)
   14507 	// result: @x.Block (MOVHloadidx  <t> [off] {sym} ptr idx mem)
   14508 	for {
   14509 		t := v.Type
   14510 		x := v.Args[0]
   14511 		if x.Op != OpS390XMOVHloadidx {
   14512 			break
   14513 		}
   14514 		off := x.AuxInt
   14515 		sym := x.Aux
   14516 		_ = x.Args[2]
   14517 		ptr := x.Args[0]
   14518 		idx := x.Args[1]
   14519 		mem := x.Args[2]
   14520 		if !(x.Uses == 1 && clobber(x)) {
   14521 			break
   14522 		}
   14523 		b = x.Block
   14524 		v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, t)
   14525 		v.reset(OpCopy)
   14526 		v.AddArg(v0)
   14527 		v0.AuxInt = off
   14528 		v0.Aux = sym
   14529 		v0.AddArg(ptr)
   14530 		v0.AddArg(idx)
   14531 		v0.AddArg(mem)
   14532 		return true
   14533 	}
   14534 	// match: (MOVDreg <t> x:(MOVWZloadidx [off] {sym} ptr idx mem))
   14535 	// cond: x.Uses == 1 && clobber(x)
   14536 	// result: @x.Block (MOVWZloadidx <t> [off] {sym} ptr idx mem)
   14537 	for {
   14538 		t := v.Type
   14539 		x := v.Args[0]
   14540 		if x.Op != OpS390XMOVWZloadidx {
   14541 			break
   14542 		}
   14543 		off := x.AuxInt
   14544 		sym := x.Aux
   14545 		_ = x.Args[2]
   14546 		ptr := x.Args[0]
   14547 		idx := x.Args[1]
   14548 		mem := x.Args[2]
   14549 		if !(x.Uses == 1 && clobber(x)) {
   14550 			break
   14551 		}
   14552 		b = x.Block
   14553 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, t)
   14554 		v.reset(OpCopy)
   14555 		v.AddArg(v0)
   14556 		v0.AuxInt = off
   14557 		v0.Aux = sym
   14558 		v0.AddArg(ptr)
   14559 		v0.AddArg(idx)
   14560 		v0.AddArg(mem)
   14561 		return true
   14562 	}
   14563 	// match: (MOVDreg <t> x:(MOVWloadidx [off] {sym} ptr idx mem))
   14564 	// cond: x.Uses == 1 && clobber(x)
   14565 	// result: @x.Block (MOVWloadidx  <t> [off] {sym} ptr idx mem)
   14566 	for {
   14567 		t := v.Type
   14568 		x := v.Args[0]
   14569 		if x.Op != OpS390XMOVWloadidx {
   14570 			break
   14571 		}
   14572 		off := x.AuxInt
   14573 		sym := x.Aux
   14574 		_ = x.Args[2]
   14575 		ptr := x.Args[0]
   14576 		idx := x.Args[1]
   14577 		mem := x.Args[2]
   14578 		if !(x.Uses == 1 && clobber(x)) {
   14579 			break
   14580 		}
   14581 		b = x.Block
   14582 		v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, t)
   14583 		v.reset(OpCopy)
   14584 		v.AddArg(v0)
   14585 		v0.AuxInt = off
   14586 		v0.Aux = sym
   14587 		v0.AddArg(ptr)
   14588 		v0.AddArg(idx)
   14589 		v0.AddArg(mem)
   14590 		return true
   14591 	}
   14592 	// match: (MOVDreg <t> x:(MOVDloadidx [off] {sym} ptr idx mem))
   14593 	// cond: x.Uses == 1 && clobber(x)
   14594 	// result: @x.Block (MOVDloadidx  <t> [off] {sym} ptr idx mem)
   14595 	for {
   14596 		t := v.Type
   14597 		x := v.Args[0]
   14598 		if x.Op != OpS390XMOVDloadidx {
   14599 			break
   14600 		}
   14601 		off := x.AuxInt
   14602 		sym := x.Aux
   14603 		_ = x.Args[2]
   14604 		ptr := x.Args[0]
   14605 		idx := x.Args[1]
   14606 		mem := x.Args[2]
   14607 		if !(x.Uses == 1 && clobber(x)) {
   14608 			break
   14609 		}
   14610 		b = x.Block
   14611 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, t)
   14612 		v.reset(OpCopy)
   14613 		v.AddArg(v0)
   14614 		v0.AuxInt = off
   14615 		v0.Aux = sym
   14616 		v0.AddArg(ptr)
   14617 		v0.AddArg(idx)
   14618 		v0.AddArg(mem)
   14619 		return true
   14620 	}
   14621 	return false
   14622 }
   14623 func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool {
   14624 	// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
   14625 	// cond: is20Bit(off1+off2)
   14626 	// result: (MOVDstore  [off1+off2] {sym} ptr val mem)
   14627 	for {
   14628 		off1 := v.AuxInt
   14629 		sym := v.Aux
   14630 		_ = v.Args[2]
   14631 		v_0 := v.Args[0]
   14632 		if v_0.Op != OpS390XADDconst {
   14633 			break
   14634 		}
   14635 		off2 := v_0.AuxInt
   14636 		ptr := v_0.Args[0]
   14637 		val := v.Args[1]
   14638 		mem := v.Args[2]
   14639 		if !(is20Bit(off1 + off2)) {
   14640 			break
   14641 		}
   14642 		v.reset(OpS390XMOVDstore)
   14643 		v.AuxInt = off1 + off2
   14644 		v.Aux = sym
   14645 		v.AddArg(ptr)
   14646 		v.AddArg(val)
   14647 		v.AddArg(mem)
   14648 		return true
   14649 	}
   14650 	// match: (MOVDstore [off] {sym} ptr (MOVDconst [c]) mem)
   14651 	// cond: is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB
   14652 	// result: (MOVDstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
   14653 	for {
   14654 		off := v.AuxInt
   14655 		sym := v.Aux
   14656 		_ = v.Args[2]
   14657 		ptr := v.Args[0]
   14658 		v_1 := v.Args[1]
   14659 		if v_1.Op != OpS390XMOVDconst {
   14660 			break
   14661 		}
   14662 		c := v_1.AuxInt
   14663 		mem := v.Args[2]
   14664 		if !(is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB) {
   14665 			break
   14666 		}
   14667 		v.reset(OpS390XMOVDstoreconst)
   14668 		v.AuxInt = makeValAndOff(c, off)
   14669 		v.Aux = sym
   14670 		v.AddArg(ptr)
   14671 		v.AddArg(mem)
   14672 		return true
   14673 	}
   14674 	// match: (MOVDstore [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) val mem)
   14675 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%8 == 0 && (off1+off2)%8 == 0))
   14676 	// result: (MOVDstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   14677 	for {
   14678 		off1 := v.AuxInt
   14679 		sym1 := v.Aux
   14680 		_ = v.Args[2]
   14681 		v_0 := v.Args[0]
   14682 		if v_0.Op != OpS390XMOVDaddr {
   14683 			break
   14684 		}
   14685 		t := v_0.Type
   14686 		off2 := v_0.AuxInt
   14687 		sym2 := v_0.Aux
   14688 		base := v_0.Args[0]
   14689 		val := v.Args[1]
   14690 		mem := v.Args[2]
   14691 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%8 == 0 && (off1+off2)%8 == 0))) {
   14692 			break
   14693 		}
   14694 		v.reset(OpS390XMOVDstore)
   14695 		v.AuxInt = off1 + off2
   14696 		v.Aux = mergeSym(sym1, sym2)
   14697 		v.AddArg(base)
   14698 		v.AddArg(val)
   14699 		v.AddArg(mem)
   14700 		return true
   14701 	}
   14702 	// match: (MOVDstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
   14703 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   14704 	// result: (MOVDstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   14705 	for {
   14706 		off1 := v.AuxInt
   14707 		sym1 := v.Aux
   14708 		_ = v.Args[2]
   14709 		v_0 := v.Args[0]
   14710 		if v_0.Op != OpS390XMOVDaddridx {
   14711 			break
   14712 		}
   14713 		off2 := v_0.AuxInt
   14714 		sym2 := v_0.Aux
   14715 		_ = v_0.Args[1]
   14716 		ptr := v_0.Args[0]
   14717 		idx := v_0.Args[1]
   14718 		val := v.Args[1]
   14719 		mem := v.Args[2]
   14720 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   14721 			break
   14722 		}
   14723 		v.reset(OpS390XMOVDstoreidx)
   14724 		v.AuxInt = off1 + off2
   14725 		v.Aux = mergeSym(sym1, sym2)
   14726 		v.AddArg(ptr)
   14727 		v.AddArg(idx)
   14728 		v.AddArg(val)
   14729 		v.AddArg(mem)
   14730 		return true
   14731 	}
   14732 	// match: (MOVDstore [off] {sym} (ADD ptr idx) val mem)
   14733 	// cond: ptr.Op != OpSB
   14734 	// result: (MOVDstoreidx  [off] {sym} ptr idx val mem)
   14735 	for {
   14736 		off := v.AuxInt
   14737 		sym := v.Aux
   14738 		_ = v.Args[2]
   14739 		v_0 := v.Args[0]
   14740 		if v_0.Op != OpS390XADD {
   14741 			break
   14742 		}
   14743 		_ = v_0.Args[1]
   14744 		ptr := v_0.Args[0]
   14745 		idx := v_0.Args[1]
   14746 		val := v.Args[1]
   14747 		mem := v.Args[2]
   14748 		if !(ptr.Op != OpSB) {
   14749 			break
   14750 		}
   14751 		v.reset(OpS390XMOVDstoreidx)
   14752 		v.AuxInt = off
   14753 		v.Aux = sym
   14754 		v.AddArg(ptr)
   14755 		v.AddArg(idx)
   14756 		v.AddArg(val)
   14757 		v.AddArg(mem)
   14758 		return true
   14759 	}
   14760 	// match: (MOVDstore [i] {s} p w1 x:(MOVDstore [i-8] {s} p w0 mem))
   14761 	// cond: p.Op != OpSB   && x.Uses == 1   && is20Bit(i-8)   && clobber(x)
   14762 	// result: (STMG2 [i-8] {s} p w0 w1 mem)
   14763 	for {
   14764 		i := v.AuxInt
   14765 		s := v.Aux
   14766 		_ = v.Args[2]
   14767 		p := v.Args[0]
   14768 		w1 := v.Args[1]
   14769 		x := v.Args[2]
   14770 		if x.Op != OpS390XMOVDstore {
   14771 			break
   14772 		}
   14773 		if x.AuxInt != i-8 {
   14774 			break
   14775 		}
   14776 		if x.Aux != s {
   14777 			break
   14778 		}
   14779 		_ = x.Args[2]
   14780 		if p != x.Args[0] {
   14781 			break
   14782 		}
   14783 		w0 := x.Args[1]
   14784 		mem := x.Args[2]
   14785 		if !(p.Op != OpSB && x.Uses == 1 && is20Bit(i-8) && clobber(x)) {
   14786 			break
   14787 		}
   14788 		v.reset(OpS390XSTMG2)
   14789 		v.AuxInt = i - 8
   14790 		v.Aux = s
   14791 		v.AddArg(p)
   14792 		v.AddArg(w0)
   14793 		v.AddArg(w1)
   14794 		v.AddArg(mem)
   14795 		return true
   14796 	}
   14797 	// match: (MOVDstore [i] {s} p w2 x:(STMG2 [i-16] {s} p w0 w1 mem))
   14798 	// cond: x.Uses == 1   && is20Bit(i-16)   && clobber(x)
   14799 	// result: (STMG3 [i-16] {s} p w0 w1 w2 mem)
   14800 	for {
   14801 		i := v.AuxInt
   14802 		s := v.Aux
   14803 		_ = v.Args[2]
   14804 		p := v.Args[0]
   14805 		w2 := v.Args[1]
   14806 		x := v.Args[2]
   14807 		if x.Op != OpS390XSTMG2 {
   14808 			break
   14809 		}
   14810 		if x.AuxInt != i-16 {
   14811 			break
   14812 		}
   14813 		if x.Aux != s {
   14814 			break
   14815 		}
   14816 		_ = x.Args[3]
   14817 		if p != x.Args[0] {
   14818 			break
   14819 		}
   14820 		w0 := x.Args[1]
   14821 		w1 := x.Args[2]
   14822 		mem := x.Args[3]
   14823 		if !(x.Uses == 1 && is20Bit(i-16) && clobber(x)) {
   14824 			break
   14825 		}
   14826 		v.reset(OpS390XSTMG3)
   14827 		v.AuxInt = i - 16
   14828 		v.Aux = s
   14829 		v.AddArg(p)
   14830 		v.AddArg(w0)
   14831 		v.AddArg(w1)
   14832 		v.AddArg(w2)
   14833 		v.AddArg(mem)
   14834 		return true
   14835 	}
   14836 	// match: (MOVDstore [i] {s} p w3 x:(STMG3 [i-24] {s} p w0 w1 w2 mem))
   14837 	// cond: x.Uses == 1   && is20Bit(i-24)   && clobber(x)
   14838 	// result: (STMG4 [i-24] {s} p w0 w1 w2 w3 mem)
   14839 	for {
   14840 		i := v.AuxInt
   14841 		s := v.Aux
   14842 		_ = v.Args[2]
   14843 		p := v.Args[0]
   14844 		w3 := v.Args[1]
   14845 		x := v.Args[2]
   14846 		if x.Op != OpS390XSTMG3 {
   14847 			break
   14848 		}
   14849 		if x.AuxInt != i-24 {
   14850 			break
   14851 		}
   14852 		if x.Aux != s {
   14853 			break
   14854 		}
   14855 		_ = x.Args[4]
   14856 		if p != x.Args[0] {
   14857 			break
   14858 		}
   14859 		w0 := x.Args[1]
   14860 		w1 := x.Args[2]
   14861 		w2 := x.Args[3]
   14862 		mem := x.Args[4]
   14863 		if !(x.Uses == 1 && is20Bit(i-24) && clobber(x)) {
   14864 			break
   14865 		}
   14866 		v.reset(OpS390XSTMG4)
   14867 		v.AuxInt = i - 24
   14868 		v.Aux = s
   14869 		v.AddArg(p)
   14870 		v.AddArg(w0)
   14871 		v.AddArg(w1)
   14872 		v.AddArg(w2)
   14873 		v.AddArg(w3)
   14874 		v.AddArg(mem)
   14875 		return true
   14876 	}
   14877 	return false
   14878 }
   14879 func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool {
   14880 	// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
   14881 	// cond: isU12Bit(ValAndOff(sc).Off()+off)
   14882 	// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   14883 	for {
   14884 		sc := v.AuxInt
   14885 		s := v.Aux
   14886 		_ = v.Args[1]
   14887 		v_0 := v.Args[0]
   14888 		if v_0.Op != OpS390XADDconst {
   14889 			break
   14890 		}
   14891 		off := v_0.AuxInt
   14892 		ptr := v_0.Args[0]
   14893 		mem := v.Args[1]
   14894 		if !(isU12Bit(ValAndOff(sc).Off() + off)) {
   14895 			break
   14896 		}
   14897 		v.reset(OpS390XMOVDstoreconst)
   14898 		v.AuxInt = ValAndOff(sc).add(off)
   14899 		v.Aux = s
   14900 		v.AddArg(ptr)
   14901 		v.AddArg(mem)
   14902 		return true
   14903 	}
   14904 	// match: (MOVDstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
   14905 	// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
   14906 	// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   14907 	for {
   14908 		sc := v.AuxInt
   14909 		sym1 := v.Aux
   14910 		_ = v.Args[1]
   14911 		v_0 := v.Args[0]
   14912 		if v_0.Op != OpS390XMOVDaddr {
   14913 			break
   14914 		}
   14915 		off := v_0.AuxInt
   14916 		sym2 := v_0.Aux
   14917 		ptr := v_0.Args[0]
   14918 		mem := v.Args[1]
   14919 		if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
   14920 			break
   14921 		}
   14922 		v.reset(OpS390XMOVDstoreconst)
   14923 		v.AuxInt = ValAndOff(sc).add(off)
   14924 		v.Aux = mergeSym(sym1, sym2)
   14925 		v.AddArg(ptr)
   14926 		v.AddArg(mem)
   14927 		return true
   14928 	}
   14929 	return false
   14930 }
   14931 func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool {
   14932 	// match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
   14933 	// cond: is20Bit(c+d)
   14934 	// result: (MOVDstoreidx  [c+d] {sym} ptr idx val mem)
   14935 	for {
   14936 		c := v.AuxInt
   14937 		sym := v.Aux
   14938 		_ = v.Args[3]
   14939 		v_0 := v.Args[0]
   14940 		if v_0.Op != OpS390XADDconst {
   14941 			break
   14942 		}
   14943 		d := v_0.AuxInt
   14944 		ptr := v_0.Args[0]
   14945 		idx := v.Args[1]
   14946 		val := v.Args[2]
   14947 		mem := v.Args[3]
   14948 		if !(is20Bit(c + d)) {
   14949 			break
   14950 		}
   14951 		v.reset(OpS390XMOVDstoreidx)
   14952 		v.AuxInt = c + d
   14953 		v.Aux = sym
   14954 		v.AddArg(ptr)
   14955 		v.AddArg(idx)
   14956 		v.AddArg(val)
   14957 		v.AddArg(mem)
   14958 		return true
   14959 	}
   14960 	// match: (MOVDstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
   14961 	// cond: is20Bit(c+d)
   14962 	// result: (MOVDstoreidx  [c+d] {sym} ptr idx val mem)
   14963 	for {
   14964 		c := v.AuxInt
   14965 		sym := v.Aux
   14966 		_ = v.Args[3]
   14967 		idx := v.Args[0]
   14968 		v_1 := v.Args[1]
   14969 		if v_1.Op != OpS390XADDconst {
   14970 			break
   14971 		}
   14972 		d := v_1.AuxInt
   14973 		ptr := v_1.Args[0]
   14974 		val := v.Args[2]
   14975 		mem := v.Args[3]
   14976 		if !(is20Bit(c + d)) {
   14977 			break
   14978 		}
   14979 		v.reset(OpS390XMOVDstoreidx)
   14980 		v.AuxInt = c + d
   14981 		v.Aux = sym
   14982 		v.AddArg(ptr)
   14983 		v.AddArg(idx)
   14984 		v.AddArg(val)
   14985 		v.AddArg(mem)
   14986 		return true
   14987 	}
   14988 	// match: (MOVDstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
   14989 	// cond: is20Bit(c+d)
   14990 	// result: (MOVDstoreidx  [c+d] {sym} ptr idx val mem)
   14991 	for {
   14992 		c := v.AuxInt
   14993 		sym := v.Aux
   14994 		_ = v.Args[3]
   14995 		ptr := v.Args[0]
   14996 		v_1 := v.Args[1]
   14997 		if v_1.Op != OpS390XADDconst {
   14998 			break
   14999 		}
   15000 		d := v_1.AuxInt
   15001 		idx := v_1.Args[0]
   15002 		val := v.Args[2]
   15003 		mem := v.Args[3]
   15004 		if !(is20Bit(c + d)) {
   15005 			break
   15006 		}
   15007 		v.reset(OpS390XMOVDstoreidx)
   15008 		v.AuxInt = c + d
   15009 		v.Aux = sym
   15010 		v.AddArg(ptr)
   15011 		v.AddArg(idx)
   15012 		v.AddArg(val)
   15013 		v.AddArg(mem)
   15014 		return true
   15015 	}
   15016 	// match: (MOVDstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
   15017 	// cond: is20Bit(c+d)
   15018 	// result: (MOVDstoreidx  [c+d] {sym} ptr idx val mem)
   15019 	for {
   15020 		c := v.AuxInt
   15021 		sym := v.Aux
   15022 		_ = v.Args[3]
   15023 		v_0 := v.Args[0]
   15024 		if v_0.Op != OpS390XADDconst {
   15025 			break
   15026 		}
   15027 		d := v_0.AuxInt
   15028 		idx := v_0.Args[0]
   15029 		ptr := v.Args[1]
   15030 		val := v.Args[2]
   15031 		mem := v.Args[3]
   15032 		if !(is20Bit(c + d)) {
   15033 			break
   15034 		}
   15035 		v.reset(OpS390XMOVDstoreidx)
   15036 		v.AuxInt = c + d
   15037 		v.Aux = sym
   15038 		v.AddArg(ptr)
   15039 		v.AddArg(idx)
   15040 		v.AddArg(val)
   15041 		v.AddArg(mem)
   15042 		return true
   15043 	}
   15044 	return false
   15045 }
   15046 func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool {
   15047 	// match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
   15048 	// cond: x.Uses == 1   && clobber(x)
   15049 	// result: (MOVWBRstore [i-2] {s} p w mem)
   15050 	for {
   15051 		i := v.AuxInt
   15052 		s := v.Aux
   15053 		_ = v.Args[2]
   15054 		p := v.Args[0]
   15055 		v_1 := v.Args[1]
   15056 		if v_1.Op != OpS390XSRDconst {
   15057 			break
   15058 		}
   15059 		if v_1.AuxInt != 16 {
   15060 			break
   15061 		}
   15062 		w := v_1.Args[0]
   15063 		x := v.Args[2]
   15064 		if x.Op != OpS390XMOVHBRstore {
   15065 			break
   15066 		}
   15067 		if x.AuxInt != i-2 {
   15068 			break
   15069 		}
   15070 		if x.Aux != s {
   15071 			break
   15072 		}
   15073 		_ = x.Args[2]
   15074 		if p != x.Args[0] {
   15075 			break
   15076 		}
   15077 		if w != x.Args[1] {
   15078 			break
   15079 		}
   15080 		mem := x.Args[2]
   15081 		if !(x.Uses == 1 && clobber(x)) {
   15082 			break
   15083 		}
   15084 		v.reset(OpS390XMOVWBRstore)
   15085 		v.AuxInt = i - 2
   15086 		v.Aux = s
   15087 		v.AddArg(p)
   15088 		v.AddArg(w)
   15089 		v.AddArg(mem)
   15090 		return true
   15091 	}
   15092 	// match: (MOVHBRstore [i] {s} p (SRDconst [j] w) x:(MOVHBRstore [i-2] {s} p w0:(SRDconst [j-16] w) mem))
   15093 	// cond: x.Uses == 1   && clobber(x)
   15094 	// result: (MOVWBRstore [i-2] {s} p w0 mem)
   15095 	for {
   15096 		i := v.AuxInt
   15097 		s := v.Aux
   15098 		_ = v.Args[2]
   15099 		p := v.Args[0]
   15100 		v_1 := v.Args[1]
   15101 		if v_1.Op != OpS390XSRDconst {
   15102 			break
   15103 		}
   15104 		j := v_1.AuxInt
   15105 		w := v_1.Args[0]
   15106 		x := v.Args[2]
   15107 		if x.Op != OpS390XMOVHBRstore {
   15108 			break
   15109 		}
   15110 		if x.AuxInt != i-2 {
   15111 			break
   15112 		}
   15113 		if x.Aux != s {
   15114 			break
   15115 		}
   15116 		_ = x.Args[2]
   15117 		if p != x.Args[0] {
   15118 			break
   15119 		}
   15120 		w0 := x.Args[1]
   15121 		if w0.Op != OpS390XSRDconst {
   15122 			break
   15123 		}
   15124 		if w0.AuxInt != j-16 {
   15125 			break
   15126 		}
   15127 		if w != w0.Args[0] {
   15128 			break
   15129 		}
   15130 		mem := x.Args[2]
   15131 		if !(x.Uses == 1 && clobber(x)) {
   15132 			break
   15133 		}
   15134 		v.reset(OpS390XMOVWBRstore)
   15135 		v.AuxInt = i - 2
   15136 		v.Aux = s
   15137 		v.AddArg(p)
   15138 		v.AddArg(w0)
   15139 		v.AddArg(mem)
   15140 		return true
   15141 	}
   15142 	// match: (MOVHBRstore [i] {s} p (SRWconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
   15143 	// cond: x.Uses == 1   && clobber(x)
   15144 	// result: (MOVWBRstore [i-2] {s} p w mem)
   15145 	for {
   15146 		i := v.AuxInt
   15147 		s := v.Aux
   15148 		_ = v.Args[2]
   15149 		p := v.Args[0]
   15150 		v_1 := v.Args[1]
   15151 		if v_1.Op != OpS390XSRWconst {
   15152 			break
   15153 		}
   15154 		if v_1.AuxInt != 16 {
   15155 			break
   15156 		}
   15157 		w := v_1.Args[0]
   15158 		x := v.Args[2]
   15159 		if x.Op != OpS390XMOVHBRstore {
   15160 			break
   15161 		}
   15162 		if x.AuxInt != i-2 {
   15163 			break
   15164 		}
   15165 		if x.Aux != s {
   15166 			break
   15167 		}
   15168 		_ = x.Args[2]
   15169 		if p != x.Args[0] {
   15170 			break
   15171 		}
   15172 		if w != x.Args[1] {
   15173 			break
   15174 		}
   15175 		mem := x.Args[2]
   15176 		if !(x.Uses == 1 && clobber(x)) {
   15177 			break
   15178 		}
   15179 		v.reset(OpS390XMOVWBRstore)
   15180 		v.AuxInt = i - 2
   15181 		v.Aux = s
   15182 		v.AddArg(p)
   15183 		v.AddArg(w)
   15184 		v.AddArg(mem)
   15185 		return true
   15186 	}
   15187 	// match: (MOVHBRstore [i] {s} p (SRWconst [j] w) x:(MOVHBRstore [i-2] {s} p w0:(SRWconst [j-16] w) mem))
   15188 	// cond: x.Uses == 1   && clobber(x)
   15189 	// result: (MOVWBRstore [i-2] {s} p w0 mem)
   15190 	for {
   15191 		i := v.AuxInt
   15192 		s := v.Aux
   15193 		_ = v.Args[2]
   15194 		p := v.Args[0]
   15195 		v_1 := v.Args[1]
   15196 		if v_1.Op != OpS390XSRWconst {
   15197 			break
   15198 		}
   15199 		j := v_1.AuxInt
   15200 		w := v_1.Args[0]
   15201 		x := v.Args[2]
   15202 		if x.Op != OpS390XMOVHBRstore {
   15203 			break
   15204 		}
   15205 		if x.AuxInt != i-2 {
   15206 			break
   15207 		}
   15208 		if x.Aux != s {
   15209 			break
   15210 		}
   15211 		_ = x.Args[2]
   15212 		if p != x.Args[0] {
   15213 			break
   15214 		}
   15215 		w0 := x.Args[1]
   15216 		if w0.Op != OpS390XSRWconst {
   15217 			break
   15218 		}
   15219 		if w0.AuxInt != j-16 {
   15220 			break
   15221 		}
   15222 		if w != w0.Args[0] {
   15223 			break
   15224 		}
   15225 		mem := x.Args[2]
   15226 		if !(x.Uses == 1 && clobber(x)) {
   15227 			break
   15228 		}
   15229 		v.reset(OpS390XMOVWBRstore)
   15230 		v.AuxInt = i - 2
   15231 		v.Aux = s
   15232 		v.AddArg(p)
   15233 		v.AddArg(w0)
   15234 		v.AddArg(mem)
   15235 		return true
   15236 	}
   15237 	return false
   15238 }
   15239 func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool {
   15240 	// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
   15241 	// cond: x.Uses == 1   && clobber(x)
   15242 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15243 	for {
   15244 		i := v.AuxInt
   15245 		s := v.Aux
   15246 		_ = v.Args[3]
   15247 		p := v.Args[0]
   15248 		idx := v.Args[1]
   15249 		v_2 := v.Args[2]
   15250 		if v_2.Op != OpS390XSRDconst {
   15251 			break
   15252 		}
   15253 		if v_2.AuxInt != 16 {
   15254 			break
   15255 		}
   15256 		w := v_2.Args[0]
   15257 		x := v.Args[3]
   15258 		if x.Op != OpS390XMOVHBRstoreidx {
   15259 			break
   15260 		}
   15261 		if x.AuxInt != i-2 {
   15262 			break
   15263 		}
   15264 		if x.Aux != s {
   15265 			break
   15266 		}
   15267 		_ = x.Args[3]
   15268 		if p != x.Args[0] {
   15269 			break
   15270 		}
   15271 		if idx != x.Args[1] {
   15272 			break
   15273 		}
   15274 		if w != x.Args[2] {
   15275 			break
   15276 		}
   15277 		mem := x.Args[3]
   15278 		if !(x.Uses == 1 && clobber(x)) {
   15279 			break
   15280 		}
   15281 		v.reset(OpS390XMOVWBRstoreidx)
   15282 		v.AuxInt = i - 2
   15283 		v.Aux = s
   15284 		v.AddArg(p)
   15285 		v.AddArg(idx)
   15286 		v.AddArg(w)
   15287 		v.AddArg(mem)
   15288 		return true
   15289 	}
   15290 	// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
   15291 	// cond: x.Uses == 1   && clobber(x)
   15292 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15293 	for {
   15294 		i := v.AuxInt
   15295 		s := v.Aux
   15296 		_ = v.Args[3]
   15297 		p := v.Args[0]
   15298 		idx := v.Args[1]
   15299 		v_2 := v.Args[2]
   15300 		if v_2.Op != OpS390XSRDconst {
   15301 			break
   15302 		}
   15303 		if v_2.AuxInt != 16 {
   15304 			break
   15305 		}
   15306 		w := v_2.Args[0]
   15307 		x := v.Args[3]
   15308 		if x.Op != OpS390XMOVHBRstoreidx {
   15309 			break
   15310 		}
   15311 		if x.AuxInt != i-2 {
   15312 			break
   15313 		}
   15314 		if x.Aux != s {
   15315 			break
   15316 		}
   15317 		_ = x.Args[3]
   15318 		if idx != x.Args[0] {
   15319 			break
   15320 		}
   15321 		if p != x.Args[1] {
   15322 			break
   15323 		}
   15324 		if w != x.Args[2] {
   15325 			break
   15326 		}
   15327 		mem := x.Args[3]
   15328 		if !(x.Uses == 1 && clobber(x)) {
   15329 			break
   15330 		}
   15331 		v.reset(OpS390XMOVWBRstoreidx)
   15332 		v.AuxInt = i - 2
   15333 		v.Aux = s
   15334 		v.AddArg(p)
   15335 		v.AddArg(idx)
   15336 		v.AddArg(w)
   15337 		v.AddArg(mem)
   15338 		return true
   15339 	}
   15340 	// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
   15341 	// cond: x.Uses == 1   && clobber(x)
   15342 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15343 	for {
   15344 		i := v.AuxInt
   15345 		s := v.Aux
   15346 		_ = v.Args[3]
   15347 		idx := v.Args[0]
   15348 		p := v.Args[1]
   15349 		v_2 := v.Args[2]
   15350 		if v_2.Op != OpS390XSRDconst {
   15351 			break
   15352 		}
   15353 		if v_2.AuxInt != 16 {
   15354 			break
   15355 		}
   15356 		w := v_2.Args[0]
   15357 		x := v.Args[3]
   15358 		if x.Op != OpS390XMOVHBRstoreidx {
   15359 			break
   15360 		}
   15361 		if x.AuxInt != i-2 {
   15362 			break
   15363 		}
   15364 		if x.Aux != s {
   15365 			break
   15366 		}
   15367 		_ = x.Args[3]
   15368 		if p != x.Args[0] {
   15369 			break
   15370 		}
   15371 		if idx != x.Args[1] {
   15372 			break
   15373 		}
   15374 		if w != x.Args[2] {
   15375 			break
   15376 		}
   15377 		mem := x.Args[3]
   15378 		if !(x.Uses == 1 && clobber(x)) {
   15379 			break
   15380 		}
   15381 		v.reset(OpS390XMOVWBRstoreidx)
   15382 		v.AuxInt = i - 2
   15383 		v.Aux = s
   15384 		v.AddArg(p)
   15385 		v.AddArg(idx)
   15386 		v.AddArg(w)
   15387 		v.AddArg(mem)
   15388 		return true
   15389 	}
   15390 	// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
   15391 	// cond: x.Uses == 1   && clobber(x)
   15392 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15393 	for {
   15394 		i := v.AuxInt
   15395 		s := v.Aux
   15396 		_ = v.Args[3]
   15397 		idx := v.Args[0]
   15398 		p := v.Args[1]
   15399 		v_2 := v.Args[2]
   15400 		if v_2.Op != OpS390XSRDconst {
   15401 			break
   15402 		}
   15403 		if v_2.AuxInt != 16 {
   15404 			break
   15405 		}
   15406 		w := v_2.Args[0]
   15407 		x := v.Args[3]
   15408 		if x.Op != OpS390XMOVHBRstoreidx {
   15409 			break
   15410 		}
   15411 		if x.AuxInt != i-2 {
   15412 			break
   15413 		}
   15414 		if x.Aux != s {
   15415 			break
   15416 		}
   15417 		_ = x.Args[3]
   15418 		if idx != x.Args[0] {
   15419 			break
   15420 		}
   15421 		if p != x.Args[1] {
   15422 			break
   15423 		}
   15424 		if w != x.Args[2] {
   15425 			break
   15426 		}
   15427 		mem := x.Args[3]
   15428 		if !(x.Uses == 1 && clobber(x)) {
   15429 			break
   15430 		}
   15431 		v.reset(OpS390XMOVWBRstoreidx)
   15432 		v.AuxInt = i - 2
   15433 		v.Aux = s
   15434 		v.AddArg(p)
   15435 		v.AddArg(idx)
   15436 		v.AddArg(w)
   15437 		v.AddArg(mem)
   15438 		return true
   15439 	}
   15440 	// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRDconst [j-16] w) mem))
   15441 	// cond: x.Uses == 1   && clobber(x)
   15442 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15443 	for {
   15444 		i := v.AuxInt
   15445 		s := v.Aux
   15446 		_ = v.Args[3]
   15447 		p := v.Args[0]
   15448 		idx := v.Args[1]
   15449 		v_2 := v.Args[2]
   15450 		if v_2.Op != OpS390XSRDconst {
   15451 			break
   15452 		}
   15453 		j := v_2.AuxInt
   15454 		w := v_2.Args[0]
   15455 		x := v.Args[3]
   15456 		if x.Op != OpS390XMOVHBRstoreidx {
   15457 			break
   15458 		}
   15459 		if x.AuxInt != i-2 {
   15460 			break
   15461 		}
   15462 		if x.Aux != s {
   15463 			break
   15464 		}
   15465 		_ = x.Args[3]
   15466 		if p != x.Args[0] {
   15467 			break
   15468 		}
   15469 		if idx != x.Args[1] {
   15470 			break
   15471 		}
   15472 		w0 := x.Args[2]
   15473 		if w0.Op != OpS390XSRDconst {
   15474 			break
   15475 		}
   15476 		if w0.AuxInt != j-16 {
   15477 			break
   15478 		}
   15479 		if w != w0.Args[0] {
   15480 			break
   15481 		}
   15482 		mem := x.Args[3]
   15483 		if !(x.Uses == 1 && clobber(x)) {
   15484 			break
   15485 		}
   15486 		v.reset(OpS390XMOVWBRstoreidx)
   15487 		v.AuxInt = i - 2
   15488 		v.Aux = s
   15489 		v.AddArg(p)
   15490 		v.AddArg(idx)
   15491 		v.AddArg(w0)
   15492 		v.AddArg(mem)
   15493 		return true
   15494 	}
   15495 	// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRDconst [j-16] w) mem))
   15496 	// cond: x.Uses == 1   && clobber(x)
   15497 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15498 	for {
   15499 		i := v.AuxInt
   15500 		s := v.Aux
   15501 		_ = v.Args[3]
   15502 		p := v.Args[0]
   15503 		idx := v.Args[1]
   15504 		v_2 := v.Args[2]
   15505 		if v_2.Op != OpS390XSRDconst {
   15506 			break
   15507 		}
   15508 		j := v_2.AuxInt
   15509 		w := v_2.Args[0]
   15510 		x := v.Args[3]
   15511 		if x.Op != OpS390XMOVHBRstoreidx {
   15512 			break
   15513 		}
   15514 		if x.AuxInt != i-2 {
   15515 			break
   15516 		}
   15517 		if x.Aux != s {
   15518 			break
   15519 		}
   15520 		_ = x.Args[3]
   15521 		if idx != x.Args[0] {
   15522 			break
   15523 		}
   15524 		if p != x.Args[1] {
   15525 			break
   15526 		}
   15527 		w0 := x.Args[2]
   15528 		if w0.Op != OpS390XSRDconst {
   15529 			break
   15530 		}
   15531 		if w0.AuxInt != j-16 {
   15532 			break
   15533 		}
   15534 		if w != w0.Args[0] {
   15535 			break
   15536 		}
   15537 		mem := x.Args[3]
   15538 		if !(x.Uses == 1 && clobber(x)) {
   15539 			break
   15540 		}
   15541 		v.reset(OpS390XMOVWBRstoreidx)
   15542 		v.AuxInt = i - 2
   15543 		v.Aux = s
   15544 		v.AddArg(p)
   15545 		v.AddArg(idx)
   15546 		v.AddArg(w0)
   15547 		v.AddArg(mem)
   15548 		return true
   15549 	}
   15550 	// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRDconst [j-16] w) mem))
   15551 	// cond: x.Uses == 1   && clobber(x)
   15552 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15553 	for {
   15554 		i := v.AuxInt
   15555 		s := v.Aux
   15556 		_ = v.Args[3]
   15557 		idx := v.Args[0]
   15558 		p := v.Args[1]
   15559 		v_2 := v.Args[2]
   15560 		if v_2.Op != OpS390XSRDconst {
   15561 			break
   15562 		}
   15563 		j := v_2.AuxInt
   15564 		w := v_2.Args[0]
   15565 		x := v.Args[3]
   15566 		if x.Op != OpS390XMOVHBRstoreidx {
   15567 			break
   15568 		}
   15569 		if x.AuxInt != i-2 {
   15570 			break
   15571 		}
   15572 		if x.Aux != s {
   15573 			break
   15574 		}
   15575 		_ = x.Args[3]
   15576 		if p != x.Args[0] {
   15577 			break
   15578 		}
   15579 		if idx != x.Args[1] {
   15580 			break
   15581 		}
   15582 		w0 := x.Args[2]
   15583 		if w0.Op != OpS390XSRDconst {
   15584 			break
   15585 		}
   15586 		if w0.AuxInt != j-16 {
   15587 			break
   15588 		}
   15589 		if w != w0.Args[0] {
   15590 			break
   15591 		}
   15592 		mem := x.Args[3]
   15593 		if !(x.Uses == 1 && clobber(x)) {
   15594 			break
   15595 		}
   15596 		v.reset(OpS390XMOVWBRstoreidx)
   15597 		v.AuxInt = i - 2
   15598 		v.Aux = s
   15599 		v.AddArg(p)
   15600 		v.AddArg(idx)
   15601 		v.AddArg(w0)
   15602 		v.AddArg(mem)
   15603 		return true
   15604 	}
   15605 	// match: (MOVHBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRDconst [j-16] w) mem))
   15606 	// cond: x.Uses == 1   && clobber(x)
   15607 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15608 	for {
   15609 		i := v.AuxInt
   15610 		s := v.Aux
   15611 		_ = v.Args[3]
   15612 		idx := v.Args[0]
   15613 		p := v.Args[1]
   15614 		v_2 := v.Args[2]
   15615 		if v_2.Op != OpS390XSRDconst {
   15616 			break
   15617 		}
   15618 		j := v_2.AuxInt
   15619 		w := v_2.Args[0]
   15620 		x := v.Args[3]
   15621 		if x.Op != OpS390XMOVHBRstoreidx {
   15622 			break
   15623 		}
   15624 		if x.AuxInt != i-2 {
   15625 			break
   15626 		}
   15627 		if x.Aux != s {
   15628 			break
   15629 		}
   15630 		_ = x.Args[3]
   15631 		if idx != x.Args[0] {
   15632 			break
   15633 		}
   15634 		if p != x.Args[1] {
   15635 			break
   15636 		}
   15637 		w0 := x.Args[2]
   15638 		if w0.Op != OpS390XSRDconst {
   15639 			break
   15640 		}
   15641 		if w0.AuxInt != j-16 {
   15642 			break
   15643 		}
   15644 		if w != w0.Args[0] {
   15645 			break
   15646 		}
   15647 		mem := x.Args[3]
   15648 		if !(x.Uses == 1 && clobber(x)) {
   15649 			break
   15650 		}
   15651 		v.reset(OpS390XMOVWBRstoreidx)
   15652 		v.AuxInt = i - 2
   15653 		v.Aux = s
   15654 		v.AddArg(p)
   15655 		v.AddArg(idx)
   15656 		v.AddArg(w0)
   15657 		v.AddArg(mem)
   15658 		return true
   15659 	}
   15660 	// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
   15661 	// cond: x.Uses == 1   && clobber(x)
   15662 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15663 	for {
   15664 		i := v.AuxInt
   15665 		s := v.Aux
   15666 		_ = v.Args[3]
   15667 		p := v.Args[0]
   15668 		idx := v.Args[1]
   15669 		v_2 := v.Args[2]
   15670 		if v_2.Op != OpS390XSRWconst {
   15671 			break
   15672 		}
   15673 		if v_2.AuxInt != 16 {
   15674 			break
   15675 		}
   15676 		w := v_2.Args[0]
   15677 		x := v.Args[3]
   15678 		if x.Op != OpS390XMOVHBRstoreidx {
   15679 			break
   15680 		}
   15681 		if x.AuxInt != i-2 {
   15682 			break
   15683 		}
   15684 		if x.Aux != s {
   15685 			break
   15686 		}
   15687 		_ = x.Args[3]
   15688 		if p != x.Args[0] {
   15689 			break
   15690 		}
   15691 		if idx != x.Args[1] {
   15692 			break
   15693 		}
   15694 		if w != x.Args[2] {
   15695 			break
   15696 		}
   15697 		mem := x.Args[3]
   15698 		if !(x.Uses == 1 && clobber(x)) {
   15699 			break
   15700 		}
   15701 		v.reset(OpS390XMOVWBRstoreidx)
   15702 		v.AuxInt = i - 2
   15703 		v.Aux = s
   15704 		v.AddArg(p)
   15705 		v.AddArg(idx)
   15706 		v.AddArg(w)
   15707 		v.AddArg(mem)
   15708 		return true
   15709 	}
   15710 	// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
   15711 	// cond: x.Uses == 1   && clobber(x)
   15712 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15713 	for {
   15714 		i := v.AuxInt
   15715 		s := v.Aux
   15716 		_ = v.Args[3]
   15717 		p := v.Args[0]
   15718 		idx := v.Args[1]
   15719 		v_2 := v.Args[2]
   15720 		if v_2.Op != OpS390XSRWconst {
   15721 			break
   15722 		}
   15723 		if v_2.AuxInt != 16 {
   15724 			break
   15725 		}
   15726 		w := v_2.Args[0]
   15727 		x := v.Args[3]
   15728 		if x.Op != OpS390XMOVHBRstoreidx {
   15729 			break
   15730 		}
   15731 		if x.AuxInt != i-2 {
   15732 			break
   15733 		}
   15734 		if x.Aux != s {
   15735 			break
   15736 		}
   15737 		_ = x.Args[3]
   15738 		if idx != x.Args[0] {
   15739 			break
   15740 		}
   15741 		if p != x.Args[1] {
   15742 			break
   15743 		}
   15744 		if w != x.Args[2] {
   15745 			break
   15746 		}
   15747 		mem := x.Args[3]
   15748 		if !(x.Uses == 1 && clobber(x)) {
   15749 			break
   15750 		}
   15751 		v.reset(OpS390XMOVWBRstoreidx)
   15752 		v.AuxInt = i - 2
   15753 		v.Aux = s
   15754 		v.AddArg(p)
   15755 		v.AddArg(idx)
   15756 		v.AddArg(w)
   15757 		v.AddArg(mem)
   15758 		return true
   15759 	}
   15760 	return false
   15761 }
   15762 func rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v *Value) bool {
   15763 	// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
   15764 	// cond: x.Uses == 1   && clobber(x)
   15765 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15766 	for {
   15767 		i := v.AuxInt
   15768 		s := v.Aux
   15769 		_ = v.Args[3]
   15770 		idx := v.Args[0]
   15771 		p := v.Args[1]
   15772 		v_2 := v.Args[2]
   15773 		if v_2.Op != OpS390XSRWconst {
   15774 			break
   15775 		}
   15776 		if v_2.AuxInt != 16 {
   15777 			break
   15778 		}
   15779 		w := v_2.Args[0]
   15780 		x := v.Args[3]
   15781 		if x.Op != OpS390XMOVHBRstoreidx {
   15782 			break
   15783 		}
   15784 		if x.AuxInt != i-2 {
   15785 			break
   15786 		}
   15787 		if x.Aux != s {
   15788 			break
   15789 		}
   15790 		_ = x.Args[3]
   15791 		if p != x.Args[0] {
   15792 			break
   15793 		}
   15794 		if idx != x.Args[1] {
   15795 			break
   15796 		}
   15797 		if w != x.Args[2] {
   15798 			break
   15799 		}
   15800 		mem := x.Args[3]
   15801 		if !(x.Uses == 1 && clobber(x)) {
   15802 			break
   15803 		}
   15804 		v.reset(OpS390XMOVWBRstoreidx)
   15805 		v.AuxInt = i - 2
   15806 		v.Aux = s
   15807 		v.AddArg(p)
   15808 		v.AddArg(idx)
   15809 		v.AddArg(w)
   15810 		v.AddArg(mem)
   15811 		return true
   15812 	}
   15813 	// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} idx p w mem))
   15814 	// cond: x.Uses == 1   && clobber(x)
   15815 	// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
   15816 	for {
   15817 		i := v.AuxInt
   15818 		s := v.Aux
   15819 		_ = v.Args[3]
   15820 		idx := v.Args[0]
   15821 		p := v.Args[1]
   15822 		v_2 := v.Args[2]
   15823 		if v_2.Op != OpS390XSRWconst {
   15824 			break
   15825 		}
   15826 		if v_2.AuxInt != 16 {
   15827 			break
   15828 		}
   15829 		w := v_2.Args[0]
   15830 		x := v.Args[3]
   15831 		if x.Op != OpS390XMOVHBRstoreidx {
   15832 			break
   15833 		}
   15834 		if x.AuxInt != i-2 {
   15835 			break
   15836 		}
   15837 		if x.Aux != s {
   15838 			break
   15839 		}
   15840 		_ = x.Args[3]
   15841 		if idx != x.Args[0] {
   15842 			break
   15843 		}
   15844 		if p != x.Args[1] {
   15845 			break
   15846 		}
   15847 		if w != x.Args[2] {
   15848 			break
   15849 		}
   15850 		mem := x.Args[3]
   15851 		if !(x.Uses == 1 && clobber(x)) {
   15852 			break
   15853 		}
   15854 		v.reset(OpS390XMOVWBRstoreidx)
   15855 		v.AuxInt = i - 2
   15856 		v.Aux = s
   15857 		v.AddArg(p)
   15858 		v.AddArg(idx)
   15859 		v.AddArg(w)
   15860 		v.AddArg(mem)
   15861 		return true
   15862 	}
   15863 	// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRWconst [j-16] w) mem))
   15864 	// cond: x.Uses == 1   && clobber(x)
   15865 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15866 	for {
   15867 		i := v.AuxInt
   15868 		s := v.Aux
   15869 		_ = v.Args[3]
   15870 		p := v.Args[0]
   15871 		idx := v.Args[1]
   15872 		v_2 := v.Args[2]
   15873 		if v_2.Op != OpS390XSRWconst {
   15874 			break
   15875 		}
   15876 		j := v_2.AuxInt
   15877 		w := v_2.Args[0]
   15878 		x := v.Args[3]
   15879 		if x.Op != OpS390XMOVHBRstoreidx {
   15880 			break
   15881 		}
   15882 		if x.AuxInt != i-2 {
   15883 			break
   15884 		}
   15885 		if x.Aux != s {
   15886 			break
   15887 		}
   15888 		_ = x.Args[3]
   15889 		if p != x.Args[0] {
   15890 			break
   15891 		}
   15892 		if idx != x.Args[1] {
   15893 			break
   15894 		}
   15895 		w0 := x.Args[2]
   15896 		if w0.Op != OpS390XSRWconst {
   15897 			break
   15898 		}
   15899 		if w0.AuxInt != j-16 {
   15900 			break
   15901 		}
   15902 		if w != w0.Args[0] {
   15903 			break
   15904 		}
   15905 		mem := x.Args[3]
   15906 		if !(x.Uses == 1 && clobber(x)) {
   15907 			break
   15908 		}
   15909 		v.reset(OpS390XMOVWBRstoreidx)
   15910 		v.AuxInt = i - 2
   15911 		v.Aux = s
   15912 		v.AddArg(p)
   15913 		v.AddArg(idx)
   15914 		v.AddArg(w0)
   15915 		v.AddArg(mem)
   15916 		return true
   15917 	}
   15918 	// match: (MOVHBRstoreidx [i] {s} p idx (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRWconst [j-16] w) mem))
   15919 	// cond: x.Uses == 1   && clobber(x)
   15920 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15921 	for {
   15922 		i := v.AuxInt
   15923 		s := v.Aux
   15924 		_ = v.Args[3]
   15925 		p := v.Args[0]
   15926 		idx := v.Args[1]
   15927 		v_2 := v.Args[2]
   15928 		if v_2.Op != OpS390XSRWconst {
   15929 			break
   15930 		}
   15931 		j := v_2.AuxInt
   15932 		w := v_2.Args[0]
   15933 		x := v.Args[3]
   15934 		if x.Op != OpS390XMOVHBRstoreidx {
   15935 			break
   15936 		}
   15937 		if x.AuxInt != i-2 {
   15938 			break
   15939 		}
   15940 		if x.Aux != s {
   15941 			break
   15942 		}
   15943 		_ = x.Args[3]
   15944 		if idx != x.Args[0] {
   15945 			break
   15946 		}
   15947 		if p != x.Args[1] {
   15948 			break
   15949 		}
   15950 		w0 := x.Args[2]
   15951 		if w0.Op != OpS390XSRWconst {
   15952 			break
   15953 		}
   15954 		if w0.AuxInt != j-16 {
   15955 			break
   15956 		}
   15957 		if w != w0.Args[0] {
   15958 			break
   15959 		}
   15960 		mem := x.Args[3]
   15961 		if !(x.Uses == 1 && clobber(x)) {
   15962 			break
   15963 		}
   15964 		v.reset(OpS390XMOVWBRstoreidx)
   15965 		v.AuxInt = i - 2
   15966 		v.Aux = s
   15967 		v.AddArg(p)
   15968 		v.AddArg(idx)
   15969 		v.AddArg(w0)
   15970 		v.AddArg(mem)
   15971 		return true
   15972 	}
   15973 	// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} p idx w0:(SRWconst [j-16] w) mem))
   15974 	// cond: x.Uses == 1   && clobber(x)
   15975 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   15976 	for {
   15977 		i := v.AuxInt
   15978 		s := v.Aux
   15979 		_ = v.Args[3]
   15980 		idx := v.Args[0]
   15981 		p := v.Args[1]
   15982 		v_2 := v.Args[2]
   15983 		if v_2.Op != OpS390XSRWconst {
   15984 			break
   15985 		}
   15986 		j := v_2.AuxInt
   15987 		w := v_2.Args[0]
   15988 		x := v.Args[3]
   15989 		if x.Op != OpS390XMOVHBRstoreidx {
   15990 			break
   15991 		}
   15992 		if x.AuxInt != i-2 {
   15993 			break
   15994 		}
   15995 		if x.Aux != s {
   15996 			break
   15997 		}
   15998 		_ = x.Args[3]
   15999 		if p != x.Args[0] {
   16000 			break
   16001 		}
   16002 		if idx != x.Args[1] {
   16003 			break
   16004 		}
   16005 		w0 := x.Args[2]
   16006 		if w0.Op != OpS390XSRWconst {
   16007 			break
   16008 		}
   16009 		if w0.AuxInt != j-16 {
   16010 			break
   16011 		}
   16012 		if w != w0.Args[0] {
   16013 			break
   16014 		}
   16015 		mem := x.Args[3]
   16016 		if !(x.Uses == 1 && clobber(x)) {
   16017 			break
   16018 		}
   16019 		v.reset(OpS390XMOVWBRstoreidx)
   16020 		v.AuxInt = i - 2
   16021 		v.Aux = s
   16022 		v.AddArg(p)
   16023 		v.AddArg(idx)
   16024 		v.AddArg(w0)
   16025 		v.AddArg(mem)
   16026 		return true
   16027 	}
   16028 	// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [j] w) x:(MOVHBRstoreidx [i-2] {s} idx p w0:(SRWconst [j-16] w) mem))
   16029 	// cond: x.Uses == 1   && clobber(x)
   16030 	// result: (MOVWBRstoreidx [i-2] {s} p idx w0 mem)
   16031 	for {
   16032 		i := v.AuxInt
   16033 		s := v.Aux
   16034 		_ = v.Args[3]
   16035 		idx := v.Args[0]
   16036 		p := v.Args[1]
   16037 		v_2 := v.Args[2]
   16038 		if v_2.Op != OpS390XSRWconst {
   16039 			break
   16040 		}
   16041 		j := v_2.AuxInt
   16042 		w := v_2.Args[0]
   16043 		x := v.Args[3]
   16044 		if x.Op != OpS390XMOVHBRstoreidx {
   16045 			break
   16046 		}
   16047 		if x.AuxInt != i-2 {
   16048 			break
   16049 		}
   16050 		if x.Aux != s {
   16051 			break
   16052 		}
   16053 		_ = x.Args[3]
   16054 		if idx != x.Args[0] {
   16055 			break
   16056 		}
   16057 		if p != x.Args[1] {
   16058 			break
   16059 		}
   16060 		w0 := x.Args[2]
   16061 		if w0.Op != OpS390XSRWconst {
   16062 			break
   16063 		}
   16064 		if w0.AuxInt != j-16 {
   16065 			break
   16066 		}
   16067 		if w != w0.Args[0] {
   16068 			break
   16069 		}
   16070 		mem := x.Args[3]
   16071 		if !(x.Uses == 1 && clobber(x)) {
   16072 			break
   16073 		}
   16074 		v.reset(OpS390XMOVWBRstoreidx)
   16075 		v.AuxInt = i - 2
   16076 		v.Aux = s
   16077 		v.AddArg(p)
   16078 		v.AddArg(idx)
   16079 		v.AddArg(w0)
   16080 		v.AddArg(mem)
   16081 		return true
   16082 	}
   16083 	return false
   16084 }
   16085 func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool {
   16086 	// match: (MOVHZload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
   16087 	// cond: isSamePtr(ptr1, ptr2)
   16088 	// result: (MOVHZreg x)
   16089 	for {
   16090 		off := v.AuxInt
   16091 		sym := v.Aux
   16092 		_ = v.Args[1]
   16093 		ptr1 := v.Args[0]
   16094 		v_1 := v.Args[1]
   16095 		if v_1.Op != OpS390XMOVHstore {
   16096 			break
   16097 		}
   16098 		if v_1.AuxInt != off {
   16099 			break
   16100 		}
   16101 		if v_1.Aux != sym {
   16102 			break
   16103 		}
   16104 		_ = v_1.Args[2]
   16105 		ptr2 := v_1.Args[0]
   16106 		x := v_1.Args[1]
   16107 		if !(isSamePtr(ptr1, ptr2)) {
   16108 			break
   16109 		}
   16110 		v.reset(OpS390XMOVHZreg)
   16111 		v.AddArg(x)
   16112 		return true
   16113 	}
   16114 	// match: (MOVHZload [off1] {sym} (ADDconst [off2] ptr) mem)
   16115 	// cond: is20Bit(off1+off2)
   16116 	// result: (MOVHZload [off1+off2] {sym} ptr mem)
   16117 	for {
   16118 		off1 := v.AuxInt
   16119 		sym := v.Aux
   16120 		_ = v.Args[1]
   16121 		v_0 := v.Args[0]
   16122 		if v_0.Op != OpS390XADDconst {
   16123 			break
   16124 		}
   16125 		off2 := v_0.AuxInt
   16126 		ptr := v_0.Args[0]
   16127 		mem := v.Args[1]
   16128 		if !(is20Bit(off1 + off2)) {
   16129 			break
   16130 		}
   16131 		v.reset(OpS390XMOVHZload)
   16132 		v.AuxInt = off1 + off2
   16133 		v.Aux = sym
   16134 		v.AddArg(ptr)
   16135 		v.AddArg(mem)
   16136 		return true
   16137 	}
   16138 	// match: (MOVHZload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
   16139 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%2 == 0 && (off1+off2)%2 == 0))
   16140 	// result: (MOVHZload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   16141 	for {
   16142 		off1 := v.AuxInt
   16143 		sym1 := v.Aux
   16144 		_ = v.Args[1]
   16145 		v_0 := v.Args[0]
   16146 		if v_0.Op != OpS390XMOVDaddr {
   16147 			break
   16148 		}
   16149 		t := v_0.Type
   16150 		off2 := v_0.AuxInt
   16151 		sym2 := v_0.Aux
   16152 		base := v_0.Args[0]
   16153 		mem := v.Args[1]
   16154 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%2 == 0 && (off1+off2)%2 == 0))) {
   16155 			break
   16156 		}
   16157 		v.reset(OpS390XMOVHZload)
   16158 		v.AuxInt = off1 + off2
   16159 		v.Aux = mergeSym(sym1, sym2)
   16160 		v.AddArg(base)
   16161 		v.AddArg(mem)
   16162 		return true
   16163 	}
   16164 	// match: (MOVHZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   16165 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   16166 	// result: (MOVHZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   16167 	for {
   16168 		off1 := v.AuxInt
   16169 		sym1 := v.Aux
   16170 		_ = v.Args[1]
   16171 		v_0 := v.Args[0]
   16172 		if v_0.Op != OpS390XMOVDaddridx {
   16173 			break
   16174 		}
   16175 		off2 := v_0.AuxInt
   16176 		sym2 := v_0.Aux
   16177 		_ = v_0.Args[1]
   16178 		ptr := v_0.Args[0]
   16179 		idx := v_0.Args[1]
   16180 		mem := v.Args[1]
   16181 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   16182 			break
   16183 		}
   16184 		v.reset(OpS390XMOVHZloadidx)
   16185 		v.AuxInt = off1 + off2
   16186 		v.Aux = mergeSym(sym1, sym2)
   16187 		v.AddArg(ptr)
   16188 		v.AddArg(idx)
   16189 		v.AddArg(mem)
   16190 		return true
   16191 	}
   16192 	// match: (MOVHZload [off] {sym} (ADD ptr idx) mem)
   16193 	// cond: ptr.Op != OpSB
   16194 	// result: (MOVHZloadidx [off] {sym} ptr idx mem)
   16195 	for {
   16196 		off := v.AuxInt
   16197 		sym := v.Aux
   16198 		_ = v.Args[1]
   16199 		v_0 := v.Args[0]
   16200 		if v_0.Op != OpS390XADD {
   16201 			break
   16202 		}
   16203 		_ = v_0.Args[1]
   16204 		ptr := v_0.Args[0]
   16205 		idx := v_0.Args[1]
   16206 		mem := v.Args[1]
   16207 		if !(ptr.Op != OpSB) {
   16208 			break
   16209 		}
   16210 		v.reset(OpS390XMOVHZloadidx)
   16211 		v.AuxInt = off
   16212 		v.Aux = sym
   16213 		v.AddArg(ptr)
   16214 		v.AddArg(idx)
   16215 		v.AddArg(mem)
   16216 		return true
   16217 	}
   16218 	return false
   16219 }
   16220 func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool {
   16221 	// match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   16222 	// cond: is20Bit(c+d)
   16223 	// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
   16224 	for {
   16225 		c := v.AuxInt
   16226 		sym := v.Aux
   16227 		_ = v.Args[2]
   16228 		v_0 := v.Args[0]
   16229 		if v_0.Op != OpS390XADDconst {
   16230 			break
   16231 		}
   16232 		d := v_0.AuxInt
   16233 		ptr := v_0.Args[0]
   16234 		idx := v.Args[1]
   16235 		mem := v.Args[2]
   16236 		if !(is20Bit(c + d)) {
   16237 			break
   16238 		}
   16239 		v.reset(OpS390XMOVHZloadidx)
   16240 		v.AuxInt = c + d
   16241 		v.Aux = sym
   16242 		v.AddArg(ptr)
   16243 		v.AddArg(idx)
   16244 		v.AddArg(mem)
   16245 		return true
   16246 	}
   16247 	// match: (MOVHZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   16248 	// cond: is20Bit(c+d)
   16249 	// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
   16250 	for {
   16251 		c := v.AuxInt
   16252 		sym := v.Aux
   16253 		_ = v.Args[2]
   16254 		idx := v.Args[0]
   16255 		v_1 := v.Args[1]
   16256 		if v_1.Op != OpS390XADDconst {
   16257 			break
   16258 		}
   16259 		d := v_1.AuxInt
   16260 		ptr := v_1.Args[0]
   16261 		mem := v.Args[2]
   16262 		if !(is20Bit(c + d)) {
   16263 			break
   16264 		}
   16265 		v.reset(OpS390XMOVHZloadidx)
   16266 		v.AuxInt = c + d
   16267 		v.Aux = sym
   16268 		v.AddArg(ptr)
   16269 		v.AddArg(idx)
   16270 		v.AddArg(mem)
   16271 		return true
   16272 	}
   16273 	// match: (MOVHZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   16274 	// cond: is20Bit(c+d)
   16275 	// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
   16276 	for {
   16277 		c := v.AuxInt
   16278 		sym := v.Aux
   16279 		_ = v.Args[2]
   16280 		ptr := v.Args[0]
   16281 		v_1 := v.Args[1]
   16282 		if v_1.Op != OpS390XADDconst {
   16283 			break
   16284 		}
   16285 		d := v_1.AuxInt
   16286 		idx := v_1.Args[0]
   16287 		mem := v.Args[2]
   16288 		if !(is20Bit(c + d)) {
   16289 			break
   16290 		}
   16291 		v.reset(OpS390XMOVHZloadidx)
   16292 		v.AuxInt = c + d
   16293 		v.Aux = sym
   16294 		v.AddArg(ptr)
   16295 		v.AddArg(idx)
   16296 		v.AddArg(mem)
   16297 		return true
   16298 	}
   16299 	// match: (MOVHZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   16300 	// cond: is20Bit(c+d)
   16301 	// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
   16302 	for {
   16303 		c := v.AuxInt
   16304 		sym := v.Aux
   16305 		_ = v.Args[2]
   16306 		v_0 := v.Args[0]
   16307 		if v_0.Op != OpS390XADDconst {
   16308 			break
   16309 		}
   16310 		d := v_0.AuxInt
   16311 		idx := v_0.Args[0]
   16312 		ptr := v.Args[1]
   16313 		mem := v.Args[2]
   16314 		if !(is20Bit(c + d)) {
   16315 			break
   16316 		}
   16317 		v.reset(OpS390XMOVHZloadidx)
   16318 		v.AuxInt = c + d
   16319 		v.Aux = sym
   16320 		v.AddArg(ptr)
   16321 		v.AddArg(idx)
   16322 		v.AddArg(mem)
   16323 		return true
   16324 	}
   16325 	return false
   16326 }
   16327 func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool {
   16328 	b := v.Block
   16329 	_ = b
   16330 	// match: (MOVHZreg x:(MOVBZload _ _))
   16331 	// cond:
   16332 	// result: (MOVDreg x)
   16333 	for {
   16334 		x := v.Args[0]
   16335 		if x.Op != OpS390XMOVBZload {
   16336 			break
   16337 		}
   16338 		_ = x.Args[1]
   16339 		v.reset(OpS390XMOVDreg)
   16340 		v.AddArg(x)
   16341 		return true
   16342 	}
   16343 	// match: (MOVHZreg x:(MOVHZload _ _))
   16344 	// cond:
   16345 	// result: (MOVDreg x)
   16346 	for {
   16347 		x := v.Args[0]
   16348 		if x.Op != OpS390XMOVHZload {
   16349 			break
   16350 		}
   16351 		_ = x.Args[1]
   16352 		v.reset(OpS390XMOVDreg)
   16353 		v.AddArg(x)
   16354 		return true
   16355 	}
   16356 	// match: (MOVHZreg x:(Arg <t>))
   16357 	// cond: (is8BitInt(t) || is16BitInt(t)) && !isSigned(t)
   16358 	// result: (MOVDreg x)
   16359 	for {
   16360 		x := v.Args[0]
   16361 		if x.Op != OpArg {
   16362 			break
   16363 		}
   16364 		t := x.Type
   16365 		if !((is8BitInt(t) || is16BitInt(t)) && !isSigned(t)) {
   16366 			break
   16367 		}
   16368 		v.reset(OpS390XMOVDreg)
   16369 		v.AddArg(x)
   16370 		return true
   16371 	}
   16372 	// match: (MOVHZreg x:(MOVBZreg _))
   16373 	// cond:
   16374 	// result: (MOVDreg x)
   16375 	for {
   16376 		x := v.Args[0]
   16377 		if x.Op != OpS390XMOVBZreg {
   16378 			break
   16379 		}
   16380 		v.reset(OpS390XMOVDreg)
   16381 		v.AddArg(x)
   16382 		return true
   16383 	}
   16384 	// match: (MOVHZreg x:(MOVHZreg _))
   16385 	// cond:
   16386 	// result: (MOVDreg x)
   16387 	for {
   16388 		x := v.Args[0]
   16389 		if x.Op != OpS390XMOVHZreg {
   16390 			break
   16391 		}
   16392 		v.reset(OpS390XMOVDreg)
   16393 		v.AddArg(x)
   16394 		return true
   16395 	}
   16396 	// match: (MOVHZreg (MOVDconst [c]))
   16397 	// cond:
   16398 	// result: (MOVDconst [int64(uint16(c))])
   16399 	for {
   16400 		v_0 := v.Args[0]
   16401 		if v_0.Op != OpS390XMOVDconst {
   16402 			break
   16403 		}
   16404 		c := v_0.AuxInt
   16405 		v.reset(OpS390XMOVDconst)
   16406 		v.AuxInt = int64(uint16(c))
   16407 		return true
   16408 	}
   16409 	// match: (MOVHZreg x:(MOVHZload [off] {sym} ptr mem))
   16410 	// cond: x.Uses == 1 && clobber(x)
   16411 	// result: @x.Block (MOVHZload <v.Type> [off] {sym} ptr mem)
   16412 	for {
   16413 		x := v.Args[0]
   16414 		if x.Op != OpS390XMOVHZload {
   16415 			break
   16416 		}
   16417 		off := x.AuxInt
   16418 		sym := x.Aux
   16419 		_ = x.Args[1]
   16420 		ptr := x.Args[0]
   16421 		mem := x.Args[1]
   16422 		if !(x.Uses == 1 && clobber(x)) {
   16423 			break
   16424 		}
   16425 		b = x.Block
   16426 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, v.Type)
   16427 		v.reset(OpCopy)
   16428 		v.AddArg(v0)
   16429 		v0.AuxInt = off
   16430 		v0.Aux = sym
   16431 		v0.AddArg(ptr)
   16432 		v0.AddArg(mem)
   16433 		return true
   16434 	}
   16435 	// match: (MOVHZreg x:(MOVHload [off] {sym} ptr mem))
   16436 	// cond: x.Uses == 1 && clobber(x)
   16437 	// result: @x.Block (MOVHZload <v.Type> [off] {sym} ptr mem)
   16438 	for {
   16439 		x := v.Args[0]
   16440 		if x.Op != OpS390XMOVHload {
   16441 			break
   16442 		}
   16443 		off := x.AuxInt
   16444 		sym := x.Aux
   16445 		_ = x.Args[1]
   16446 		ptr := x.Args[0]
   16447 		mem := x.Args[1]
   16448 		if !(x.Uses == 1 && clobber(x)) {
   16449 			break
   16450 		}
   16451 		b = x.Block
   16452 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, v.Type)
   16453 		v.reset(OpCopy)
   16454 		v.AddArg(v0)
   16455 		v0.AuxInt = off
   16456 		v0.Aux = sym
   16457 		v0.AddArg(ptr)
   16458 		v0.AddArg(mem)
   16459 		return true
   16460 	}
   16461 	// match: (MOVHZreg x:(MOVHZloadidx [off] {sym} ptr idx mem))
   16462 	// cond: x.Uses == 1 && clobber(x)
   16463 	// result: @x.Block (MOVHZloadidx <v.Type> [off] {sym} ptr idx mem)
   16464 	for {
   16465 		x := v.Args[0]
   16466 		if x.Op != OpS390XMOVHZloadidx {
   16467 			break
   16468 		}
   16469 		off := x.AuxInt
   16470 		sym := x.Aux
   16471 		_ = x.Args[2]
   16472 		ptr := x.Args[0]
   16473 		idx := x.Args[1]
   16474 		mem := x.Args[2]
   16475 		if !(x.Uses == 1 && clobber(x)) {
   16476 			break
   16477 		}
   16478 		b = x.Block
   16479 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, v.Type)
   16480 		v.reset(OpCopy)
   16481 		v.AddArg(v0)
   16482 		v0.AuxInt = off
   16483 		v0.Aux = sym
   16484 		v0.AddArg(ptr)
   16485 		v0.AddArg(idx)
   16486 		v0.AddArg(mem)
   16487 		return true
   16488 	}
   16489 	// match: (MOVHZreg x:(MOVHloadidx [off] {sym} ptr idx mem))
   16490 	// cond: x.Uses == 1 && clobber(x)
   16491 	// result: @x.Block (MOVHZloadidx <v.Type> [off] {sym} ptr idx mem)
   16492 	for {
   16493 		x := v.Args[0]
   16494 		if x.Op != OpS390XMOVHloadidx {
   16495 			break
   16496 		}
   16497 		off := x.AuxInt
   16498 		sym := x.Aux
   16499 		_ = x.Args[2]
   16500 		ptr := x.Args[0]
   16501 		idx := x.Args[1]
   16502 		mem := x.Args[2]
   16503 		if !(x.Uses == 1 && clobber(x)) {
   16504 			break
   16505 		}
   16506 		b = x.Block
   16507 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, v.Type)
   16508 		v.reset(OpCopy)
   16509 		v.AddArg(v0)
   16510 		v0.AuxInt = off
   16511 		v0.Aux = sym
   16512 		v0.AddArg(ptr)
   16513 		v0.AddArg(idx)
   16514 		v0.AddArg(mem)
   16515 		return true
   16516 	}
   16517 	return false
   16518 }
   16519 func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool {
   16520 	// match: (MOVHload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
   16521 	// cond: isSamePtr(ptr1, ptr2)
   16522 	// result: (MOVHreg x)
   16523 	for {
   16524 		off := v.AuxInt
   16525 		sym := v.Aux
   16526 		_ = v.Args[1]
   16527 		ptr1 := v.Args[0]
   16528 		v_1 := v.Args[1]
   16529 		if v_1.Op != OpS390XMOVHstore {
   16530 			break
   16531 		}
   16532 		if v_1.AuxInt != off {
   16533 			break
   16534 		}
   16535 		if v_1.Aux != sym {
   16536 			break
   16537 		}
   16538 		_ = v_1.Args[2]
   16539 		ptr2 := v_1.Args[0]
   16540 		x := v_1.Args[1]
   16541 		if !(isSamePtr(ptr1, ptr2)) {
   16542 			break
   16543 		}
   16544 		v.reset(OpS390XMOVHreg)
   16545 		v.AddArg(x)
   16546 		return true
   16547 	}
   16548 	// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
   16549 	// cond: is20Bit(off1+off2)
   16550 	// result: (MOVHload  [off1+off2] {sym} ptr mem)
   16551 	for {
   16552 		off1 := v.AuxInt
   16553 		sym := v.Aux
   16554 		_ = v.Args[1]
   16555 		v_0 := v.Args[0]
   16556 		if v_0.Op != OpS390XADDconst {
   16557 			break
   16558 		}
   16559 		off2 := v_0.AuxInt
   16560 		ptr := v_0.Args[0]
   16561 		mem := v.Args[1]
   16562 		if !(is20Bit(off1 + off2)) {
   16563 			break
   16564 		}
   16565 		v.reset(OpS390XMOVHload)
   16566 		v.AuxInt = off1 + off2
   16567 		v.Aux = sym
   16568 		v.AddArg(ptr)
   16569 		v.AddArg(mem)
   16570 		return true
   16571 	}
   16572 	// match: (MOVHload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
   16573 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%2 == 0 && (off1+off2)%2 == 0))
   16574 	// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   16575 	for {
   16576 		off1 := v.AuxInt
   16577 		sym1 := v.Aux
   16578 		_ = v.Args[1]
   16579 		v_0 := v.Args[0]
   16580 		if v_0.Op != OpS390XMOVDaddr {
   16581 			break
   16582 		}
   16583 		t := v_0.Type
   16584 		off2 := v_0.AuxInt
   16585 		sym2 := v_0.Aux
   16586 		base := v_0.Args[0]
   16587 		mem := v.Args[1]
   16588 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%2 == 0 && (off1+off2)%2 == 0))) {
   16589 			break
   16590 		}
   16591 		v.reset(OpS390XMOVHload)
   16592 		v.AuxInt = off1 + off2
   16593 		v.Aux = mergeSym(sym1, sym2)
   16594 		v.AddArg(base)
   16595 		v.AddArg(mem)
   16596 		return true
   16597 	}
   16598 	// match: (MOVHload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   16599 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   16600 	// result: (MOVHloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   16601 	for {
   16602 		off1 := v.AuxInt
   16603 		sym1 := v.Aux
   16604 		_ = v.Args[1]
   16605 		v_0 := v.Args[0]
   16606 		if v_0.Op != OpS390XMOVDaddridx {
   16607 			break
   16608 		}
   16609 		off2 := v_0.AuxInt
   16610 		sym2 := v_0.Aux
   16611 		_ = v_0.Args[1]
   16612 		ptr := v_0.Args[0]
   16613 		idx := v_0.Args[1]
   16614 		mem := v.Args[1]
   16615 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   16616 			break
   16617 		}
   16618 		v.reset(OpS390XMOVHloadidx)
   16619 		v.AuxInt = off1 + off2
   16620 		v.Aux = mergeSym(sym1, sym2)
   16621 		v.AddArg(ptr)
   16622 		v.AddArg(idx)
   16623 		v.AddArg(mem)
   16624 		return true
   16625 	}
   16626 	// match: (MOVHload [off] {sym} (ADD ptr idx) mem)
   16627 	// cond: ptr.Op != OpSB
   16628 	// result: (MOVHloadidx  [off] {sym} ptr idx mem)
   16629 	for {
   16630 		off := v.AuxInt
   16631 		sym := v.Aux
   16632 		_ = v.Args[1]
   16633 		v_0 := v.Args[0]
   16634 		if v_0.Op != OpS390XADD {
   16635 			break
   16636 		}
   16637 		_ = v_0.Args[1]
   16638 		ptr := v_0.Args[0]
   16639 		idx := v_0.Args[1]
   16640 		mem := v.Args[1]
   16641 		if !(ptr.Op != OpSB) {
   16642 			break
   16643 		}
   16644 		v.reset(OpS390XMOVHloadidx)
   16645 		v.AuxInt = off
   16646 		v.Aux = sym
   16647 		v.AddArg(ptr)
   16648 		v.AddArg(idx)
   16649 		v.AddArg(mem)
   16650 		return true
   16651 	}
   16652 	return false
   16653 }
   16654 func rewriteValueS390X_OpS390XMOVHloadidx_0(v *Value) bool {
   16655 	// match: (MOVHloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   16656 	// cond: is20Bit(c+d)
   16657 	// result: (MOVHloadidx  [c+d] {sym} ptr idx mem)
   16658 	for {
   16659 		c := v.AuxInt
   16660 		sym := v.Aux
   16661 		_ = v.Args[2]
   16662 		v_0 := v.Args[0]
   16663 		if v_0.Op != OpS390XADDconst {
   16664 			break
   16665 		}
   16666 		d := v_0.AuxInt
   16667 		ptr := v_0.Args[0]
   16668 		idx := v.Args[1]
   16669 		mem := v.Args[2]
   16670 		if !(is20Bit(c + d)) {
   16671 			break
   16672 		}
   16673 		v.reset(OpS390XMOVHloadidx)
   16674 		v.AuxInt = c + d
   16675 		v.Aux = sym
   16676 		v.AddArg(ptr)
   16677 		v.AddArg(idx)
   16678 		v.AddArg(mem)
   16679 		return true
   16680 	}
   16681 	// match: (MOVHloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   16682 	// cond: is20Bit(c+d)
   16683 	// result: (MOVHloadidx  [c+d] {sym} ptr idx mem)
   16684 	for {
   16685 		c := v.AuxInt
   16686 		sym := v.Aux
   16687 		_ = v.Args[2]
   16688 		idx := v.Args[0]
   16689 		v_1 := v.Args[1]
   16690 		if v_1.Op != OpS390XADDconst {
   16691 			break
   16692 		}
   16693 		d := v_1.AuxInt
   16694 		ptr := v_1.Args[0]
   16695 		mem := v.Args[2]
   16696 		if !(is20Bit(c + d)) {
   16697 			break
   16698 		}
   16699 		v.reset(OpS390XMOVHloadidx)
   16700 		v.AuxInt = c + d
   16701 		v.Aux = sym
   16702 		v.AddArg(ptr)
   16703 		v.AddArg(idx)
   16704 		v.AddArg(mem)
   16705 		return true
   16706 	}
   16707 	// match: (MOVHloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   16708 	// cond: is20Bit(c+d)
   16709 	// result: (MOVHloadidx  [c+d] {sym} ptr idx mem)
   16710 	for {
   16711 		c := v.AuxInt
   16712 		sym := v.Aux
   16713 		_ = v.Args[2]
   16714 		ptr := v.Args[0]
   16715 		v_1 := v.Args[1]
   16716 		if v_1.Op != OpS390XADDconst {
   16717 			break
   16718 		}
   16719 		d := v_1.AuxInt
   16720 		idx := v_1.Args[0]
   16721 		mem := v.Args[2]
   16722 		if !(is20Bit(c + d)) {
   16723 			break
   16724 		}
   16725 		v.reset(OpS390XMOVHloadidx)
   16726 		v.AuxInt = c + d
   16727 		v.Aux = sym
   16728 		v.AddArg(ptr)
   16729 		v.AddArg(idx)
   16730 		v.AddArg(mem)
   16731 		return true
   16732 	}
   16733 	// match: (MOVHloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   16734 	// cond: is20Bit(c+d)
   16735 	// result: (MOVHloadidx  [c+d] {sym} ptr idx mem)
   16736 	for {
   16737 		c := v.AuxInt
   16738 		sym := v.Aux
   16739 		_ = v.Args[2]
   16740 		v_0 := v.Args[0]
   16741 		if v_0.Op != OpS390XADDconst {
   16742 			break
   16743 		}
   16744 		d := v_0.AuxInt
   16745 		idx := v_0.Args[0]
   16746 		ptr := v.Args[1]
   16747 		mem := v.Args[2]
   16748 		if !(is20Bit(c + d)) {
   16749 			break
   16750 		}
   16751 		v.reset(OpS390XMOVHloadidx)
   16752 		v.AuxInt = c + d
   16753 		v.Aux = sym
   16754 		v.AddArg(ptr)
   16755 		v.AddArg(idx)
   16756 		v.AddArg(mem)
   16757 		return true
   16758 	}
   16759 	return false
   16760 }
   16761 func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool {
   16762 	b := v.Block
   16763 	_ = b
   16764 	// match: (MOVHreg x:(MOVBload _ _))
   16765 	// cond:
   16766 	// result: (MOVDreg x)
   16767 	for {
   16768 		x := v.Args[0]
   16769 		if x.Op != OpS390XMOVBload {
   16770 			break
   16771 		}
   16772 		_ = x.Args[1]
   16773 		v.reset(OpS390XMOVDreg)
   16774 		v.AddArg(x)
   16775 		return true
   16776 	}
   16777 	// match: (MOVHreg x:(MOVBZload _ _))
   16778 	// cond:
   16779 	// result: (MOVDreg x)
   16780 	for {
   16781 		x := v.Args[0]
   16782 		if x.Op != OpS390XMOVBZload {
   16783 			break
   16784 		}
   16785 		_ = x.Args[1]
   16786 		v.reset(OpS390XMOVDreg)
   16787 		v.AddArg(x)
   16788 		return true
   16789 	}
   16790 	// match: (MOVHreg x:(MOVHload _ _))
   16791 	// cond:
   16792 	// result: (MOVDreg x)
   16793 	for {
   16794 		x := v.Args[0]
   16795 		if x.Op != OpS390XMOVHload {
   16796 			break
   16797 		}
   16798 		_ = x.Args[1]
   16799 		v.reset(OpS390XMOVDreg)
   16800 		v.AddArg(x)
   16801 		return true
   16802 	}
   16803 	// match: (MOVHreg x:(Arg <t>))
   16804 	// cond: (is8BitInt(t) || is16BitInt(t)) && isSigned(t)
   16805 	// result: (MOVDreg x)
   16806 	for {
   16807 		x := v.Args[0]
   16808 		if x.Op != OpArg {
   16809 			break
   16810 		}
   16811 		t := x.Type
   16812 		if !((is8BitInt(t) || is16BitInt(t)) && isSigned(t)) {
   16813 			break
   16814 		}
   16815 		v.reset(OpS390XMOVDreg)
   16816 		v.AddArg(x)
   16817 		return true
   16818 	}
   16819 	// match: (MOVHreg x:(MOVBreg _))
   16820 	// cond:
   16821 	// result: (MOVDreg x)
   16822 	for {
   16823 		x := v.Args[0]
   16824 		if x.Op != OpS390XMOVBreg {
   16825 			break
   16826 		}
   16827 		v.reset(OpS390XMOVDreg)
   16828 		v.AddArg(x)
   16829 		return true
   16830 	}
   16831 	// match: (MOVHreg x:(MOVBZreg _))
   16832 	// cond:
   16833 	// result: (MOVDreg x)
   16834 	for {
   16835 		x := v.Args[0]
   16836 		if x.Op != OpS390XMOVBZreg {
   16837 			break
   16838 		}
   16839 		v.reset(OpS390XMOVDreg)
   16840 		v.AddArg(x)
   16841 		return true
   16842 	}
   16843 	// match: (MOVHreg x:(MOVHreg _))
   16844 	// cond:
   16845 	// result: (MOVDreg x)
   16846 	for {
   16847 		x := v.Args[0]
   16848 		if x.Op != OpS390XMOVHreg {
   16849 			break
   16850 		}
   16851 		v.reset(OpS390XMOVDreg)
   16852 		v.AddArg(x)
   16853 		return true
   16854 	}
   16855 	// match: (MOVHreg (MOVDconst [c]))
   16856 	// cond:
   16857 	// result: (MOVDconst [int64(int16(c))])
   16858 	for {
   16859 		v_0 := v.Args[0]
   16860 		if v_0.Op != OpS390XMOVDconst {
   16861 			break
   16862 		}
   16863 		c := v_0.AuxInt
   16864 		v.reset(OpS390XMOVDconst)
   16865 		v.AuxInt = int64(int16(c))
   16866 		return true
   16867 	}
   16868 	// match: (MOVHreg x:(MOVHZload [off] {sym} ptr mem))
   16869 	// cond: x.Uses == 1 && clobber(x)
   16870 	// result: @x.Block (MOVHload  <v.Type> [off] {sym} ptr mem)
   16871 	for {
   16872 		x := v.Args[0]
   16873 		if x.Op != OpS390XMOVHZload {
   16874 			break
   16875 		}
   16876 		off := x.AuxInt
   16877 		sym := x.Aux
   16878 		_ = x.Args[1]
   16879 		ptr := x.Args[0]
   16880 		mem := x.Args[1]
   16881 		if !(x.Uses == 1 && clobber(x)) {
   16882 			break
   16883 		}
   16884 		b = x.Block
   16885 		v0 := b.NewValue0(v.Pos, OpS390XMOVHload, v.Type)
   16886 		v.reset(OpCopy)
   16887 		v.AddArg(v0)
   16888 		v0.AuxInt = off
   16889 		v0.Aux = sym
   16890 		v0.AddArg(ptr)
   16891 		v0.AddArg(mem)
   16892 		return true
   16893 	}
   16894 	// match: (MOVHreg x:(MOVHload [off] {sym} ptr mem))
   16895 	// cond: x.Uses == 1 && clobber(x)
   16896 	// result: @x.Block (MOVHload  <v.Type> [off] {sym} ptr mem)
   16897 	for {
   16898 		x := v.Args[0]
   16899 		if x.Op != OpS390XMOVHload {
   16900 			break
   16901 		}
   16902 		off := x.AuxInt
   16903 		sym := x.Aux
   16904 		_ = x.Args[1]
   16905 		ptr := x.Args[0]
   16906 		mem := x.Args[1]
   16907 		if !(x.Uses == 1 && clobber(x)) {
   16908 			break
   16909 		}
   16910 		b = x.Block
   16911 		v0 := b.NewValue0(v.Pos, OpS390XMOVHload, v.Type)
   16912 		v.reset(OpCopy)
   16913 		v.AddArg(v0)
   16914 		v0.AuxInt = off
   16915 		v0.Aux = sym
   16916 		v0.AddArg(ptr)
   16917 		v0.AddArg(mem)
   16918 		return true
   16919 	}
   16920 	return false
   16921 }
   16922 func rewriteValueS390X_OpS390XMOVHreg_10(v *Value) bool {
   16923 	b := v.Block
   16924 	_ = b
   16925 	// match: (MOVHreg x:(MOVHZloadidx [off] {sym} ptr idx mem))
   16926 	// cond: x.Uses == 1 && clobber(x)
   16927 	// result: @x.Block (MOVHloadidx  <v.Type> [off] {sym} ptr idx mem)
   16928 	for {
   16929 		x := v.Args[0]
   16930 		if x.Op != OpS390XMOVHZloadidx {
   16931 			break
   16932 		}
   16933 		off := x.AuxInt
   16934 		sym := x.Aux
   16935 		_ = x.Args[2]
   16936 		ptr := x.Args[0]
   16937 		idx := x.Args[1]
   16938 		mem := x.Args[2]
   16939 		if !(x.Uses == 1 && clobber(x)) {
   16940 			break
   16941 		}
   16942 		b = x.Block
   16943 		v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, v.Type)
   16944 		v.reset(OpCopy)
   16945 		v.AddArg(v0)
   16946 		v0.AuxInt = off
   16947 		v0.Aux = sym
   16948 		v0.AddArg(ptr)
   16949 		v0.AddArg(idx)
   16950 		v0.AddArg(mem)
   16951 		return true
   16952 	}
   16953 	// match: (MOVHreg x:(MOVHloadidx [off] {sym} ptr idx mem))
   16954 	// cond: x.Uses == 1 && clobber(x)
   16955 	// result: @x.Block (MOVHloadidx  <v.Type> [off] {sym} ptr idx mem)
   16956 	for {
   16957 		x := v.Args[0]
   16958 		if x.Op != OpS390XMOVHloadidx {
   16959 			break
   16960 		}
   16961 		off := x.AuxInt
   16962 		sym := x.Aux
   16963 		_ = x.Args[2]
   16964 		ptr := x.Args[0]
   16965 		idx := x.Args[1]
   16966 		mem := x.Args[2]
   16967 		if !(x.Uses == 1 && clobber(x)) {
   16968 			break
   16969 		}
   16970 		b = x.Block
   16971 		v0 := b.NewValue0(v.Pos, OpS390XMOVHloadidx, v.Type)
   16972 		v.reset(OpCopy)
   16973 		v.AddArg(v0)
   16974 		v0.AuxInt = off
   16975 		v0.Aux = sym
   16976 		v0.AddArg(ptr)
   16977 		v0.AddArg(idx)
   16978 		v0.AddArg(mem)
   16979 		return true
   16980 	}
   16981 	return false
   16982 }
   16983 func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool {
   16984 	// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
   16985 	// cond:
   16986 	// result: (MOVHstore [off] {sym} ptr x mem)
   16987 	for {
   16988 		off := v.AuxInt
   16989 		sym := v.Aux
   16990 		_ = v.Args[2]
   16991 		ptr := v.Args[0]
   16992 		v_1 := v.Args[1]
   16993 		if v_1.Op != OpS390XMOVHreg {
   16994 			break
   16995 		}
   16996 		x := v_1.Args[0]
   16997 		mem := v.Args[2]
   16998 		v.reset(OpS390XMOVHstore)
   16999 		v.AuxInt = off
   17000 		v.Aux = sym
   17001 		v.AddArg(ptr)
   17002 		v.AddArg(x)
   17003 		v.AddArg(mem)
   17004 		return true
   17005 	}
   17006 	// match: (MOVHstore [off] {sym} ptr (MOVHZreg x) mem)
   17007 	// cond:
   17008 	// result: (MOVHstore [off] {sym} ptr x mem)
   17009 	for {
   17010 		off := v.AuxInt
   17011 		sym := v.Aux
   17012 		_ = v.Args[2]
   17013 		ptr := v.Args[0]
   17014 		v_1 := v.Args[1]
   17015 		if v_1.Op != OpS390XMOVHZreg {
   17016 			break
   17017 		}
   17018 		x := v_1.Args[0]
   17019 		mem := v.Args[2]
   17020 		v.reset(OpS390XMOVHstore)
   17021 		v.AuxInt = off
   17022 		v.Aux = sym
   17023 		v.AddArg(ptr)
   17024 		v.AddArg(x)
   17025 		v.AddArg(mem)
   17026 		return true
   17027 	}
   17028 	// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
   17029 	// cond: is20Bit(off1+off2)
   17030 	// result: (MOVHstore  [off1+off2] {sym} ptr val mem)
   17031 	for {
   17032 		off1 := v.AuxInt
   17033 		sym := v.Aux
   17034 		_ = v.Args[2]
   17035 		v_0 := v.Args[0]
   17036 		if v_0.Op != OpS390XADDconst {
   17037 			break
   17038 		}
   17039 		off2 := v_0.AuxInt
   17040 		ptr := v_0.Args[0]
   17041 		val := v.Args[1]
   17042 		mem := v.Args[2]
   17043 		if !(is20Bit(off1 + off2)) {
   17044 			break
   17045 		}
   17046 		v.reset(OpS390XMOVHstore)
   17047 		v.AuxInt = off1 + off2
   17048 		v.Aux = sym
   17049 		v.AddArg(ptr)
   17050 		v.AddArg(val)
   17051 		v.AddArg(mem)
   17052 		return true
   17053 	}
   17054 	// match: (MOVHstore [off] {sym} ptr (MOVDconst [c]) mem)
   17055 	// cond: isU12Bit(off) && ptr.Op != OpSB
   17056 	// result: (MOVHstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem)
   17057 	for {
   17058 		off := v.AuxInt
   17059 		sym := v.Aux
   17060 		_ = v.Args[2]
   17061 		ptr := v.Args[0]
   17062 		v_1 := v.Args[1]
   17063 		if v_1.Op != OpS390XMOVDconst {
   17064 			break
   17065 		}
   17066 		c := v_1.AuxInt
   17067 		mem := v.Args[2]
   17068 		if !(isU12Bit(off) && ptr.Op != OpSB) {
   17069 			break
   17070 		}
   17071 		v.reset(OpS390XMOVHstoreconst)
   17072 		v.AuxInt = makeValAndOff(int64(int16(c)), off)
   17073 		v.Aux = sym
   17074 		v.AddArg(ptr)
   17075 		v.AddArg(mem)
   17076 		return true
   17077 	}
   17078 	// match: (MOVHstore [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) val mem)
   17079 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%2 == 0 && (off1+off2)%2 == 0))
   17080 	// result: (MOVHstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   17081 	for {
   17082 		off1 := v.AuxInt
   17083 		sym1 := v.Aux
   17084 		_ = v.Args[2]
   17085 		v_0 := v.Args[0]
   17086 		if v_0.Op != OpS390XMOVDaddr {
   17087 			break
   17088 		}
   17089 		t := v_0.Type
   17090 		off2 := v_0.AuxInt
   17091 		sym2 := v_0.Aux
   17092 		base := v_0.Args[0]
   17093 		val := v.Args[1]
   17094 		mem := v.Args[2]
   17095 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%2 == 0 && (off1+off2)%2 == 0))) {
   17096 			break
   17097 		}
   17098 		v.reset(OpS390XMOVHstore)
   17099 		v.AuxInt = off1 + off2
   17100 		v.Aux = mergeSym(sym1, sym2)
   17101 		v.AddArg(base)
   17102 		v.AddArg(val)
   17103 		v.AddArg(mem)
   17104 		return true
   17105 	}
   17106 	// match: (MOVHstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
   17107 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   17108 	// result: (MOVHstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   17109 	for {
   17110 		off1 := v.AuxInt
   17111 		sym1 := v.Aux
   17112 		_ = v.Args[2]
   17113 		v_0 := v.Args[0]
   17114 		if v_0.Op != OpS390XMOVDaddridx {
   17115 			break
   17116 		}
   17117 		off2 := v_0.AuxInt
   17118 		sym2 := v_0.Aux
   17119 		_ = v_0.Args[1]
   17120 		ptr := v_0.Args[0]
   17121 		idx := v_0.Args[1]
   17122 		val := v.Args[1]
   17123 		mem := v.Args[2]
   17124 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   17125 			break
   17126 		}
   17127 		v.reset(OpS390XMOVHstoreidx)
   17128 		v.AuxInt = off1 + off2
   17129 		v.Aux = mergeSym(sym1, sym2)
   17130 		v.AddArg(ptr)
   17131 		v.AddArg(idx)
   17132 		v.AddArg(val)
   17133 		v.AddArg(mem)
   17134 		return true
   17135 	}
   17136 	// match: (MOVHstore [off] {sym} (ADD ptr idx) val mem)
   17137 	// cond: ptr.Op != OpSB
   17138 	// result: (MOVHstoreidx  [off] {sym} ptr idx val mem)
   17139 	for {
   17140 		off := v.AuxInt
   17141 		sym := v.Aux
   17142 		_ = v.Args[2]
   17143 		v_0 := v.Args[0]
   17144 		if v_0.Op != OpS390XADD {
   17145 			break
   17146 		}
   17147 		_ = v_0.Args[1]
   17148 		ptr := v_0.Args[0]
   17149 		idx := v_0.Args[1]
   17150 		val := v.Args[1]
   17151 		mem := v.Args[2]
   17152 		if !(ptr.Op != OpSB) {
   17153 			break
   17154 		}
   17155 		v.reset(OpS390XMOVHstoreidx)
   17156 		v.AuxInt = off
   17157 		v.Aux = sym
   17158 		v.AddArg(ptr)
   17159 		v.AddArg(idx)
   17160 		v.AddArg(val)
   17161 		v.AddArg(mem)
   17162 		return true
   17163 	}
   17164 	// match: (MOVHstore [i] {s} p w x:(MOVHstore [i-2] {s} p (SRDconst [16] w) mem))
   17165 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   17166 	// result: (MOVWstore [i-2] {s} p w mem)
   17167 	for {
   17168 		i := v.AuxInt
   17169 		s := v.Aux
   17170 		_ = v.Args[2]
   17171 		p := v.Args[0]
   17172 		w := v.Args[1]
   17173 		x := v.Args[2]
   17174 		if x.Op != OpS390XMOVHstore {
   17175 			break
   17176 		}
   17177 		if x.AuxInt != i-2 {
   17178 			break
   17179 		}
   17180 		if x.Aux != s {
   17181 			break
   17182 		}
   17183 		_ = x.Args[2]
   17184 		if p != x.Args[0] {
   17185 			break
   17186 		}
   17187 		x_1 := x.Args[1]
   17188 		if x_1.Op != OpS390XSRDconst {
   17189 			break
   17190 		}
   17191 		if x_1.AuxInt != 16 {
   17192 			break
   17193 		}
   17194 		if w != x_1.Args[0] {
   17195 			break
   17196 		}
   17197 		mem := x.Args[2]
   17198 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   17199 			break
   17200 		}
   17201 		v.reset(OpS390XMOVWstore)
   17202 		v.AuxInt = i - 2
   17203 		v.Aux = s
   17204 		v.AddArg(p)
   17205 		v.AddArg(w)
   17206 		v.AddArg(mem)
   17207 		return true
   17208 	}
   17209 	// match: (MOVHstore [i] {s} p w0:(SRDconst [j] w) x:(MOVHstore [i-2] {s} p (SRDconst [j+16] w) mem))
   17210 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   17211 	// result: (MOVWstore [i-2] {s} p w0 mem)
   17212 	for {
   17213 		i := v.AuxInt
   17214 		s := v.Aux
   17215 		_ = v.Args[2]
   17216 		p := v.Args[0]
   17217 		w0 := v.Args[1]
   17218 		if w0.Op != OpS390XSRDconst {
   17219 			break
   17220 		}
   17221 		j := w0.AuxInt
   17222 		w := w0.Args[0]
   17223 		x := v.Args[2]
   17224 		if x.Op != OpS390XMOVHstore {
   17225 			break
   17226 		}
   17227 		if x.AuxInt != i-2 {
   17228 			break
   17229 		}
   17230 		if x.Aux != s {
   17231 			break
   17232 		}
   17233 		_ = x.Args[2]
   17234 		if p != x.Args[0] {
   17235 			break
   17236 		}
   17237 		x_1 := x.Args[1]
   17238 		if x_1.Op != OpS390XSRDconst {
   17239 			break
   17240 		}
   17241 		if x_1.AuxInt != j+16 {
   17242 			break
   17243 		}
   17244 		if w != x_1.Args[0] {
   17245 			break
   17246 		}
   17247 		mem := x.Args[2]
   17248 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   17249 			break
   17250 		}
   17251 		v.reset(OpS390XMOVWstore)
   17252 		v.AuxInt = i - 2
   17253 		v.Aux = s
   17254 		v.AddArg(p)
   17255 		v.AddArg(w0)
   17256 		v.AddArg(mem)
   17257 		return true
   17258 	}
   17259 	// match: (MOVHstore [i] {s} p w x:(MOVHstore [i-2] {s} p (SRWconst [16] w) mem))
   17260 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   17261 	// result: (MOVWstore [i-2] {s} p w mem)
   17262 	for {
   17263 		i := v.AuxInt
   17264 		s := v.Aux
   17265 		_ = v.Args[2]
   17266 		p := v.Args[0]
   17267 		w := v.Args[1]
   17268 		x := v.Args[2]
   17269 		if x.Op != OpS390XMOVHstore {
   17270 			break
   17271 		}
   17272 		if x.AuxInt != i-2 {
   17273 			break
   17274 		}
   17275 		if x.Aux != s {
   17276 			break
   17277 		}
   17278 		_ = x.Args[2]
   17279 		if p != x.Args[0] {
   17280 			break
   17281 		}
   17282 		x_1 := x.Args[1]
   17283 		if x_1.Op != OpS390XSRWconst {
   17284 			break
   17285 		}
   17286 		if x_1.AuxInt != 16 {
   17287 			break
   17288 		}
   17289 		if w != x_1.Args[0] {
   17290 			break
   17291 		}
   17292 		mem := x.Args[2]
   17293 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   17294 			break
   17295 		}
   17296 		v.reset(OpS390XMOVWstore)
   17297 		v.AuxInt = i - 2
   17298 		v.Aux = s
   17299 		v.AddArg(p)
   17300 		v.AddArg(w)
   17301 		v.AddArg(mem)
   17302 		return true
   17303 	}
   17304 	return false
   17305 }
   17306 func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool {
   17307 	// match: (MOVHstore [i] {s} p w0:(SRWconst [j] w) x:(MOVHstore [i-2] {s} p (SRWconst [j+16] w) mem))
   17308 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   17309 	// result: (MOVWstore [i-2] {s} p w0 mem)
   17310 	for {
   17311 		i := v.AuxInt
   17312 		s := v.Aux
   17313 		_ = v.Args[2]
   17314 		p := v.Args[0]
   17315 		w0 := v.Args[1]
   17316 		if w0.Op != OpS390XSRWconst {
   17317 			break
   17318 		}
   17319 		j := w0.AuxInt
   17320 		w := w0.Args[0]
   17321 		x := v.Args[2]
   17322 		if x.Op != OpS390XMOVHstore {
   17323 			break
   17324 		}
   17325 		if x.AuxInt != i-2 {
   17326 			break
   17327 		}
   17328 		if x.Aux != s {
   17329 			break
   17330 		}
   17331 		_ = x.Args[2]
   17332 		if p != x.Args[0] {
   17333 			break
   17334 		}
   17335 		x_1 := x.Args[1]
   17336 		if x_1.Op != OpS390XSRWconst {
   17337 			break
   17338 		}
   17339 		if x_1.AuxInt != j+16 {
   17340 			break
   17341 		}
   17342 		if w != x_1.Args[0] {
   17343 			break
   17344 		}
   17345 		mem := x.Args[2]
   17346 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   17347 			break
   17348 		}
   17349 		v.reset(OpS390XMOVWstore)
   17350 		v.AuxInt = i - 2
   17351 		v.Aux = s
   17352 		v.AddArg(p)
   17353 		v.AddArg(w0)
   17354 		v.AddArg(mem)
   17355 		return true
   17356 	}
   17357 	return false
   17358 }
   17359 func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool {
   17360 	b := v.Block
   17361 	_ = b
   17362 	typ := &b.Func.Config.Types
   17363 	_ = typ
   17364 	// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
   17365 	// cond: isU12Bit(ValAndOff(sc).Off()+off)
   17366 	// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   17367 	for {
   17368 		sc := v.AuxInt
   17369 		s := v.Aux
   17370 		_ = v.Args[1]
   17371 		v_0 := v.Args[0]
   17372 		if v_0.Op != OpS390XADDconst {
   17373 			break
   17374 		}
   17375 		off := v_0.AuxInt
   17376 		ptr := v_0.Args[0]
   17377 		mem := v.Args[1]
   17378 		if !(isU12Bit(ValAndOff(sc).Off() + off)) {
   17379 			break
   17380 		}
   17381 		v.reset(OpS390XMOVHstoreconst)
   17382 		v.AuxInt = ValAndOff(sc).add(off)
   17383 		v.Aux = s
   17384 		v.AddArg(ptr)
   17385 		v.AddArg(mem)
   17386 		return true
   17387 	}
   17388 	// match: (MOVHstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
   17389 	// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
   17390 	// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   17391 	for {
   17392 		sc := v.AuxInt
   17393 		sym1 := v.Aux
   17394 		_ = v.Args[1]
   17395 		v_0 := v.Args[0]
   17396 		if v_0.Op != OpS390XMOVDaddr {
   17397 			break
   17398 		}
   17399 		off := v_0.AuxInt
   17400 		sym2 := v_0.Aux
   17401 		ptr := v_0.Args[0]
   17402 		mem := v.Args[1]
   17403 		if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
   17404 			break
   17405 		}
   17406 		v.reset(OpS390XMOVHstoreconst)
   17407 		v.AuxInt = ValAndOff(sc).add(off)
   17408 		v.Aux = mergeSym(sym1, sym2)
   17409 		v.AddArg(ptr)
   17410 		v.AddArg(mem)
   17411 		return true
   17412 	}
   17413 	// match: (MOVHstoreconst [c] {s} p x:(MOVHstoreconst [a] {s} p mem))
   17414 	// cond: p.Op != OpSB   && x.Uses == 1   && ValAndOff(a).Off() + 2 == ValAndOff(c).Off()   && clobber(x)
   17415 	// result: (MOVWstore [ValAndOff(a).Off()] {s} p (MOVDconst [int64(int32(ValAndOff(c).Val()&0xffff | ValAndOff(a).Val()<<16))]) mem)
   17416 	for {
   17417 		c := v.AuxInt
   17418 		s := v.Aux
   17419 		_ = v.Args[1]
   17420 		p := v.Args[0]
   17421 		x := v.Args[1]
   17422 		if x.Op != OpS390XMOVHstoreconst {
   17423 			break
   17424 		}
   17425 		a := x.AuxInt
   17426 		if x.Aux != s {
   17427 			break
   17428 		}
   17429 		_ = x.Args[1]
   17430 		if p != x.Args[0] {
   17431 			break
   17432 		}
   17433 		mem := x.Args[1]
   17434 		if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
   17435 			break
   17436 		}
   17437 		v.reset(OpS390XMOVWstore)
   17438 		v.AuxInt = ValAndOff(a).Off()
   17439 		v.Aux = s
   17440 		v.AddArg(p)
   17441 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   17442 		v0.AuxInt = int64(int32(ValAndOff(c).Val()&0xffff | ValAndOff(a).Val()<<16))
   17443 		v.AddArg(v0)
   17444 		v.AddArg(mem)
   17445 		return true
   17446 	}
   17447 	return false
   17448 }
   17449 func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool {
   17450 	// match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
   17451 	// cond: is20Bit(c+d)
   17452 	// result: (MOVHstoreidx  [c+d] {sym} ptr idx val mem)
   17453 	for {
   17454 		c := v.AuxInt
   17455 		sym := v.Aux
   17456 		_ = v.Args[3]
   17457 		v_0 := v.Args[0]
   17458 		if v_0.Op != OpS390XADDconst {
   17459 			break
   17460 		}
   17461 		d := v_0.AuxInt
   17462 		ptr := v_0.Args[0]
   17463 		idx := v.Args[1]
   17464 		val := v.Args[2]
   17465 		mem := v.Args[3]
   17466 		if !(is20Bit(c + d)) {
   17467 			break
   17468 		}
   17469 		v.reset(OpS390XMOVHstoreidx)
   17470 		v.AuxInt = c + d
   17471 		v.Aux = sym
   17472 		v.AddArg(ptr)
   17473 		v.AddArg(idx)
   17474 		v.AddArg(val)
   17475 		v.AddArg(mem)
   17476 		return true
   17477 	}
   17478 	// match: (MOVHstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
   17479 	// cond: is20Bit(c+d)
   17480 	// result: (MOVHstoreidx  [c+d] {sym} ptr idx val mem)
   17481 	for {
   17482 		c := v.AuxInt
   17483 		sym := v.Aux
   17484 		_ = v.Args[3]
   17485 		idx := v.Args[0]
   17486 		v_1 := v.Args[1]
   17487 		if v_1.Op != OpS390XADDconst {
   17488 			break
   17489 		}
   17490 		d := v_1.AuxInt
   17491 		ptr := v_1.Args[0]
   17492 		val := v.Args[2]
   17493 		mem := v.Args[3]
   17494 		if !(is20Bit(c + d)) {
   17495 			break
   17496 		}
   17497 		v.reset(OpS390XMOVHstoreidx)
   17498 		v.AuxInt = c + d
   17499 		v.Aux = sym
   17500 		v.AddArg(ptr)
   17501 		v.AddArg(idx)
   17502 		v.AddArg(val)
   17503 		v.AddArg(mem)
   17504 		return true
   17505 	}
   17506 	// match: (MOVHstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
   17507 	// cond: is20Bit(c+d)
   17508 	// result: (MOVHstoreidx  [c+d] {sym} ptr idx val mem)
   17509 	for {
   17510 		c := v.AuxInt
   17511 		sym := v.Aux
   17512 		_ = v.Args[3]
   17513 		ptr := v.Args[0]
   17514 		v_1 := v.Args[1]
   17515 		if v_1.Op != OpS390XADDconst {
   17516 			break
   17517 		}
   17518 		d := v_1.AuxInt
   17519 		idx := v_1.Args[0]
   17520 		val := v.Args[2]
   17521 		mem := v.Args[3]
   17522 		if !(is20Bit(c + d)) {
   17523 			break
   17524 		}
   17525 		v.reset(OpS390XMOVHstoreidx)
   17526 		v.AuxInt = c + d
   17527 		v.Aux = sym
   17528 		v.AddArg(ptr)
   17529 		v.AddArg(idx)
   17530 		v.AddArg(val)
   17531 		v.AddArg(mem)
   17532 		return true
   17533 	}
   17534 	// match: (MOVHstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
   17535 	// cond: is20Bit(c+d)
   17536 	// result: (MOVHstoreidx  [c+d] {sym} ptr idx val mem)
   17537 	for {
   17538 		c := v.AuxInt
   17539 		sym := v.Aux
   17540 		_ = v.Args[3]
   17541 		v_0 := v.Args[0]
   17542 		if v_0.Op != OpS390XADDconst {
   17543 			break
   17544 		}
   17545 		d := v_0.AuxInt
   17546 		idx := v_0.Args[0]
   17547 		ptr := v.Args[1]
   17548 		val := v.Args[2]
   17549 		mem := v.Args[3]
   17550 		if !(is20Bit(c + d)) {
   17551 			break
   17552 		}
   17553 		v.reset(OpS390XMOVHstoreidx)
   17554 		v.AuxInt = c + d
   17555 		v.Aux = sym
   17556 		v.AddArg(ptr)
   17557 		v.AddArg(idx)
   17558 		v.AddArg(val)
   17559 		v.AddArg(mem)
   17560 		return true
   17561 	}
   17562 	// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [16] w) mem))
   17563 	// cond: x.Uses == 1   && clobber(x)
   17564 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   17565 	for {
   17566 		i := v.AuxInt
   17567 		s := v.Aux
   17568 		_ = v.Args[3]
   17569 		p := v.Args[0]
   17570 		idx := v.Args[1]
   17571 		w := v.Args[2]
   17572 		x := v.Args[3]
   17573 		if x.Op != OpS390XMOVHstoreidx {
   17574 			break
   17575 		}
   17576 		if x.AuxInt != i-2 {
   17577 			break
   17578 		}
   17579 		if x.Aux != s {
   17580 			break
   17581 		}
   17582 		_ = x.Args[3]
   17583 		if p != x.Args[0] {
   17584 			break
   17585 		}
   17586 		if idx != x.Args[1] {
   17587 			break
   17588 		}
   17589 		x_2 := x.Args[2]
   17590 		if x_2.Op != OpS390XSRDconst {
   17591 			break
   17592 		}
   17593 		if x_2.AuxInt != 16 {
   17594 			break
   17595 		}
   17596 		if w != x_2.Args[0] {
   17597 			break
   17598 		}
   17599 		mem := x.Args[3]
   17600 		if !(x.Uses == 1 && clobber(x)) {
   17601 			break
   17602 		}
   17603 		v.reset(OpS390XMOVWstoreidx)
   17604 		v.AuxInt = i - 2
   17605 		v.Aux = s
   17606 		v.AddArg(p)
   17607 		v.AddArg(idx)
   17608 		v.AddArg(w)
   17609 		v.AddArg(mem)
   17610 		return true
   17611 	}
   17612 	// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [16] w) mem))
   17613 	// cond: x.Uses == 1   && clobber(x)
   17614 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   17615 	for {
   17616 		i := v.AuxInt
   17617 		s := v.Aux
   17618 		_ = v.Args[3]
   17619 		p := v.Args[0]
   17620 		idx := v.Args[1]
   17621 		w := v.Args[2]
   17622 		x := v.Args[3]
   17623 		if x.Op != OpS390XMOVHstoreidx {
   17624 			break
   17625 		}
   17626 		if x.AuxInt != i-2 {
   17627 			break
   17628 		}
   17629 		if x.Aux != s {
   17630 			break
   17631 		}
   17632 		_ = x.Args[3]
   17633 		if idx != x.Args[0] {
   17634 			break
   17635 		}
   17636 		if p != x.Args[1] {
   17637 			break
   17638 		}
   17639 		x_2 := x.Args[2]
   17640 		if x_2.Op != OpS390XSRDconst {
   17641 			break
   17642 		}
   17643 		if x_2.AuxInt != 16 {
   17644 			break
   17645 		}
   17646 		if w != x_2.Args[0] {
   17647 			break
   17648 		}
   17649 		mem := x.Args[3]
   17650 		if !(x.Uses == 1 && clobber(x)) {
   17651 			break
   17652 		}
   17653 		v.reset(OpS390XMOVWstoreidx)
   17654 		v.AuxInt = i - 2
   17655 		v.Aux = s
   17656 		v.AddArg(p)
   17657 		v.AddArg(idx)
   17658 		v.AddArg(w)
   17659 		v.AddArg(mem)
   17660 		return true
   17661 	}
   17662 	// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [16] w) mem))
   17663 	// cond: x.Uses == 1   && clobber(x)
   17664 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   17665 	for {
   17666 		i := v.AuxInt
   17667 		s := v.Aux
   17668 		_ = v.Args[3]
   17669 		idx := v.Args[0]
   17670 		p := v.Args[1]
   17671 		w := v.Args[2]
   17672 		x := v.Args[3]
   17673 		if x.Op != OpS390XMOVHstoreidx {
   17674 			break
   17675 		}
   17676 		if x.AuxInt != i-2 {
   17677 			break
   17678 		}
   17679 		if x.Aux != s {
   17680 			break
   17681 		}
   17682 		_ = x.Args[3]
   17683 		if p != x.Args[0] {
   17684 			break
   17685 		}
   17686 		if idx != x.Args[1] {
   17687 			break
   17688 		}
   17689 		x_2 := x.Args[2]
   17690 		if x_2.Op != OpS390XSRDconst {
   17691 			break
   17692 		}
   17693 		if x_2.AuxInt != 16 {
   17694 			break
   17695 		}
   17696 		if w != x_2.Args[0] {
   17697 			break
   17698 		}
   17699 		mem := x.Args[3]
   17700 		if !(x.Uses == 1 && clobber(x)) {
   17701 			break
   17702 		}
   17703 		v.reset(OpS390XMOVWstoreidx)
   17704 		v.AuxInt = i - 2
   17705 		v.Aux = s
   17706 		v.AddArg(p)
   17707 		v.AddArg(idx)
   17708 		v.AddArg(w)
   17709 		v.AddArg(mem)
   17710 		return true
   17711 	}
   17712 	// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [16] w) mem))
   17713 	// cond: x.Uses == 1   && clobber(x)
   17714 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   17715 	for {
   17716 		i := v.AuxInt
   17717 		s := v.Aux
   17718 		_ = v.Args[3]
   17719 		idx := v.Args[0]
   17720 		p := v.Args[1]
   17721 		w := v.Args[2]
   17722 		x := v.Args[3]
   17723 		if x.Op != OpS390XMOVHstoreidx {
   17724 			break
   17725 		}
   17726 		if x.AuxInt != i-2 {
   17727 			break
   17728 		}
   17729 		if x.Aux != s {
   17730 			break
   17731 		}
   17732 		_ = x.Args[3]
   17733 		if idx != x.Args[0] {
   17734 			break
   17735 		}
   17736 		if p != x.Args[1] {
   17737 			break
   17738 		}
   17739 		x_2 := x.Args[2]
   17740 		if x_2.Op != OpS390XSRDconst {
   17741 			break
   17742 		}
   17743 		if x_2.AuxInt != 16 {
   17744 			break
   17745 		}
   17746 		if w != x_2.Args[0] {
   17747 			break
   17748 		}
   17749 		mem := x.Args[3]
   17750 		if !(x.Uses == 1 && clobber(x)) {
   17751 			break
   17752 		}
   17753 		v.reset(OpS390XMOVWstoreidx)
   17754 		v.AuxInt = i - 2
   17755 		v.Aux = s
   17756 		v.AddArg(p)
   17757 		v.AddArg(idx)
   17758 		v.AddArg(w)
   17759 		v.AddArg(mem)
   17760 		return true
   17761 	}
   17762 	// match: (MOVHstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
   17763 	// cond: x.Uses == 1   && clobber(x)
   17764 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   17765 	for {
   17766 		i := v.AuxInt
   17767 		s := v.Aux
   17768 		_ = v.Args[3]
   17769 		p := v.Args[0]
   17770 		idx := v.Args[1]
   17771 		w0 := v.Args[2]
   17772 		if w0.Op != OpS390XSRDconst {
   17773 			break
   17774 		}
   17775 		j := w0.AuxInt
   17776 		w := w0.Args[0]
   17777 		x := v.Args[3]
   17778 		if x.Op != OpS390XMOVHstoreidx {
   17779 			break
   17780 		}
   17781 		if x.AuxInt != i-2 {
   17782 			break
   17783 		}
   17784 		if x.Aux != s {
   17785 			break
   17786 		}
   17787 		_ = x.Args[3]
   17788 		if p != x.Args[0] {
   17789 			break
   17790 		}
   17791 		if idx != x.Args[1] {
   17792 			break
   17793 		}
   17794 		x_2 := x.Args[2]
   17795 		if x_2.Op != OpS390XSRDconst {
   17796 			break
   17797 		}
   17798 		if x_2.AuxInt != j+16 {
   17799 			break
   17800 		}
   17801 		if w != x_2.Args[0] {
   17802 			break
   17803 		}
   17804 		mem := x.Args[3]
   17805 		if !(x.Uses == 1 && clobber(x)) {
   17806 			break
   17807 		}
   17808 		v.reset(OpS390XMOVWstoreidx)
   17809 		v.AuxInt = i - 2
   17810 		v.Aux = s
   17811 		v.AddArg(p)
   17812 		v.AddArg(idx)
   17813 		v.AddArg(w0)
   17814 		v.AddArg(mem)
   17815 		return true
   17816 	}
   17817 	// match: (MOVHstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [j+16] w) mem))
   17818 	// cond: x.Uses == 1   && clobber(x)
   17819 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   17820 	for {
   17821 		i := v.AuxInt
   17822 		s := v.Aux
   17823 		_ = v.Args[3]
   17824 		p := v.Args[0]
   17825 		idx := v.Args[1]
   17826 		w0 := v.Args[2]
   17827 		if w0.Op != OpS390XSRDconst {
   17828 			break
   17829 		}
   17830 		j := w0.AuxInt
   17831 		w := w0.Args[0]
   17832 		x := v.Args[3]
   17833 		if x.Op != OpS390XMOVHstoreidx {
   17834 			break
   17835 		}
   17836 		if x.AuxInt != i-2 {
   17837 			break
   17838 		}
   17839 		if x.Aux != s {
   17840 			break
   17841 		}
   17842 		_ = x.Args[3]
   17843 		if idx != x.Args[0] {
   17844 			break
   17845 		}
   17846 		if p != x.Args[1] {
   17847 			break
   17848 		}
   17849 		x_2 := x.Args[2]
   17850 		if x_2.Op != OpS390XSRDconst {
   17851 			break
   17852 		}
   17853 		if x_2.AuxInt != j+16 {
   17854 			break
   17855 		}
   17856 		if w != x_2.Args[0] {
   17857 			break
   17858 		}
   17859 		mem := x.Args[3]
   17860 		if !(x.Uses == 1 && clobber(x)) {
   17861 			break
   17862 		}
   17863 		v.reset(OpS390XMOVWstoreidx)
   17864 		v.AuxInt = i - 2
   17865 		v.Aux = s
   17866 		v.AddArg(p)
   17867 		v.AddArg(idx)
   17868 		v.AddArg(w0)
   17869 		v.AddArg(mem)
   17870 		return true
   17871 	}
   17872 	return false
   17873 }
   17874 func rewriteValueS390X_OpS390XMOVHstoreidx_10(v *Value) bool {
   17875 	// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
   17876 	// cond: x.Uses == 1   && clobber(x)
   17877 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   17878 	for {
   17879 		i := v.AuxInt
   17880 		s := v.Aux
   17881 		_ = v.Args[3]
   17882 		idx := v.Args[0]
   17883 		p := v.Args[1]
   17884 		w0 := v.Args[2]
   17885 		if w0.Op != OpS390XSRDconst {
   17886 			break
   17887 		}
   17888 		j := w0.AuxInt
   17889 		w := w0.Args[0]
   17890 		x := v.Args[3]
   17891 		if x.Op != OpS390XMOVHstoreidx {
   17892 			break
   17893 		}
   17894 		if x.AuxInt != i-2 {
   17895 			break
   17896 		}
   17897 		if x.Aux != s {
   17898 			break
   17899 		}
   17900 		_ = x.Args[3]
   17901 		if p != x.Args[0] {
   17902 			break
   17903 		}
   17904 		if idx != x.Args[1] {
   17905 			break
   17906 		}
   17907 		x_2 := x.Args[2]
   17908 		if x_2.Op != OpS390XSRDconst {
   17909 			break
   17910 		}
   17911 		if x_2.AuxInt != j+16 {
   17912 			break
   17913 		}
   17914 		if w != x_2.Args[0] {
   17915 			break
   17916 		}
   17917 		mem := x.Args[3]
   17918 		if !(x.Uses == 1 && clobber(x)) {
   17919 			break
   17920 		}
   17921 		v.reset(OpS390XMOVWstoreidx)
   17922 		v.AuxInt = i - 2
   17923 		v.Aux = s
   17924 		v.AddArg(p)
   17925 		v.AddArg(idx)
   17926 		v.AddArg(w0)
   17927 		v.AddArg(mem)
   17928 		return true
   17929 	}
   17930 	// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRDconst [j+16] w) mem))
   17931 	// cond: x.Uses == 1   && clobber(x)
   17932 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   17933 	for {
   17934 		i := v.AuxInt
   17935 		s := v.Aux
   17936 		_ = v.Args[3]
   17937 		idx := v.Args[0]
   17938 		p := v.Args[1]
   17939 		w0 := v.Args[2]
   17940 		if w0.Op != OpS390XSRDconst {
   17941 			break
   17942 		}
   17943 		j := w0.AuxInt
   17944 		w := w0.Args[0]
   17945 		x := v.Args[3]
   17946 		if x.Op != OpS390XMOVHstoreidx {
   17947 			break
   17948 		}
   17949 		if x.AuxInt != i-2 {
   17950 			break
   17951 		}
   17952 		if x.Aux != s {
   17953 			break
   17954 		}
   17955 		_ = x.Args[3]
   17956 		if idx != x.Args[0] {
   17957 			break
   17958 		}
   17959 		if p != x.Args[1] {
   17960 			break
   17961 		}
   17962 		x_2 := x.Args[2]
   17963 		if x_2.Op != OpS390XSRDconst {
   17964 			break
   17965 		}
   17966 		if x_2.AuxInt != j+16 {
   17967 			break
   17968 		}
   17969 		if w != x_2.Args[0] {
   17970 			break
   17971 		}
   17972 		mem := x.Args[3]
   17973 		if !(x.Uses == 1 && clobber(x)) {
   17974 			break
   17975 		}
   17976 		v.reset(OpS390XMOVWstoreidx)
   17977 		v.AuxInt = i - 2
   17978 		v.Aux = s
   17979 		v.AddArg(p)
   17980 		v.AddArg(idx)
   17981 		v.AddArg(w0)
   17982 		v.AddArg(mem)
   17983 		return true
   17984 	}
   17985 	// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [16] w) mem))
   17986 	// cond: x.Uses == 1   && clobber(x)
   17987 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   17988 	for {
   17989 		i := v.AuxInt
   17990 		s := v.Aux
   17991 		_ = v.Args[3]
   17992 		p := v.Args[0]
   17993 		idx := v.Args[1]
   17994 		w := v.Args[2]
   17995 		x := v.Args[3]
   17996 		if x.Op != OpS390XMOVHstoreidx {
   17997 			break
   17998 		}
   17999 		if x.AuxInt != i-2 {
   18000 			break
   18001 		}
   18002 		if x.Aux != s {
   18003 			break
   18004 		}
   18005 		_ = x.Args[3]
   18006 		if p != x.Args[0] {
   18007 			break
   18008 		}
   18009 		if idx != x.Args[1] {
   18010 			break
   18011 		}
   18012 		x_2 := x.Args[2]
   18013 		if x_2.Op != OpS390XSRWconst {
   18014 			break
   18015 		}
   18016 		if x_2.AuxInt != 16 {
   18017 			break
   18018 		}
   18019 		if w != x_2.Args[0] {
   18020 			break
   18021 		}
   18022 		mem := x.Args[3]
   18023 		if !(x.Uses == 1 && clobber(x)) {
   18024 			break
   18025 		}
   18026 		v.reset(OpS390XMOVWstoreidx)
   18027 		v.AuxInt = i - 2
   18028 		v.Aux = s
   18029 		v.AddArg(p)
   18030 		v.AddArg(idx)
   18031 		v.AddArg(w)
   18032 		v.AddArg(mem)
   18033 		return true
   18034 	}
   18035 	// match: (MOVHstoreidx [i] {s} p idx w x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [16] w) mem))
   18036 	// cond: x.Uses == 1   && clobber(x)
   18037 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   18038 	for {
   18039 		i := v.AuxInt
   18040 		s := v.Aux
   18041 		_ = v.Args[3]
   18042 		p := v.Args[0]
   18043 		idx := v.Args[1]
   18044 		w := v.Args[2]
   18045 		x := v.Args[3]
   18046 		if x.Op != OpS390XMOVHstoreidx {
   18047 			break
   18048 		}
   18049 		if x.AuxInt != i-2 {
   18050 			break
   18051 		}
   18052 		if x.Aux != s {
   18053 			break
   18054 		}
   18055 		_ = x.Args[3]
   18056 		if idx != x.Args[0] {
   18057 			break
   18058 		}
   18059 		if p != x.Args[1] {
   18060 			break
   18061 		}
   18062 		x_2 := x.Args[2]
   18063 		if x_2.Op != OpS390XSRWconst {
   18064 			break
   18065 		}
   18066 		if x_2.AuxInt != 16 {
   18067 			break
   18068 		}
   18069 		if w != x_2.Args[0] {
   18070 			break
   18071 		}
   18072 		mem := x.Args[3]
   18073 		if !(x.Uses == 1 && clobber(x)) {
   18074 			break
   18075 		}
   18076 		v.reset(OpS390XMOVWstoreidx)
   18077 		v.AuxInt = i - 2
   18078 		v.Aux = s
   18079 		v.AddArg(p)
   18080 		v.AddArg(idx)
   18081 		v.AddArg(w)
   18082 		v.AddArg(mem)
   18083 		return true
   18084 	}
   18085 	// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [16] w) mem))
   18086 	// cond: x.Uses == 1   && clobber(x)
   18087 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   18088 	for {
   18089 		i := v.AuxInt
   18090 		s := v.Aux
   18091 		_ = v.Args[3]
   18092 		idx := v.Args[0]
   18093 		p := v.Args[1]
   18094 		w := v.Args[2]
   18095 		x := v.Args[3]
   18096 		if x.Op != OpS390XMOVHstoreidx {
   18097 			break
   18098 		}
   18099 		if x.AuxInt != i-2 {
   18100 			break
   18101 		}
   18102 		if x.Aux != s {
   18103 			break
   18104 		}
   18105 		_ = x.Args[3]
   18106 		if p != x.Args[0] {
   18107 			break
   18108 		}
   18109 		if idx != x.Args[1] {
   18110 			break
   18111 		}
   18112 		x_2 := x.Args[2]
   18113 		if x_2.Op != OpS390XSRWconst {
   18114 			break
   18115 		}
   18116 		if x_2.AuxInt != 16 {
   18117 			break
   18118 		}
   18119 		if w != x_2.Args[0] {
   18120 			break
   18121 		}
   18122 		mem := x.Args[3]
   18123 		if !(x.Uses == 1 && clobber(x)) {
   18124 			break
   18125 		}
   18126 		v.reset(OpS390XMOVWstoreidx)
   18127 		v.AuxInt = i - 2
   18128 		v.Aux = s
   18129 		v.AddArg(p)
   18130 		v.AddArg(idx)
   18131 		v.AddArg(w)
   18132 		v.AddArg(mem)
   18133 		return true
   18134 	}
   18135 	// match: (MOVHstoreidx [i] {s} idx p w x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [16] w) mem))
   18136 	// cond: x.Uses == 1   && clobber(x)
   18137 	// result: (MOVWstoreidx [i-2] {s} p idx w mem)
   18138 	for {
   18139 		i := v.AuxInt
   18140 		s := v.Aux
   18141 		_ = v.Args[3]
   18142 		idx := v.Args[0]
   18143 		p := v.Args[1]
   18144 		w := v.Args[2]
   18145 		x := v.Args[3]
   18146 		if x.Op != OpS390XMOVHstoreidx {
   18147 			break
   18148 		}
   18149 		if x.AuxInt != i-2 {
   18150 			break
   18151 		}
   18152 		if x.Aux != s {
   18153 			break
   18154 		}
   18155 		_ = x.Args[3]
   18156 		if idx != x.Args[0] {
   18157 			break
   18158 		}
   18159 		if p != x.Args[1] {
   18160 			break
   18161 		}
   18162 		x_2 := x.Args[2]
   18163 		if x_2.Op != OpS390XSRWconst {
   18164 			break
   18165 		}
   18166 		if x_2.AuxInt != 16 {
   18167 			break
   18168 		}
   18169 		if w != x_2.Args[0] {
   18170 			break
   18171 		}
   18172 		mem := x.Args[3]
   18173 		if !(x.Uses == 1 && clobber(x)) {
   18174 			break
   18175 		}
   18176 		v.reset(OpS390XMOVWstoreidx)
   18177 		v.AuxInt = i - 2
   18178 		v.Aux = s
   18179 		v.AddArg(p)
   18180 		v.AddArg(idx)
   18181 		v.AddArg(w)
   18182 		v.AddArg(mem)
   18183 		return true
   18184 	}
   18185 	// match: (MOVHstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [j+16] w) mem))
   18186 	// cond: x.Uses == 1   && clobber(x)
   18187 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   18188 	for {
   18189 		i := v.AuxInt
   18190 		s := v.Aux
   18191 		_ = v.Args[3]
   18192 		p := v.Args[0]
   18193 		idx := v.Args[1]
   18194 		w0 := v.Args[2]
   18195 		if w0.Op != OpS390XSRWconst {
   18196 			break
   18197 		}
   18198 		j := w0.AuxInt
   18199 		w := w0.Args[0]
   18200 		x := v.Args[3]
   18201 		if x.Op != OpS390XMOVHstoreidx {
   18202 			break
   18203 		}
   18204 		if x.AuxInt != i-2 {
   18205 			break
   18206 		}
   18207 		if x.Aux != s {
   18208 			break
   18209 		}
   18210 		_ = x.Args[3]
   18211 		if p != x.Args[0] {
   18212 			break
   18213 		}
   18214 		if idx != x.Args[1] {
   18215 			break
   18216 		}
   18217 		x_2 := x.Args[2]
   18218 		if x_2.Op != OpS390XSRWconst {
   18219 			break
   18220 		}
   18221 		if x_2.AuxInt != j+16 {
   18222 			break
   18223 		}
   18224 		if w != x_2.Args[0] {
   18225 			break
   18226 		}
   18227 		mem := x.Args[3]
   18228 		if !(x.Uses == 1 && clobber(x)) {
   18229 			break
   18230 		}
   18231 		v.reset(OpS390XMOVWstoreidx)
   18232 		v.AuxInt = i - 2
   18233 		v.Aux = s
   18234 		v.AddArg(p)
   18235 		v.AddArg(idx)
   18236 		v.AddArg(w0)
   18237 		v.AddArg(mem)
   18238 		return true
   18239 	}
   18240 	// match: (MOVHstoreidx [i] {s} p idx w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [j+16] w) mem))
   18241 	// cond: x.Uses == 1   && clobber(x)
   18242 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   18243 	for {
   18244 		i := v.AuxInt
   18245 		s := v.Aux
   18246 		_ = v.Args[3]
   18247 		p := v.Args[0]
   18248 		idx := v.Args[1]
   18249 		w0 := v.Args[2]
   18250 		if w0.Op != OpS390XSRWconst {
   18251 			break
   18252 		}
   18253 		j := w0.AuxInt
   18254 		w := w0.Args[0]
   18255 		x := v.Args[3]
   18256 		if x.Op != OpS390XMOVHstoreidx {
   18257 			break
   18258 		}
   18259 		if x.AuxInt != i-2 {
   18260 			break
   18261 		}
   18262 		if x.Aux != s {
   18263 			break
   18264 		}
   18265 		_ = x.Args[3]
   18266 		if idx != x.Args[0] {
   18267 			break
   18268 		}
   18269 		if p != x.Args[1] {
   18270 			break
   18271 		}
   18272 		x_2 := x.Args[2]
   18273 		if x_2.Op != OpS390XSRWconst {
   18274 			break
   18275 		}
   18276 		if x_2.AuxInt != j+16 {
   18277 			break
   18278 		}
   18279 		if w != x_2.Args[0] {
   18280 			break
   18281 		}
   18282 		mem := x.Args[3]
   18283 		if !(x.Uses == 1 && clobber(x)) {
   18284 			break
   18285 		}
   18286 		v.reset(OpS390XMOVWstoreidx)
   18287 		v.AuxInt = i - 2
   18288 		v.Aux = s
   18289 		v.AddArg(p)
   18290 		v.AddArg(idx)
   18291 		v.AddArg(w0)
   18292 		v.AddArg(mem)
   18293 		return true
   18294 	}
   18295 	// match: (MOVHstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRWconst [j+16] w) mem))
   18296 	// cond: x.Uses == 1   && clobber(x)
   18297 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   18298 	for {
   18299 		i := v.AuxInt
   18300 		s := v.Aux
   18301 		_ = v.Args[3]
   18302 		idx := v.Args[0]
   18303 		p := v.Args[1]
   18304 		w0 := v.Args[2]
   18305 		if w0.Op != OpS390XSRWconst {
   18306 			break
   18307 		}
   18308 		j := w0.AuxInt
   18309 		w := w0.Args[0]
   18310 		x := v.Args[3]
   18311 		if x.Op != OpS390XMOVHstoreidx {
   18312 			break
   18313 		}
   18314 		if x.AuxInt != i-2 {
   18315 			break
   18316 		}
   18317 		if x.Aux != s {
   18318 			break
   18319 		}
   18320 		_ = x.Args[3]
   18321 		if p != x.Args[0] {
   18322 			break
   18323 		}
   18324 		if idx != x.Args[1] {
   18325 			break
   18326 		}
   18327 		x_2 := x.Args[2]
   18328 		if x_2.Op != OpS390XSRWconst {
   18329 			break
   18330 		}
   18331 		if x_2.AuxInt != j+16 {
   18332 			break
   18333 		}
   18334 		if w != x_2.Args[0] {
   18335 			break
   18336 		}
   18337 		mem := x.Args[3]
   18338 		if !(x.Uses == 1 && clobber(x)) {
   18339 			break
   18340 		}
   18341 		v.reset(OpS390XMOVWstoreidx)
   18342 		v.AuxInt = i - 2
   18343 		v.Aux = s
   18344 		v.AddArg(p)
   18345 		v.AddArg(idx)
   18346 		v.AddArg(w0)
   18347 		v.AddArg(mem)
   18348 		return true
   18349 	}
   18350 	// match: (MOVHstoreidx [i] {s} idx p w0:(SRWconst [j] w) x:(MOVHstoreidx [i-2] {s} idx p (SRWconst [j+16] w) mem))
   18351 	// cond: x.Uses == 1   && clobber(x)
   18352 	// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
   18353 	for {
   18354 		i := v.AuxInt
   18355 		s := v.Aux
   18356 		_ = v.Args[3]
   18357 		idx := v.Args[0]
   18358 		p := v.Args[1]
   18359 		w0 := v.Args[2]
   18360 		if w0.Op != OpS390XSRWconst {
   18361 			break
   18362 		}
   18363 		j := w0.AuxInt
   18364 		w := w0.Args[0]
   18365 		x := v.Args[3]
   18366 		if x.Op != OpS390XMOVHstoreidx {
   18367 			break
   18368 		}
   18369 		if x.AuxInt != i-2 {
   18370 			break
   18371 		}
   18372 		if x.Aux != s {
   18373 			break
   18374 		}
   18375 		_ = x.Args[3]
   18376 		if idx != x.Args[0] {
   18377 			break
   18378 		}
   18379 		if p != x.Args[1] {
   18380 			break
   18381 		}
   18382 		x_2 := x.Args[2]
   18383 		if x_2.Op != OpS390XSRWconst {
   18384 			break
   18385 		}
   18386 		if x_2.AuxInt != j+16 {
   18387 			break
   18388 		}
   18389 		if w != x_2.Args[0] {
   18390 			break
   18391 		}
   18392 		mem := x.Args[3]
   18393 		if !(x.Uses == 1 && clobber(x)) {
   18394 			break
   18395 		}
   18396 		v.reset(OpS390XMOVWstoreidx)
   18397 		v.AuxInt = i - 2
   18398 		v.Aux = s
   18399 		v.AddArg(p)
   18400 		v.AddArg(idx)
   18401 		v.AddArg(w0)
   18402 		v.AddArg(mem)
   18403 		return true
   18404 	}
   18405 	return false
   18406 }
   18407 func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool {
   18408 	// match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem))
   18409 	// cond: x.Uses == 1   && clobber(x)
   18410 	// result: (MOVDBRstore [i-4] {s} p w mem)
   18411 	for {
   18412 		i := v.AuxInt
   18413 		s := v.Aux
   18414 		_ = v.Args[2]
   18415 		p := v.Args[0]
   18416 		v_1 := v.Args[1]
   18417 		if v_1.Op != OpS390XSRDconst {
   18418 			break
   18419 		}
   18420 		if v_1.AuxInt != 32 {
   18421 			break
   18422 		}
   18423 		w := v_1.Args[0]
   18424 		x := v.Args[2]
   18425 		if x.Op != OpS390XMOVWBRstore {
   18426 			break
   18427 		}
   18428 		if x.AuxInt != i-4 {
   18429 			break
   18430 		}
   18431 		if x.Aux != s {
   18432 			break
   18433 		}
   18434 		_ = x.Args[2]
   18435 		if p != x.Args[0] {
   18436 			break
   18437 		}
   18438 		if w != x.Args[1] {
   18439 			break
   18440 		}
   18441 		mem := x.Args[2]
   18442 		if !(x.Uses == 1 && clobber(x)) {
   18443 			break
   18444 		}
   18445 		v.reset(OpS390XMOVDBRstore)
   18446 		v.AuxInt = i - 4
   18447 		v.Aux = s
   18448 		v.AddArg(p)
   18449 		v.AddArg(w)
   18450 		v.AddArg(mem)
   18451 		return true
   18452 	}
   18453 	// match: (MOVWBRstore [i] {s} p (SRDconst [j] w) x:(MOVWBRstore [i-4] {s} p w0:(SRDconst [j-32] w) mem))
   18454 	// cond: x.Uses == 1   && clobber(x)
   18455 	// result: (MOVDBRstore [i-4] {s} p w0 mem)
   18456 	for {
   18457 		i := v.AuxInt
   18458 		s := v.Aux
   18459 		_ = v.Args[2]
   18460 		p := v.Args[0]
   18461 		v_1 := v.Args[1]
   18462 		if v_1.Op != OpS390XSRDconst {
   18463 			break
   18464 		}
   18465 		j := v_1.AuxInt
   18466 		w := v_1.Args[0]
   18467 		x := v.Args[2]
   18468 		if x.Op != OpS390XMOVWBRstore {
   18469 			break
   18470 		}
   18471 		if x.AuxInt != i-4 {
   18472 			break
   18473 		}
   18474 		if x.Aux != s {
   18475 			break
   18476 		}
   18477 		_ = x.Args[2]
   18478 		if p != x.Args[0] {
   18479 			break
   18480 		}
   18481 		w0 := x.Args[1]
   18482 		if w0.Op != OpS390XSRDconst {
   18483 			break
   18484 		}
   18485 		if w0.AuxInt != j-32 {
   18486 			break
   18487 		}
   18488 		if w != w0.Args[0] {
   18489 			break
   18490 		}
   18491 		mem := x.Args[2]
   18492 		if !(x.Uses == 1 && clobber(x)) {
   18493 			break
   18494 		}
   18495 		v.reset(OpS390XMOVDBRstore)
   18496 		v.AuxInt = i - 4
   18497 		v.Aux = s
   18498 		v.AddArg(p)
   18499 		v.AddArg(w0)
   18500 		v.AddArg(mem)
   18501 		return true
   18502 	}
   18503 	return false
   18504 }
   18505 func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool {
   18506 	// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
   18507 	// cond: x.Uses == 1   && clobber(x)
   18508 	// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
   18509 	for {
   18510 		i := v.AuxInt
   18511 		s := v.Aux
   18512 		_ = v.Args[3]
   18513 		p := v.Args[0]
   18514 		idx := v.Args[1]
   18515 		v_2 := v.Args[2]
   18516 		if v_2.Op != OpS390XSRDconst {
   18517 			break
   18518 		}
   18519 		if v_2.AuxInt != 32 {
   18520 			break
   18521 		}
   18522 		w := v_2.Args[0]
   18523 		x := v.Args[3]
   18524 		if x.Op != OpS390XMOVWBRstoreidx {
   18525 			break
   18526 		}
   18527 		if x.AuxInt != i-4 {
   18528 			break
   18529 		}
   18530 		if x.Aux != s {
   18531 			break
   18532 		}
   18533 		_ = x.Args[3]
   18534 		if p != x.Args[0] {
   18535 			break
   18536 		}
   18537 		if idx != x.Args[1] {
   18538 			break
   18539 		}
   18540 		if w != x.Args[2] {
   18541 			break
   18542 		}
   18543 		mem := x.Args[3]
   18544 		if !(x.Uses == 1 && clobber(x)) {
   18545 			break
   18546 		}
   18547 		v.reset(OpS390XMOVDBRstoreidx)
   18548 		v.AuxInt = i - 4
   18549 		v.Aux = s
   18550 		v.AddArg(p)
   18551 		v.AddArg(idx)
   18552 		v.AddArg(w)
   18553 		v.AddArg(mem)
   18554 		return true
   18555 	}
   18556 	// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} idx p w mem))
   18557 	// cond: x.Uses == 1   && clobber(x)
   18558 	// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
   18559 	for {
   18560 		i := v.AuxInt
   18561 		s := v.Aux
   18562 		_ = v.Args[3]
   18563 		p := v.Args[0]
   18564 		idx := v.Args[1]
   18565 		v_2 := v.Args[2]
   18566 		if v_2.Op != OpS390XSRDconst {
   18567 			break
   18568 		}
   18569 		if v_2.AuxInt != 32 {
   18570 			break
   18571 		}
   18572 		w := v_2.Args[0]
   18573 		x := v.Args[3]
   18574 		if x.Op != OpS390XMOVWBRstoreidx {
   18575 			break
   18576 		}
   18577 		if x.AuxInt != i-4 {
   18578 			break
   18579 		}
   18580 		if x.Aux != s {
   18581 			break
   18582 		}
   18583 		_ = x.Args[3]
   18584 		if idx != x.Args[0] {
   18585 			break
   18586 		}
   18587 		if p != x.Args[1] {
   18588 			break
   18589 		}
   18590 		if w != x.Args[2] {
   18591 			break
   18592 		}
   18593 		mem := x.Args[3]
   18594 		if !(x.Uses == 1 && clobber(x)) {
   18595 			break
   18596 		}
   18597 		v.reset(OpS390XMOVDBRstoreidx)
   18598 		v.AuxInt = i - 4
   18599 		v.Aux = s
   18600 		v.AddArg(p)
   18601 		v.AddArg(idx)
   18602 		v.AddArg(w)
   18603 		v.AddArg(mem)
   18604 		return true
   18605 	}
   18606 	// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
   18607 	// cond: x.Uses == 1   && clobber(x)
   18608 	// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
   18609 	for {
   18610 		i := v.AuxInt
   18611 		s := v.Aux
   18612 		_ = v.Args[3]
   18613 		idx := v.Args[0]
   18614 		p := v.Args[1]
   18615 		v_2 := v.Args[2]
   18616 		if v_2.Op != OpS390XSRDconst {
   18617 			break
   18618 		}
   18619 		if v_2.AuxInt != 32 {
   18620 			break
   18621 		}
   18622 		w := v_2.Args[0]
   18623 		x := v.Args[3]
   18624 		if x.Op != OpS390XMOVWBRstoreidx {
   18625 			break
   18626 		}
   18627 		if x.AuxInt != i-4 {
   18628 			break
   18629 		}
   18630 		if x.Aux != s {
   18631 			break
   18632 		}
   18633 		_ = x.Args[3]
   18634 		if p != x.Args[0] {
   18635 			break
   18636 		}
   18637 		if idx != x.Args[1] {
   18638 			break
   18639 		}
   18640 		if w != x.Args[2] {
   18641 			break
   18642 		}
   18643 		mem := x.Args[3]
   18644 		if !(x.Uses == 1 && clobber(x)) {
   18645 			break
   18646 		}
   18647 		v.reset(OpS390XMOVDBRstoreidx)
   18648 		v.AuxInt = i - 4
   18649 		v.Aux = s
   18650 		v.AddArg(p)
   18651 		v.AddArg(idx)
   18652 		v.AddArg(w)
   18653 		v.AddArg(mem)
   18654 		return true
   18655 	}
   18656 	// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} idx p w mem))
   18657 	// cond: x.Uses == 1   && clobber(x)
   18658 	// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
   18659 	for {
   18660 		i := v.AuxInt
   18661 		s := v.Aux
   18662 		_ = v.Args[3]
   18663 		idx := v.Args[0]
   18664 		p := v.Args[1]
   18665 		v_2 := v.Args[2]
   18666 		if v_2.Op != OpS390XSRDconst {
   18667 			break
   18668 		}
   18669 		if v_2.AuxInt != 32 {
   18670 			break
   18671 		}
   18672 		w := v_2.Args[0]
   18673 		x := v.Args[3]
   18674 		if x.Op != OpS390XMOVWBRstoreidx {
   18675 			break
   18676 		}
   18677 		if x.AuxInt != i-4 {
   18678 			break
   18679 		}
   18680 		if x.Aux != s {
   18681 			break
   18682 		}
   18683 		_ = x.Args[3]
   18684 		if idx != x.Args[0] {
   18685 			break
   18686 		}
   18687 		if p != x.Args[1] {
   18688 			break
   18689 		}
   18690 		if w != x.Args[2] {
   18691 			break
   18692 		}
   18693 		mem := x.Args[3]
   18694 		if !(x.Uses == 1 && clobber(x)) {
   18695 			break
   18696 		}
   18697 		v.reset(OpS390XMOVDBRstoreidx)
   18698 		v.AuxInt = i - 4
   18699 		v.Aux = s
   18700 		v.AddArg(p)
   18701 		v.AddArg(idx)
   18702 		v.AddArg(w)
   18703 		v.AddArg(mem)
   18704 		return true
   18705 	}
   18706 	// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} p idx w0:(SRDconst [j-32] w) mem))
   18707 	// cond: x.Uses == 1   && clobber(x)
   18708 	// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
   18709 	for {
   18710 		i := v.AuxInt
   18711 		s := v.Aux
   18712 		_ = v.Args[3]
   18713 		p := v.Args[0]
   18714 		idx := v.Args[1]
   18715 		v_2 := v.Args[2]
   18716 		if v_2.Op != OpS390XSRDconst {
   18717 			break
   18718 		}
   18719 		j := v_2.AuxInt
   18720 		w := v_2.Args[0]
   18721 		x := v.Args[3]
   18722 		if x.Op != OpS390XMOVWBRstoreidx {
   18723 			break
   18724 		}
   18725 		if x.AuxInt != i-4 {
   18726 			break
   18727 		}
   18728 		if x.Aux != s {
   18729 			break
   18730 		}
   18731 		_ = x.Args[3]
   18732 		if p != x.Args[0] {
   18733 			break
   18734 		}
   18735 		if idx != x.Args[1] {
   18736 			break
   18737 		}
   18738 		w0 := x.Args[2]
   18739 		if w0.Op != OpS390XSRDconst {
   18740 			break
   18741 		}
   18742 		if w0.AuxInt != j-32 {
   18743 			break
   18744 		}
   18745 		if w != w0.Args[0] {
   18746 			break
   18747 		}
   18748 		mem := x.Args[3]
   18749 		if !(x.Uses == 1 && clobber(x)) {
   18750 			break
   18751 		}
   18752 		v.reset(OpS390XMOVDBRstoreidx)
   18753 		v.AuxInt = i - 4
   18754 		v.Aux = s
   18755 		v.AddArg(p)
   18756 		v.AddArg(idx)
   18757 		v.AddArg(w0)
   18758 		v.AddArg(mem)
   18759 		return true
   18760 	}
   18761 	// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} idx p w0:(SRDconst [j-32] w) mem))
   18762 	// cond: x.Uses == 1   && clobber(x)
   18763 	// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
   18764 	for {
   18765 		i := v.AuxInt
   18766 		s := v.Aux
   18767 		_ = v.Args[3]
   18768 		p := v.Args[0]
   18769 		idx := v.Args[1]
   18770 		v_2 := v.Args[2]
   18771 		if v_2.Op != OpS390XSRDconst {
   18772 			break
   18773 		}
   18774 		j := v_2.AuxInt
   18775 		w := v_2.Args[0]
   18776 		x := v.Args[3]
   18777 		if x.Op != OpS390XMOVWBRstoreidx {
   18778 			break
   18779 		}
   18780 		if x.AuxInt != i-4 {
   18781 			break
   18782 		}
   18783 		if x.Aux != s {
   18784 			break
   18785 		}
   18786 		_ = x.Args[3]
   18787 		if idx != x.Args[0] {
   18788 			break
   18789 		}
   18790 		if p != x.Args[1] {
   18791 			break
   18792 		}
   18793 		w0 := x.Args[2]
   18794 		if w0.Op != OpS390XSRDconst {
   18795 			break
   18796 		}
   18797 		if w0.AuxInt != j-32 {
   18798 			break
   18799 		}
   18800 		if w != w0.Args[0] {
   18801 			break
   18802 		}
   18803 		mem := x.Args[3]
   18804 		if !(x.Uses == 1 && clobber(x)) {
   18805 			break
   18806 		}
   18807 		v.reset(OpS390XMOVDBRstoreidx)
   18808 		v.AuxInt = i - 4
   18809 		v.Aux = s
   18810 		v.AddArg(p)
   18811 		v.AddArg(idx)
   18812 		v.AddArg(w0)
   18813 		v.AddArg(mem)
   18814 		return true
   18815 	}
   18816 	// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} p idx w0:(SRDconst [j-32] w) mem))
   18817 	// cond: x.Uses == 1   && clobber(x)
   18818 	// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
   18819 	for {
   18820 		i := v.AuxInt
   18821 		s := v.Aux
   18822 		_ = v.Args[3]
   18823 		idx := v.Args[0]
   18824 		p := v.Args[1]
   18825 		v_2 := v.Args[2]
   18826 		if v_2.Op != OpS390XSRDconst {
   18827 			break
   18828 		}
   18829 		j := v_2.AuxInt
   18830 		w := v_2.Args[0]
   18831 		x := v.Args[3]
   18832 		if x.Op != OpS390XMOVWBRstoreidx {
   18833 			break
   18834 		}
   18835 		if x.AuxInt != i-4 {
   18836 			break
   18837 		}
   18838 		if x.Aux != s {
   18839 			break
   18840 		}
   18841 		_ = x.Args[3]
   18842 		if p != x.Args[0] {
   18843 			break
   18844 		}
   18845 		if idx != x.Args[1] {
   18846 			break
   18847 		}
   18848 		w0 := x.Args[2]
   18849 		if w0.Op != OpS390XSRDconst {
   18850 			break
   18851 		}
   18852 		if w0.AuxInt != j-32 {
   18853 			break
   18854 		}
   18855 		if w != w0.Args[0] {
   18856 			break
   18857 		}
   18858 		mem := x.Args[3]
   18859 		if !(x.Uses == 1 && clobber(x)) {
   18860 			break
   18861 		}
   18862 		v.reset(OpS390XMOVDBRstoreidx)
   18863 		v.AuxInt = i - 4
   18864 		v.Aux = s
   18865 		v.AddArg(p)
   18866 		v.AddArg(idx)
   18867 		v.AddArg(w0)
   18868 		v.AddArg(mem)
   18869 		return true
   18870 	}
   18871 	// match: (MOVWBRstoreidx [i] {s} idx p (SRDconst [j] w) x:(MOVWBRstoreidx [i-4] {s} idx p w0:(SRDconst [j-32] w) mem))
   18872 	// cond: x.Uses == 1   && clobber(x)
   18873 	// result: (MOVDBRstoreidx [i-4] {s} p idx w0 mem)
   18874 	for {
   18875 		i := v.AuxInt
   18876 		s := v.Aux
   18877 		_ = v.Args[3]
   18878 		idx := v.Args[0]
   18879 		p := v.Args[1]
   18880 		v_2 := v.Args[2]
   18881 		if v_2.Op != OpS390XSRDconst {
   18882 			break
   18883 		}
   18884 		j := v_2.AuxInt
   18885 		w := v_2.Args[0]
   18886 		x := v.Args[3]
   18887 		if x.Op != OpS390XMOVWBRstoreidx {
   18888 			break
   18889 		}
   18890 		if x.AuxInt != i-4 {
   18891 			break
   18892 		}
   18893 		if x.Aux != s {
   18894 			break
   18895 		}
   18896 		_ = x.Args[3]
   18897 		if idx != x.Args[0] {
   18898 			break
   18899 		}
   18900 		if p != x.Args[1] {
   18901 			break
   18902 		}
   18903 		w0 := x.Args[2]
   18904 		if w0.Op != OpS390XSRDconst {
   18905 			break
   18906 		}
   18907 		if w0.AuxInt != j-32 {
   18908 			break
   18909 		}
   18910 		if w != w0.Args[0] {
   18911 			break
   18912 		}
   18913 		mem := x.Args[3]
   18914 		if !(x.Uses == 1 && clobber(x)) {
   18915 			break
   18916 		}
   18917 		v.reset(OpS390XMOVDBRstoreidx)
   18918 		v.AuxInt = i - 4
   18919 		v.Aux = s
   18920 		v.AddArg(p)
   18921 		v.AddArg(idx)
   18922 		v.AddArg(w0)
   18923 		v.AddArg(mem)
   18924 		return true
   18925 	}
   18926 	return false
   18927 }
   18928 func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool {
   18929 	// match: (MOVWZload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
   18930 	// cond: isSamePtr(ptr1, ptr2)
   18931 	// result: (MOVWZreg x)
   18932 	for {
   18933 		off := v.AuxInt
   18934 		sym := v.Aux
   18935 		_ = v.Args[1]
   18936 		ptr1 := v.Args[0]
   18937 		v_1 := v.Args[1]
   18938 		if v_1.Op != OpS390XMOVWstore {
   18939 			break
   18940 		}
   18941 		if v_1.AuxInt != off {
   18942 			break
   18943 		}
   18944 		if v_1.Aux != sym {
   18945 			break
   18946 		}
   18947 		_ = v_1.Args[2]
   18948 		ptr2 := v_1.Args[0]
   18949 		x := v_1.Args[1]
   18950 		if !(isSamePtr(ptr1, ptr2)) {
   18951 			break
   18952 		}
   18953 		v.reset(OpS390XMOVWZreg)
   18954 		v.AddArg(x)
   18955 		return true
   18956 	}
   18957 	// match: (MOVWZload [off1] {sym} (ADDconst [off2] ptr) mem)
   18958 	// cond: is20Bit(off1+off2)
   18959 	// result: (MOVWZload [off1+off2] {sym} ptr mem)
   18960 	for {
   18961 		off1 := v.AuxInt
   18962 		sym := v.Aux
   18963 		_ = v.Args[1]
   18964 		v_0 := v.Args[0]
   18965 		if v_0.Op != OpS390XADDconst {
   18966 			break
   18967 		}
   18968 		off2 := v_0.AuxInt
   18969 		ptr := v_0.Args[0]
   18970 		mem := v.Args[1]
   18971 		if !(is20Bit(off1 + off2)) {
   18972 			break
   18973 		}
   18974 		v.reset(OpS390XMOVWZload)
   18975 		v.AuxInt = off1 + off2
   18976 		v.Aux = sym
   18977 		v.AddArg(ptr)
   18978 		v.AddArg(mem)
   18979 		return true
   18980 	}
   18981 	// match: (MOVWZload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
   18982 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%4 == 0 && (off1+off2)%4 == 0))
   18983 	// result: (MOVWZload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   18984 	for {
   18985 		off1 := v.AuxInt
   18986 		sym1 := v.Aux
   18987 		_ = v.Args[1]
   18988 		v_0 := v.Args[0]
   18989 		if v_0.Op != OpS390XMOVDaddr {
   18990 			break
   18991 		}
   18992 		t := v_0.Type
   18993 		off2 := v_0.AuxInt
   18994 		sym2 := v_0.Aux
   18995 		base := v_0.Args[0]
   18996 		mem := v.Args[1]
   18997 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%4 == 0 && (off1+off2)%4 == 0))) {
   18998 			break
   18999 		}
   19000 		v.reset(OpS390XMOVWZload)
   19001 		v.AuxInt = off1 + off2
   19002 		v.Aux = mergeSym(sym1, sym2)
   19003 		v.AddArg(base)
   19004 		v.AddArg(mem)
   19005 		return true
   19006 	}
   19007 	// match: (MOVWZload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   19008 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   19009 	// result: (MOVWZloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   19010 	for {
   19011 		off1 := v.AuxInt
   19012 		sym1 := v.Aux
   19013 		_ = v.Args[1]
   19014 		v_0 := v.Args[0]
   19015 		if v_0.Op != OpS390XMOVDaddridx {
   19016 			break
   19017 		}
   19018 		off2 := v_0.AuxInt
   19019 		sym2 := v_0.Aux
   19020 		_ = v_0.Args[1]
   19021 		ptr := v_0.Args[0]
   19022 		idx := v_0.Args[1]
   19023 		mem := v.Args[1]
   19024 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   19025 			break
   19026 		}
   19027 		v.reset(OpS390XMOVWZloadidx)
   19028 		v.AuxInt = off1 + off2
   19029 		v.Aux = mergeSym(sym1, sym2)
   19030 		v.AddArg(ptr)
   19031 		v.AddArg(idx)
   19032 		v.AddArg(mem)
   19033 		return true
   19034 	}
   19035 	// match: (MOVWZload [off] {sym} (ADD ptr idx) mem)
   19036 	// cond: ptr.Op != OpSB
   19037 	// result: (MOVWZloadidx [off] {sym} ptr idx mem)
   19038 	for {
   19039 		off := v.AuxInt
   19040 		sym := v.Aux
   19041 		_ = v.Args[1]
   19042 		v_0 := v.Args[0]
   19043 		if v_0.Op != OpS390XADD {
   19044 			break
   19045 		}
   19046 		_ = v_0.Args[1]
   19047 		ptr := v_0.Args[0]
   19048 		idx := v_0.Args[1]
   19049 		mem := v.Args[1]
   19050 		if !(ptr.Op != OpSB) {
   19051 			break
   19052 		}
   19053 		v.reset(OpS390XMOVWZloadidx)
   19054 		v.AuxInt = off
   19055 		v.Aux = sym
   19056 		v.AddArg(ptr)
   19057 		v.AddArg(idx)
   19058 		v.AddArg(mem)
   19059 		return true
   19060 	}
   19061 	return false
   19062 }
   19063 func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool {
   19064 	// match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   19065 	// cond: is20Bit(c+d)
   19066 	// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
   19067 	for {
   19068 		c := v.AuxInt
   19069 		sym := v.Aux
   19070 		_ = v.Args[2]
   19071 		v_0 := v.Args[0]
   19072 		if v_0.Op != OpS390XADDconst {
   19073 			break
   19074 		}
   19075 		d := v_0.AuxInt
   19076 		ptr := v_0.Args[0]
   19077 		idx := v.Args[1]
   19078 		mem := v.Args[2]
   19079 		if !(is20Bit(c + d)) {
   19080 			break
   19081 		}
   19082 		v.reset(OpS390XMOVWZloadidx)
   19083 		v.AuxInt = c + d
   19084 		v.Aux = sym
   19085 		v.AddArg(ptr)
   19086 		v.AddArg(idx)
   19087 		v.AddArg(mem)
   19088 		return true
   19089 	}
   19090 	// match: (MOVWZloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   19091 	// cond: is20Bit(c+d)
   19092 	// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
   19093 	for {
   19094 		c := v.AuxInt
   19095 		sym := v.Aux
   19096 		_ = v.Args[2]
   19097 		idx := v.Args[0]
   19098 		v_1 := v.Args[1]
   19099 		if v_1.Op != OpS390XADDconst {
   19100 			break
   19101 		}
   19102 		d := v_1.AuxInt
   19103 		ptr := v_1.Args[0]
   19104 		mem := v.Args[2]
   19105 		if !(is20Bit(c + d)) {
   19106 			break
   19107 		}
   19108 		v.reset(OpS390XMOVWZloadidx)
   19109 		v.AuxInt = c + d
   19110 		v.Aux = sym
   19111 		v.AddArg(ptr)
   19112 		v.AddArg(idx)
   19113 		v.AddArg(mem)
   19114 		return true
   19115 	}
   19116 	// match: (MOVWZloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   19117 	// cond: is20Bit(c+d)
   19118 	// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
   19119 	for {
   19120 		c := v.AuxInt
   19121 		sym := v.Aux
   19122 		_ = v.Args[2]
   19123 		ptr := v.Args[0]
   19124 		v_1 := v.Args[1]
   19125 		if v_1.Op != OpS390XADDconst {
   19126 			break
   19127 		}
   19128 		d := v_1.AuxInt
   19129 		idx := v_1.Args[0]
   19130 		mem := v.Args[2]
   19131 		if !(is20Bit(c + d)) {
   19132 			break
   19133 		}
   19134 		v.reset(OpS390XMOVWZloadidx)
   19135 		v.AuxInt = c + d
   19136 		v.Aux = sym
   19137 		v.AddArg(ptr)
   19138 		v.AddArg(idx)
   19139 		v.AddArg(mem)
   19140 		return true
   19141 	}
   19142 	// match: (MOVWZloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   19143 	// cond: is20Bit(c+d)
   19144 	// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
   19145 	for {
   19146 		c := v.AuxInt
   19147 		sym := v.Aux
   19148 		_ = v.Args[2]
   19149 		v_0 := v.Args[0]
   19150 		if v_0.Op != OpS390XADDconst {
   19151 			break
   19152 		}
   19153 		d := v_0.AuxInt
   19154 		idx := v_0.Args[0]
   19155 		ptr := v.Args[1]
   19156 		mem := v.Args[2]
   19157 		if !(is20Bit(c + d)) {
   19158 			break
   19159 		}
   19160 		v.reset(OpS390XMOVWZloadidx)
   19161 		v.AuxInt = c + d
   19162 		v.Aux = sym
   19163 		v.AddArg(ptr)
   19164 		v.AddArg(idx)
   19165 		v.AddArg(mem)
   19166 		return true
   19167 	}
   19168 	return false
   19169 }
   19170 func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool {
   19171 	b := v.Block
   19172 	_ = b
   19173 	// match: (MOVWZreg x:(MOVBZload _ _))
   19174 	// cond:
   19175 	// result: (MOVDreg x)
   19176 	for {
   19177 		x := v.Args[0]
   19178 		if x.Op != OpS390XMOVBZload {
   19179 			break
   19180 		}
   19181 		_ = x.Args[1]
   19182 		v.reset(OpS390XMOVDreg)
   19183 		v.AddArg(x)
   19184 		return true
   19185 	}
   19186 	// match: (MOVWZreg x:(MOVHZload _ _))
   19187 	// cond:
   19188 	// result: (MOVDreg x)
   19189 	for {
   19190 		x := v.Args[0]
   19191 		if x.Op != OpS390XMOVHZload {
   19192 			break
   19193 		}
   19194 		_ = x.Args[1]
   19195 		v.reset(OpS390XMOVDreg)
   19196 		v.AddArg(x)
   19197 		return true
   19198 	}
   19199 	// match: (MOVWZreg x:(MOVWZload _ _))
   19200 	// cond:
   19201 	// result: (MOVDreg x)
   19202 	for {
   19203 		x := v.Args[0]
   19204 		if x.Op != OpS390XMOVWZload {
   19205 			break
   19206 		}
   19207 		_ = x.Args[1]
   19208 		v.reset(OpS390XMOVDreg)
   19209 		v.AddArg(x)
   19210 		return true
   19211 	}
   19212 	// match: (MOVWZreg x:(Arg <t>))
   19213 	// cond: (is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && !isSigned(t)
   19214 	// result: (MOVDreg x)
   19215 	for {
   19216 		x := v.Args[0]
   19217 		if x.Op != OpArg {
   19218 			break
   19219 		}
   19220 		t := x.Type
   19221 		if !((is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && !isSigned(t)) {
   19222 			break
   19223 		}
   19224 		v.reset(OpS390XMOVDreg)
   19225 		v.AddArg(x)
   19226 		return true
   19227 	}
   19228 	// match: (MOVWZreg x:(MOVBZreg _))
   19229 	// cond:
   19230 	// result: (MOVDreg x)
   19231 	for {
   19232 		x := v.Args[0]
   19233 		if x.Op != OpS390XMOVBZreg {
   19234 			break
   19235 		}
   19236 		v.reset(OpS390XMOVDreg)
   19237 		v.AddArg(x)
   19238 		return true
   19239 	}
   19240 	// match: (MOVWZreg x:(MOVHZreg _))
   19241 	// cond:
   19242 	// result: (MOVDreg x)
   19243 	for {
   19244 		x := v.Args[0]
   19245 		if x.Op != OpS390XMOVHZreg {
   19246 			break
   19247 		}
   19248 		v.reset(OpS390XMOVDreg)
   19249 		v.AddArg(x)
   19250 		return true
   19251 	}
   19252 	// match: (MOVWZreg x:(MOVWZreg _))
   19253 	// cond:
   19254 	// result: (MOVDreg x)
   19255 	for {
   19256 		x := v.Args[0]
   19257 		if x.Op != OpS390XMOVWZreg {
   19258 			break
   19259 		}
   19260 		v.reset(OpS390XMOVDreg)
   19261 		v.AddArg(x)
   19262 		return true
   19263 	}
   19264 	// match: (MOVWZreg (MOVDconst [c]))
   19265 	// cond:
   19266 	// result: (MOVDconst [int64(uint32(c))])
   19267 	for {
   19268 		v_0 := v.Args[0]
   19269 		if v_0.Op != OpS390XMOVDconst {
   19270 			break
   19271 		}
   19272 		c := v_0.AuxInt
   19273 		v.reset(OpS390XMOVDconst)
   19274 		v.AuxInt = int64(uint32(c))
   19275 		return true
   19276 	}
   19277 	// match: (MOVWZreg x:(MOVWZload [off] {sym} ptr mem))
   19278 	// cond: x.Uses == 1 && clobber(x)
   19279 	// result: @x.Block (MOVWZload <v.Type> [off] {sym} ptr mem)
   19280 	for {
   19281 		x := v.Args[0]
   19282 		if x.Op != OpS390XMOVWZload {
   19283 			break
   19284 		}
   19285 		off := x.AuxInt
   19286 		sym := x.Aux
   19287 		_ = x.Args[1]
   19288 		ptr := x.Args[0]
   19289 		mem := x.Args[1]
   19290 		if !(x.Uses == 1 && clobber(x)) {
   19291 			break
   19292 		}
   19293 		b = x.Block
   19294 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, v.Type)
   19295 		v.reset(OpCopy)
   19296 		v.AddArg(v0)
   19297 		v0.AuxInt = off
   19298 		v0.Aux = sym
   19299 		v0.AddArg(ptr)
   19300 		v0.AddArg(mem)
   19301 		return true
   19302 	}
   19303 	// match: (MOVWZreg x:(MOVWload [off] {sym} ptr mem))
   19304 	// cond: x.Uses == 1 && clobber(x)
   19305 	// result: @x.Block (MOVWZload <v.Type> [off] {sym} ptr mem)
   19306 	for {
   19307 		x := v.Args[0]
   19308 		if x.Op != OpS390XMOVWload {
   19309 			break
   19310 		}
   19311 		off := x.AuxInt
   19312 		sym := x.Aux
   19313 		_ = x.Args[1]
   19314 		ptr := x.Args[0]
   19315 		mem := x.Args[1]
   19316 		if !(x.Uses == 1 && clobber(x)) {
   19317 			break
   19318 		}
   19319 		b = x.Block
   19320 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, v.Type)
   19321 		v.reset(OpCopy)
   19322 		v.AddArg(v0)
   19323 		v0.AuxInt = off
   19324 		v0.Aux = sym
   19325 		v0.AddArg(ptr)
   19326 		v0.AddArg(mem)
   19327 		return true
   19328 	}
   19329 	return false
   19330 }
   19331 func rewriteValueS390X_OpS390XMOVWZreg_10(v *Value) bool {
   19332 	b := v.Block
   19333 	_ = b
   19334 	// match: (MOVWZreg x:(MOVWZloadidx [off] {sym} ptr idx mem))
   19335 	// cond: x.Uses == 1 && clobber(x)
   19336 	// result: @x.Block (MOVWZloadidx <v.Type> [off] {sym} ptr idx mem)
   19337 	for {
   19338 		x := v.Args[0]
   19339 		if x.Op != OpS390XMOVWZloadidx {
   19340 			break
   19341 		}
   19342 		off := x.AuxInt
   19343 		sym := x.Aux
   19344 		_ = x.Args[2]
   19345 		ptr := x.Args[0]
   19346 		idx := x.Args[1]
   19347 		mem := x.Args[2]
   19348 		if !(x.Uses == 1 && clobber(x)) {
   19349 			break
   19350 		}
   19351 		b = x.Block
   19352 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, v.Type)
   19353 		v.reset(OpCopy)
   19354 		v.AddArg(v0)
   19355 		v0.AuxInt = off
   19356 		v0.Aux = sym
   19357 		v0.AddArg(ptr)
   19358 		v0.AddArg(idx)
   19359 		v0.AddArg(mem)
   19360 		return true
   19361 	}
   19362 	// match: (MOVWZreg x:(MOVWloadidx [off] {sym} ptr idx mem))
   19363 	// cond: x.Uses == 1 && clobber(x)
   19364 	// result: @x.Block (MOVWZloadidx <v.Type> [off] {sym} ptr idx mem)
   19365 	for {
   19366 		x := v.Args[0]
   19367 		if x.Op != OpS390XMOVWloadidx {
   19368 			break
   19369 		}
   19370 		off := x.AuxInt
   19371 		sym := x.Aux
   19372 		_ = x.Args[2]
   19373 		ptr := x.Args[0]
   19374 		idx := x.Args[1]
   19375 		mem := x.Args[2]
   19376 		if !(x.Uses == 1 && clobber(x)) {
   19377 			break
   19378 		}
   19379 		b = x.Block
   19380 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, v.Type)
   19381 		v.reset(OpCopy)
   19382 		v.AddArg(v0)
   19383 		v0.AuxInt = off
   19384 		v0.Aux = sym
   19385 		v0.AddArg(ptr)
   19386 		v0.AddArg(idx)
   19387 		v0.AddArg(mem)
   19388 		return true
   19389 	}
   19390 	return false
   19391 }
   19392 func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool {
   19393 	// match: (MOVWload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
   19394 	// cond: isSamePtr(ptr1, ptr2)
   19395 	// result: (MOVWreg x)
   19396 	for {
   19397 		off := v.AuxInt
   19398 		sym := v.Aux
   19399 		_ = v.Args[1]
   19400 		ptr1 := v.Args[0]
   19401 		v_1 := v.Args[1]
   19402 		if v_1.Op != OpS390XMOVWstore {
   19403 			break
   19404 		}
   19405 		if v_1.AuxInt != off {
   19406 			break
   19407 		}
   19408 		if v_1.Aux != sym {
   19409 			break
   19410 		}
   19411 		_ = v_1.Args[2]
   19412 		ptr2 := v_1.Args[0]
   19413 		x := v_1.Args[1]
   19414 		if !(isSamePtr(ptr1, ptr2)) {
   19415 			break
   19416 		}
   19417 		v.reset(OpS390XMOVWreg)
   19418 		v.AddArg(x)
   19419 		return true
   19420 	}
   19421 	// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
   19422 	// cond: is20Bit(off1+off2)
   19423 	// result: (MOVWload  [off1+off2] {sym} ptr mem)
   19424 	for {
   19425 		off1 := v.AuxInt
   19426 		sym := v.Aux
   19427 		_ = v.Args[1]
   19428 		v_0 := v.Args[0]
   19429 		if v_0.Op != OpS390XADDconst {
   19430 			break
   19431 		}
   19432 		off2 := v_0.AuxInt
   19433 		ptr := v_0.Args[0]
   19434 		mem := v.Args[1]
   19435 		if !(is20Bit(off1 + off2)) {
   19436 			break
   19437 		}
   19438 		v.reset(OpS390XMOVWload)
   19439 		v.AuxInt = off1 + off2
   19440 		v.Aux = sym
   19441 		v.AddArg(ptr)
   19442 		v.AddArg(mem)
   19443 		return true
   19444 	}
   19445 	// match: (MOVWload [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) mem)
   19446 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%4 == 0 && (off1+off2)%4 == 0))
   19447 	// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   19448 	for {
   19449 		off1 := v.AuxInt
   19450 		sym1 := v.Aux
   19451 		_ = v.Args[1]
   19452 		v_0 := v.Args[0]
   19453 		if v_0.Op != OpS390XMOVDaddr {
   19454 			break
   19455 		}
   19456 		t := v_0.Type
   19457 		off2 := v_0.AuxInt
   19458 		sym2 := v_0.Aux
   19459 		base := v_0.Args[0]
   19460 		mem := v.Args[1]
   19461 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%4 == 0 && (off1+off2)%4 == 0))) {
   19462 			break
   19463 		}
   19464 		v.reset(OpS390XMOVWload)
   19465 		v.AuxInt = off1 + off2
   19466 		v.Aux = mergeSym(sym1, sym2)
   19467 		v.AddArg(base)
   19468 		v.AddArg(mem)
   19469 		return true
   19470 	}
   19471 	// match: (MOVWload [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) mem)
   19472 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   19473 	// result: (MOVWloadidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   19474 	for {
   19475 		off1 := v.AuxInt
   19476 		sym1 := v.Aux
   19477 		_ = v.Args[1]
   19478 		v_0 := v.Args[0]
   19479 		if v_0.Op != OpS390XMOVDaddridx {
   19480 			break
   19481 		}
   19482 		off2 := v_0.AuxInt
   19483 		sym2 := v_0.Aux
   19484 		_ = v_0.Args[1]
   19485 		ptr := v_0.Args[0]
   19486 		idx := v_0.Args[1]
   19487 		mem := v.Args[1]
   19488 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   19489 			break
   19490 		}
   19491 		v.reset(OpS390XMOVWloadidx)
   19492 		v.AuxInt = off1 + off2
   19493 		v.Aux = mergeSym(sym1, sym2)
   19494 		v.AddArg(ptr)
   19495 		v.AddArg(idx)
   19496 		v.AddArg(mem)
   19497 		return true
   19498 	}
   19499 	// match: (MOVWload [off] {sym} (ADD ptr idx) mem)
   19500 	// cond: ptr.Op != OpSB
   19501 	// result: (MOVWloadidx  [off] {sym} ptr idx mem)
   19502 	for {
   19503 		off := v.AuxInt
   19504 		sym := v.Aux
   19505 		_ = v.Args[1]
   19506 		v_0 := v.Args[0]
   19507 		if v_0.Op != OpS390XADD {
   19508 			break
   19509 		}
   19510 		_ = v_0.Args[1]
   19511 		ptr := v_0.Args[0]
   19512 		idx := v_0.Args[1]
   19513 		mem := v.Args[1]
   19514 		if !(ptr.Op != OpSB) {
   19515 			break
   19516 		}
   19517 		v.reset(OpS390XMOVWloadidx)
   19518 		v.AuxInt = off
   19519 		v.Aux = sym
   19520 		v.AddArg(ptr)
   19521 		v.AddArg(idx)
   19522 		v.AddArg(mem)
   19523 		return true
   19524 	}
   19525 	return false
   19526 }
   19527 func rewriteValueS390X_OpS390XMOVWloadidx_0(v *Value) bool {
   19528 	// match: (MOVWloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
   19529 	// cond: is20Bit(c+d)
   19530 	// result: (MOVWloadidx  [c+d] {sym} ptr idx mem)
   19531 	for {
   19532 		c := v.AuxInt
   19533 		sym := v.Aux
   19534 		_ = v.Args[2]
   19535 		v_0 := v.Args[0]
   19536 		if v_0.Op != OpS390XADDconst {
   19537 			break
   19538 		}
   19539 		d := v_0.AuxInt
   19540 		ptr := v_0.Args[0]
   19541 		idx := v.Args[1]
   19542 		mem := v.Args[2]
   19543 		if !(is20Bit(c + d)) {
   19544 			break
   19545 		}
   19546 		v.reset(OpS390XMOVWloadidx)
   19547 		v.AuxInt = c + d
   19548 		v.Aux = sym
   19549 		v.AddArg(ptr)
   19550 		v.AddArg(idx)
   19551 		v.AddArg(mem)
   19552 		return true
   19553 	}
   19554 	// match: (MOVWloadidx [c] {sym} idx (ADDconst [d] ptr) mem)
   19555 	// cond: is20Bit(c+d)
   19556 	// result: (MOVWloadidx  [c+d] {sym} ptr idx mem)
   19557 	for {
   19558 		c := v.AuxInt
   19559 		sym := v.Aux
   19560 		_ = v.Args[2]
   19561 		idx := v.Args[0]
   19562 		v_1 := v.Args[1]
   19563 		if v_1.Op != OpS390XADDconst {
   19564 			break
   19565 		}
   19566 		d := v_1.AuxInt
   19567 		ptr := v_1.Args[0]
   19568 		mem := v.Args[2]
   19569 		if !(is20Bit(c + d)) {
   19570 			break
   19571 		}
   19572 		v.reset(OpS390XMOVWloadidx)
   19573 		v.AuxInt = c + d
   19574 		v.Aux = sym
   19575 		v.AddArg(ptr)
   19576 		v.AddArg(idx)
   19577 		v.AddArg(mem)
   19578 		return true
   19579 	}
   19580 	// match: (MOVWloadidx [c] {sym} ptr (ADDconst [d] idx) mem)
   19581 	// cond: is20Bit(c+d)
   19582 	// result: (MOVWloadidx  [c+d] {sym} ptr idx mem)
   19583 	for {
   19584 		c := v.AuxInt
   19585 		sym := v.Aux
   19586 		_ = v.Args[2]
   19587 		ptr := v.Args[0]
   19588 		v_1 := v.Args[1]
   19589 		if v_1.Op != OpS390XADDconst {
   19590 			break
   19591 		}
   19592 		d := v_1.AuxInt
   19593 		idx := v_1.Args[0]
   19594 		mem := v.Args[2]
   19595 		if !(is20Bit(c + d)) {
   19596 			break
   19597 		}
   19598 		v.reset(OpS390XMOVWloadidx)
   19599 		v.AuxInt = c + d
   19600 		v.Aux = sym
   19601 		v.AddArg(ptr)
   19602 		v.AddArg(idx)
   19603 		v.AddArg(mem)
   19604 		return true
   19605 	}
   19606 	// match: (MOVWloadidx [c] {sym} (ADDconst [d] idx) ptr mem)
   19607 	// cond: is20Bit(c+d)
   19608 	// result: (MOVWloadidx  [c+d] {sym} ptr idx mem)
   19609 	for {
   19610 		c := v.AuxInt
   19611 		sym := v.Aux
   19612 		_ = v.Args[2]
   19613 		v_0 := v.Args[0]
   19614 		if v_0.Op != OpS390XADDconst {
   19615 			break
   19616 		}
   19617 		d := v_0.AuxInt
   19618 		idx := v_0.Args[0]
   19619 		ptr := v.Args[1]
   19620 		mem := v.Args[2]
   19621 		if !(is20Bit(c + d)) {
   19622 			break
   19623 		}
   19624 		v.reset(OpS390XMOVWloadidx)
   19625 		v.AuxInt = c + d
   19626 		v.Aux = sym
   19627 		v.AddArg(ptr)
   19628 		v.AddArg(idx)
   19629 		v.AddArg(mem)
   19630 		return true
   19631 	}
   19632 	return false
   19633 }
   19634 func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool {
   19635 	// match: (MOVWreg x:(MOVBload _ _))
   19636 	// cond:
   19637 	// result: (MOVDreg x)
   19638 	for {
   19639 		x := v.Args[0]
   19640 		if x.Op != OpS390XMOVBload {
   19641 			break
   19642 		}
   19643 		_ = x.Args[1]
   19644 		v.reset(OpS390XMOVDreg)
   19645 		v.AddArg(x)
   19646 		return true
   19647 	}
   19648 	// match: (MOVWreg x:(MOVBZload _ _))
   19649 	// cond:
   19650 	// result: (MOVDreg x)
   19651 	for {
   19652 		x := v.Args[0]
   19653 		if x.Op != OpS390XMOVBZload {
   19654 			break
   19655 		}
   19656 		_ = x.Args[1]
   19657 		v.reset(OpS390XMOVDreg)
   19658 		v.AddArg(x)
   19659 		return true
   19660 	}
   19661 	// match: (MOVWreg x:(MOVHload _ _))
   19662 	// cond:
   19663 	// result: (MOVDreg x)
   19664 	for {
   19665 		x := v.Args[0]
   19666 		if x.Op != OpS390XMOVHload {
   19667 			break
   19668 		}
   19669 		_ = x.Args[1]
   19670 		v.reset(OpS390XMOVDreg)
   19671 		v.AddArg(x)
   19672 		return true
   19673 	}
   19674 	// match: (MOVWreg x:(MOVHZload _ _))
   19675 	// cond:
   19676 	// result: (MOVDreg x)
   19677 	for {
   19678 		x := v.Args[0]
   19679 		if x.Op != OpS390XMOVHZload {
   19680 			break
   19681 		}
   19682 		_ = x.Args[1]
   19683 		v.reset(OpS390XMOVDreg)
   19684 		v.AddArg(x)
   19685 		return true
   19686 	}
   19687 	// match: (MOVWreg x:(MOVWload _ _))
   19688 	// cond:
   19689 	// result: (MOVDreg x)
   19690 	for {
   19691 		x := v.Args[0]
   19692 		if x.Op != OpS390XMOVWload {
   19693 			break
   19694 		}
   19695 		_ = x.Args[1]
   19696 		v.reset(OpS390XMOVDreg)
   19697 		v.AddArg(x)
   19698 		return true
   19699 	}
   19700 	// match: (MOVWreg x:(Arg <t>))
   19701 	// cond: (is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && isSigned(t)
   19702 	// result: (MOVDreg x)
   19703 	for {
   19704 		x := v.Args[0]
   19705 		if x.Op != OpArg {
   19706 			break
   19707 		}
   19708 		t := x.Type
   19709 		if !((is8BitInt(t) || is16BitInt(t) || is32BitInt(t)) && isSigned(t)) {
   19710 			break
   19711 		}
   19712 		v.reset(OpS390XMOVDreg)
   19713 		v.AddArg(x)
   19714 		return true
   19715 	}
   19716 	// match: (MOVWreg x:(MOVBreg _))
   19717 	// cond:
   19718 	// result: (MOVDreg x)
   19719 	for {
   19720 		x := v.Args[0]
   19721 		if x.Op != OpS390XMOVBreg {
   19722 			break
   19723 		}
   19724 		v.reset(OpS390XMOVDreg)
   19725 		v.AddArg(x)
   19726 		return true
   19727 	}
   19728 	// match: (MOVWreg x:(MOVBZreg _))
   19729 	// cond:
   19730 	// result: (MOVDreg x)
   19731 	for {
   19732 		x := v.Args[0]
   19733 		if x.Op != OpS390XMOVBZreg {
   19734 			break
   19735 		}
   19736 		v.reset(OpS390XMOVDreg)
   19737 		v.AddArg(x)
   19738 		return true
   19739 	}
   19740 	// match: (MOVWreg x:(MOVHreg _))
   19741 	// cond:
   19742 	// result: (MOVDreg x)
   19743 	for {
   19744 		x := v.Args[0]
   19745 		if x.Op != OpS390XMOVHreg {
   19746 			break
   19747 		}
   19748 		v.reset(OpS390XMOVDreg)
   19749 		v.AddArg(x)
   19750 		return true
   19751 	}
   19752 	// match: (MOVWreg x:(MOVHreg _))
   19753 	// cond:
   19754 	// result: (MOVDreg x)
   19755 	for {
   19756 		x := v.Args[0]
   19757 		if x.Op != OpS390XMOVHreg {
   19758 			break
   19759 		}
   19760 		v.reset(OpS390XMOVDreg)
   19761 		v.AddArg(x)
   19762 		return true
   19763 	}
   19764 	return false
   19765 }
   19766 func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool {
   19767 	b := v.Block
   19768 	_ = b
   19769 	// match: (MOVWreg x:(MOVWreg _))
   19770 	// cond:
   19771 	// result: (MOVDreg x)
   19772 	for {
   19773 		x := v.Args[0]
   19774 		if x.Op != OpS390XMOVWreg {
   19775 			break
   19776 		}
   19777 		v.reset(OpS390XMOVDreg)
   19778 		v.AddArg(x)
   19779 		return true
   19780 	}
   19781 	// match: (MOVWreg (MOVDconst [c]))
   19782 	// cond:
   19783 	// result: (MOVDconst [int64(int32(c))])
   19784 	for {
   19785 		v_0 := v.Args[0]
   19786 		if v_0.Op != OpS390XMOVDconst {
   19787 			break
   19788 		}
   19789 		c := v_0.AuxInt
   19790 		v.reset(OpS390XMOVDconst)
   19791 		v.AuxInt = int64(int32(c))
   19792 		return true
   19793 	}
   19794 	// match: (MOVWreg x:(MOVWZload [off] {sym} ptr mem))
   19795 	// cond: x.Uses == 1 && clobber(x)
   19796 	// result: @x.Block (MOVWload  <v.Type> [off] {sym} ptr mem)
   19797 	for {
   19798 		x := v.Args[0]
   19799 		if x.Op != OpS390XMOVWZload {
   19800 			break
   19801 		}
   19802 		off := x.AuxInt
   19803 		sym := x.Aux
   19804 		_ = x.Args[1]
   19805 		ptr := x.Args[0]
   19806 		mem := x.Args[1]
   19807 		if !(x.Uses == 1 && clobber(x)) {
   19808 			break
   19809 		}
   19810 		b = x.Block
   19811 		v0 := b.NewValue0(v.Pos, OpS390XMOVWload, v.Type)
   19812 		v.reset(OpCopy)
   19813 		v.AddArg(v0)
   19814 		v0.AuxInt = off
   19815 		v0.Aux = sym
   19816 		v0.AddArg(ptr)
   19817 		v0.AddArg(mem)
   19818 		return true
   19819 	}
   19820 	// match: (MOVWreg x:(MOVWload [off] {sym} ptr mem))
   19821 	// cond: x.Uses == 1 && clobber(x)
   19822 	// result: @x.Block (MOVWload  <v.Type> [off] {sym} ptr mem)
   19823 	for {
   19824 		x := v.Args[0]
   19825 		if x.Op != OpS390XMOVWload {
   19826 			break
   19827 		}
   19828 		off := x.AuxInt
   19829 		sym := x.Aux
   19830 		_ = x.Args[1]
   19831 		ptr := x.Args[0]
   19832 		mem := x.Args[1]
   19833 		if !(x.Uses == 1 && clobber(x)) {
   19834 			break
   19835 		}
   19836 		b = x.Block
   19837 		v0 := b.NewValue0(v.Pos, OpS390XMOVWload, v.Type)
   19838 		v.reset(OpCopy)
   19839 		v.AddArg(v0)
   19840 		v0.AuxInt = off
   19841 		v0.Aux = sym
   19842 		v0.AddArg(ptr)
   19843 		v0.AddArg(mem)
   19844 		return true
   19845 	}
   19846 	// match: (MOVWreg x:(MOVWZloadidx [off] {sym} ptr idx mem))
   19847 	// cond: x.Uses == 1 && clobber(x)
   19848 	// result: @x.Block (MOVWloadidx  <v.Type> [off] {sym} ptr idx mem)
   19849 	for {
   19850 		x := v.Args[0]
   19851 		if x.Op != OpS390XMOVWZloadidx {
   19852 			break
   19853 		}
   19854 		off := x.AuxInt
   19855 		sym := x.Aux
   19856 		_ = x.Args[2]
   19857 		ptr := x.Args[0]
   19858 		idx := x.Args[1]
   19859 		mem := x.Args[2]
   19860 		if !(x.Uses == 1 && clobber(x)) {
   19861 			break
   19862 		}
   19863 		b = x.Block
   19864 		v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, v.Type)
   19865 		v.reset(OpCopy)
   19866 		v.AddArg(v0)
   19867 		v0.AuxInt = off
   19868 		v0.Aux = sym
   19869 		v0.AddArg(ptr)
   19870 		v0.AddArg(idx)
   19871 		v0.AddArg(mem)
   19872 		return true
   19873 	}
   19874 	// match: (MOVWreg x:(MOVWloadidx [off] {sym} ptr idx mem))
   19875 	// cond: x.Uses == 1 && clobber(x)
   19876 	// result: @x.Block (MOVWloadidx  <v.Type> [off] {sym} ptr idx mem)
   19877 	for {
   19878 		x := v.Args[0]
   19879 		if x.Op != OpS390XMOVWloadidx {
   19880 			break
   19881 		}
   19882 		off := x.AuxInt
   19883 		sym := x.Aux
   19884 		_ = x.Args[2]
   19885 		ptr := x.Args[0]
   19886 		idx := x.Args[1]
   19887 		mem := x.Args[2]
   19888 		if !(x.Uses == 1 && clobber(x)) {
   19889 			break
   19890 		}
   19891 		b = x.Block
   19892 		v0 := b.NewValue0(v.Pos, OpS390XMOVWloadidx, v.Type)
   19893 		v.reset(OpCopy)
   19894 		v.AddArg(v0)
   19895 		v0.AuxInt = off
   19896 		v0.Aux = sym
   19897 		v0.AddArg(ptr)
   19898 		v0.AddArg(idx)
   19899 		v0.AddArg(mem)
   19900 		return true
   19901 	}
   19902 	return false
   19903 }
   19904 func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool {
   19905 	// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
   19906 	// cond:
   19907 	// result: (MOVWstore [off] {sym} ptr x mem)
   19908 	for {
   19909 		off := v.AuxInt
   19910 		sym := v.Aux
   19911 		_ = v.Args[2]
   19912 		ptr := v.Args[0]
   19913 		v_1 := v.Args[1]
   19914 		if v_1.Op != OpS390XMOVWreg {
   19915 			break
   19916 		}
   19917 		x := v_1.Args[0]
   19918 		mem := v.Args[2]
   19919 		v.reset(OpS390XMOVWstore)
   19920 		v.AuxInt = off
   19921 		v.Aux = sym
   19922 		v.AddArg(ptr)
   19923 		v.AddArg(x)
   19924 		v.AddArg(mem)
   19925 		return true
   19926 	}
   19927 	// match: (MOVWstore [off] {sym} ptr (MOVWZreg x) mem)
   19928 	// cond:
   19929 	// result: (MOVWstore [off] {sym} ptr x mem)
   19930 	for {
   19931 		off := v.AuxInt
   19932 		sym := v.Aux
   19933 		_ = v.Args[2]
   19934 		ptr := v.Args[0]
   19935 		v_1 := v.Args[1]
   19936 		if v_1.Op != OpS390XMOVWZreg {
   19937 			break
   19938 		}
   19939 		x := v_1.Args[0]
   19940 		mem := v.Args[2]
   19941 		v.reset(OpS390XMOVWstore)
   19942 		v.AuxInt = off
   19943 		v.Aux = sym
   19944 		v.AddArg(ptr)
   19945 		v.AddArg(x)
   19946 		v.AddArg(mem)
   19947 		return true
   19948 	}
   19949 	// match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem)
   19950 	// cond: is20Bit(off1+off2)
   19951 	// result: (MOVWstore  [off1+off2] {sym} ptr val mem)
   19952 	for {
   19953 		off1 := v.AuxInt
   19954 		sym := v.Aux
   19955 		_ = v.Args[2]
   19956 		v_0 := v.Args[0]
   19957 		if v_0.Op != OpS390XADDconst {
   19958 			break
   19959 		}
   19960 		off2 := v_0.AuxInt
   19961 		ptr := v_0.Args[0]
   19962 		val := v.Args[1]
   19963 		mem := v.Args[2]
   19964 		if !(is20Bit(off1 + off2)) {
   19965 			break
   19966 		}
   19967 		v.reset(OpS390XMOVWstore)
   19968 		v.AuxInt = off1 + off2
   19969 		v.Aux = sym
   19970 		v.AddArg(ptr)
   19971 		v.AddArg(val)
   19972 		v.AddArg(mem)
   19973 		return true
   19974 	}
   19975 	// match: (MOVWstore [off] {sym} ptr (MOVDconst [c]) mem)
   19976 	// cond: is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB
   19977 	// result: (MOVWstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem)
   19978 	for {
   19979 		off := v.AuxInt
   19980 		sym := v.Aux
   19981 		_ = v.Args[2]
   19982 		ptr := v.Args[0]
   19983 		v_1 := v.Args[1]
   19984 		if v_1.Op != OpS390XMOVDconst {
   19985 			break
   19986 		}
   19987 		c := v_1.AuxInt
   19988 		mem := v.Args[2]
   19989 		if !(is16Bit(c) && isU12Bit(off) && ptr.Op != OpSB) {
   19990 			break
   19991 		}
   19992 		v.reset(OpS390XMOVWstoreconst)
   19993 		v.AuxInt = makeValAndOff(int64(int32(c)), off)
   19994 		v.Aux = sym
   19995 		v.AddArg(ptr)
   19996 		v.AddArg(mem)
   19997 		return true
   19998 	}
   19999 	// match: (MOVWstore [off1] {sym1} (MOVDaddr <t> [off2] {sym2} base) val mem)
   20000 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%4 == 0 && (off1+off2)%4 == 0))
   20001 	// result: (MOVWstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   20002 	for {
   20003 		off1 := v.AuxInt
   20004 		sym1 := v.Aux
   20005 		_ = v.Args[2]
   20006 		v_0 := v.Args[0]
   20007 		if v_0.Op != OpS390XMOVDaddr {
   20008 			break
   20009 		}
   20010 		t := v_0.Type
   20011 		off2 := v_0.AuxInt
   20012 		sym2 := v_0.Aux
   20013 		base := v_0.Args[0]
   20014 		val := v.Args[1]
   20015 		mem := v.Args[2]
   20016 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || (t.IsPtr() && t.ElemType().Alignment()%4 == 0 && (off1+off2)%4 == 0))) {
   20017 			break
   20018 		}
   20019 		v.reset(OpS390XMOVWstore)
   20020 		v.AuxInt = off1 + off2
   20021 		v.Aux = mergeSym(sym1, sym2)
   20022 		v.AddArg(base)
   20023 		v.AddArg(val)
   20024 		v.AddArg(mem)
   20025 		return true
   20026 	}
   20027 	// match: (MOVWstore [off1] {sym1} (MOVDaddridx [off2] {sym2} ptr idx) val mem)
   20028 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   20029 	// result: (MOVWstoreidx [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   20030 	for {
   20031 		off1 := v.AuxInt
   20032 		sym1 := v.Aux
   20033 		_ = v.Args[2]
   20034 		v_0 := v.Args[0]
   20035 		if v_0.Op != OpS390XMOVDaddridx {
   20036 			break
   20037 		}
   20038 		off2 := v_0.AuxInt
   20039 		sym2 := v_0.Aux
   20040 		_ = v_0.Args[1]
   20041 		ptr := v_0.Args[0]
   20042 		idx := v_0.Args[1]
   20043 		val := v.Args[1]
   20044 		mem := v.Args[2]
   20045 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   20046 			break
   20047 		}
   20048 		v.reset(OpS390XMOVWstoreidx)
   20049 		v.AuxInt = off1 + off2
   20050 		v.Aux = mergeSym(sym1, sym2)
   20051 		v.AddArg(ptr)
   20052 		v.AddArg(idx)
   20053 		v.AddArg(val)
   20054 		v.AddArg(mem)
   20055 		return true
   20056 	}
   20057 	// match: (MOVWstore [off] {sym} (ADD ptr idx) val mem)
   20058 	// cond: ptr.Op != OpSB
   20059 	// result: (MOVWstoreidx  [off] {sym} ptr idx val mem)
   20060 	for {
   20061 		off := v.AuxInt
   20062 		sym := v.Aux
   20063 		_ = v.Args[2]
   20064 		v_0 := v.Args[0]
   20065 		if v_0.Op != OpS390XADD {
   20066 			break
   20067 		}
   20068 		_ = v_0.Args[1]
   20069 		ptr := v_0.Args[0]
   20070 		idx := v_0.Args[1]
   20071 		val := v.Args[1]
   20072 		mem := v.Args[2]
   20073 		if !(ptr.Op != OpSB) {
   20074 			break
   20075 		}
   20076 		v.reset(OpS390XMOVWstoreidx)
   20077 		v.AuxInt = off
   20078 		v.Aux = sym
   20079 		v.AddArg(ptr)
   20080 		v.AddArg(idx)
   20081 		v.AddArg(val)
   20082 		v.AddArg(mem)
   20083 		return true
   20084 	}
   20085 	// match: (MOVWstore [i] {s} p (SRDconst [32] w) x:(MOVWstore [i-4] {s} p w mem))
   20086 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   20087 	// result: (MOVDstore [i-4] {s} p w mem)
   20088 	for {
   20089 		i := v.AuxInt
   20090 		s := v.Aux
   20091 		_ = v.Args[2]
   20092 		p := v.Args[0]
   20093 		v_1 := v.Args[1]
   20094 		if v_1.Op != OpS390XSRDconst {
   20095 			break
   20096 		}
   20097 		if v_1.AuxInt != 32 {
   20098 			break
   20099 		}
   20100 		w := v_1.Args[0]
   20101 		x := v.Args[2]
   20102 		if x.Op != OpS390XMOVWstore {
   20103 			break
   20104 		}
   20105 		if x.AuxInt != i-4 {
   20106 			break
   20107 		}
   20108 		if x.Aux != s {
   20109 			break
   20110 		}
   20111 		_ = x.Args[2]
   20112 		if p != x.Args[0] {
   20113 			break
   20114 		}
   20115 		if w != x.Args[1] {
   20116 			break
   20117 		}
   20118 		mem := x.Args[2]
   20119 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   20120 			break
   20121 		}
   20122 		v.reset(OpS390XMOVDstore)
   20123 		v.AuxInt = i - 4
   20124 		v.Aux = s
   20125 		v.AddArg(p)
   20126 		v.AddArg(w)
   20127 		v.AddArg(mem)
   20128 		return true
   20129 	}
   20130 	// match: (MOVWstore [i] {s} p w0:(SRDconst [j] w) x:(MOVWstore [i-4] {s} p (SRDconst [j+32] w) mem))
   20131 	// cond: p.Op != OpSB   && x.Uses == 1   && clobber(x)
   20132 	// result: (MOVDstore [i-4] {s} p w0 mem)
   20133 	for {
   20134 		i := v.AuxInt
   20135 		s := v.Aux
   20136 		_ = v.Args[2]
   20137 		p := v.Args[0]
   20138 		w0 := v.Args[1]
   20139 		if w0.Op != OpS390XSRDconst {
   20140 			break
   20141 		}
   20142 		j := w0.AuxInt
   20143 		w := w0.Args[0]
   20144 		x := v.Args[2]
   20145 		if x.Op != OpS390XMOVWstore {
   20146 			break
   20147 		}
   20148 		if x.AuxInt != i-4 {
   20149 			break
   20150 		}
   20151 		if x.Aux != s {
   20152 			break
   20153 		}
   20154 		_ = x.Args[2]
   20155 		if p != x.Args[0] {
   20156 			break
   20157 		}
   20158 		x_1 := x.Args[1]
   20159 		if x_1.Op != OpS390XSRDconst {
   20160 			break
   20161 		}
   20162 		if x_1.AuxInt != j+32 {
   20163 			break
   20164 		}
   20165 		if w != x_1.Args[0] {
   20166 			break
   20167 		}
   20168 		mem := x.Args[2]
   20169 		if !(p.Op != OpSB && x.Uses == 1 && clobber(x)) {
   20170 			break
   20171 		}
   20172 		v.reset(OpS390XMOVDstore)
   20173 		v.AuxInt = i - 4
   20174 		v.Aux = s
   20175 		v.AddArg(p)
   20176 		v.AddArg(w0)
   20177 		v.AddArg(mem)
   20178 		return true
   20179 	}
   20180 	// match: (MOVWstore [i] {s} p w1 x:(MOVWstore [i-4] {s} p w0 mem))
   20181 	// cond: p.Op != OpSB   && x.Uses == 1   && is20Bit(i-4)   && clobber(x)
   20182 	// result: (STM2 [i-4] {s} p w0 w1 mem)
   20183 	for {
   20184 		i := v.AuxInt
   20185 		s := v.Aux
   20186 		_ = v.Args[2]
   20187 		p := v.Args[0]
   20188 		w1 := v.Args[1]
   20189 		x := v.Args[2]
   20190 		if x.Op != OpS390XMOVWstore {
   20191 			break
   20192 		}
   20193 		if x.AuxInt != i-4 {
   20194 			break
   20195 		}
   20196 		if x.Aux != s {
   20197 			break
   20198 		}
   20199 		_ = x.Args[2]
   20200 		if p != x.Args[0] {
   20201 			break
   20202 		}
   20203 		w0 := x.Args[1]
   20204 		mem := x.Args[2]
   20205 		if !(p.Op != OpSB && x.Uses == 1 && is20Bit(i-4) && clobber(x)) {
   20206 			break
   20207 		}
   20208 		v.reset(OpS390XSTM2)
   20209 		v.AuxInt = i - 4
   20210 		v.Aux = s
   20211 		v.AddArg(p)
   20212 		v.AddArg(w0)
   20213 		v.AddArg(w1)
   20214 		v.AddArg(mem)
   20215 		return true
   20216 	}
   20217 	return false
   20218 }
   20219 func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool {
   20220 	// match: (MOVWstore [i] {s} p w2 x:(STM2 [i-8] {s} p w0 w1 mem))
   20221 	// cond: x.Uses == 1   && is20Bit(i-8)   && clobber(x)
   20222 	// result: (STM3 [i-8] {s} p w0 w1 w2 mem)
   20223 	for {
   20224 		i := v.AuxInt
   20225 		s := v.Aux
   20226 		_ = v.Args[2]
   20227 		p := v.Args[0]
   20228 		w2 := v.Args[1]
   20229 		x := v.Args[2]
   20230 		if x.Op != OpS390XSTM2 {
   20231 			break
   20232 		}
   20233 		if x.AuxInt != i-8 {
   20234 			break
   20235 		}
   20236 		if x.Aux != s {
   20237 			break
   20238 		}
   20239 		_ = x.Args[3]
   20240 		if p != x.Args[0] {
   20241 			break
   20242 		}
   20243 		w0 := x.Args[1]
   20244 		w1 := x.Args[2]
   20245 		mem := x.Args[3]
   20246 		if !(x.Uses == 1 && is20Bit(i-8) && clobber(x)) {
   20247 			break
   20248 		}
   20249 		v.reset(OpS390XSTM3)
   20250 		v.AuxInt = i - 8
   20251 		v.Aux = s
   20252 		v.AddArg(p)
   20253 		v.AddArg(w0)
   20254 		v.AddArg(w1)
   20255 		v.AddArg(w2)
   20256 		v.AddArg(mem)
   20257 		return true
   20258 	}
   20259 	// match: (MOVWstore [i] {s} p w3 x:(STM3 [i-12] {s} p w0 w1 w2 mem))
   20260 	// cond: x.Uses == 1   && is20Bit(i-12)   && clobber(x)
   20261 	// result: (STM4 [i-12] {s} p w0 w1 w2 w3 mem)
   20262 	for {
   20263 		i := v.AuxInt
   20264 		s := v.Aux
   20265 		_ = v.Args[2]
   20266 		p := v.Args[0]
   20267 		w3 := v.Args[1]
   20268 		x := v.Args[2]
   20269 		if x.Op != OpS390XSTM3 {
   20270 			break
   20271 		}
   20272 		if x.AuxInt != i-12 {
   20273 			break
   20274 		}
   20275 		if x.Aux != s {
   20276 			break
   20277 		}
   20278 		_ = x.Args[4]
   20279 		if p != x.Args[0] {
   20280 			break
   20281 		}
   20282 		w0 := x.Args[1]
   20283 		w1 := x.Args[2]
   20284 		w2 := x.Args[3]
   20285 		mem := x.Args[4]
   20286 		if !(x.Uses == 1 && is20Bit(i-12) && clobber(x)) {
   20287 			break
   20288 		}
   20289 		v.reset(OpS390XSTM4)
   20290 		v.AuxInt = i - 12
   20291 		v.Aux = s
   20292 		v.AddArg(p)
   20293 		v.AddArg(w0)
   20294 		v.AddArg(w1)
   20295 		v.AddArg(w2)
   20296 		v.AddArg(w3)
   20297 		v.AddArg(mem)
   20298 		return true
   20299 	}
   20300 	return false
   20301 }
   20302 func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool {
   20303 	b := v.Block
   20304 	_ = b
   20305 	typ := &b.Func.Config.Types
   20306 	_ = typ
   20307 	// match: (MOVWstoreconst [sc] {s} (ADDconst [off] ptr) mem)
   20308 	// cond: isU12Bit(ValAndOff(sc).Off()+off)
   20309 	// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   20310 	for {
   20311 		sc := v.AuxInt
   20312 		s := v.Aux
   20313 		_ = v.Args[1]
   20314 		v_0 := v.Args[0]
   20315 		if v_0.Op != OpS390XADDconst {
   20316 			break
   20317 		}
   20318 		off := v_0.AuxInt
   20319 		ptr := v_0.Args[0]
   20320 		mem := v.Args[1]
   20321 		if !(isU12Bit(ValAndOff(sc).Off() + off)) {
   20322 			break
   20323 		}
   20324 		v.reset(OpS390XMOVWstoreconst)
   20325 		v.AuxInt = ValAndOff(sc).add(off)
   20326 		v.Aux = s
   20327 		v.AddArg(ptr)
   20328 		v.AddArg(mem)
   20329 		return true
   20330 	}
   20331 	// match: (MOVWstoreconst [sc] {sym1} (MOVDaddr [off] {sym2} ptr) mem)
   20332 	// cond: ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
   20333 	// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   20334 	for {
   20335 		sc := v.AuxInt
   20336 		sym1 := v.Aux
   20337 		_ = v.Args[1]
   20338 		v_0 := v.Args[0]
   20339 		if v_0.Op != OpS390XMOVDaddr {
   20340 			break
   20341 		}
   20342 		off := v_0.AuxInt
   20343 		sym2 := v_0.Aux
   20344 		ptr := v_0.Args[0]
   20345 		mem := v.Args[1]
   20346 		if !(ptr.Op != OpSB && canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
   20347 			break
   20348 		}
   20349 		v.reset(OpS390XMOVWstoreconst)
   20350 		v.AuxInt = ValAndOff(sc).add(off)
   20351 		v.Aux = mergeSym(sym1, sym2)
   20352 		v.AddArg(ptr)
   20353 		v.AddArg(mem)
   20354 		return true
   20355 	}
   20356 	// match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
   20357 	// cond: p.Op != OpSB   && x.Uses == 1   && ValAndOff(a).Off() + 4 == ValAndOff(c).Off()   && clobber(x)
   20358 	// result: (MOVDstore [ValAndOff(a).Off()] {s} p (MOVDconst [ValAndOff(c).Val()&0xffffffff | ValAndOff(a).Val()<<32]) mem)
   20359 	for {
   20360 		c := v.AuxInt
   20361 		s := v.Aux
   20362 		_ = v.Args[1]
   20363 		p := v.Args[0]
   20364 		x := v.Args[1]
   20365 		if x.Op != OpS390XMOVWstoreconst {
   20366 			break
   20367 		}
   20368 		a := x.AuxInt
   20369 		if x.Aux != s {
   20370 			break
   20371 		}
   20372 		_ = x.Args[1]
   20373 		if p != x.Args[0] {
   20374 			break
   20375 		}
   20376 		mem := x.Args[1]
   20377 		if !(p.Op != OpSB && x.Uses == 1 && ValAndOff(a).Off()+4 == ValAndOff(c).Off() && clobber(x)) {
   20378 			break
   20379 		}
   20380 		v.reset(OpS390XMOVDstore)
   20381 		v.AuxInt = ValAndOff(a).Off()
   20382 		v.Aux = s
   20383 		v.AddArg(p)
   20384 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   20385 		v0.AuxInt = ValAndOff(c).Val()&0xffffffff | ValAndOff(a).Val()<<32
   20386 		v.AddArg(v0)
   20387 		v.AddArg(mem)
   20388 		return true
   20389 	}
   20390 	return false
   20391 }
   20392 func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool {
   20393 	// match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
   20394 	// cond: is20Bit(c+d)
   20395 	// result: (MOVWstoreidx  [c+d] {sym} ptr idx val mem)
   20396 	for {
   20397 		c := v.AuxInt
   20398 		sym := v.Aux
   20399 		_ = v.Args[3]
   20400 		v_0 := v.Args[0]
   20401 		if v_0.Op != OpS390XADDconst {
   20402 			break
   20403 		}
   20404 		d := v_0.AuxInt
   20405 		ptr := v_0.Args[0]
   20406 		idx := v.Args[1]
   20407 		val := v.Args[2]
   20408 		mem := v.Args[3]
   20409 		if !(is20Bit(c + d)) {
   20410 			break
   20411 		}
   20412 		v.reset(OpS390XMOVWstoreidx)
   20413 		v.AuxInt = c + d
   20414 		v.Aux = sym
   20415 		v.AddArg(ptr)
   20416 		v.AddArg(idx)
   20417 		v.AddArg(val)
   20418 		v.AddArg(mem)
   20419 		return true
   20420 	}
   20421 	// match: (MOVWstoreidx [c] {sym} idx (ADDconst [d] ptr) val mem)
   20422 	// cond: is20Bit(c+d)
   20423 	// result: (MOVWstoreidx  [c+d] {sym} ptr idx val mem)
   20424 	for {
   20425 		c := v.AuxInt
   20426 		sym := v.Aux
   20427 		_ = v.Args[3]
   20428 		idx := v.Args[0]
   20429 		v_1 := v.Args[1]
   20430 		if v_1.Op != OpS390XADDconst {
   20431 			break
   20432 		}
   20433 		d := v_1.AuxInt
   20434 		ptr := v_1.Args[0]
   20435 		val := v.Args[2]
   20436 		mem := v.Args[3]
   20437 		if !(is20Bit(c + d)) {
   20438 			break
   20439 		}
   20440 		v.reset(OpS390XMOVWstoreidx)
   20441 		v.AuxInt = c + d
   20442 		v.Aux = sym
   20443 		v.AddArg(ptr)
   20444 		v.AddArg(idx)
   20445 		v.AddArg(val)
   20446 		v.AddArg(mem)
   20447 		return true
   20448 	}
   20449 	// match: (MOVWstoreidx [c] {sym} ptr (ADDconst [d] idx) val mem)
   20450 	// cond: is20Bit(c+d)
   20451 	// result: (MOVWstoreidx  [c+d] {sym} ptr idx val mem)
   20452 	for {
   20453 		c := v.AuxInt
   20454 		sym := v.Aux
   20455 		_ = v.Args[3]
   20456 		ptr := v.Args[0]
   20457 		v_1 := v.Args[1]
   20458 		if v_1.Op != OpS390XADDconst {
   20459 			break
   20460 		}
   20461 		d := v_1.AuxInt
   20462 		idx := v_1.Args[0]
   20463 		val := v.Args[2]
   20464 		mem := v.Args[3]
   20465 		if !(is20Bit(c + d)) {
   20466 			break
   20467 		}
   20468 		v.reset(OpS390XMOVWstoreidx)
   20469 		v.AuxInt = c + d
   20470 		v.Aux = sym
   20471 		v.AddArg(ptr)
   20472 		v.AddArg(idx)
   20473 		v.AddArg(val)
   20474 		v.AddArg(mem)
   20475 		return true
   20476 	}
   20477 	// match: (MOVWstoreidx [c] {sym} (ADDconst [d] idx) ptr val mem)
   20478 	// cond: is20Bit(c+d)
   20479 	// result: (MOVWstoreidx  [c+d] {sym} ptr idx val mem)
   20480 	for {
   20481 		c := v.AuxInt
   20482 		sym := v.Aux
   20483 		_ = v.Args[3]
   20484 		v_0 := v.Args[0]
   20485 		if v_0.Op != OpS390XADDconst {
   20486 			break
   20487 		}
   20488 		d := v_0.AuxInt
   20489 		idx := v_0.Args[0]
   20490 		ptr := v.Args[1]
   20491 		val := v.Args[2]
   20492 		mem := v.Args[3]
   20493 		if !(is20Bit(c + d)) {
   20494 			break
   20495 		}
   20496 		v.reset(OpS390XMOVWstoreidx)
   20497 		v.AuxInt = c + d
   20498 		v.Aux = sym
   20499 		v.AddArg(ptr)
   20500 		v.AddArg(idx)
   20501 		v.AddArg(val)
   20502 		v.AddArg(mem)
   20503 		return true
   20504 	}
   20505 	// match: (MOVWstoreidx [i] {s} p idx w x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [32] w) mem))
   20506 	// cond: x.Uses == 1   && clobber(x)
   20507 	// result: (MOVDstoreidx [i-4] {s} p idx w mem)
   20508 	for {
   20509 		i := v.AuxInt
   20510 		s := v.Aux
   20511 		_ = v.Args[3]
   20512 		p := v.Args[0]
   20513 		idx := v.Args[1]
   20514 		w := v.Args[2]
   20515 		x := v.Args[3]
   20516 		if x.Op != OpS390XMOVWstoreidx {
   20517 			break
   20518 		}
   20519 		if x.AuxInt != i-4 {
   20520 			break
   20521 		}
   20522 		if x.Aux != s {
   20523 			break
   20524 		}
   20525 		_ = x.Args[3]
   20526 		if p != x.Args[0] {
   20527 			break
   20528 		}
   20529 		if idx != x.Args[1] {
   20530 			break
   20531 		}
   20532 		x_2 := x.Args[2]
   20533 		if x_2.Op != OpS390XSRDconst {
   20534 			break
   20535 		}
   20536 		if x_2.AuxInt != 32 {
   20537 			break
   20538 		}
   20539 		if w != x_2.Args[0] {
   20540 			break
   20541 		}
   20542 		mem := x.Args[3]
   20543 		if !(x.Uses == 1 && clobber(x)) {
   20544 			break
   20545 		}
   20546 		v.reset(OpS390XMOVDstoreidx)
   20547 		v.AuxInt = i - 4
   20548 		v.Aux = s
   20549 		v.AddArg(p)
   20550 		v.AddArg(idx)
   20551 		v.AddArg(w)
   20552 		v.AddArg(mem)
   20553 		return true
   20554 	}
   20555 	// match: (MOVWstoreidx [i] {s} p idx w x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [32] w) mem))
   20556 	// cond: x.Uses == 1   && clobber(x)
   20557 	// result: (MOVDstoreidx [i-4] {s} p idx w mem)
   20558 	for {
   20559 		i := v.AuxInt
   20560 		s := v.Aux
   20561 		_ = v.Args[3]
   20562 		p := v.Args[0]
   20563 		idx := v.Args[1]
   20564 		w := v.Args[2]
   20565 		x := v.Args[3]
   20566 		if x.Op != OpS390XMOVWstoreidx {
   20567 			break
   20568 		}
   20569 		if x.AuxInt != i-4 {
   20570 			break
   20571 		}
   20572 		if x.Aux != s {
   20573 			break
   20574 		}
   20575 		_ = x.Args[3]
   20576 		if idx != x.Args[0] {
   20577 			break
   20578 		}
   20579 		if p != x.Args[1] {
   20580 			break
   20581 		}
   20582 		x_2 := x.Args[2]
   20583 		if x_2.Op != OpS390XSRDconst {
   20584 			break
   20585 		}
   20586 		if x_2.AuxInt != 32 {
   20587 			break
   20588 		}
   20589 		if w != x_2.Args[0] {
   20590 			break
   20591 		}
   20592 		mem := x.Args[3]
   20593 		if !(x.Uses == 1 && clobber(x)) {
   20594 			break
   20595 		}
   20596 		v.reset(OpS390XMOVDstoreidx)
   20597 		v.AuxInt = i - 4
   20598 		v.Aux = s
   20599 		v.AddArg(p)
   20600 		v.AddArg(idx)
   20601 		v.AddArg(w)
   20602 		v.AddArg(mem)
   20603 		return true
   20604 	}
   20605 	// match: (MOVWstoreidx [i] {s} idx p w x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [32] w) mem))
   20606 	// cond: x.Uses == 1   && clobber(x)
   20607 	// result: (MOVDstoreidx [i-4] {s} p idx w mem)
   20608 	for {
   20609 		i := v.AuxInt
   20610 		s := v.Aux
   20611 		_ = v.Args[3]
   20612 		idx := v.Args[0]
   20613 		p := v.Args[1]
   20614 		w := v.Args[2]
   20615 		x := v.Args[3]
   20616 		if x.Op != OpS390XMOVWstoreidx {
   20617 			break
   20618 		}
   20619 		if x.AuxInt != i-4 {
   20620 			break
   20621 		}
   20622 		if x.Aux != s {
   20623 			break
   20624 		}
   20625 		_ = x.Args[3]
   20626 		if p != x.Args[0] {
   20627 			break
   20628 		}
   20629 		if idx != x.Args[1] {
   20630 			break
   20631 		}
   20632 		x_2 := x.Args[2]
   20633 		if x_2.Op != OpS390XSRDconst {
   20634 			break
   20635 		}
   20636 		if x_2.AuxInt != 32 {
   20637 			break
   20638 		}
   20639 		if w != x_2.Args[0] {
   20640 			break
   20641 		}
   20642 		mem := x.Args[3]
   20643 		if !(x.Uses == 1 && clobber(x)) {
   20644 			break
   20645 		}
   20646 		v.reset(OpS390XMOVDstoreidx)
   20647 		v.AuxInt = i - 4
   20648 		v.Aux = s
   20649 		v.AddArg(p)
   20650 		v.AddArg(idx)
   20651 		v.AddArg(w)
   20652 		v.AddArg(mem)
   20653 		return true
   20654 	}
   20655 	// match: (MOVWstoreidx [i] {s} idx p w x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [32] w) mem))
   20656 	// cond: x.Uses == 1   && clobber(x)
   20657 	// result: (MOVDstoreidx [i-4] {s} p idx w mem)
   20658 	for {
   20659 		i := v.AuxInt
   20660 		s := v.Aux
   20661 		_ = v.Args[3]
   20662 		idx := v.Args[0]
   20663 		p := v.Args[1]
   20664 		w := v.Args[2]
   20665 		x := v.Args[3]
   20666 		if x.Op != OpS390XMOVWstoreidx {
   20667 			break
   20668 		}
   20669 		if x.AuxInt != i-4 {
   20670 			break
   20671 		}
   20672 		if x.Aux != s {
   20673 			break
   20674 		}
   20675 		_ = x.Args[3]
   20676 		if idx != x.Args[0] {
   20677 			break
   20678 		}
   20679 		if p != x.Args[1] {
   20680 			break
   20681 		}
   20682 		x_2 := x.Args[2]
   20683 		if x_2.Op != OpS390XSRDconst {
   20684 			break
   20685 		}
   20686 		if x_2.AuxInt != 32 {
   20687 			break
   20688 		}
   20689 		if w != x_2.Args[0] {
   20690 			break
   20691 		}
   20692 		mem := x.Args[3]
   20693 		if !(x.Uses == 1 && clobber(x)) {
   20694 			break
   20695 		}
   20696 		v.reset(OpS390XMOVDstoreidx)
   20697 		v.AuxInt = i - 4
   20698 		v.Aux = s
   20699 		v.AddArg(p)
   20700 		v.AddArg(idx)
   20701 		v.AddArg(w)
   20702 		v.AddArg(mem)
   20703 		return true
   20704 	}
   20705 	// match: (MOVWstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
   20706 	// cond: x.Uses == 1   && clobber(x)
   20707 	// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
   20708 	for {
   20709 		i := v.AuxInt
   20710 		s := v.Aux
   20711 		_ = v.Args[3]
   20712 		p := v.Args[0]
   20713 		idx := v.Args[1]
   20714 		w0 := v.Args[2]
   20715 		if w0.Op != OpS390XSRDconst {
   20716 			break
   20717 		}
   20718 		j := w0.AuxInt
   20719 		w := w0.Args[0]
   20720 		x := v.Args[3]
   20721 		if x.Op != OpS390XMOVWstoreidx {
   20722 			break
   20723 		}
   20724 		if x.AuxInt != i-4 {
   20725 			break
   20726 		}
   20727 		if x.Aux != s {
   20728 			break
   20729 		}
   20730 		_ = x.Args[3]
   20731 		if p != x.Args[0] {
   20732 			break
   20733 		}
   20734 		if idx != x.Args[1] {
   20735 			break
   20736 		}
   20737 		x_2 := x.Args[2]
   20738 		if x_2.Op != OpS390XSRDconst {
   20739 			break
   20740 		}
   20741 		if x_2.AuxInt != j+32 {
   20742 			break
   20743 		}
   20744 		if w != x_2.Args[0] {
   20745 			break
   20746 		}
   20747 		mem := x.Args[3]
   20748 		if !(x.Uses == 1 && clobber(x)) {
   20749 			break
   20750 		}
   20751 		v.reset(OpS390XMOVDstoreidx)
   20752 		v.AuxInt = i - 4
   20753 		v.Aux = s
   20754 		v.AddArg(p)
   20755 		v.AddArg(idx)
   20756 		v.AddArg(w0)
   20757 		v.AddArg(mem)
   20758 		return true
   20759 	}
   20760 	// match: (MOVWstoreidx [i] {s} p idx w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [j+32] w) mem))
   20761 	// cond: x.Uses == 1   && clobber(x)
   20762 	// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
   20763 	for {
   20764 		i := v.AuxInt
   20765 		s := v.Aux
   20766 		_ = v.Args[3]
   20767 		p := v.Args[0]
   20768 		idx := v.Args[1]
   20769 		w0 := v.Args[2]
   20770 		if w0.Op != OpS390XSRDconst {
   20771 			break
   20772 		}
   20773 		j := w0.AuxInt
   20774 		w := w0.Args[0]
   20775 		x := v.Args[3]
   20776 		if x.Op != OpS390XMOVWstoreidx {
   20777 			break
   20778 		}
   20779 		if x.AuxInt != i-4 {
   20780 			break
   20781 		}
   20782 		if x.Aux != s {
   20783 			break
   20784 		}
   20785 		_ = x.Args[3]
   20786 		if idx != x.Args[0] {
   20787 			break
   20788 		}
   20789 		if p != x.Args[1] {
   20790 			break
   20791 		}
   20792 		x_2 := x.Args[2]
   20793 		if x_2.Op != OpS390XSRDconst {
   20794 			break
   20795 		}
   20796 		if x_2.AuxInt != j+32 {
   20797 			break
   20798 		}
   20799 		if w != x_2.Args[0] {
   20800 			break
   20801 		}
   20802 		mem := x.Args[3]
   20803 		if !(x.Uses == 1 && clobber(x)) {
   20804 			break
   20805 		}
   20806 		v.reset(OpS390XMOVDstoreidx)
   20807 		v.AuxInt = i - 4
   20808 		v.Aux = s
   20809 		v.AddArg(p)
   20810 		v.AddArg(idx)
   20811 		v.AddArg(w0)
   20812 		v.AddArg(mem)
   20813 		return true
   20814 	}
   20815 	return false
   20816 }
   20817 func rewriteValueS390X_OpS390XMOVWstoreidx_10(v *Value) bool {
   20818 	// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
   20819 	// cond: x.Uses == 1   && clobber(x)
   20820 	// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
   20821 	for {
   20822 		i := v.AuxInt
   20823 		s := v.Aux
   20824 		_ = v.Args[3]
   20825 		idx := v.Args[0]
   20826 		p := v.Args[1]
   20827 		w0 := v.Args[2]
   20828 		if w0.Op != OpS390XSRDconst {
   20829 			break
   20830 		}
   20831 		j := w0.AuxInt
   20832 		w := w0.Args[0]
   20833 		x := v.Args[3]
   20834 		if x.Op != OpS390XMOVWstoreidx {
   20835 			break
   20836 		}
   20837 		if x.AuxInt != i-4 {
   20838 			break
   20839 		}
   20840 		if x.Aux != s {
   20841 			break
   20842 		}
   20843 		_ = x.Args[3]
   20844 		if p != x.Args[0] {
   20845 			break
   20846 		}
   20847 		if idx != x.Args[1] {
   20848 			break
   20849 		}
   20850 		x_2 := x.Args[2]
   20851 		if x_2.Op != OpS390XSRDconst {
   20852 			break
   20853 		}
   20854 		if x_2.AuxInt != j+32 {
   20855 			break
   20856 		}
   20857 		if w != x_2.Args[0] {
   20858 			break
   20859 		}
   20860 		mem := x.Args[3]
   20861 		if !(x.Uses == 1 && clobber(x)) {
   20862 			break
   20863 		}
   20864 		v.reset(OpS390XMOVDstoreidx)
   20865 		v.AuxInt = i - 4
   20866 		v.Aux = s
   20867 		v.AddArg(p)
   20868 		v.AddArg(idx)
   20869 		v.AddArg(w0)
   20870 		v.AddArg(mem)
   20871 		return true
   20872 	}
   20873 	// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} idx p (SRDconst [j+32] w) mem))
   20874 	// cond: x.Uses == 1   && clobber(x)
   20875 	// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
   20876 	for {
   20877 		i := v.AuxInt
   20878 		s := v.Aux
   20879 		_ = v.Args[3]
   20880 		idx := v.Args[0]
   20881 		p := v.Args[1]
   20882 		w0 := v.Args[2]
   20883 		if w0.Op != OpS390XSRDconst {
   20884 			break
   20885 		}
   20886 		j := w0.AuxInt
   20887 		w := w0.Args[0]
   20888 		x := v.Args[3]
   20889 		if x.Op != OpS390XMOVWstoreidx {
   20890 			break
   20891 		}
   20892 		if x.AuxInt != i-4 {
   20893 			break
   20894 		}
   20895 		if x.Aux != s {
   20896 			break
   20897 		}
   20898 		_ = x.Args[3]
   20899 		if idx != x.Args[0] {
   20900 			break
   20901 		}
   20902 		if p != x.Args[1] {
   20903 			break
   20904 		}
   20905 		x_2 := x.Args[2]
   20906 		if x_2.Op != OpS390XSRDconst {
   20907 			break
   20908 		}
   20909 		if x_2.AuxInt != j+32 {
   20910 			break
   20911 		}
   20912 		if w != x_2.Args[0] {
   20913 			break
   20914 		}
   20915 		mem := x.Args[3]
   20916 		if !(x.Uses == 1 && clobber(x)) {
   20917 			break
   20918 		}
   20919 		v.reset(OpS390XMOVDstoreidx)
   20920 		v.AuxInt = i - 4
   20921 		v.Aux = s
   20922 		v.AddArg(p)
   20923 		v.AddArg(idx)
   20924 		v.AddArg(w0)
   20925 		v.AddArg(mem)
   20926 		return true
   20927 	}
   20928 	return false
   20929 }
   20930 func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool {
   20931 	// match: (MULLD x (MOVDconst [c]))
   20932 	// cond: is32Bit(c)
   20933 	// result: (MULLDconst [c] x)
   20934 	for {
   20935 		_ = v.Args[1]
   20936 		x := v.Args[0]
   20937 		v_1 := v.Args[1]
   20938 		if v_1.Op != OpS390XMOVDconst {
   20939 			break
   20940 		}
   20941 		c := v_1.AuxInt
   20942 		if !(is32Bit(c)) {
   20943 			break
   20944 		}
   20945 		v.reset(OpS390XMULLDconst)
   20946 		v.AuxInt = c
   20947 		v.AddArg(x)
   20948 		return true
   20949 	}
   20950 	// match: (MULLD (MOVDconst [c]) x)
   20951 	// cond: is32Bit(c)
   20952 	// result: (MULLDconst [c] x)
   20953 	for {
   20954 		_ = v.Args[1]
   20955 		v_0 := v.Args[0]
   20956 		if v_0.Op != OpS390XMOVDconst {
   20957 			break
   20958 		}
   20959 		c := v_0.AuxInt
   20960 		x := v.Args[1]
   20961 		if !(is32Bit(c)) {
   20962 			break
   20963 		}
   20964 		v.reset(OpS390XMULLDconst)
   20965 		v.AuxInt = c
   20966 		v.AddArg(x)
   20967 		return true
   20968 	}
   20969 	// match: (MULLD <t> x g:(MOVDload [off] {sym} ptr mem))
   20970 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   20971 	// result: (MULLDload <t> [off] {sym} x ptr mem)
   20972 	for {
   20973 		t := v.Type
   20974 		_ = v.Args[1]
   20975 		x := v.Args[0]
   20976 		g := v.Args[1]
   20977 		if g.Op != OpS390XMOVDload {
   20978 			break
   20979 		}
   20980 		off := g.AuxInt
   20981 		sym := g.Aux
   20982 		_ = g.Args[1]
   20983 		ptr := g.Args[0]
   20984 		mem := g.Args[1]
   20985 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   20986 			break
   20987 		}
   20988 		v.reset(OpS390XMULLDload)
   20989 		v.Type = t
   20990 		v.AuxInt = off
   20991 		v.Aux = sym
   20992 		v.AddArg(x)
   20993 		v.AddArg(ptr)
   20994 		v.AddArg(mem)
   20995 		return true
   20996 	}
   20997 	// match: (MULLD <t> g:(MOVDload [off] {sym} ptr mem) x)
   20998 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   20999 	// result: (MULLDload <t> [off] {sym} x ptr mem)
   21000 	for {
   21001 		t := v.Type
   21002 		_ = v.Args[1]
   21003 		g := v.Args[0]
   21004 		if g.Op != OpS390XMOVDload {
   21005 			break
   21006 		}
   21007 		off := g.AuxInt
   21008 		sym := g.Aux
   21009 		_ = g.Args[1]
   21010 		ptr := g.Args[0]
   21011 		mem := g.Args[1]
   21012 		x := v.Args[1]
   21013 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21014 			break
   21015 		}
   21016 		v.reset(OpS390XMULLDload)
   21017 		v.Type = t
   21018 		v.AuxInt = off
   21019 		v.Aux = sym
   21020 		v.AddArg(x)
   21021 		v.AddArg(ptr)
   21022 		v.AddArg(mem)
   21023 		return true
   21024 	}
   21025 	// match: (MULLD <t> g:(MOVDload [off] {sym} ptr mem) x)
   21026 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21027 	// result: (MULLDload <t> [off] {sym} x ptr mem)
   21028 	for {
   21029 		t := v.Type
   21030 		_ = v.Args[1]
   21031 		g := v.Args[0]
   21032 		if g.Op != OpS390XMOVDload {
   21033 			break
   21034 		}
   21035 		off := g.AuxInt
   21036 		sym := g.Aux
   21037 		_ = g.Args[1]
   21038 		ptr := g.Args[0]
   21039 		mem := g.Args[1]
   21040 		x := v.Args[1]
   21041 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21042 			break
   21043 		}
   21044 		v.reset(OpS390XMULLDload)
   21045 		v.Type = t
   21046 		v.AuxInt = off
   21047 		v.Aux = sym
   21048 		v.AddArg(x)
   21049 		v.AddArg(ptr)
   21050 		v.AddArg(mem)
   21051 		return true
   21052 	}
   21053 	// match: (MULLD <t> x g:(MOVDload [off] {sym} ptr mem))
   21054 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21055 	// result: (MULLDload <t> [off] {sym} x ptr mem)
   21056 	for {
   21057 		t := v.Type
   21058 		_ = v.Args[1]
   21059 		x := v.Args[0]
   21060 		g := v.Args[1]
   21061 		if g.Op != OpS390XMOVDload {
   21062 			break
   21063 		}
   21064 		off := g.AuxInt
   21065 		sym := g.Aux
   21066 		_ = g.Args[1]
   21067 		ptr := g.Args[0]
   21068 		mem := g.Args[1]
   21069 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21070 			break
   21071 		}
   21072 		v.reset(OpS390XMULLDload)
   21073 		v.Type = t
   21074 		v.AuxInt = off
   21075 		v.Aux = sym
   21076 		v.AddArg(x)
   21077 		v.AddArg(ptr)
   21078 		v.AddArg(mem)
   21079 		return true
   21080 	}
   21081 	return false
   21082 }
   21083 func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool {
   21084 	b := v.Block
   21085 	_ = b
   21086 	// match: (MULLDconst [-1] x)
   21087 	// cond:
   21088 	// result: (NEG x)
   21089 	for {
   21090 		if v.AuxInt != -1 {
   21091 			break
   21092 		}
   21093 		x := v.Args[0]
   21094 		v.reset(OpS390XNEG)
   21095 		v.AddArg(x)
   21096 		return true
   21097 	}
   21098 	// match: (MULLDconst [0] _)
   21099 	// cond:
   21100 	// result: (MOVDconst [0])
   21101 	for {
   21102 		if v.AuxInt != 0 {
   21103 			break
   21104 		}
   21105 		v.reset(OpS390XMOVDconst)
   21106 		v.AuxInt = 0
   21107 		return true
   21108 	}
   21109 	// match: (MULLDconst [1] x)
   21110 	// cond:
   21111 	// result: x
   21112 	for {
   21113 		if v.AuxInt != 1 {
   21114 			break
   21115 		}
   21116 		x := v.Args[0]
   21117 		v.reset(OpCopy)
   21118 		v.Type = x.Type
   21119 		v.AddArg(x)
   21120 		return true
   21121 	}
   21122 	// match: (MULLDconst [c] x)
   21123 	// cond: isPowerOfTwo(c)
   21124 	// result: (SLDconst [log2(c)] x)
   21125 	for {
   21126 		c := v.AuxInt
   21127 		x := v.Args[0]
   21128 		if !(isPowerOfTwo(c)) {
   21129 			break
   21130 		}
   21131 		v.reset(OpS390XSLDconst)
   21132 		v.AuxInt = log2(c)
   21133 		v.AddArg(x)
   21134 		return true
   21135 	}
   21136 	// match: (MULLDconst [c] x)
   21137 	// cond: isPowerOfTwo(c+1) && c >= 15
   21138 	// result: (SUB (SLDconst <v.Type> [log2(c+1)] x) x)
   21139 	for {
   21140 		c := v.AuxInt
   21141 		x := v.Args[0]
   21142 		if !(isPowerOfTwo(c+1) && c >= 15) {
   21143 			break
   21144 		}
   21145 		v.reset(OpS390XSUB)
   21146 		v0 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   21147 		v0.AuxInt = log2(c + 1)
   21148 		v0.AddArg(x)
   21149 		v.AddArg(v0)
   21150 		v.AddArg(x)
   21151 		return true
   21152 	}
   21153 	// match: (MULLDconst [c] x)
   21154 	// cond: isPowerOfTwo(c-1) && c >= 17
   21155 	// result: (ADD (SLDconst <v.Type> [log2(c-1)] x) x)
   21156 	for {
   21157 		c := v.AuxInt
   21158 		x := v.Args[0]
   21159 		if !(isPowerOfTwo(c-1) && c >= 17) {
   21160 			break
   21161 		}
   21162 		v.reset(OpS390XADD)
   21163 		v0 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   21164 		v0.AuxInt = log2(c - 1)
   21165 		v0.AddArg(x)
   21166 		v.AddArg(v0)
   21167 		v.AddArg(x)
   21168 		return true
   21169 	}
   21170 	// match: (MULLDconst [c] (MOVDconst [d]))
   21171 	// cond:
   21172 	// result: (MOVDconst [c*d])
   21173 	for {
   21174 		c := v.AuxInt
   21175 		v_0 := v.Args[0]
   21176 		if v_0.Op != OpS390XMOVDconst {
   21177 			break
   21178 		}
   21179 		d := v_0.AuxInt
   21180 		v.reset(OpS390XMOVDconst)
   21181 		v.AuxInt = c * d
   21182 		return true
   21183 	}
   21184 	return false
   21185 }
   21186 func rewriteValueS390X_OpS390XMULLDload_0(v *Value) bool {
   21187 	b := v.Block
   21188 	_ = b
   21189 	// match: (MULLDload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
   21190 	// cond: isSamePtr(ptr1, ptr2)
   21191 	// result: (MULLD x (LGDR <t> y))
   21192 	for {
   21193 		t := v.Type
   21194 		off := v.AuxInt
   21195 		sym := v.Aux
   21196 		_ = v.Args[2]
   21197 		x := v.Args[0]
   21198 		ptr1 := v.Args[1]
   21199 		v_2 := v.Args[2]
   21200 		if v_2.Op != OpS390XFMOVDstore {
   21201 			break
   21202 		}
   21203 		if v_2.AuxInt != off {
   21204 			break
   21205 		}
   21206 		if v_2.Aux != sym {
   21207 			break
   21208 		}
   21209 		_ = v_2.Args[2]
   21210 		ptr2 := v_2.Args[0]
   21211 		y := v_2.Args[1]
   21212 		if !(isSamePtr(ptr1, ptr2)) {
   21213 			break
   21214 		}
   21215 		v.reset(OpS390XMULLD)
   21216 		v.AddArg(x)
   21217 		v0 := b.NewValue0(v.Pos, OpS390XLGDR, t)
   21218 		v0.AddArg(y)
   21219 		v.AddArg(v0)
   21220 		return true
   21221 	}
   21222 	// match: (MULLDload [off1] {sym} x (ADDconst [off2] ptr) mem)
   21223 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   21224 	// result: (MULLDload [off1+off2] {sym} x ptr mem)
   21225 	for {
   21226 		off1 := v.AuxInt
   21227 		sym := v.Aux
   21228 		_ = v.Args[2]
   21229 		x := v.Args[0]
   21230 		v_1 := v.Args[1]
   21231 		if v_1.Op != OpS390XADDconst {
   21232 			break
   21233 		}
   21234 		off2 := v_1.AuxInt
   21235 		ptr := v_1.Args[0]
   21236 		mem := v.Args[2]
   21237 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   21238 			break
   21239 		}
   21240 		v.reset(OpS390XMULLDload)
   21241 		v.AuxInt = off1 + off2
   21242 		v.Aux = sym
   21243 		v.AddArg(x)
   21244 		v.AddArg(ptr)
   21245 		v.AddArg(mem)
   21246 		return true
   21247 	}
   21248 	// match: (MULLDload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   21249 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   21250 	// result: (MULLDload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   21251 	for {
   21252 		o1 := v.AuxInt
   21253 		s1 := v.Aux
   21254 		_ = v.Args[2]
   21255 		x := v.Args[0]
   21256 		v_1 := v.Args[1]
   21257 		if v_1.Op != OpS390XMOVDaddr {
   21258 			break
   21259 		}
   21260 		o2 := v_1.AuxInt
   21261 		s2 := v_1.Aux
   21262 		ptr := v_1.Args[0]
   21263 		mem := v.Args[2]
   21264 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   21265 			break
   21266 		}
   21267 		v.reset(OpS390XMULLDload)
   21268 		v.AuxInt = o1 + o2
   21269 		v.Aux = mergeSym(s1, s2)
   21270 		v.AddArg(x)
   21271 		v.AddArg(ptr)
   21272 		v.AddArg(mem)
   21273 		return true
   21274 	}
   21275 	return false
   21276 }
   21277 func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool {
   21278 	// match: (MULLW x (MOVDconst [c]))
   21279 	// cond:
   21280 	// result: (MULLWconst [int64(int32(c))] x)
   21281 	for {
   21282 		_ = v.Args[1]
   21283 		x := v.Args[0]
   21284 		v_1 := v.Args[1]
   21285 		if v_1.Op != OpS390XMOVDconst {
   21286 			break
   21287 		}
   21288 		c := v_1.AuxInt
   21289 		v.reset(OpS390XMULLWconst)
   21290 		v.AuxInt = int64(int32(c))
   21291 		v.AddArg(x)
   21292 		return true
   21293 	}
   21294 	// match: (MULLW (MOVDconst [c]) x)
   21295 	// cond:
   21296 	// result: (MULLWconst [int64(int32(c))] x)
   21297 	for {
   21298 		_ = v.Args[1]
   21299 		v_0 := v.Args[0]
   21300 		if v_0.Op != OpS390XMOVDconst {
   21301 			break
   21302 		}
   21303 		c := v_0.AuxInt
   21304 		x := v.Args[1]
   21305 		v.reset(OpS390XMULLWconst)
   21306 		v.AuxInt = int64(int32(c))
   21307 		v.AddArg(x)
   21308 		return true
   21309 	}
   21310 	// match: (MULLW <t> x g:(MOVWload [off] {sym} ptr mem))
   21311 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21312 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21313 	for {
   21314 		t := v.Type
   21315 		_ = v.Args[1]
   21316 		x := v.Args[0]
   21317 		g := v.Args[1]
   21318 		if g.Op != OpS390XMOVWload {
   21319 			break
   21320 		}
   21321 		off := g.AuxInt
   21322 		sym := g.Aux
   21323 		_ = g.Args[1]
   21324 		ptr := g.Args[0]
   21325 		mem := g.Args[1]
   21326 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21327 			break
   21328 		}
   21329 		v.reset(OpS390XMULLWload)
   21330 		v.Type = t
   21331 		v.AuxInt = off
   21332 		v.Aux = sym
   21333 		v.AddArg(x)
   21334 		v.AddArg(ptr)
   21335 		v.AddArg(mem)
   21336 		return true
   21337 	}
   21338 	// match: (MULLW <t> g:(MOVWload [off] {sym} ptr mem) x)
   21339 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21340 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21341 	for {
   21342 		t := v.Type
   21343 		_ = v.Args[1]
   21344 		g := v.Args[0]
   21345 		if g.Op != OpS390XMOVWload {
   21346 			break
   21347 		}
   21348 		off := g.AuxInt
   21349 		sym := g.Aux
   21350 		_ = g.Args[1]
   21351 		ptr := g.Args[0]
   21352 		mem := g.Args[1]
   21353 		x := v.Args[1]
   21354 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21355 			break
   21356 		}
   21357 		v.reset(OpS390XMULLWload)
   21358 		v.Type = t
   21359 		v.AuxInt = off
   21360 		v.Aux = sym
   21361 		v.AddArg(x)
   21362 		v.AddArg(ptr)
   21363 		v.AddArg(mem)
   21364 		return true
   21365 	}
   21366 	// match: (MULLW <t> g:(MOVWload [off] {sym} ptr mem) x)
   21367 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21368 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21369 	for {
   21370 		t := v.Type
   21371 		_ = v.Args[1]
   21372 		g := v.Args[0]
   21373 		if g.Op != OpS390XMOVWload {
   21374 			break
   21375 		}
   21376 		off := g.AuxInt
   21377 		sym := g.Aux
   21378 		_ = g.Args[1]
   21379 		ptr := g.Args[0]
   21380 		mem := g.Args[1]
   21381 		x := v.Args[1]
   21382 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21383 			break
   21384 		}
   21385 		v.reset(OpS390XMULLWload)
   21386 		v.Type = t
   21387 		v.AuxInt = off
   21388 		v.Aux = sym
   21389 		v.AddArg(x)
   21390 		v.AddArg(ptr)
   21391 		v.AddArg(mem)
   21392 		return true
   21393 	}
   21394 	// match: (MULLW <t> x g:(MOVWload [off] {sym} ptr mem))
   21395 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21396 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21397 	for {
   21398 		t := v.Type
   21399 		_ = v.Args[1]
   21400 		x := v.Args[0]
   21401 		g := v.Args[1]
   21402 		if g.Op != OpS390XMOVWload {
   21403 			break
   21404 		}
   21405 		off := g.AuxInt
   21406 		sym := g.Aux
   21407 		_ = g.Args[1]
   21408 		ptr := g.Args[0]
   21409 		mem := g.Args[1]
   21410 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21411 			break
   21412 		}
   21413 		v.reset(OpS390XMULLWload)
   21414 		v.Type = t
   21415 		v.AuxInt = off
   21416 		v.Aux = sym
   21417 		v.AddArg(x)
   21418 		v.AddArg(ptr)
   21419 		v.AddArg(mem)
   21420 		return true
   21421 	}
   21422 	// match: (MULLW <t> x g:(MOVWZload [off] {sym} ptr mem))
   21423 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21424 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21425 	for {
   21426 		t := v.Type
   21427 		_ = v.Args[1]
   21428 		x := v.Args[0]
   21429 		g := v.Args[1]
   21430 		if g.Op != OpS390XMOVWZload {
   21431 			break
   21432 		}
   21433 		off := g.AuxInt
   21434 		sym := g.Aux
   21435 		_ = g.Args[1]
   21436 		ptr := g.Args[0]
   21437 		mem := g.Args[1]
   21438 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21439 			break
   21440 		}
   21441 		v.reset(OpS390XMULLWload)
   21442 		v.Type = t
   21443 		v.AuxInt = off
   21444 		v.Aux = sym
   21445 		v.AddArg(x)
   21446 		v.AddArg(ptr)
   21447 		v.AddArg(mem)
   21448 		return true
   21449 	}
   21450 	// match: (MULLW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   21451 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21452 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21453 	for {
   21454 		t := v.Type
   21455 		_ = v.Args[1]
   21456 		g := v.Args[0]
   21457 		if g.Op != OpS390XMOVWZload {
   21458 			break
   21459 		}
   21460 		off := g.AuxInt
   21461 		sym := g.Aux
   21462 		_ = g.Args[1]
   21463 		ptr := g.Args[0]
   21464 		mem := g.Args[1]
   21465 		x := v.Args[1]
   21466 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21467 			break
   21468 		}
   21469 		v.reset(OpS390XMULLWload)
   21470 		v.Type = t
   21471 		v.AuxInt = off
   21472 		v.Aux = sym
   21473 		v.AddArg(x)
   21474 		v.AddArg(ptr)
   21475 		v.AddArg(mem)
   21476 		return true
   21477 	}
   21478 	// match: (MULLW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   21479 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21480 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21481 	for {
   21482 		t := v.Type
   21483 		_ = v.Args[1]
   21484 		g := v.Args[0]
   21485 		if g.Op != OpS390XMOVWZload {
   21486 			break
   21487 		}
   21488 		off := g.AuxInt
   21489 		sym := g.Aux
   21490 		_ = g.Args[1]
   21491 		ptr := g.Args[0]
   21492 		mem := g.Args[1]
   21493 		x := v.Args[1]
   21494 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21495 			break
   21496 		}
   21497 		v.reset(OpS390XMULLWload)
   21498 		v.Type = t
   21499 		v.AuxInt = off
   21500 		v.Aux = sym
   21501 		v.AddArg(x)
   21502 		v.AddArg(ptr)
   21503 		v.AddArg(mem)
   21504 		return true
   21505 	}
   21506 	// match: (MULLW <t> x g:(MOVWZload [off] {sym} ptr mem))
   21507 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   21508 	// result: (MULLWload <t> [off] {sym} x ptr mem)
   21509 	for {
   21510 		t := v.Type
   21511 		_ = v.Args[1]
   21512 		x := v.Args[0]
   21513 		g := v.Args[1]
   21514 		if g.Op != OpS390XMOVWZload {
   21515 			break
   21516 		}
   21517 		off := g.AuxInt
   21518 		sym := g.Aux
   21519 		_ = g.Args[1]
   21520 		ptr := g.Args[0]
   21521 		mem := g.Args[1]
   21522 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   21523 			break
   21524 		}
   21525 		v.reset(OpS390XMULLWload)
   21526 		v.Type = t
   21527 		v.AuxInt = off
   21528 		v.Aux = sym
   21529 		v.AddArg(x)
   21530 		v.AddArg(ptr)
   21531 		v.AddArg(mem)
   21532 		return true
   21533 	}
   21534 	return false
   21535 }
   21536 func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool {
   21537 	b := v.Block
   21538 	_ = b
   21539 	// match: (MULLWconst [-1] x)
   21540 	// cond:
   21541 	// result: (NEGW x)
   21542 	for {
   21543 		if v.AuxInt != -1 {
   21544 			break
   21545 		}
   21546 		x := v.Args[0]
   21547 		v.reset(OpS390XNEGW)
   21548 		v.AddArg(x)
   21549 		return true
   21550 	}
   21551 	// match: (MULLWconst [0] _)
   21552 	// cond:
   21553 	// result: (MOVDconst [0])
   21554 	for {
   21555 		if v.AuxInt != 0 {
   21556 			break
   21557 		}
   21558 		v.reset(OpS390XMOVDconst)
   21559 		v.AuxInt = 0
   21560 		return true
   21561 	}
   21562 	// match: (MULLWconst [1] x)
   21563 	// cond:
   21564 	// result: x
   21565 	for {
   21566 		if v.AuxInt != 1 {
   21567 			break
   21568 		}
   21569 		x := v.Args[0]
   21570 		v.reset(OpCopy)
   21571 		v.Type = x.Type
   21572 		v.AddArg(x)
   21573 		return true
   21574 	}
   21575 	// match: (MULLWconst [c] x)
   21576 	// cond: isPowerOfTwo(c)
   21577 	// result: (SLWconst [log2(c)] x)
   21578 	for {
   21579 		c := v.AuxInt
   21580 		x := v.Args[0]
   21581 		if !(isPowerOfTwo(c)) {
   21582 			break
   21583 		}
   21584 		v.reset(OpS390XSLWconst)
   21585 		v.AuxInt = log2(c)
   21586 		v.AddArg(x)
   21587 		return true
   21588 	}
   21589 	// match: (MULLWconst [c] x)
   21590 	// cond: isPowerOfTwo(c+1) && c >= 15
   21591 	// result: (SUBW (SLWconst <v.Type> [log2(c+1)] x) x)
   21592 	for {
   21593 		c := v.AuxInt
   21594 		x := v.Args[0]
   21595 		if !(isPowerOfTwo(c+1) && c >= 15) {
   21596 			break
   21597 		}
   21598 		v.reset(OpS390XSUBW)
   21599 		v0 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   21600 		v0.AuxInt = log2(c + 1)
   21601 		v0.AddArg(x)
   21602 		v.AddArg(v0)
   21603 		v.AddArg(x)
   21604 		return true
   21605 	}
   21606 	// match: (MULLWconst [c] x)
   21607 	// cond: isPowerOfTwo(c-1) && c >= 17
   21608 	// result: (ADDW (SLWconst <v.Type> [log2(c-1)] x) x)
   21609 	for {
   21610 		c := v.AuxInt
   21611 		x := v.Args[0]
   21612 		if !(isPowerOfTwo(c-1) && c >= 17) {
   21613 			break
   21614 		}
   21615 		v.reset(OpS390XADDW)
   21616 		v0 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   21617 		v0.AuxInt = log2(c - 1)
   21618 		v0.AddArg(x)
   21619 		v.AddArg(v0)
   21620 		v.AddArg(x)
   21621 		return true
   21622 	}
   21623 	// match: (MULLWconst [c] (MOVDconst [d]))
   21624 	// cond:
   21625 	// result: (MOVDconst [int64(int32(c*d))])
   21626 	for {
   21627 		c := v.AuxInt
   21628 		v_0 := v.Args[0]
   21629 		if v_0.Op != OpS390XMOVDconst {
   21630 			break
   21631 		}
   21632 		d := v_0.AuxInt
   21633 		v.reset(OpS390XMOVDconst)
   21634 		v.AuxInt = int64(int32(c * d))
   21635 		return true
   21636 	}
   21637 	return false
   21638 }
   21639 func rewriteValueS390X_OpS390XMULLWload_0(v *Value) bool {
   21640 	// match: (MULLWload [off1] {sym} x (ADDconst [off2] ptr) mem)
   21641 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   21642 	// result: (MULLWload [off1+off2] {sym} x ptr mem)
   21643 	for {
   21644 		off1 := v.AuxInt
   21645 		sym := v.Aux
   21646 		_ = v.Args[2]
   21647 		x := v.Args[0]
   21648 		v_1 := v.Args[1]
   21649 		if v_1.Op != OpS390XADDconst {
   21650 			break
   21651 		}
   21652 		off2 := v_1.AuxInt
   21653 		ptr := v_1.Args[0]
   21654 		mem := v.Args[2]
   21655 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   21656 			break
   21657 		}
   21658 		v.reset(OpS390XMULLWload)
   21659 		v.AuxInt = off1 + off2
   21660 		v.Aux = sym
   21661 		v.AddArg(x)
   21662 		v.AddArg(ptr)
   21663 		v.AddArg(mem)
   21664 		return true
   21665 	}
   21666 	// match: (MULLWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   21667 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   21668 	// result: (MULLWload [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   21669 	for {
   21670 		o1 := v.AuxInt
   21671 		s1 := v.Aux
   21672 		_ = v.Args[2]
   21673 		x := v.Args[0]
   21674 		v_1 := v.Args[1]
   21675 		if v_1.Op != OpS390XMOVDaddr {
   21676 			break
   21677 		}
   21678 		o2 := v_1.AuxInt
   21679 		s2 := v_1.Aux
   21680 		ptr := v_1.Args[0]
   21681 		mem := v.Args[2]
   21682 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   21683 			break
   21684 		}
   21685 		v.reset(OpS390XMULLWload)
   21686 		v.AuxInt = o1 + o2
   21687 		v.Aux = mergeSym(s1, s2)
   21688 		v.AddArg(x)
   21689 		v.AddArg(ptr)
   21690 		v.AddArg(mem)
   21691 		return true
   21692 	}
   21693 	return false
   21694 }
   21695 func rewriteValueS390X_OpS390XNEG_0(v *Value) bool {
   21696 	// match: (NEG (MOVDconst [c]))
   21697 	// cond:
   21698 	// result: (MOVDconst [-c])
   21699 	for {
   21700 		v_0 := v.Args[0]
   21701 		if v_0.Op != OpS390XMOVDconst {
   21702 			break
   21703 		}
   21704 		c := v_0.AuxInt
   21705 		v.reset(OpS390XMOVDconst)
   21706 		v.AuxInt = -c
   21707 		return true
   21708 	}
   21709 	// match: (NEG (ADDconst [c] (NEG x)))
   21710 	// cond: c != -(1<<31)
   21711 	// result: (ADDconst [-c] x)
   21712 	for {
   21713 		v_0 := v.Args[0]
   21714 		if v_0.Op != OpS390XADDconst {
   21715 			break
   21716 		}
   21717 		c := v_0.AuxInt
   21718 		v_0_0 := v_0.Args[0]
   21719 		if v_0_0.Op != OpS390XNEG {
   21720 			break
   21721 		}
   21722 		x := v_0_0.Args[0]
   21723 		if !(c != -(1 << 31)) {
   21724 			break
   21725 		}
   21726 		v.reset(OpS390XADDconst)
   21727 		v.AuxInt = -c
   21728 		v.AddArg(x)
   21729 		return true
   21730 	}
   21731 	return false
   21732 }
   21733 func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool {
   21734 	// match: (NEGW (MOVDconst [c]))
   21735 	// cond:
   21736 	// result: (MOVDconst [int64(int32(-c))])
   21737 	for {
   21738 		v_0 := v.Args[0]
   21739 		if v_0.Op != OpS390XMOVDconst {
   21740 			break
   21741 		}
   21742 		c := v_0.AuxInt
   21743 		v.reset(OpS390XMOVDconst)
   21744 		v.AuxInt = int64(int32(-c))
   21745 		return true
   21746 	}
   21747 	return false
   21748 }
   21749 func rewriteValueS390X_OpS390XNOT_0(v *Value) bool {
   21750 	b := v.Block
   21751 	_ = b
   21752 	typ := &b.Func.Config.Types
   21753 	_ = typ
   21754 	// match: (NOT x)
   21755 	// cond: true
   21756 	// result: (XOR (MOVDconst [-1]) x)
   21757 	for {
   21758 		x := v.Args[0]
   21759 		if !(true) {
   21760 			break
   21761 		}
   21762 		v.reset(OpS390XXOR)
   21763 		v0 := b.NewValue0(v.Pos, OpS390XMOVDconst, typ.UInt64)
   21764 		v0.AuxInt = -1
   21765 		v.AddArg(v0)
   21766 		v.AddArg(x)
   21767 		return true
   21768 	}
   21769 	return false
   21770 }
   21771 func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool {
   21772 	// match: (NOTW x)
   21773 	// cond: true
   21774 	// result: (XORWconst [-1] x)
   21775 	for {
   21776 		x := v.Args[0]
   21777 		if !(true) {
   21778 			break
   21779 		}
   21780 		v.reset(OpS390XXORWconst)
   21781 		v.AuxInt = -1
   21782 		v.AddArg(x)
   21783 		return true
   21784 	}
   21785 	return false
   21786 }
   21787 func rewriteValueS390X_OpS390XOR_0(v *Value) bool {
   21788 	b := v.Block
   21789 	_ = b
   21790 	// match: (OR x (MOVDconst [c]))
   21791 	// cond: isU32Bit(c)
   21792 	// result: (ORconst [c] x)
   21793 	for {
   21794 		_ = v.Args[1]
   21795 		x := v.Args[0]
   21796 		v_1 := v.Args[1]
   21797 		if v_1.Op != OpS390XMOVDconst {
   21798 			break
   21799 		}
   21800 		c := v_1.AuxInt
   21801 		if !(isU32Bit(c)) {
   21802 			break
   21803 		}
   21804 		v.reset(OpS390XORconst)
   21805 		v.AuxInt = c
   21806 		v.AddArg(x)
   21807 		return true
   21808 	}
   21809 	// match: (OR (MOVDconst [c]) x)
   21810 	// cond: isU32Bit(c)
   21811 	// result: (ORconst [c] x)
   21812 	for {
   21813 		_ = v.Args[1]
   21814 		v_0 := v.Args[0]
   21815 		if v_0.Op != OpS390XMOVDconst {
   21816 			break
   21817 		}
   21818 		c := v_0.AuxInt
   21819 		x := v.Args[1]
   21820 		if !(isU32Bit(c)) {
   21821 			break
   21822 		}
   21823 		v.reset(OpS390XORconst)
   21824 		v.AuxInt = c
   21825 		v.AddArg(x)
   21826 		return true
   21827 	}
   21828 	// match: (OR (SLDconst x [c]) (SRDconst x [d]))
   21829 	// cond: d == 64-c
   21830 	// result: (RLLGconst [c] x)
   21831 	for {
   21832 		_ = v.Args[1]
   21833 		v_0 := v.Args[0]
   21834 		if v_0.Op != OpS390XSLDconst {
   21835 			break
   21836 		}
   21837 		c := v_0.AuxInt
   21838 		x := v_0.Args[0]
   21839 		v_1 := v.Args[1]
   21840 		if v_1.Op != OpS390XSRDconst {
   21841 			break
   21842 		}
   21843 		d := v_1.AuxInt
   21844 		if x != v_1.Args[0] {
   21845 			break
   21846 		}
   21847 		if !(d == 64-c) {
   21848 			break
   21849 		}
   21850 		v.reset(OpS390XRLLGconst)
   21851 		v.AuxInt = c
   21852 		v.AddArg(x)
   21853 		return true
   21854 	}
   21855 	// match: (OR (SRDconst x [d]) (SLDconst x [c]))
   21856 	// cond: d == 64-c
   21857 	// result: (RLLGconst [c] x)
   21858 	for {
   21859 		_ = v.Args[1]
   21860 		v_0 := v.Args[0]
   21861 		if v_0.Op != OpS390XSRDconst {
   21862 			break
   21863 		}
   21864 		d := v_0.AuxInt
   21865 		x := v_0.Args[0]
   21866 		v_1 := v.Args[1]
   21867 		if v_1.Op != OpS390XSLDconst {
   21868 			break
   21869 		}
   21870 		c := v_1.AuxInt
   21871 		if x != v_1.Args[0] {
   21872 			break
   21873 		}
   21874 		if !(d == 64-c) {
   21875 			break
   21876 		}
   21877 		v.reset(OpS390XRLLGconst)
   21878 		v.AuxInt = c
   21879 		v.AddArg(x)
   21880 		return true
   21881 	}
   21882 	// match: (OR (MOVDconst [-1<<63]) (LGDR <t> x))
   21883 	// cond:
   21884 	// result: (LGDR <t> (LNDFR <x.Type> x))
   21885 	for {
   21886 		_ = v.Args[1]
   21887 		v_0 := v.Args[0]
   21888 		if v_0.Op != OpS390XMOVDconst {
   21889 			break
   21890 		}
   21891 		if v_0.AuxInt != -1<<63 {
   21892 			break
   21893 		}
   21894 		v_1 := v.Args[1]
   21895 		if v_1.Op != OpS390XLGDR {
   21896 			break
   21897 		}
   21898 		t := v_1.Type
   21899 		x := v_1.Args[0]
   21900 		v.reset(OpS390XLGDR)
   21901 		v.Type = t
   21902 		v0 := b.NewValue0(v.Pos, OpS390XLNDFR, x.Type)
   21903 		v0.AddArg(x)
   21904 		v.AddArg(v0)
   21905 		return true
   21906 	}
   21907 	// match: (OR (LGDR <t> x) (MOVDconst [-1<<63]))
   21908 	// cond:
   21909 	// result: (LGDR <t> (LNDFR <x.Type> x))
   21910 	for {
   21911 		_ = v.Args[1]
   21912 		v_0 := v.Args[0]
   21913 		if v_0.Op != OpS390XLGDR {
   21914 			break
   21915 		}
   21916 		t := v_0.Type
   21917 		x := v_0.Args[0]
   21918 		v_1 := v.Args[1]
   21919 		if v_1.Op != OpS390XMOVDconst {
   21920 			break
   21921 		}
   21922 		if v_1.AuxInt != -1<<63 {
   21923 			break
   21924 		}
   21925 		v.reset(OpS390XLGDR)
   21926 		v.Type = t
   21927 		v0 := b.NewValue0(v.Pos, OpS390XLNDFR, x.Type)
   21928 		v0.AddArg(x)
   21929 		v.AddArg(v0)
   21930 		return true
   21931 	}
   21932 	// match: (OR (SLDconst [63] (SRDconst [63] (LGDR x))) (LGDR (LPDFR <t> y)))
   21933 	// cond:
   21934 	// result: (LGDR (CPSDR <t> y x))
   21935 	for {
   21936 		_ = v.Args[1]
   21937 		v_0 := v.Args[0]
   21938 		if v_0.Op != OpS390XSLDconst {
   21939 			break
   21940 		}
   21941 		if v_0.AuxInt != 63 {
   21942 			break
   21943 		}
   21944 		v_0_0 := v_0.Args[0]
   21945 		if v_0_0.Op != OpS390XSRDconst {
   21946 			break
   21947 		}
   21948 		if v_0_0.AuxInt != 63 {
   21949 			break
   21950 		}
   21951 		v_0_0_0 := v_0_0.Args[0]
   21952 		if v_0_0_0.Op != OpS390XLGDR {
   21953 			break
   21954 		}
   21955 		x := v_0_0_0.Args[0]
   21956 		v_1 := v.Args[1]
   21957 		if v_1.Op != OpS390XLGDR {
   21958 			break
   21959 		}
   21960 		v_1_0 := v_1.Args[0]
   21961 		if v_1_0.Op != OpS390XLPDFR {
   21962 			break
   21963 		}
   21964 		t := v_1_0.Type
   21965 		y := v_1_0.Args[0]
   21966 		v.reset(OpS390XLGDR)
   21967 		v0 := b.NewValue0(v.Pos, OpS390XCPSDR, t)
   21968 		v0.AddArg(y)
   21969 		v0.AddArg(x)
   21970 		v.AddArg(v0)
   21971 		return true
   21972 	}
   21973 	// match: (OR (LGDR (LPDFR <t> y)) (SLDconst [63] (SRDconst [63] (LGDR x))))
   21974 	// cond:
   21975 	// result: (LGDR (CPSDR <t> y x))
   21976 	for {
   21977 		_ = v.Args[1]
   21978 		v_0 := v.Args[0]
   21979 		if v_0.Op != OpS390XLGDR {
   21980 			break
   21981 		}
   21982 		v_0_0 := v_0.Args[0]
   21983 		if v_0_0.Op != OpS390XLPDFR {
   21984 			break
   21985 		}
   21986 		t := v_0_0.Type
   21987 		y := v_0_0.Args[0]
   21988 		v_1 := v.Args[1]
   21989 		if v_1.Op != OpS390XSLDconst {
   21990 			break
   21991 		}
   21992 		if v_1.AuxInt != 63 {
   21993 			break
   21994 		}
   21995 		v_1_0 := v_1.Args[0]
   21996 		if v_1_0.Op != OpS390XSRDconst {
   21997 			break
   21998 		}
   21999 		if v_1_0.AuxInt != 63 {
   22000 			break
   22001 		}
   22002 		v_1_0_0 := v_1_0.Args[0]
   22003 		if v_1_0_0.Op != OpS390XLGDR {
   22004 			break
   22005 		}
   22006 		x := v_1_0_0.Args[0]
   22007 		v.reset(OpS390XLGDR)
   22008 		v0 := b.NewValue0(v.Pos, OpS390XCPSDR, t)
   22009 		v0.AddArg(y)
   22010 		v0.AddArg(x)
   22011 		v.AddArg(v0)
   22012 		return true
   22013 	}
   22014 	// match: (OR (SLDconst [63] (SRDconst [63] (LGDR x))) (MOVDconst [c]))
   22015 	// cond: c & -1<<63 == 0
   22016 	// result: (LGDR (CPSDR <x.Type> (FMOVDconst <x.Type> [c]) x))
   22017 	for {
   22018 		_ = v.Args[1]
   22019 		v_0 := v.Args[0]
   22020 		if v_0.Op != OpS390XSLDconst {
   22021 			break
   22022 		}
   22023 		if v_0.AuxInt != 63 {
   22024 			break
   22025 		}
   22026 		v_0_0 := v_0.Args[0]
   22027 		if v_0_0.Op != OpS390XSRDconst {
   22028 			break
   22029 		}
   22030 		if v_0_0.AuxInt != 63 {
   22031 			break
   22032 		}
   22033 		v_0_0_0 := v_0_0.Args[0]
   22034 		if v_0_0_0.Op != OpS390XLGDR {
   22035 			break
   22036 		}
   22037 		x := v_0_0_0.Args[0]
   22038 		v_1 := v.Args[1]
   22039 		if v_1.Op != OpS390XMOVDconst {
   22040 			break
   22041 		}
   22042 		c := v_1.AuxInt
   22043 		if !(c&-1<<63 == 0) {
   22044 			break
   22045 		}
   22046 		v.reset(OpS390XLGDR)
   22047 		v0 := b.NewValue0(v.Pos, OpS390XCPSDR, x.Type)
   22048 		v1 := b.NewValue0(v.Pos, OpS390XFMOVDconst, x.Type)
   22049 		v1.AuxInt = c
   22050 		v0.AddArg(v1)
   22051 		v0.AddArg(x)
   22052 		v.AddArg(v0)
   22053 		return true
   22054 	}
   22055 	// match: (OR (MOVDconst [c]) (SLDconst [63] (SRDconst [63] (LGDR x))))
   22056 	// cond: c & -1<<63 == 0
   22057 	// result: (LGDR (CPSDR <x.Type> (FMOVDconst <x.Type> [c]) x))
   22058 	for {
   22059 		_ = v.Args[1]
   22060 		v_0 := v.Args[0]
   22061 		if v_0.Op != OpS390XMOVDconst {
   22062 			break
   22063 		}
   22064 		c := v_0.AuxInt
   22065 		v_1 := v.Args[1]
   22066 		if v_1.Op != OpS390XSLDconst {
   22067 			break
   22068 		}
   22069 		if v_1.AuxInt != 63 {
   22070 			break
   22071 		}
   22072 		v_1_0 := v_1.Args[0]
   22073 		if v_1_0.Op != OpS390XSRDconst {
   22074 			break
   22075 		}
   22076 		if v_1_0.AuxInt != 63 {
   22077 			break
   22078 		}
   22079 		v_1_0_0 := v_1_0.Args[0]
   22080 		if v_1_0_0.Op != OpS390XLGDR {
   22081 			break
   22082 		}
   22083 		x := v_1_0_0.Args[0]
   22084 		if !(c&-1<<63 == 0) {
   22085 			break
   22086 		}
   22087 		v.reset(OpS390XLGDR)
   22088 		v0 := b.NewValue0(v.Pos, OpS390XCPSDR, x.Type)
   22089 		v1 := b.NewValue0(v.Pos, OpS390XFMOVDconst, x.Type)
   22090 		v1.AuxInt = c
   22091 		v0.AddArg(v1)
   22092 		v0.AddArg(x)
   22093 		v.AddArg(v0)
   22094 		return true
   22095 	}
   22096 	return false
   22097 }
   22098 func rewriteValueS390X_OpS390XOR_10(v *Value) bool {
   22099 	b := v.Block
   22100 	_ = b
   22101 	typ := &b.Func.Config.Types
   22102 	_ = typ
   22103 	// match: (OR (MOVDconst [c]) (MOVDconst [d]))
   22104 	// cond:
   22105 	// result: (MOVDconst [c|d])
   22106 	for {
   22107 		_ = v.Args[1]
   22108 		v_0 := v.Args[0]
   22109 		if v_0.Op != OpS390XMOVDconst {
   22110 			break
   22111 		}
   22112 		c := v_0.AuxInt
   22113 		v_1 := v.Args[1]
   22114 		if v_1.Op != OpS390XMOVDconst {
   22115 			break
   22116 		}
   22117 		d := v_1.AuxInt
   22118 		v.reset(OpS390XMOVDconst)
   22119 		v.AuxInt = c | d
   22120 		return true
   22121 	}
   22122 	// match: (OR (MOVDconst [d]) (MOVDconst [c]))
   22123 	// cond:
   22124 	// result: (MOVDconst [c|d])
   22125 	for {
   22126 		_ = v.Args[1]
   22127 		v_0 := v.Args[0]
   22128 		if v_0.Op != OpS390XMOVDconst {
   22129 			break
   22130 		}
   22131 		d := v_0.AuxInt
   22132 		v_1 := v.Args[1]
   22133 		if v_1.Op != OpS390XMOVDconst {
   22134 			break
   22135 		}
   22136 		c := v_1.AuxInt
   22137 		v.reset(OpS390XMOVDconst)
   22138 		v.AuxInt = c | d
   22139 		return true
   22140 	}
   22141 	// match: (OR x x)
   22142 	// cond:
   22143 	// result: x
   22144 	for {
   22145 		_ = v.Args[1]
   22146 		x := v.Args[0]
   22147 		if x != v.Args[1] {
   22148 			break
   22149 		}
   22150 		v.reset(OpCopy)
   22151 		v.Type = x.Type
   22152 		v.AddArg(x)
   22153 		return true
   22154 	}
   22155 	// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
   22156 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   22157 	// result: (ORload <t> [off] {sym} x ptr mem)
   22158 	for {
   22159 		t := v.Type
   22160 		_ = v.Args[1]
   22161 		x := v.Args[0]
   22162 		g := v.Args[1]
   22163 		if g.Op != OpS390XMOVDload {
   22164 			break
   22165 		}
   22166 		off := g.AuxInt
   22167 		sym := g.Aux
   22168 		_ = g.Args[1]
   22169 		ptr := g.Args[0]
   22170 		mem := g.Args[1]
   22171 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   22172 			break
   22173 		}
   22174 		v.reset(OpS390XORload)
   22175 		v.Type = t
   22176 		v.AuxInt = off
   22177 		v.Aux = sym
   22178 		v.AddArg(x)
   22179 		v.AddArg(ptr)
   22180 		v.AddArg(mem)
   22181 		return true
   22182 	}
   22183 	// match: (OR <t> g:(MOVDload [off] {sym} ptr mem) x)
   22184 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   22185 	// result: (ORload <t> [off] {sym} x ptr mem)
   22186 	for {
   22187 		t := v.Type
   22188 		_ = v.Args[1]
   22189 		g := v.Args[0]
   22190 		if g.Op != OpS390XMOVDload {
   22191 			break
   22192 		}
   22193 		off := g.AuxInt
   22194 		sym := g.Aux
   22195 		_ = g.Args[1]
   22196 		ptr := g.Args[0]
   22197 		mem := g.Args[1]
   22198 		x := v.Args[1]
   22199 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   22200 			break
   22201 		}
   22202 		v.reset(OpS390XORload)
   22203 		v.Type = t
   22204 		v.AuxInt = off
   22205 		v.Aux = sym
   22206 		v.AddArg(x)
   22207 		v.AddArg(ptr)
   22208 		v.AddArg(mem)
   22209 		return true
   22210 	}
   22211 	// match: (OR <t> g:(MOVDload [off] {sym} ptr mem) x)
   22212 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   22213 	// result: (ORload <t> [off] {sym} x ptr mem)
   22214 	for {
   22215 		t := v.Type
   22216 		_ = v.Args[1]
   22217 		g := v.Args[0]
   22218 		if g.Op != OpS390XMOVDload {
   22219 			break
   22220 		}
   22221 		off := g.AuxInt
   22222 		sym := g.Aux
   22223 		_ = g.Args[1]
   22224 		ptr := g.Args[0]
   22225 		mem := g.Args[1]
   22226 		x := v.Args[1]
   22227 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   22228 			break
   22229 		}
   22230 		v.reset(OpS390XORload)
   22231 		v.Type = t
   22232 		v.AuxInt = off
   22233 		v.Aux = sym
   22234 		v.AddArg(x)
   22235 		v.AddArg(ptr)
   22236 		v.AddArg(mem)
   22237 		return true
   22238 	}
   22239 	// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
   22240 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   22241 	// result: (ORload <t> [off] {sym} x ptr mem)
   22242 	for {
   22243 		t := v.Type
   22244 		_ = v.Args[1]
   22245 		x := v.Args[0]
   22246 		g := v.Args[1]
   22247 		if g.Op != OpS390XMOVDload {
   22248 			break
   22249 		}
   22250 		off := g.AuxInt
   22251 		sym := g.Aux
   22252 		_ = g.Args[1]
   22253 		ptr := g.Args[0]
   22254 		mem := g.Args[1]
   22255 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   22256 			break
   22257 		}
   22258 		v.reset(OpS390XORload)
   22259 		v.Type = t
   22260 		v.AuxInt = off
   22261 		v.Aux = sym
   22262 		v.AddArg(x)
   22263 		v.AddArg(ptr)
   22264 		v.AddArg(mem)
   22265 		return true
   22266 	}
   22267 	// match: (OR x1:(MOVBZload [i1] {s} p mem) sh:(SLDconst [8] x0:(MOVBZload [i0] {s} p mem)))
   22268 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   22269 	// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
   22270 	for {
   22271 		_ = v.Args[1]
   22272 		x1 := v.Args[0]
   22273 		if x1.Op != OpS390XMOVBZload {
   22274 			break
   22275 		}
   22276 		i1 := x1.AuxInt
   22277 		s := x1.Aux
   22278 		_ = x1.Args[1]
   22279 		p := x1.Args[0]
   22280 		mem := x1.Args[1]
   22281 		sh := v.Args[1]
   22282 		if sh.Op != OpS390XSLDconst {
   22283 			break
   22284 		}
   22285 		if sh.AuxInt != 8 {
   22286 			break
   22287 		}
   22288 		x0 := sh.Args[0]
   22289 		if x0.Op != OpS390XMOVBZload {
   22290 			break
   22291 		}
   22292 		i0 := x0.AuxInt
   22293 		if x0.Aux != s {
   22294 			break
   22295 		}
   22296 		_ = x0.Args[1]
   22297 		if p != x0.Args[0] {
   22298 			break
   22299 		}
   22300 		if mem != x0.Args[1] {
   22301 			break
   22302 		}
   22303 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   22304 			break
   22305 		}
   22306 		b = mergePoint(b, x0, x1)
   22307 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   22308 		v.reset(OpCopy)
   22309 		v.AddArg(v0)
   22310 		v0.AuxInt = i0
   22311 		v0.Aux = s
   22312 		v0.AddArg(p)
   22313 		v0.AddArg(mem)
   22314 		return true
   22315 	}
   22316 	// match: (OR sh:(SLDconst [8] x0:(MOVBZload [i0] {s} p mem)) x1:(MOVBZload [i1] {s} p mem))
   22317 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   22318 	// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
   22319 	for {
   22320 		_ = v.Args[1]
   22321 		sh := v.Args[0]
   22322 		if sh.Op != OpS390XSLDconst {
   22323 			break
   22324 		}
   22325 		if sh.AuxInt != 8 {
   22326 			break
   22327 		}
   22328 		x0 := sh.Args[0]
   22329 		if x0.Op != OpS390XMOVBZload {
   22330 			break
   22331 		}
   22332 		i0 := x0.AuxInt
   22333 		s := x0.Aux
   22334 		_ = x0.Args[1]
   22335 		p := x0.Args[0]
   22336 		mem := x0.Args[1]
   22337 		x1 := v.Args[1]
   22338 		if x1.Op != OpS390XMOVBZload {
   22339 			break
   22340 		}
   22341 		i1 := x1.AuxInt
   22342 		if x1.Aux != s {
   22343 			break
   22344 		}
   22345 		_ = x1.Args[1]
   22346 		if p != x1.Args[0] {
   22347 			break
   22348 		}
   22349 		if mem != x1.Args[1] {
   22350 			break
   22351 		}
   22352 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   22353 			break
   22354 		}
   22355 		b = mergePoint(b, x0, x1)
   22356 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   22357 		v.reset(OpCopy)
   22358 		v.AddArg(v0)
   22359 		v0.AuxInt = i0
   22360 		v0.Aux = s
   22361 		v0.AddArg(p)
   22362 		v0.AddArg(mem)
   22363 		return true
   22364 	}
   22365 	// match: (OR x1:(MOVHZload [i1] {s} p mem) sh:(SLDconst [16] x0:(MOVHZload [i0] {s} p mem)))
   22366 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   22367 	// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
   22368 	for {
   22369 		_ = v.Args[1]
   22370 		x1 := v.Args[0]
   22371 		if x1.Op != OpS390XMOVHZload {
   22372 			break
   22373 		}
   22374 		i1 := x1.AuxInt
   22375 		s := x1.Aux
   22376 		_ = x1.Args[1]
   22377 		p := x1.Args[0]
   22378 		mem := x1.Args[1]
   22379 		sh := v.Args[1]
   22380 		if sh.Op != OpS390XSLDconst {
   22381 			break
   22382 		}
   22383 		if sh.AuxInt != 16 {
   22384 			break
   22385 		}
   22386 		x0 := sh.Args[0]
   22387 		if x0.Op != OpS390XMOVHZload {
   22388 			break
   22389 		}
   22390 		i0 := x0.AuxInt
   22391 		if x0.Aux != s {
   22392 			break
   22393 		}
   22394 		_ = x0.Args[1]
   22395 		if p != x0.Args[0] {
   22396 			break
   22397 		}
   22398 		if mem != x0.Args[1] {
   22399 			break
   22400 		}
   22401 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   22402 			break
   22403 		}
   22404 		b = mergePoint(b, x0, x1)
   22405 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   22406 		v.reset(OpCopy)
   22407 		v.AddArg(v0)
   22408 		v0.AuxInt = i0
   22409 		v0.Aux = s
   22410 		v0.AddArg(p)
   22411 		v0.AddArg(mem)
   22412 		return true
   22413 	}
   22414 	return false
   22415 }
   22416 func rewriteValueS390X_OpS390XOR_20(v *Value) bool {
   22417 	b := v.Block
   22418 	_ = b
   22419 	typ := &b.Func.Config.Types
   22420 	_ = typ
   22421 	// match: (OR sh:(SLDconst [16] x0:(MOVHZload [i0] {s} p mem)) x1:(MOVHZload [i1] {s} p mem))
   22422 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   22423 	// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
   22424 	for {
   22425 		_ = v.Args[1]
   22426 		sh := v.Args[0]
   22427 		if sh.Op != OpS390XSLDconst {
   22428 			break
   22429 		}
   22430 		if sh.AuxInt != 16 {
   22431 			break
   22432 		}
   22433 		x0 := sh.Args[0]
   22434 		if x0.Op != OpS390XMOVHZload {
   22435 			break
   22436 		}
   22437 		i0 := x0.AuxInt
   22438 		s := x0.Aux
   22439 		_ = x0.Args[1]
   22440 		p := x0.Args[0]
   22441 		mem := x0.Args[1]
   22442 		x1 := v.Args[1]
   22443 		if x1.Op != OpS390XMOVHZload {
   22444 			break
   22445 		}
   22446 		i1 := x1.AuxInt
   22447 		if x1.Aux != s {
   22448 			break
   22449 		}
   22450 		_ = x1.Args[1]
   22451 		if p != x1.Args[0] {
   22452 			break
   22453 		}
   22454 		if mem != x1.Args[1] {
   22455 			break
   22456 		}
   22457 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   22458 			break
   22459 		}
   22460 		b = mergePoint(b, x0, x1)
   22461 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   22462 		v.reset(OpCopy)
   22463 		v.AddArg(v0)
   22464 		v0.AuxInt = i0
   22465 		v0.Aux = s
   22466 		v0.AddArg(p)
   22467 		v0.AddArg(mem)
   22468 		return true
   22469 	}
   22470 	// match: (OR x1:(MOVWZload [i1] {s} p mem) sh:(SLDconst [32] x0:(MOVWZload [i0] {s} p mem)))
   22471 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   22472 	// result: @mergePoint(b,x0,x1) (MOVDload [i0] {s} p mem)
   22473 	for {
   22474 		_ = v.Args[1]
   22475 		x1 := v.Args[0]
   22476 		if x1.Op != OpS390XMOVWZload {
   22477 			break
   22478 		}
   22479 		i1 := x1.AuxInt
   22480 		s := x1.Aux
   22481 		_ = x1.Args[1]
   22482 		p := x1.Args[0]
   22483 		mem := x1.Args[1]
   22484 		sh := v.Args[1]
   22485 		if sh.Op != OpS390XSLDconst {
   22486 			break
   22487 		}
   22488 		if sh.AuxInt != 32 {
   22489 			break
   22490 		}
   22491 		x0 := sh.Args[0]
   22492 		if x0.Op != OpS390XMOVWZload {
   22493 			break
   22494 		}
   22495 		i0 := x0.AuxInt
   22496 		if x0.Aux != s {
   22497 			break
   22498 		}
   22499 		_ = x0.Args[1]
   22500 		if p != x0.Args[0] {
   22501 			break
   22502 		}
   22503 		if mem != x0.Args[1] {
   22504 			break
   22505 		}
   22506 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   22507 			break
   22508 		}
   22509 		b = mergePoint(b, x0, x1)
   22510 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   22511 		v.reset(OpCopy)
   22512 		v.AddArg(v0)
   22513 		v0.AuxInt = i0
   22514 		v0.Aux = s
   22515 		v0.AddArg(p)
   22516 		v0.AddArg(mem)
   22517 		return true
   22518 	}
   22519 	// match: (OR sh:(SLDconst [32] x0:(MOVWZload [i0] {s} p mem)) x1:(MOVWZload [i1] {s} p mem))
   22520 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   22521 	// result: @mergePoint(b,x0,x1) (MOVDload [i0] {s} p mem)
   22522 	for {
   22523 		_ = v.Args[1]
   22524 		sh := v.Args[0]
   22525 		if sh.Op != OpS390XSLDconst {
   22526 			break
   22527 		}
   22528 		if sh.AuxInt != 32 {
   22529 			break
   22530 		}
   22531 		x0 := sh.Args[0]
   22532 		if x0.Op != OpS390XMOVWZload {
   22533 			break
   22534 		}
   22535 		i0 := x0.AuxInt
   22536 		s := x0.Aux
   22537 		_ = x0.Args[1]
   22538 		p := x0.Args[0]
   22539 		mem := x0.Args[1]
   22540 		x1 := v.Args[1]
   22541 		if x1.Op != OpS390XMOVWZload {
   22542 			break
   22543 		}
   22544 		i1 := x1.AuxInt
   22545 		if x1.Aux != s {
   22546 			break
   22547 		}
   22548 		_ = x1.Args[1]
   22549 		if p != x1.Args[0] {
   22550 			break
   22551 		}
   22552 		if mem != x1.Args[1] {
   22553 			break
   22554 		}
   22555 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   22556 			break
   22557 		}
   22558 		b = mergePoint(b, x0, x1)
   22559 		v0 := b.NewValue0(v.Pos, OpS390XMOVDload, typ.UInt64)
   22560 		v.reset(OpCopy)
   22561 		v.AddArg(v0)
   22562 		v0.AuxInt = i0
   22563 		v0.Aux = s
   22564 		v0.AddArg(p)
   22565 		v0.AddArg(mem)
   22566 		return true
   22567 	}
   22568 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) y))
   22569 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22570 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   22571 	for {
   22572 		_ = v.Args[1]
   22573 		s0 := v.Args[0]
   22574 		if s0.Op != OpS390XSLDconst {
   22575 			break
   22576 		}
   22577 		j0 := s0.AuxInt
   22578 		x0 := s0.Args[0]
   22579 		if x0.Op != OpS390XMOVBZload {
   22580 			break
   22581 		}
   22582 		i0 := x0.AuxInt
   22583 		s := x0.Aux
   22584 		_ = x0.Args[1]
   22585 		p := x0.Args[0]
   22586 		mem := x0.Args[1]
   22587 		or := v.Args[1]
   22588 		if or.Op != OpS390XOR {
   22589 			break
   22590 		}
   22591 		_ = or.Args[1]
   22592 		s1 := or.Args[0]
   22593 		if s1.Op != OpS390XSLDconst {
   22594 			break
   22595 		}
   22596 		j1 := s1.AuxInt
   22597 		x1 := s1.Args[0]
   22598 		if x1.Op != OpS390XMOVBZload {
   22599 			break
   22600 		}
   22601 		i1 := x1.AuxInt
   22602 		if x1.Aux != s {
   22603 			break
   22604 		}
   22605 		_ = x1.Args[1]
   22606 		if p != x1.Args[0] {
   22607 			break
   22608 		}
   22609 		if mem != x1.Args[1] {
   22610 			break
   22611 		}
   22612 		y := or.Args[1]
   22613 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22614 			break
   22615 		}
   22616 		b = mergePoint(b, x0, x1)
   22617 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   22618 		v.reset(OpCopy)
   22619 		v.AddArg(v0)
   22620 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   22621 		v1.AuxInt = j1
   22622 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   22623 		v2.AuxInt = i0
   22624 		v2.Aux = s
   22625 		v2.AddArg(p)
   22626 		v2.AddArg(mem)
   22627 		v1.AddArg(v2)
   22628 		v0.AddArg(v1)
   22629 		v0.AddArg(y)
   22630 		return true
   22631 	}
   22632 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))))
   22633 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22634 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   22635 	for {
   22636 		_ = v.Args[1]
   22637 		s0 := v.Args[0]
   22638 		if s0.Op != OpS390XSLDconst {
   22639 			break
   22640 		}
   22641 		j0 := s0.AuxInt
   22642 		x0 := s0.Args[0]
   22643 		if x0.Op != OpS390XMOVBZload {
   22644 			break
   22645 		}
   22646 		i0 := x0.AuxInt
   22647 		s := x0.Aux
   22648 		_ = x0.Args[1]
   22649 		p := x0.Args[0]
   22650 		mem := x0.Args[1]
   22651 		or := v.Args[1]
   22652 		if or.Op != OpS390XOR {
   22653 			break
   22654 		}
   22655 		_ = or.Args[1]
   22656 		y := or.Args[0]
   22657 		s1 := or.Args[1]
   22658 		if s1.Op != OpS390XSLDconst {
   22659 			break
   22660 		}
   22661 		j1 := s1.AuxInt
   22662 		x1 := s1.Args[0]
   22663 		if x1.Op != OpS390XMOVBZload {
   22664 			break
   22665 		}
   22666 		i1 := x1.AuxInt
   22667 		if x1.Aux != s {
   22668 			break
   22669 		}
   22670 		_ = x1.Args[1]
   22671 		if p != x1.Args[0] {
   22672 			break
   22673 		}
   22674 		if mem != x1.Args[1] {
   22675 			break
   22676 		}
   22677 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22678 			break
   22679 		}
   22680 		b = mergePoint(b, x0, x1)
   22681 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   22682 		v.reset(OpCopy)
   22683 		v.AddArg(v0)
   22684 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   22685 		v1.AuxInt = j1
   22686 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   22687 		v2.AuxInt = i0
   22688 		v2.Aux = s
   22689 		v2.AddArg(p)
   22690 		v2.AddArg(mem)
   22691 		v1.AddArg(v2)
   22692 		v0.AddArg(v1)
   22693 		v0.AddArg(y)
   22694 		return true
   22695 	}
   22696 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) y) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
   22697 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22698 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   22699 	for {
   22700 		_ = v.Args[1]
   22701 		or := v.Args[0]
   22702 		if or.Op != OpS390XOR {
   22703 			break
   22704 		}
   22705 		_ = or.Args[1]
   22706 		s1 := or.Args[0]
   22707 		if s1.Op != OpS390XSLDconst {
   22708 			break
   22709 		}
   22710 		j1 := s1.AuxInt
   22711 		x1 := s1.Args[0]
   22712 		if x1.Op != OpS390XMOVBZload {
   22713 			break
   22714 		}
   22715 		i1 := x1.AuxInt
   22716 		s := x1.Aux
   22717 		_ = x1.Args[1]
   22718 		p := x1.Args[0]
   22719 		mem := x1.Args[1]
   22720 		y := or.Args[1]
   22721 		s0 := v.Args[1]
   22722 		if s0.Op != OpS390XSLDconst {
   22723 			break
   22724 		}
   22725 		j0 := s0.AuxInt
   22726 		x0 := s0.Args[0]
   22727 		if x0.Op != OpS390XMOVBZload {
   22728 			break
   22729 		}
   22730 		i0 := x0.AuxInt
   22731 		if x0.Aux != s {
   22732 			break
   22733 		}
   22734 		_ = x0.Args[1]
   22735 		if p != x0.Args[0] {
   22736 			break
   22737 		}
   22738 		if mem != x0.Args[1] {
   22739 			break
   22740 		}
   22741 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22742 			break
   22743 		}
   22744 		b = mergePoint(b, x0, x1)
   22745 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   22746 		v.reset(OpCopy)
   22747 		v.AddArg(v0)
   22748 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   22749 		v1.AuxInt = j1
   22750 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   22751 		v2.AuxInt = i0
   22752 		v2.Aux = s
   22753 		v2.AddArg(p)
   22754 		v2.AddArg(mem)
   22755 		v1.AddArg(v2)
   22756 		v0.AddArg(v1)
   22757 		v0.AddArg(y)
   22758 		return true
   22759 	}
   22760 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
   22761 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22762 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   22763 	for {
   22764 		_ = v.Args[1]
   22765 		or := v.Args[0]
   22766 		if or.Op != OpS390XOR {
   22767 			break
   22768 		}
   22769 		_ = or.Args[1]
   22770 		y := or.Args[0]
   22771 		s1 := or.Args[1]
   22772 		if s1.Op != OpS390XSLDconst {
   22773 			break
   22774 		}
   22775 		j1 := s1.AuxInt
   22776 		x1 := s1.Args[0]
   22777 		if x1.Op != OpS390XMOVBZload {
   22778 			break
   22779 		}
   22780 		i1 := x1.AuxInt
   22781 		s := x1.Aux
   22782 		_ = x1.Args[1]
   22783 		p := x1.Args[0]
   22784 		mem := x1.Args[1]
   22785 		s0 := v.Args[1]
   22786 		if s0.Op != OpS390XSLDconst {
   22787 			break
   22788 		}
   22789 		j0 := s0.AuxInt
   22790 		x0 := s0.Args[0]
   22791 		if x0.Op != OpS390XMOVBZload {
   22792 			break
   22793 		}
   22794 		i0 := x0.AuxInt
   22795 		if x0.Aux != s {
   22796 			break
   22797 		}
   22798 		_ = x0.Args[1]
   22799 		if p != x0.Args[0] {
   22800 			break
   22801 		}
   22802 		if mem != x0.Args[1] {
   22803 			break
   22804 		}
   22805 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22806 			break
   22807 		}
   22808 		b = mergePoint(b, x0, x1)
   22809 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   22810 		v.reset(OpCopy)
   22811 		v.AddArg(v0)
   22812 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   22813 		v1.AuxInt = j1
   22814 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   22815 		v2.AuxInt = i0
   22816 		v2.Aux = s
   22817 		v2.AddArg(p)
   22818 		v2.AddArg(mem)
   22819 		v1.AddArg(v2)
   22820 		v0.AddArg(v1)
   22821 		v0.AddArg(y)
   22822 		return true
   22823 	}
   22824 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem)) y))
   22825 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22826 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
   22827 	for {
   22828 		_ = v.Args[1]
   22829 		s0 := v.Args[0]
   22830 		if s0.Op != OpS390XSLDconst {
   22831 			break
   22832 		}
   22833 		j0 := s0.AuxInt
   22834 		x0 := s0.Args[0]
   22835 		if x0.Op != OpS390XMOVHZload {
   22836 			break
   22837 		}
   22838 		i0 := x0.AuxInt
   22839 		s := x0.Aux
   22840 		_ = x0.Args[1]
   22841 		p := x0.Args[0]
   22842 		mem := x0.Args[1]
   22843 		or := v.Args[1]
   22844 		if or.Op != OpS390XOR {
   22845 			break
   22846 		}
   22847 		_ = or.Args[1]
   22848 		s1 := or.Args[0]
   22849 		if s1.Op != OpS390XSLDconst {
   22850 			break
   22851 		}
   22852 		j1 := s1.AuxInt
   22853 		x1 := s1.Args[0]
   22854 		if x1.Op != OpS390XMOVHZload {
   22855 			break
   22856 		}
   22857 		i1 := x1.AuxInt
   22858 		if x1.Aux != s {
   22859 			break
   22860 		}
   22861 		_ = x1.Args[1]
   22862 		if p != x1.Args[0] {
   22863 			break
   22864 		}
   22865 		if mem != x1.Args[1] {
   22866 			break
   22867 		}
   22868 		y := or.Args[1]
   22869 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22870 			break
   22871 		}
   22872 		b = mergePoint(b, x0, x1)
   22873 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   22874 		v.reset(OpCopy)
   22875 		v.AddArg(v0)
   22876 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   22877 		v1.AuxInt = j1
   22878 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   22879 		v2.AuxInt = i0
   22880 		v2.Aux = s
   22881 		v2.AddArg(p)
   22882 		v2.AddArg(mem)
   22883 		v1.AddArg(v2)
   22884 		v0.AddArg(v1)
   22885 		v0.AddArg(y)
   22886 		return true
   22887 	}
   22888 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem))))
   22889 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22890 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
   22891 	for {
   22892 		_ = v.Args[1]
   22893 		s0 := v.Args[0]
   22894 		if s0.Op != OpS390XSLDconst {
   22895 			break
   22896 		}
   22897 		j0 := s0.AuxInt
   22898 		x0 := s0.Args[0]
   22899 		if x0.Op != OpS390XMOVHZload {
   22900 			break
   22901 		}
   22902 		i0 := x0.AuxInt
   22903 		s := x0.Aux
   22904 		_ = x0.Args[1]
   22905 		p := x0.Args[0]
   22906 		mem := x0.Args[1]
   22907 		or := v.Args[1]
   22908 		if or.Op != OpS390XOR {
   22909 			break
   22910 		}
   22911 		_ = or.Args[1]
   22912 		y := or.Args[0]
   22913 		s1 := or.Args[1]
   22914 		if s1.Op != OpS390XSLDconst {
   22915 			break
   22916 		}
   22917 		j1 := s1.AuxInt
   22918 		x1 := s1.Args[0]
   22919 		if x1.Op != OpS390XMOVHZload {
   22920 			break
   22921 		}
   22922 		i1 := x1.AuxInt
   22923 		if x1.Aux != s {
   22924 			break
   22925 		}
   22926 		_ = x1.Args[1]
   22927 		if p != x1.Args[0] {
   22928 			break
   22929 		}
   22930 		if mem != x1.Args[1] {
   22931 			break
   22932 		}
   22933 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22934 			break
   22935 		}
   22936 		b = mergePoint(b, x0, x1)
   22937 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   22938 		v.reset(OpCopy)
   22939 		v.AddArg(v0)
   22940 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   22941 		v1.AuxInt = j1
   22942 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   22943 		v2.AuxInt = i0
   22944 		v2.Aux = s
   22945 		v2.AddArg(p)
   22946 		v2.AddArg(mem)
   22947 		v1.AddArg(v2)
   22948 		v0.AddArg(v1)
   22949 		v0.AddArg(y)
   22950 		return true
   22951 	}
   22952 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem)) y) s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)))
   22953 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   22954 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
   22955 	for {
   22956 		_ = v.Args[1]
   22957 		or := v.Args[0]
   22958 		if or.Op != OpS390XOR {
   22959 			break
   22960 		}
   22961 		_ = or.Args[1]
   22962 		s1 := or.Args[0]
   22963 		if s1.Op != OpS390XSLDconst {
   22964 			break
   22965 		}
   22966 		j1 := s1.AuxInt
   22967 		x1 := s1.Args[0]
   22968 		if x1.Op != OpS390XMOVHZload {
   22969 			break
   22970 		}
   22971 		i1 := x1.AuxInt
   22972 		s := x1.Aux
   22973 		_ = x1.Args[1]
   22974 		p := x1.Args[0]
   22975 		mem := x1.Args[1]
   22976 		y := or.Args[1]
   22977 		s0 := v.Args[1]
   22978 		if s0.Op != OpS390XSLDconst {
   22979 			break
   22980 		}
   22981 		j0 := s0.AuxInt
   22982 		x0 := s0.Args[0]
   22983 		if x0.Op != OpS390XMOVHZload {
   22984 			break
   22985 		}
   22986 		i0 := x0.AuxInt
   22987 		if x0.Aux != s {
   22988 			break
   22989 		}
   22990 		_ = x0.Args[1]
   22991 		if p != x0.Args[0] {
   22992 			break
   22993 		}
   22994 		if mem != x0.Args[1] {
   22995 			break
   22996 		}
   22997 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   22998 			break
   22999 		}
   23000 		b = mergePoint(b, x0, x1)
   23001 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   23002 		v.reset(OpCopy)
   23003 		v.AddArg(v0)
   23004 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   23005 		v1.AuxInt = j1
   23006 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   23007 		v2.AuxInt = i0
   23008 		v2.Aux = s
   23009 		v2.AddArg(p)
   23010 		v2.AddArg(mem)
   23011 		v1.AddArg(v2)
   23012 		v0.AddArg(v1)
   23013 		v0.AddArg(y)
   23014 		return true
   23015 	}
   23016 	return false
   23017 }
   23018 func rewriteValueS390X_OpS390XOR_30(v *Value) bool {
   23019 	b := v.Block
   23020 	_ = b
   23021 	typ := &b.Func.Config.Types
   23022 	_ = typ
   23023 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVHZload [i0] {s} p mem)))
   23024 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   23025 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZload [i0] {s} p mem)) y)
   23026 	for {
   23027 		_ = v.Args[1]
   23028 		or := v.Args[0]
   23029 		if or.Op != OpS390XOR {
   23030 			break
   23031 		}
   23032 		_ = or.Args[1]
   23033 		y := or.Args[0]
   23034 		s1 := or.Args[1]
   23035 		if s1.Op != OpS390XSLDconst {
   23036 			break
   23037 		}
   23038 		j1 := s1.AuxInt
   23039 		x1 := s1.Args[0]
   23040 		if x1.Op != OpS390XMOVHZload {
   23041 			break
   23042 		}
   23043 		i1 := x1.AuxInt
   23044 		s := x1.Aux
   23045 		_ = x1.Args[1]
   23046 		p := x1.Args[0]
   23047 		mem := x1.Args[1]
   23048 		s0 := v.Args[1]
   23049 		if s0.Op != OpS390XSLDconst {
   23050 			break
   23051 		}
   23052 		j0 := s0.AuxInt
   23053 		x0 := s0.Args[0]
   23054 		if x0.Op != OpS390XMOVHZload {
   23055 			break
   23056 		}
   23057 		i0 := x0.AuxInt
   23058 		if x0.Aux != s {
   23059 			break
   23060 		}
   23061 		_ = x0.Args[1]
   23062 		if p != x0.Args[0] {
   23063 			break
   23064 		}
   23065 		if mem != x0.Args[1] {
   23066 			break
   23067 		}
   23068 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   23069 			break
   23070 		}
   23071 		b = mergePoint(b, x0, x1)
   23072 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   23073 		v.reset(OpCopy)
   23074 		v.AddArg(v0)
   23075 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   23076 		v1.AuxInt = j1
   23077 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   23078 		v2.AuxInt = i0
   23079 		v2.Aux = s
   23080 		v2.AddArg(p)
   23081 		v2.AddArg(mem)
   23082 		v1.AddArg(v2)
   23083 		v0.AddArg(v1)
   23084 		v0.AddArg(y)
   23085 		return true
   23086 	}
   23087 	// match: (OR x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   23088 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23089 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23090 	for {
   23091 		_ = v.Args[1]
   23092 		x1 := v.Args[0]
   23093 		if x1.Op != OpS390XMOVBZloadidx {
   23094 			break
   23095 		}
   23096 		i1 := x1.AuxInt
   23097 		s := x1.Aux
   23098 		_ = x1.Args[2]
   23099 		p := x1.Args[0]
   23100 		idx := x1.Args[1]
   23101 		mem := x1.Args[2]
   23102 		sh := v.Args[1]
   23103 		if sh.Op != OpS390XSLDconst {
   23104 			break
   23105 		}
   23106 		if sh.AuxInt != 8 {
   23107 			break
   23108 		}
   23109 		x0 := sh.Args[0]
   23110 		if x0.Op != OpS390XMOVBZloadidx {
   23111 			break
   23112 		}
   23113 		i0 := x0.AuxInt
   23114 		if x0.Aux != s {
   23115 			break
   23116 		}
   23117 		_ = x0.Args[2]
   23118 		if p != x0.Args[0] {
   23119 			break
   23120 		}
   23121 		if idx != x0.Args[1] {
   23122 			break
   23123 		}
   23124 		if mem != x0.Args[2] {
   23125 			break
   23126 		}
   23127 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23128 			break
   23129 		}
   23130 		b = mergePoint(b, x0, x1)
   23131 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23132 		v.reset(OpCopy)
   23133 		v.AddArg(v0)
   23134 		v0.AuxInt = i0
   23135 		v0.Aux = s
   23136 		v0.AddArg(p)
   23137 		v0.AddArg(idx)
   23138 		v0.AddArg(mem)
   23139 		return true
   23140 	}
   23141 	// match: (OR x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   23142 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23143 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23144 	for {
   23145 		_ = v.Args[1]
   23146 		x1 := v.Args[0]
   23147 		if x1.Op != OpS390XMOVBZloadidx {
   23148 			break
   23149 		}
   23150 		i1 := x1.AuxInt
   23151 		s := x1.Aux
   23152 		_ = x1.Args[2]
   23153 		idx := x1.Args[0]
   23154 		p := x1.Args[1]
   23155 		mem := x1.Args[2]
   23156 		sh := v.Args[1]
   23157 		if sh.Op != OpS390XSLDconst {
   23158 			break
   23159 		}
   23160 		if sh.AuxInt != 8 {
   23161 			break
   23162 		}
   23163 		x0 := sh.Args[0]
   23164 		if x0.Op != OpS390XMOVBZloadidx {
   23165 			break
   23166 		}
   23167 		i0 := x0.AuxInt
   23168 		if x0.Aux != s {
   23169 			break
   23170 		}
   23171 		_ = x0.Args[2]
   23172 		if p != x0.Args[0] {
   23173 			break
   23174 		}
   23175 		if idx != x0.Args[1] {
   23176 			break
   23177 		}
   23178 		if mem != x0.Args[2] {
   23179 			break
   23180 		}
   23181 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23182 			break
   23183 		}
   23184 		b = mergePoint(b, x0, x1)
   23185 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23186 		v.reset(OpCopy)
   23187 		v.AddArg(v0)
   23188 		v0.AuxInt = i0
   23189 		v0.Aux = s
   23190 		v0.AddArg(p)
   23191 		v0.AddArg(idx)
   23192 		v0.AddArg(mem)
   23193 		return true
   23194 	}
   23195 	// match: (OR x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   23196 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23197 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23198 	for {
   23199 		_ = v.Args[1]
   23200 		x1 := v.Args[0]
   23201 		if x1.Op != OpS390XMOVBZloadidx {
   23202 			break
   23203 		}
   23204 		i1 := x1.AuxInt
   23205 		s := x1.Aux
   23206 		_ = x1.Args[2]
   23207 		p := x1.Args[0]
   23208 		idx := x1.Args[1]
   23209 		mem := x1.Args[2]
   23210 		sh := v.Args[1]
   23211 		if sh.Op != OpS390XSLDconst {
   23212 			break
   23213 		}
   23214 		if sh.AuxInt != 8 {
   23215 			break
   23216 		}
   23217 		x0 := sh.Args[0]
   23218 		if x0.Op != OpS390XMOVBZloadidx {
   23219 			break
   23220 		}
   23221 		i0 := x0.AuxInt
   23222 		if x0.Aux != s {
   23223 			break
   23224 		}
   23225 		_ = x0.Args[2]
   23226 		if idx != x0.Args[0] {
   23227 			break
   23228 		}
   23229 		if p != x0.Args[1] {
   23230 			break
   23231 		}
   23232 		if mem != x0.Args[2] {
   23233 			break
   23234 		}
   23235 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23236 			break
   23237 		}
   23238 		b = mergePoint(b, x0, x1)
   23239 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23240 		v.reset(OpCopy)
   23241 		v.AddArg(v0)
   23242 		v0.AuxInt = i0
   23243 		v0.Aux = s
   23244 		v0.AddArg(p)
   23245 		v0.AddArg(idx)
   23246 		v0.AddArg(mem)
   23247 		return true
   23248 	}
   23249 	// match: (OR x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   23250 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23251 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23252 	for {
   23253 		_ = v.Args[1]
   23254 		x1 := v.Args[0]
   23255 		if x1.Op != OpS390XMOVBZloadidx {
   23256 			break
   23257 		}
   23258 		i1 := x1.AuxInt
   23259 		s := x1.Aux
   23260 		_ = x1.Args[2]
   23261 		idx := x1.Args[0]
   23262 		p := x1.Args[1]
   23263 		mem := x1.Args[2]
   23264 		sh := v.Args[1]
   23265 		if sh.Op != OpS390XSLDconst {
   23266 			break
   23267 		}
   23268 		if sh.AuxInt != 8 {
   23269 			break
   23270 		}
   23271 		x0 := sh.Args[0]
   23272 		if x0.Op != OpS390XMOVBZloadidx {
   23273 			break
   23274 		}
   23275 		i0 := x0.AuxInt
   23276 		if x0.Aux != s {
   23277 			break
   23278 		}
   23279 		_ = x0.Args[2]
   23280 		if idx != x0.Args[0] {
   23281 			break
   23282 		}
   23283 		if p != x0.Args[1] {
   23284 			break
   23285 		}
   23286 		if mem != x0.Args[2] {
   23287 			break
   23288 		}
   23289 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23290 			break
   23291 		}
   23292 		b = mergePoint(b, x0, x1)
   23293 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23294 		v.reset(OpCopy)
   23295 		v.AddArg(v0)
   23296 		v0.AuxInt = i0
   23297 		v0.Aux = s
   23298 		v0.AddArg(p)
   23299 		v0.AddArg(idx)
   23300 		v0.AddArg(mem)
   23301 		return true
   23302 	}
   23303 	// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
   23304 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23305 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23306 	for {
   23307 		_ = v.Args[1]
   23308 		sh := v.Args[0]
   23309 		if sh.Op != OpS390XSLDconst {
   23310 			break
   23311 		}
   23312 		if sh.AuxInt != 8 {
   23313 			break
   23314 		}
   23315 		x0 := sh.Args[0]
   23316 		if x0.Op != OpS390XMOVBZloadidx {
   23317 			break
   23318 		}
   23319 		i0 := x0.AuxInt
   23320 		s := x0.Aux
   23321 		_ = x0.Args[2]
   23322 		p := x0.Args[0]
   23323 		idx := x0.Args[1]
   23324 		mem := x0.Args[2]
   23325 		x1 := v.Args[1]
   23326 		if x1.Op != OpS390XMOVBZloadidx {
   23327 			break
   23328 		}
   23329 		i1 := x1.AuxInt
   23330 		if x1.Aux != s {
   23331 			break
   23332 		}
   23333 		_ = x1.Args[2]
   23334 		if p != x1.Args[0] {
   23335 			break
   23336 		}
   23337 		if idx != x1.Args[1] {
   23338 			break
   23339 		}
   23340 		if mem != x1.Args[2] {
   23341 			break
   23342 		}
   23343 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23344 			break
   23345 		}
   23346 		b = mergePoint(b, x0, x1)
   23347 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23348 		v.reset(OpCopy)
   23349 		v.AddArg(v0)
   23350 		v0.AuxInt = i0
   23351 		v0.Aux = s
   23352 		v0.AddArg(p)
   23353 		v0.AddArg(idx)
   23354 		v0.AddArg(mem)
   23355 		return true
   23356 	}
   23357 	// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
   23358 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23359 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23360 	for {
   23361 		_ = v.Args[1]
   23362 		sh := v.Args[0]
   23363 		if sh.Op != OpS390XSLDconst {
   23364 			break
   23365 		}
   23366 		if sh.AuxInt != 8 {
   23367 			break
   23368 		}
   23369 		x0 := sh.Args[0]
   23370 		if x0.Op != OpS390XMOVBZloadidx {
   23371 			break
   23372 		}
   23373 		i0 := x0.AuxInt
   23374 		s := x0.Aux
   23375 		_ = x0.Args[2]
   23376 		idx := x0.Args[0]
   23377 		p := x0.Args[1]
   23378 		mem := x0.Args[2]
   23379 		x1 := v.Args[1]
   23380 		if x1.Op != OpS390XMOVBZloadidx {
   23381 			break
   23382 		}
   23383 		i1 := x1.AuxInt
   23384 		if x1.Aux != s {
   23385 			break
   23386 		}
   23387 		_ = x1.Args[2]
   23388 		if p != x1.Args[0] {
   23389 			break
   23390 		}
   23391 		if idx != x1.Args[1] {
   23392 			break
   23393 		}
   23394 		if mem != x1.Args[2] {
   23395 			break
   23396 		}
   23397 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23398 			break
   23399 		}
   23400 		b = mergePoint(b, x0, x1)
   23401 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23402 		v.reset(OpCopy)
   23403 		v.AddArg(v0)
   23404 		v0.AuxInt = i0
   23405 		v0.Aux = s
   23406 		v0.AddArg(p)
   23407 		v0.AddArg(idx)
   23408 		v0.AddArg(mem)
   23409 		return true
   23410 	}
   23411 	// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
   23412 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23413 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23414 	for {
   23415 		_ = v.Args[1]
   23416 		sh := v.Args[0]
   23417 		if sh.Op != OpS390XSLDconst {
   23418 			break
   23419 		}
   23420 		if sh.AuxInt != 8 {
   23421 			break
   23422 		}
   23423 		x0 := sh.Args[0]
   23424 		if x0.Op != OpS390XMOVBZloadidx {
   23425 			break
   23426 		}
   23427 		i0 := x0.AuxInt
   23428 		s := x0.Aux
   23429 		_ = x0.Args[2]
   23430 		p := x0.Args[0]
   23431 		idx := x0.Args[1]
   23432 		mem := x0.Args[2]
   23433 		x1 := v.Args[1]
   23434 		if x1.Op != OpS390XMOVBZloadidx {
   23435 			break
   23436 		}
   23437 		i1 := x1.AuxInt
   23438 		if x1.Aux != s {
   23439 			break
   23440 		}
   23441 		_ = x1.Args[2]
   23442 		if idx != x1.Args[0] {
   23443 			break
   23444 		}
   23445 		if p != x1.Args[1] {
   23446 			break
   23447 		}
   23448 		if mem != x1.Args[2] {
   23449 			break
   23450 		}
   23451 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23452 			break
   23453 		}
   23454 		b = mergePoint(b, x0, x1)
   23455 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23456 		v.reset(OpCopy)
   23457 		v.AddArg(v0)
   23458 		v0.AuxInt = i0
   23459 		v0.Aux = s
   23460 		v0.AddArg(p)
   23461 		v0.AddArg(idx)
   23462 		v0.AddArg(mem)
   23463 		return true
   23464 	}
   23465 	// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
   23466 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23467 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   23468 	for {
   23469 		_ = v.Args[1]
   23470 		sh := v.Args[0]
   23471 		if sh.Op != OpS390XSLDconst {
   23472 			break
   23473 		}
   23474 		if sh.AuxInt != 8 {
   23475 			break
   23476 		}
   23477 		x0 := sh.Args[0]
   23478 		if x0.Op != OpS390XMOVBZloadidx {
   23479 			break
   23480 		}
   23481 		i0 := x0.AuxInt
   23482 		s := x0.Aux
   23483 		_ = x0.Args[2]
   23484 		idx := x0.Args[0]
   23485 		p := x0.Args[1]
   23486 		mem := x0.Args[2]
   23487 		x1 := v.Args[1]
   23488 		if x1.Op != OpS390XMOVBZloadidx {
   23489 			break
   23490 		}
   23491 		i1 := x1.AuxInt
   23492 		if x1.Aux != s {
   23493 			break
   23494 		}
   23495 		_ = x1.Args[2]
   23496 		if idx != x1.Args[0] {
   23497 			break
   23498 		}
   23499 		if p != x1.Args[1] {
   23500 			break
   23501 		}
   23502 		if mem != x1.Args[2] {
   23503 			break
   23504 		}
   23505 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23506 			break
   23507 		}
   23508 		b = mergePoint(b, x0, x1)
   23509 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   23510 		v.reset(OpCopy)
   23511 		v.AddArg(v0)
   23512 		v0.AuxInt = i0
   23513 		v0.Aux = s
   23514 		v0.AddArg(p)
   23515 		v0.AddArg(idx)
   23516 		v0.AddArg(mem)
   23517 		return true
   23518 	}
   23519 	// match: (OR x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   23520 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23521 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23522 	for {
   23523 		_ = v.Args[1]
   23524 		x1 := v.Args[0]
   23525 		if x1.Op != OpS390XMOVHZloadidx {
   23526 			break
   23527 		}
   23528 		i1 := x1.AuxInt
   23529 		s := x1.Aux
   23530 		_ = x1.Args[2]
   23531 		p := x1.Args[0]
   23532 		idx := x1.Args[1]
   23533 		mem := x1.Args[2]
   23534 		sh := v.Args[1]
   23535 		if sh.Op != OpS390XSLDconst {
   23536 			break
   23537 		}
   23538 		if sh.AuxInt != 16 {
   23539 			break
   23540 		}
   23541 		x0 := sh.Args[0]
   23542 		if x0.Op != OpS390XMOVHZloadidx {
   23543 			break
   23544 		}
   23545 		i0 := x0.AuxInt
   23546 		if x0.Aux != s {
   23547 			break
   23548 		}
   23549 		_ = x0.Args[2]
   23550 		if p != x0.Args[0] {
   23551 			break
   23552 		}
   23553 		if idx != x0.Args[1] {
   23554 			break
   23555 		}
   23556 		if mem != x0.Args[2] {
   23557 			break
   23558 		}
   23559 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23560 			break
   23561 		}
   23562 		b = mergePoint(b, x0, x1)
   23563 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23564 		v.reset(OpCopy)
   23565 		v.AddArg(v0)
   23566 		v0.AuxInt = i0
   23567 		v0.Aux = s
   23568 		v0.AddArg(p)
   23569 		v0.AddArg(idx)
   23570 		v0.AddArg(mem)
   23571 		return true
   23572 	}
   23573 	return false
   23574 }
   23575 func rewriteValueS390X_OpS390XOR_40(v *Value) bool {
   23576 	b := v.Block
   23577 	_ = b
   23578 	typ := &b.Func.Config.Types
   23579 	_ = typ
   23580 	// match: (OR x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   23581 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23582 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23583 	for {
   23584 		_ = v.Args[1]
   23585 		x1 := v.Args[0]
   23586 		if x1.Op != OpS390XMOVHZloadidx {
   23587 			break
   23588 		}
   23589 		i1 := x1.AuxInt
   23590 		s := x1.Aux
   23591 		_ = x1.Args[2]
   23592 		idx := x1.Args[0]
   23593 		p := x1.Args[1]
   23594 		mem := x1.Args[2]
   23595 		sh := v.Args[1]
   23596 		if sh.Op != OpS390XSLDconst {
   23597 			break
   23598 		}
   23599 		if sh.AuxInt != 16 {
   23600 			break
   23601 		}
   23602 		x0 := sh.Args[0]
   23603 		if x0.Op != OpS390XMOVHZloadidx {
   23604 			break
   23605 		}
   23606 		i0 := x0.AuxInt
   23607 		if x0.Aux != s {
   23608 			break
   23609 		}
   23610 		_ = x0.Args[2]
   23611 		if p != x0.Args[0] {
   23612 			break
   23613 		}
   23614 		if idx != x0.Args[1] {
   23615 			break
   23616 		}
   23617 		if mem != x0.Args[2] {
   23618 			break
   23619 		}
   23620 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23621 			break
   23622 		}
   23623 		b = mergePoint(b, x0, x1)
   23624 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23625 		v.reset(OpCopy)
   23626 		v.AddArg(v0)
   23627 		v0.AuxInt = i0
   23628 		v0.Aux = s
   23629 		v0.AddArg(p)
   23630 		v0.AddArg(idx)
   23631 		v0.AddArg(mem)
   23632 		return true
   23633 	}
   23634 	// match: (OR x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   23635 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23636 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23637 	for {
   23638 		_ = v.Args[1]
   23639 		x1 := v.Args[0]
   23640 		if x1.Op != OpS390XMOVHZloadidx {
   23641 			break
   23642 		}
   23643 		i1 := x1.AuxInt
   23644 		s := x1.Aux
   23645 		_ = x1.Args[2]
   23646 		p := x1.Args[0]
   23647 		idx := x1.Args[1]
   23648 		mem := x1.Args[2]
   23649 		sh := v.Args[1]
   23650 		if sh.Op != OpS390XSLDconst {
   23651 			break
   23652 		}
   23653 		if sh.AuxInt != 16 {
   23654 			break
   23655 		}
   23656 		x0 := sh.Args[0]
   23657 		if x0.Op != OpS390XMOVHZloadidx {
   23658 			break
   23659 		}
   23660 		i0 := x0.AuxInt
   23661 		if x0.Aux != s {
   23662 			break
   23663 		}
   23664 		_ = x0.Args[2]
   23665 		if idx != x0.Args[0] {
   23666 			break
   23667 		}
   23668 		if p != x0.Args[1] {
   23669 			break
   23670 		}
   23671 		if mem != x0.Args[2] {
   23672 			break
   23673 		}
   23674 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23675 			break
   23676 		}
   23677 		b = mergePoint(b, x0, x1)
   23678 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23679 		v.reset(OpCopy)
   23680 		v.AddArg(v0)
   23681 		v0.AuxInt = i0
   23682 		v0.Aux = s
   23683 		v0.AddArg(p)
   23684 		v0.AddArg(idx)
   23685 		v0.AddArg(mem)
   23686 		return true
   23687 	}
   23688 	// match: (OR x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   23689 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23690 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23691 	for {
   23692 		_ = v.Args[1]
   23693 		x1 := v.Args[0]
   23694 		if x1.Op != OpS390XMOVHZloadidx {
   23695 			break
   23696 		}
   23697 		i1 := x1.AuxInt
   23698 		s := x1.Aux
   23699 		_ = x1.Args[2]
   23700 		idx := x1.Args[0]
   23701 		p := x1.Args[1]
   23702 		mem := x1.Args[2]
   23703 		sh := v.Args[1]
   23704 		if sh.Op != OpS390XSLDconst {
   23705 			break
   23706 		}
   23707 		if sh.AuxInt != 16 {
   23708 			break
   23709 		}
   23710 		x0 := sh.Args[0]
   23711 		if x0.Op != OpS390XMOVHZloadidx {
   23712 			break
   23713 		}
   23714 		i0 := x0.AuxInt
   23715 		if x0.Aux != s {
   23716 			break
   23717 		}
   23718 		_ = x0.Args[2]
   23719 		if idx != x0.Args[0] {
   23720 			break
   23721 		}
   23722 		if p != x0.Args[1] {
   23723 			break
   23724 		}
   23725 		if mem != x0.Args[2] {
   23726 			break
   23727 		}
   23728 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23729 			break
   23730 		}
   23731 		b = mergePoint(b, x0, x1)
   23732 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23733 		v.reset(OpCopy)
   23734 		v.AddArg(v0)
   23735 		v0.AuxInt = i0
   23736 		v0.Aux = s
   23737 		v0.AddArg(p)
   23738 		v0.AddArg(idx)
   23739 		v0.AddArg(mem)
   23740 		return true
   23741 	}
   23742 	// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
   23743 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23744 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23745 	for {
   23746 		_ = v.Args[1]
   23747 		sh := v.Args[0]
   23748 		if sh.Op != OpS390XSLDconst {
   23749 			break
   23750 		}
   23751 		if sh.AuxInt != 16 {
   23752 			break
   23753 		}
   23754 		x0 := sh.Args[0]
   23755 		if x0.Op != OpS390XMOVHZloadidx {
   23756 			break
   23757 		}
   23758 		i0 := x0.AuxInt
   23759 		s := x0.Aux
   23760 		_ = x0.Args[2]
   23761 		p := x0.Args[0]
   23762 		idx := x0.Args[1]
   23763 		mem := x0.Args[2]
   23764 		x1 := v.Args[1]
   23765 		if x1.Op != OpS390XMOVHZloadidx {
   23766 			break
   23767 		}
   23768 		i1 := x1.AuxInt
   23769 		if x1.Aux != s {
   23770 			break
   23771 		}
   23772 		_ = x1.Args[2]
   23773 		if p != x1.Args[0] {
   23774 			break
   23775 		}
   23776 		if idx != x1.Args[1] {
   23777 			break
   23778 		}
   23779 		if mem != x1.Args[2] {
   23780 			break
   23781 		}
   23782 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23783 			break
   23784 		}
   23785 		b = mergePoint(b, x0, x1)
   23786 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23787 		v.reset(OpCopy)
   23788 		v.AddArg(v0)
   23789 		v0.AuxInt = i0
   23790 		v0.Aux = s
   23791 		v0.AddArg(p)
   23792 		v0.AddArg(idx)
   23793 		v0.AddArg(mem)
   23794 		return true
   23795 	}
   23796 	// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
   23797 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23798 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23799 	for {
   23800 		_ = v.Args[1]
   23801 		sh := v.Args[0]
   23802 		if sh.Op != OpS390XSLDconst {
   23803 			break
   23804 		}
   23805 		if sh.AuxInt != 16 {
   23806 			break
   23807 		}
   23808 		x0 := sh.Args[0]
   23809 		if x0.Op != OpS390XMOVHZloadidx {
   23810 			break
   23811 		}
   23812 		i0 := x0.AuxInt
   23813 		s := x0.Aux
   23814 		_ = x0.Args[2]
   23815 		idx := x0.Args[0]
   23816 		p := x0.Args[1]
   23817 		mem := x0.Args[2]
   23818 		x1 := v.Args[1]
   23819 		if x1.Op != OpS390XMOVHZloadidx {
   23820 			break
   23821 		}
   23822 		i1 := x1.AuxInt
   23823 		if x1.Aux != s {
   23824 			break
   23825 		}
   23826 		_ = x1.Args[2]
   23827 		if p != x1.Args[0] {
   23828 			break
   23829 		}
   23830 		if idx != x1.Args[1] {
   23831 			break
   23832 		}
   23833 		if mem != x1.Args[2] {
   23834 			break
   23835 		}
   23836 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23837 			break
   23838 		}
   23839 		b = mergePoint(b, x0, x1)
   23840 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23841 		v.reset(OpCopy)
   23842 		v.AddArg(v0)
   23843 		v0.AuxInt = i0
   23844 		v0.Aux = s
   23845 		v0.AddArg(p)
   23846 		v0.AddArg(idx)
   23847 		v0.AddArg(mem)
   23848 		return true
   23849 	}
   23850 	// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
   23851 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23852 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23853 	for {
   23854 		_ = v.Args[1]
   23855 		sh := v.Args[0]
   23856 		if sh.Op != OpS390XSLDconst {
   23857 			break
   23858 		}
   23859 		if sh.AuxInt != 16 {
   23860 			break
   23861 		}
   23862 		x0 := sh.Args[0]
   23863 		if x0.Op != OpS390XMOVHZloadidx {
   23864 			break
   23865 		}
   23866 		i0 := x0.AuxInt
   23867 		s := x0.Aux
   23868 		_ = x0.Args[2]
   23869 		p := x0.Args[0]
   23870 		idx := x0.Args[1]
   23871 		mem := x0.Args[2]
   23872 		x1 := v.Args[1]
   23873 		if x1.Op != OpS390XMOVHZloadidx {
   23874 			break
   23875 		}
   23876 		i1 := x1.AuxInt
   23877 		if x1.Aux != s {
   23878 			break
   23879 		}
   23880 		_ = x1.Args[2]
   23881 		if idx != x1.Args[0] {
   23882 			break
   23883 		}
   23884 		if p != x1.Args[1] {
   23885 			break
   23886 		}
   23887 		if mem != x1.Args[2] {
   23888 			break
   23889 		}
   23890 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23891 			break
   23892 		}
   23893 		b = mergePoint(b, x0, x1)
   23894 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23895 		v.reset(OpCopy)
   23896 		v.AddArg(v0)
   23897 		v0.AuxInt = i0
   23898 		v0.Aux = s
   23899 		v0.AddArg(p)
   23900 		v0.AddArg(idx)
   23901 		v0.AddArg(mem)
   23902 		return true
   23903 	}
   23904 	// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
   23905 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23906 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   23907 	for {
   23908 		_ = v.Args[1]
   23909 		sh := v.Args[0]
   23910 		if sh.Op != OpS390XSLDconst {
   23911 			break
   23912 		}
   23913 		if sh.AuxInt != 16 {
   23914 			break
   23915 		}
   23916 		x0 := sh.Args[0]
   23917 		if x0.Op != OpS390XMOVHZloadidx {
   23918 			break
   23919 		}
   23920 		i0 := x0.AuxInt
   23921 		s := x0.Aux
   23922 		_ = x0.Args[2]
   23923 		idx := x0.Args[0]
   23924 		p := x0.Args[1]
   23925 		mem := x0.Args[2]
   23926 		x1 := v.Args[1]
   23927 		if x1.Op != OpS390XMOVHZloadidx {
   23928 			break
   23929 		}
   23930 		i1 := x1.AuxInt
   23931 		if x1.Aux != s {
   23932 			break
   23933 		}
   23934 		_ = x1.Args[2]
   23935 		if idx != x1.Args[0] {
   23936 			break
   23937 		}
   23938 		if p != x1.Args[1] {
   23939 			break
   23940 		}
   23941 		if mem != x1.Args[2] {
   23942 			break
   23943 		}
   23944 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23945 			break
   23946 		}
   23947 		b = mergePoint(b, x0, x1)
   23948 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   23949 		v.reset(OpCopy)
   23950 		v.AddArg(v0)
   23951 		v0.AuxInt = i0
   23952 		v0.Aux = s
   23953 		v0.AddArg(p)
   23954 		v0.AddArg(idx)
   23955 		v0.AddArg(mem)
   23956 		return true
   23957 	}
   23958 	// match: (OR x1:(MOVWZloadidx [i1] {s} p idx mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)))
   23959 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   23960 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   23961 	for {
   23962 		_ = v.Args[1]
   23963 		x1 := v.Args[0]
   23964 		if x1.Op != OpS390XMOVWZloadidx {
   23965 			break
   23966 		}
   23967 		i1 := x1.AuxInt
   23968 		s := x1.Aux
   23969 		_ = x1.Args[2]
   23970 		p := x1.Args[0]
   23971 		idx := x1.Args[1]
   23972 		mem := x1.Args[2]
   23973 		sh := v.Args[1]
   23974 		if sh.Op != OpS390XSLDconst {
   23975 			break
   23976 		}
   23977 		if sh.AuxInt != 32 {
   23978 			break
   23979 		}
   23980 		x0 := sh.Args[0]
   23981 		if x0.Op != OpS390XMOVWZloadidx {
   23982 			break
   23983 		}
   23984 		i0 := x0.AuxInt
   23985 		if x0.Aux != s {
   23986 			break
   23987 		}
   23988 		_ = x0.Args[2]
   23989 		if p != x0.Args[0] {
   23990 			break
   23991 		}
   23992 		if idx != x0.Args[1] {
   23993 			break
   23994 		}
   23995 		if mem != x0.Args[2] {
   23996 			break
   23997 		}
   23998 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   23999 			break
   24000 		}
   24001 		b = mergePoint(b, x0, x1)
   24002 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24003 		v.reset(OpCopy)
   24004 		v.AddArg(v0)
   24005 		v0.AuxInt = i0
   24006 		v0.Aux = s
   24007 		v0.AddArg(p)
   24008 		v0.AddArg(idx)
   24009 		v0.AddArg(mem)
   24010 		return true
   24011 	}
   24012 	// match: (OR x1:(MOVWZloadidx [i1] {s} idx p mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)))
   24013 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24014 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24015 	for {
   24016 		_ = v.Args[1]
   24017 		x1 := v.Args[0]
   24018 		if x1.Op != OpS390XMOVWZloadidx {
   24019 			break
   24020 		}
   24021 		i1 := x1.AuxInt
   24022 		s := x1.Aux
   24023 		_ = x1.Args[2]
   24024 		idx := x1.Args[0]
   24025 		p := x1.Args[1]
   24026 		mem := x1.Args[2]
   24027 		sh := v.Args[1]
   24028 		if sh.Op != OpS390XSLDconst {
   24029 			break
   24030 		}
   24031 		if sh.AuxInt != 32 {
   24032 			break
   24033 		}
   24034 		x0 := sh.Args[0]
   24035 		if x0.Op != OpS390XMOVWZloadidx {
   24036 			break
   24037 		}
   24038 		i0 := x0.AuxInt
   24039 		if x0.Aux != s {
   24040 			break
   24041 		}
   24042 		_ = x0.Args[2]
   24043 		if p != x0.Args[0] {
   24044 			break
   24045 		}
   24046 		if idx != x0.Args[1] {
   24047 			break
   24048 		}
   24049 		if mem != x0.Args[2] {
   24050 			break
   24051 		}
   24052 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24053 			break
   24054 		}
   24055 		b = mergePoint(b, x0, x1)
   24056 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24057 		v.reset(OpCopy)
   24058 		v.AddArg(v0)
   24059 		v0.AuxInt = i0
   24060 		v0.Aux = s
   24061 		v0.AddArg(p)
   24062 		v0.AddArg(idx)
   24063 		v0.AddArg(mem)
   24064 		return true
   24065 	}
   24066 	// match: (OR x1:(MOVWZloadidx [i1] {s} p idx mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)))
   24067 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24068 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24069 	for {
   24070 		_ = v.Args[1]
   24071 		x1 := v.Args[0]
   24072 		if x1.Op != OpS390XMOVWZloadidx {
   24073 			break
   24074 		}
   24075 		i1 := x1.AuxInt
   24076 		s := x1.Aux
   24077 		_ = x1.Args[2]
   24078 		p := x1.Args[0]
   24079 		idx := x1.Args[1]
   24080 		mem := x1.Args[2]
   24081 		sh := v.Args[1]
   24082 		if sh.Op != OpS390XSLDconst {
   24083 			break
   24084 		}
   24085 		if sh.AuxInt != 32 {
   24086 			break
   24087 		}
   24088 		x0 := sh.Args[0]
   24089 		if x0.Op != OpS390XMOVWZloadidx {
   24090 			break
   24091 		}
   24092 		i0 := x0.AuxInt
   24093 		if x0.Aux != s {
   24094 			break
   24095 		}
   24096 		_ = x0.Args[2]
   24097 		if idx != x0.Args[0] {
   24098 			break
   24099 		}
   24100 		if p != x0.Args[1] {
   24101 			break
   24102 		}
   24103 		if mem != x0.Args[2] {
   24104 			break
   24105 		}
   24106 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24107 			break
   24108 		}
   24109 		b = mergePoint(b, x0, x1)
   24110 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24111 		v.reset(OpCopy)
   24112 		v.AddArg(v0)
   24113 		v0.AuxInt = i0
   24114 		v0.Aux = s
   24115 		v0.AddArg(p)
   24116 		v0.AddArg(idx)
   24117 		v0.AddArg(mem)
   24118 		return true
   24119 	}
   24120 	return false
   24121 }
   24122 func rewriteValueS390X_OpS390XOR_50(v *Value) bool {
   24123 	b := v.Block
   24124 	_ = b
   24125 	typ := &b.Func.Config.Types
   24126 	_ = typ
   24127 	// match: (OR x1:(MOVWZloadidx [i1] {s} idx p mem) sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)))
   24128 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24129 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24130 	for {
   24131 		_ = v.Args[1]
   24132 		x1 := v.Args[0]
   24133 		if x1.Op != OpS390XMOVWZloadidx {
   24134 			break
   24135 		}
   24136 		i1 := x1.AuxInt
   24137 		s := x1.Aux
   24138 		_ = x1.Args[2]
   24139 		idx := x1.Args[0]
   24140 		p := x1.Args[1]
   24141 		mem := x1.Args[2]
   24142 		sh := v.Args[1]
   24143 		if sh.Op != OpS390XSLDconst {
   24144 			break
   24145 		}
   24146 		if sh.AuxInt != 32 {
   24147 			break
   24148 		}
   24149 		x0 := sh.Args[0]
   24150 		if x0.Op != OpS390XMOVWZloadidx {
   24151 			break
   24152 		}
   24153 		i0 := x0.AuxInt
   24154 		if x0.Aux != s {
   24155 			break
   24156 		}
   24157 		_ = x0.Args[2]
   24158 		if idx != x0.Args[0] {
   24159 			break
   24160 		}
   24161 		if p != x0.Args[1] {
   24162 			break
   24163 		}
   24164 		if mem != x0.Args[2] {
   24165 			break
   24166 		}
   24167 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24168 			break
   24169 		}
   24170 		b = mergePoint(b, x0, x1)
   24171 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24172 		v.reset(OpCopy)
   24173 		v.AddArg(v0)
   24174 		v0.AuxInt = i0
   24175 		v0.Aux = s
   24176 		v0.AddArg(p)
   24177 		v0.AddArg(idx)
   24178 		v0.AddArg(mem)
   24179 		return true
   24180 	}
   24181 	// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)) x1:(MOVWZloadidx [i1] {s} p idx mem))
   24182 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24183 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24184 	for {
   24185 		_ = v.Args[1]
   24186 		sh := v.Args[0]
   24187 		if sh.Op != OpS390XSLDconst {
   24188 			break
   24189 		}
   24190 		if sh.AuxInt != 32 {
   24191 			break
   24192 		}
   24193 		x0 := sh.Args[0]
   24194 		if x0.Op != OpS390XMOVWZloadidx {
   24195 			break
   24196 		}
   24197 		i0 := x0.AuxInt
   24198 		s := x0.Aux
   24199 		_ = x0.Args[2]
   24200 		p := x0.Args[0]
   24201 		idx := x0.Args[1]
   24202 		mem := x0.Args[2]
   24203 		x1 := v.Args[1]
   24204 		if x1.Op != OpS390XMOVWZloadidx {
   24205 			break
   24206 		}
   24207 		i1 := x1.AuxInt
   24208 		if x1.Aux != s {
   24209 			break
   24210 		}
   24211 		_ = x1.Args[2]
   24212 		if p != x1.Args[0] {
   24213 			break
   24214 		}
   24215 		if idx != x1.Args[1] {
   24216 			break
   24217 		}
   24218 		if mem != x1.Args[2] {
   24219 			break
   24220 		}
   24221 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24222 			break
   24223 		}
   24224 		b = mergePoint(b, x0, x1)
   24225 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24226 		v.reset(OpCopy)
   24227 		v.AddArg(v0)
   24228 		v0.AuxInt = i0
   24229 		v0.Aux = s
   24230 		v0.AddArg(p)
   24231 		v0.AddArg(idx)
   24232 		v0.AddArg(mem)
   24233 		return true
   24234 	}
   24235 	// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)) x1:(MOVWZloadidx [i1] {s} p idx mem))
   24236 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24237 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24238 	for {
   24239 		_ = v.Args[1]
   24240 		sh := v.Args[0]
   24241 		if sh.Op != OpS390XSLDconst {
   24242 			break
   24243 		}
   24244 		if sh.AuxInt != 32 {
   24245 			break
   24246 		}
   24247 		x0 := sh.Args[0]
   24248 		if x0.Op != OpS390XMOVWZloadidx {
   24249 			break
   24250 		}
   24251 		i0 := x0.AuxInt
   24252 		s := x0.Aux
   24253 		_ = x0.Args[2]
   24254 		idx := x0.Args[0]
   24255 		p := x0.Args[1]
   24256 		mem := x0.Args[2]
   24257 		x1 := v.Args[1]
   24258 		if x1.Op != OpS390XMOVWZloadidx {
   24259 			break
   24260 		}
   24261 		i1 := x1.AuxInt
   24262 		if x1.Aux != s {
   24263 			break
   24264 		}
   24265 		_ = x1.Args[2]
   24266 		if p != x1.Args[0] {
   24267 			break
   24268 		}
   24269 		if idx != x1.Args[1] {
   24270 			break
   24271 		}
   24272 		if mem != x1.Args[2] {
   24273 			break
   24274 		}
   24275 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24276 			break
   24277 		}
   24278 		b = mergePoint(b, x0, x1)
   24279 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24280 		v.reset(OpCopy)
   24281 		v.AddArg(v0)
   24282 		v0.AuxInt = i0
   24283 		v0.Aux = s
   24284 		v0.AddArg(p)
   24285 		v0.AddArg(idx)
   24286 		v0.AddArg(mem)
   24287 		return true
   24288 	}
   24289 	// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} p idx mem)) x1:(MOVWZloadidx [i1] {s} idx p mem))
   24290 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24291 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24292 	for {
   24293 		_ = v.Args[1]
   24294 		sh := v.Args[0]
   24295 		if sh.Op != OpS390XSLDconst {
   24296 			break
   24297 		}
   24298 		if sh.AuxInt != 32 {
   24299 			break
   24300 		}
   24301 		x0 := sh.Args[0]
   24302 		if x0.Op != OpS390XMOVWZloadidx {
   24303 			break
   24304 		}
   24305 		i0 := x0.AuxInt
   24306 		s := x0.Aux
   24307 		_ = x0.Args[2]
   24308 		p := x0.Args[0]
   24309 		idx := x0.Args[1]
   24310 		mem := x0.Args[2]
   24311 		x1 := v.Args[1]
   24312 		if x1.Op != OpS390XMOVWZloadidx {
   24313 			break
   24314 		}
   24315 		i1 := x1.AuxInt
   24316 		if x1.Aux != s {
   24317 			break
   24318 		}
   24319 		_ = x1.Args[2]
   24320 		if idx != x1.Args[0] {
   24321 			break
   24322 		}
   24323 		if p != x1.Args[1] {
   24324 			break
   24325 		}
   24326 		if mem != x1.Args[2] {
   24327 			break
   24328 		}
   24329 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24330 			break
   24331 		}
   24332 		b = mergePoint(b, x0, x1)
   24333 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24334 		v.reset(OpCopy)
   24335 		v.AddArg(v0)
   24336 		v0.AuxInt = i0
   24337 		v0.Aux = s
   24338 		v0.AddArg(p)
   24339 		v0.AddArg(idx)
   24340 		v0.AddArg(mem)
   24341 		return true
   24342 	}
   24343 	// match: (OR sh:(SLDconst [32] x0:(MOVWZloadidx [i0] {s} idx p mem)) x1:(MOVWZloadidx [i1] {s} idx p mem))
   24344 	// cond: i1 == i0+4   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   24345 	// result: @mergePoint(b,x0,x1) (MOVDloadidx [i0] {s} p idx mem)
   24346 	for {
   24347 		_ = v.Args[1]
   24348 		sh := v.Args[0]
   24349 		if sh.Op != OpS390XSLDconst {
   24350 			break
   24351 		}
   24352 		if sh.AuxInt != 32 {
   24353 			break
   24354 		}
   24355 		x0 := sh.Args[0]
   24356 		if x0.Op != OpS390XMOVWZloadidx {
   24357 			break
   24358 		}
   24359 		i0 := x0.AuxInt
   24360 		s := x0.Aux
   24361 		_ = x0.Args[2]
   24362 		idx := x0.Args[0]
   24363 		p := x0.Args[1]
   24364 		mem := x0.Args[2]
   24365 		x1 := v.Args[1]
   24366 		if x1.Op != OpS390XMOVWZloadidx {
   24367 			break
   24368 		}
   24369 		i1 := x1.AuxInt
   24370 		if x1.Aux != s {
   24371 			break
   24372 		}
   24373 		_ = x1.Args[2]
   24374 		if idx != x1.Args[0] {
   24375 			break
   24376 		}
   24377 		if p != x1.Args[1] {
   24378 			break
   24379 		}
   24380 		if mem != x1.Args[2] {
   24381 			break
   24382 		}
   24383 		if !(i1 == i0+4 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   24384 			break
   24385 		}
   24386 		b = mergePoint(b, x0, x1)
   24387 		v0 := b.NewValue0(v.Pos, OpS390XMOVDloadidx, typ.UInt64)
   24388 		v.reset(OpCopy)
   24389 		v.AddArg(v0)
   24390 		v0.AuxInt = i0
   24391 		v0.Aux = s
   24392 		v0.AddArg(p)
   24393 		v0.AddArg(idx)
   24394 		v0.AddArg(mem)
   24395 		return true
   24396 	}
   24397 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
   24398 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24399 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24400 	for {
   24401 		_ = v.Args[1]
   24402 		s0 := v.Args[0]
   24403 		if s0.Op != OpS390XSLDconst {
   24404 			break
   24405 		}
   24406 		j0 := s0.AuxInt
   24407 		x0 := s0.Args[0]
   24408 		if x0.Op != OpS390XMOVBZloadidx {
   24409 			break
   24410 		}
   24411 		i0 := x0.AuxInt
   24412 		s := x0.Aux
   24413 		_ = x0.Args[2]
   24414 		p := x0.Args[0]
   24415 		idx := x0.Args[1]
   24416 		mem := x0.Args[2]
   24417 		or := v.Args[1]
   24418 		if or.Op != OpS390XOR {
   24419 			break
   24420 		}
   24421 		_ = or.Args[1]
   24422 		s1 := or.Args[0]
   24423 		if s1.Op != OpS390XSLDconst {
   24424 			break
   24425 		}
   24426 		j1 := s1.AuxInt
   24427 		x1 := s1.Args[0]
   24428 		if x1.Op != OpS390XMOVBZloadidx {
   24429 			break
   24430 		}
   24431 		i1 := x1.AuxInt
   24432 		if x1.Aux != s {
   24433 			break
   24434 		}
   24435 		_ = x1.Args[2]
   24436 		if p != x1.Args[0] {
   24437 			break
   24438 		}
   24439 		if idx != x1.Args[1] {
   24440 			break
   24441 		}
   24442 		if mem != x1.Args[2] {
   24443 			break
   24444 		}
   24445 		y := or.Args[1]
   24446 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24447 			break
   24448 		}
   24449 		b = mergePoint(b, x0, x1)
   24450 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24451 		v.reset(OpCopy)
   24452 		v.AddArg(v0)
   24453 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24454 		v1.AuxInt = j1
   24455 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24456 		v2.AuxInt = i0
   24457 		v2.Aux = s
   24458 		v2.AddArg(p)
   24459 		v2.AddArg(idx)
   24460 		v2.AddArg(mem)
   24461 		v1.AddArg(v2)
   24462 		v0.AddArg(v1)
   24463 		v0.AddArg(y)
   24464 		return true
   24465 	}
   24466 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
   24467 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24468 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24469 	for {
   24470 		_ = v.Args[1]
   24471 		s0 := v.Args[0]
   24472 		if s0.Op != OpS390XSLDconst {
   24473 			break
   24474 		}
   24475 		j0 := s0.AuxInt
   24476 		x0 := s0.Args[0]
   24477 		if x0.Op != OpS390XMOVBZloadidx {
   24478 			break
   24479 		}
   24480 		i0 := x0.AuxInt
   24481 		s := x0.Aux
   24482 		_ = x0.Args[2]
   24483 		idx := x0.Args[0]
   24484 		p := x0.Args[1]
   24485 		mem := x0.Args[2]
   24486 		or := v.Args[1]
   24487 		if or.Op != OpS390XOR {
   24488 			break
   24489 		}
   24490 		_ = or.Args[1]
   24491 		s1 := or.Args[0]
   24492 		if s1.Op != OpS390XSLDconst {
   24493 			break
   24494 		}
   24495 		j1 := s1.AuxInt
   24496 		x1 := s1.Args[0]
   24497 		if x1.Op != OpS390XMOVBZloadidx {
   24498 			break
   24499 		}
   24500 		i1 := x1.AuxInt
   24501 		if x1.Aux != s {
   24502 			break
   24503 		}
   24504 		_ = x1.Args[2]
   24505 		if p != x1.Args[0] {
   24506 			break
   24507 		}
   24508 		if idx != x1.Args[1] {
   24509 			break
   24510 		}
   24511 		if mem != x1.Args[2] {
   24512 			break
   24513 		}
   24514 		y := or.Args[1]
   24515 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24516 			break
   24517 		}
   24518 		b = mergePoint(b, x0, x1)
   24519 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24520 		v.reset(OpCopy)
   24521 		v.AddArg(v0)
   24522 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24523 		v1.AuxInt = j1
   24524 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24525 		v2.AuxInt = i0
   24526 		v2.Aux = s
   24527 		v2.AddArg(p)
   24528 		v2.AddArg(idx)
   24529 		v2.AddArg(mem)
   24530 		v1.AddArg(v2)
   24531 		v0.AddArg(v1)
   24532 		v0.AddArg(y)
   24533 		return true
   24534 	}
   24535 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
   24536 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24537 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24538 	for {
   24539 		_ = v.Args[1]
   24540 		s0 := v.Args[0]
   24541 		if s0.Op != OpS390XSLDconst {
   24542 			break
   24543 		}
   24544 		j0 := s0.AuxInt
   24545 		x0 := s0.Args[0]
   24546 		if x0.Op != OpS390XMOVBZloadidx {
   24547 			break
   24548 		}
   24549 		i0 := x0.AuxInt
   24550 		s := x0.Aux
   24551 		_ = x0.Args[2]
   24552 		p := x0.Args[0]
   24553 		idx := x0.Args[1]
   24554 		mem := x0.Args[2]
   24555 		or := v.Args[1]
   24556 		if or.Op != OpS390XOR {
   24557 			break
   24558 		}
   24559 		_ = or.Args[1]
   24560 		s1 := or.Args[0]
   24561 		if s1.Op != OpS390XSLDconst {
   24562 			break
   24563 		}
   24564 		j1 := s1.AuxInt
   24565 		x1 := s1.Args[0]
   24566 		if x1.Op != OpS390XMOVBZloadidx {
   24567 			break
   24568 		}
   24569 		i1 := x1.AuxInt
   24570 		if x1.Aux != s {
   24571 			break
   24572 		}
   24573 		_ = x1.Args[2]
   24574 		if idx != x1.Args[0] {
   24575 			break
   24576 		}
   24577 		if p != x1.Args[1] {
   24578 			break
   24579 		}
   24580 		if mem != x1.Args[2] {
   24581 			break
   24582 		}
   24583 		y := or.Args[1]
   24584 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24585 			break
   24586 		}
   24587 		b = mergePoint(b, x0, x1)
   24588 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24589 		v.reset(OpCopy)
   24590 		v.AddArg(v0)
   24591 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24592 		v1.AuxInt = j1
   24593 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24594 		v2.AuxInt = i0
   24595 		v2.Aux = s
   24596 		v2.AddArg(p)
   24597 		v2.AddArg(idx)
   24598 		v2.AddArg(mem)
   24599 		v1.AddArg(v2)
   24600 		v0.AddArg(v1)
   24601 		v0.AddArg(y)
   24602 		return true
   24603 	}
   24604 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
   24605 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24606 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24607 	for {
   24608 		_ = v.Args[1]
   24609 		s0 := v.Args[0]
   24610 		if s0.Op != OpS390XSLDconst {
   24611 			break
   24612 		}
   24613 		j0 := s0.AuxInt
   24614 		x0 := s0.Args[0]
   24615 		if x0.Op != OpS390XMOVBZloadidx {
   24616 			break
   24617 		}
   24618 		i0 := x0.AuxInt
   24619 		s := x0.Aux
   24620 		_ = x0.Args[2]
   24621 		idx := x0.Args[0]
   24622 		p := x0.Args[1]
   24623 		mem := x0.Args[2]
   24624 		or := v.Args[1]
   24625 		if or.Op != OpS390XOR {
   24626 			break
   24627 		}
   24628 		_ = or.Args[1]
   24629 		s1 := or.Args[0]
   24630 		if s1.Op != OpS390XSLDconst {
   24631 			break
   24632 		}
   24633 		j1 := s1.AuxInt
   24634 		x1 := s1.Args[0]
   24635 		if x1.Op != OpS390XMOVBZloadidx {
   24636 			break
   24637 		}
   24638 		i1 := x1.AuxInt
   24639 		if x1.Aux != s {
   24640 			break
   24641 		}
   24642 		_ = x1.Args[2]
   24643 		if idx != x1.Args[0] {
   24644 			break
   24645 		}
   24646 		if p != x1.Args[1] {
   24647 			break
   24648 		}
   24649 		if mem != x1.Args[2] {
   24650 			break
   24651 		}
   24652 		y := or.Args[1]
   24653 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24654 			break
   24655 		}
   24656 		b = mergePoint(b, x0, x1)
   24657 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24658 		v.reset(OpCopy)
   24659 		v.AddArg(v0)
   24660 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24661 		v1.AuxInt = j1
   24662 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24663 		v2.AuxInt = i0
   24664 		v2.Aux = s
   24665 		v2.AddArg(p)
   24666 		v2.AddArg(idx)
   24667 		v2.AddArg(mem)
   24668 		v1.AddArg(v2)
   24669 		v0.AddArg(v1)
   24670 		v0.AddArg(y)
   24671 		return true
   24672 	}
   24673 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
   24674 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24675 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24676 	for {
   24677 		_ = v.Args[1]
   24678 		s0 := v.Args[0]
   24679 		if s0.Op != OpS390XSLDconst {
   24680 			break
   24681 		}
   24682 		j0 := s0.AuxInt
   24683 		x0 := s0.Args[0]
   24684 		if x0.Op != OpS390XMOVBZloadidx {
   24685 			break
   24686 		}
   24687 		i0 := x0.AuxInt
   24688 		s := x0.Aux
   24689 		_ = x0.Args[2]
   24690 		p := x0.Args[0]
   24691 		idx := x0.Args[1]
   24692 		mem := x0.Args[2]
   24693 		or := v.Args[1]
   24694 		if or.Op != OpS390XOR {
   24695 			break
   24696 		}
   24697 		_ = or.Args[1]
   24698 		y := or.Args[0]
   24699 		s1 := or.Args[1]
   24700 		if s1.Op != OpS390XSLDconst {
   24701 			break
   24702 		}
   24703 		j1 := s1.AuxInt
   24704 		x1 := s1.Args[0]
   24705 		if x1.Op != OpS390XMOVBZloadidx {
   24706 			break
   24707 		}
   24708 		i1 := x1.AuxInt
   24709 		if x1.Aux != s {
   24710 			break
   24711 		}
   24712 		_ = x1.Args[2]
   24713 		if p != x1.Args[0] {
   24714 			break
   24715 		}
   24716 		if idx != x1.Args[1] {
   24717 			break
   24718 		}
   24719 		if mem != x1.Args[2] {
   24720 			break
   24721 		}
   24722 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24723 			break
   24724 		}
   24725 		b = mergePoint(b, x0, x1)
   24726 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24727 		v.reset(OpCopy)
   24728 		v.AddArg(v0)
   24729 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24730 		v1.AuxInt = j1
   24731 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24732 		v2.AuxInt = i0
   24733 		v2.Aux = s
   24734 		v2.AddArg(p)
   24735 		v2.AddArg(idx)
   24736 		v2.AddArg(mem)
   24737 		v1.AddArg(v2)
   24738 		v0.AddArg(v1)
   24739 		v0.AddArg(y)
   24740 		return true
   24741 	}
   24742 	return false
   24743 }
   24744 func rewriteValueS390X_OpS390XOR_60(v *Value) bool {
   24745 	b := v.Block
   24746 	_ = b
   24747 	typ := &b.Func.Config.Types
   24748 	_ = typ
   24749 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
   24750 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24751 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24752 	for {
   24753 		_ = v.Args[1]
   24754 		s0 := v.Args[0]
   24755 		if s0.Op != OpS390XSLDconst {
   24756 			break
   24757 		}
   24758 		j0 := s0.AuxInt
   24759 		x0 := s0.Args[0]
   24760 		if x0.Op != OpS390XMOVBZloadidx {
   24761 			break
   24762 		}
   24763 		i0 := x0.AuxInt
   24764 		s := x0.Aux
   24765 		_ = x0.Args[2]
   24766 		idx := x0.Args[0]
   24767 		p := x0.Args[1]
   24768 		mem := x0.Args[2]
   24769 		or := v.Args[1]
   24770 		if or.Op != OpS390XOR {
   24771 			break
   24772 		}
   24773 		_ = or.Args[1]
   24774 		y := or.Args[0]
   24775 		s1 := or.Args[1]
   24776 		if s1.Op != OpS390XSLDconst {
   24777 			break
   24778 		}
   24779 		j1 := s1.AuxInt
   24780 		x1 := s1.Args[0]
   24781 		if x1.Op != OpS390XMOVBZloadidx {
   24782 			break
   24783 		}
   24784 		i1 := x1.AuxInt
   24785 		if x1.Aux != s {
   24786 			break
   24787 		}
   24788 		_ = x1.Args[2]
   24789 		if p != x1.Args[0] {
   24790 			break
   24791 		}
   24792 		if idx != x1.Args[1] {
   24793 			break
   24794 		}
   24795 		if mem != x1.Args[2] {
   24796 			break
   24797 		}
   24798 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24799 			break
   24800 		}
   24801 		b = mergePoint(b, x0, x1)
   24802 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24803 		v.reset(OpCopy)
   24804 		v.AddArg(v0)
   24805 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24806 		v1.AuxInt = j1
   24807 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24808 		v2.AuxInt = i0
   24809 		v2.Aux = s
   24810 		v2.AddArg(p)
   24811 		v2.AddArg(idx)
   24812 		v2.AddArg(mem)
   24813 		v1.AddArg(v2)
   24814 		v0.AddArg(v1)
   24815 		v0.AddArg(y)
   24816 		return true
   24817 	}
   24818 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
   24819 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24820 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24821 	for {
   24822 		_ = v.Args[1]
   24823 		s0 := v.Args[0]
   24824 		if s0.Op != OpS390XSLDconst {
   24825 			break
   24826 		}
   24827 		j0 := s0.AuxInt
   24828 		x0 := s0.Args[0]
   24829 		if x0.Op != OpS390XMOVBZloadidx {
   24830 			break
   24831 		}
   24832 		i0 := x0.AuxInt
   24833 		s := x0.Aux
   24834 		_ = x0.Args[2]
   24835 		p := x0.Args[0]
   24836 		idx := x0.Args[1]
   24837 		mem := x0.Args[2]
   24838 		or := v.Args[1]
   24839 		if or.Op != OpS390XOR {
   24840 			break
   24841 		}
   24842 		_ = or.Args[1]
   24843 		y := or.Args[0]
   24844 		s1 := or.Args[1]
   24845 		if s1.Op != OpS390XSLDconst {
   24846 			break
   24847 		}
   24848 		j1 := s1.AuxInt
   24849 		x1 := s1.Args[0]
   24850 		if x1.Op != OpS390XMOVBZloadidx {
   24851 			break
   24852 		}
   24853 		i1 := x1.AuxInt
   24854 		if x1.Aux != s {
   24855 			break
   24856 		}
   24857 		_ = x1.Args[2]
   24858 		if idx != x1.Args[0] {
   24859 			break
   24860 		}
   24861 		if p != x1.Args[1] {
   24862 			break
   24863 		}
   24864 		if mem != x1.Args[2] {
   24865 			break
   24866 		}
   24867 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24868 			break
   24869 		}
   24870 		b = mergePoint(b, x0, x1)
   24871 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24872 		v.reset(OpCopy)
   24873 		v.AddArg(v0)
   24874 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24875 		v1.AuxInt = j1
   24876 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24877 		v2.AuxInt = i0
   24878 		v2.Aux = s
   24879 		v2.AddArg(p)
   24880 		v2.AddArg(idx)
   24881 		v2.AddArg(mem)
   24882 		v1.AddArg(v2)
   24883 		v0.AddArg(v1)
   24884 		v0.AddArg(y)
   24885 		return true
   24886 	}
   24887 	// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
   24888 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24889 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24890 	for {
   24891 		_ = v.Args[1]
   24892 		s0 := v.Args[0]
   24893 		if s0.Op != OpS390XSLDconst {
   24894 			break
   24895 		}
   24896 		j0 := s0.AuxInt
   24897 		x0 := s0.Args[0]
   24898 		if x0.Op != OpS390XMOVBZloadidx {
   24899 			break
   24900 		}
   24901 		i0 := x0.AuxInt
   24902 		s := x0.Aux
   24903 		_ = x0.Args[2]
   24904 		idx := x0.Args[0]
   24905 		p := x0.Args[1]
   24906 		mem := x0.Args[2]
   24907 		or := v.Args[1]
   24908 		if or.Op != OpS390XOR {
   24909 			break
   24910 		}
   24911 		_ = or.Args[1]
   24912 		y := or.Args[0]
   24913 		s1 := or.Args[1]
   24914 		if s1.Op != OpS390XSLDconst {
   24915 			break
   24916 		}
   24917 		j1 := s1.AuxInt
   24918 		x1 := s1.Args[0]
   24919 		if x1.Op != OpS390XMOVBZloadidx {
   24920 			break
   24921 		}
   24922 		i1 := x1.AuxInt
   24923 		if x1.Aux != s {
   24924 			break
   24925 		}
   24926 		_ = x1.Args[2]
   24927 		if idx != x1.Args[0] {
   24928 			break
   24929 		}
   24930 		if p != x1.Args[1] {
   24931 			break
   24932 		}
   24933 		if mem != x1.Args[2] {
   24934 			break
   24935 		}
   24936 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   24937 			break
   24938 		}
   24939 		b = mergePoint(b, x0, x1)
   24940 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   24941 		v.reset(OpCopy)
   24942 		v.AddArg(v0)
   24943 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   24944 		v1.AuxInt = j1
   24945 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   24946 		v2.AuxInt = i0
   24947 		v2.Aux = s
   24948 		v2.AddArg(p)
   24949 		v2.AddArg(idx)
   24950 		v2.AddArg(mem)
   24951 		v1.AddArg(v2)
   24952 		v0.AddArg(v1)
   24953 		v0.AddArg(y)
   24954 		return true
   24955 	}
   24956 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   24957 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   24958 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   24959 	for {
   24960 		_ = v.Args[1]
   24961 		or := v.Args[0]
   24962 		if or.Op != OpS390XOR {
   24963 			break
   24964 		}
   24965 		_ = or.Args[1]
   24966 		s1 := or.Args[0]
   24967 		if s1.Op != OpS390XSLDconst {
   24968 			break
   24969 		}
   24970 		j1 := s1.AuxInt
   24971 		x1 := s1.Args[0]
   24972 		if x1.Op != OpS390XMOVBZloadidx {
   24973 			break
   24974 		}
   24975 		i1 := x1.AuxInt
   24976 		s := x1.Aux
   24977 		_ = x1.Args[2]
   24978 		p := x1.Args[0]
   24979 		idx := x1.Args[1]
   24980 		mem := x1.Args[2]
   24981 		y := or.Args[1]
   24982 		s0 := v.Args[1]
   24983 		if s0.Op != OpS390XSLDconst {
   24984 			break
   24985 		}
   24986 		j0 := s0.AuxInt
   24987 		x0 := s0.Args[0]
   24988 		if x0.Op != OpS390XMOVBZloadidx {
   24989 			break
   24990 		}
   24991 		i0 := x0.AuxInt
   24992 		if x0.Aux != s {
   24993 			break
   24994 		}
   24995 		_ = x0.Args[2]
   24996 		if p != x0.Args[0] {
   24997 			break
   24998 		}
   24999 		if idx != x0.Args[1] {
   25000 			break
   25001 		}
   25002 		if mem != x0.Args[2] {
   25003 			break
   25004 		}
   25005 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25006 			break
   25007 		}
   25008 		b = mergePoint(b, x0, x1)
   25009 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25010 		v.reset(OpCopy)
   25011 		v.AddArg(v0)
   25012 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25013 		v1.AuxInt = j1
   25014 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25015 		v2.AuxInt = i0
   25016 		v2.Aux = s
   25017 		v2.AddArg(p)
   25018 		v2.AddArg(idx)
   25019 		v2.AddArg(mem)
   25020 		v1.AddArg(v2)
   25021 		v0.AddArg(v1)
   25022 		v0.AddArg(y)
   25023 		return true
   25024 	}
   25025 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   25026 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25027 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25028 	for {
   25029 		_ = v.Args[1]
   25030 		or := v.Args[0]
   25031 		if or.Op != OpS390XOR {
   25032 			break
   25033 		}
   25034 		_ = or.Args[1]
   25035 		s1 := or.Args[0]
   25036 		if s1.Op != OpS390XSLDconst {
   25037 			break
   25038 		}
   25039 		j1 := s1.AuxInt
   25040 		x1 := s1.Args[0]
   25041 		if x1.Op != OpS390XMOVBZloadidx {
   25042 			break
   25043 		}
   25044 		i1 := x1.AuxInt
   25045 		s := x1.Aux
   25046 		_ = x1.Args[2]
   25047 		idx := x1.Args[0]
   25048 		p := x1.Args[1]
   25049 		mem := x1.Args[2]
   25050 		y := or.Args[1]
   25051 		s0 := v.Args[1]
   25052 		if s0.Op != OpS390XSLDconst {
   25053 			break
   25054 		}
   25055 		j0 := s0.AuxInt
   25056 		x0 := s0.Args[0]
   25057 		if x0.Op != OpS390XMOVBZloadidx {
   25058 			break
   25059 		}
   25060 		i0 := x0.AuxInt
   25061 		if x0.Aux != s {
   25062 			break
   25063 		}
   25064 		_ = x0.Args[2]
   25065 		if p != x0.Args[0] {
   25066 			break
   25067 		}
   25068 		if idx != x0.Args[1] {
   25069 			break
   25070 		}
   25071 		if mem != x0.Args[2] {
   25072 			break
   25073 		}
   25074 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25075 			break
   25076 		}
   25077 		b = mergePoint(b, x0, x1)
   25078 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25079 		v.reset(OpCopy)
   25080 		v.AddArg(v0)
   25081 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25082 		v1.AuxInt = j1
   25083 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25084 		v2.AuxInt = i0
   25085 		v2.Aux = s
   25086 		v2.AddArg(p)
   25087 		v2.AddArg(idx)
   25088 		v2.AddArg(mem)
   25089 		v1.AddArg(v2)
   25090 		v0.AddArg(v1)
   25091 		v0.AddArg(y)
   25092 		return true
   25093 	}
   25094 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   25095 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25096 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25097 	for {
   25098 		_ = v.Args[1]
   25099 		or := v.Args[0]
   25100 		if or.Op != OpS390XOR {
   25101 			break
   25102 		}
   25103 		_ = or.Args[1]
   25104 		y := or.Args[0]
   25105 		s1 := or.Args[1]
   25106 		if s1.Op != OpS390XSLDconst {
   25107 			break
   25108 		}
   25109 		j1 := s1.AuxInt
   25110 		x1 := s1.Args[0]
   25111 		if x1.Op != OpS390XMOVBZloadidx {
   25112 			break
   25113 		}
   25114 		i1 := x1.AuxInt
   25115 		s := x1.Aux
   25116 		_ = x1.Args[2]
   25117 		p := x1.Args[0]
   25118 		idx := x1.Args[1]
   25119 		mem := x1.Args[2]
   25120 		s0 := v.Args[1]
   25121 		if s0.Op != OpS390XSLDconst {
   25122 			break
   25123 		}
   25124 		j0 := s0.AuxInt
   25125 		x0 := s0.Args[0]
   25126 		if x0.Op != OpS390XMOVBZloadidx {
   25127 			break
   25128 		}
   25129 		i0 := x0.AuxInt
   25130 		if x0.Aux != s {
   25131 			break
   25132 		}
   25133 		_ = x0.Args[2]
   25134 		if p != x0.Args[0] {
   25135 			break
   25136 		}
   25137 		if idx != x0.Args[1] {
   25138 			break
   25139 		}
   25140 		if mem != x0.Args[2] {
   25141 			break
   25142 		}
   25143 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25144 			break
   25145 		}
   25146 		b = mergePoint(b, x0, x1)
   25147 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25148 		v.reset(OpCopy)
   25149 		v.AddArg(v0)
   25150 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25151 		v1.AuxInt = j1
   25152 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25153 		v2.AuxInt = i0
   25154 		v2.Aux = s
   25155 		v2.AddArg(p)
   25156 		v2.AddArg(idx)
   25157 		v2.AddArg(mem)
   25158 		v1.AddArg(v2)
   25159 		v0.AddArg(v1)
   25160 		v0.AddArg(y)
   25161 		return true
   25162 	}
   25163 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   25164 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25165 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25166 	for {
   25167 		_ = v.Args[1]
   25168 		or := v.Args[0]
   25169 		if or.Op != OpS390XOR {
   25170 			break
   25171 		}
   25172 		_ = or.Args[1]
   25173 		y := or.Args[0]
   25174 		s1 := or.Args[1]
   25175 		if s1.Op != OpS390XSLDconst {
   25176 			break
   25177 		}
   25178 		j1 := s1.AuxInt
   25179 		x1 := s1.Args[0]
   25180 		if x1.Op != OpS390XMOVBZloadidx {
   25181 			break
   25182 		}
   25183 		i1 := x1.AuxInt
   25184 		s := x1.Aux
   25185 		_ = x1.Args[2]
   25186 		idx := x1.Args[0]
   25187 		p := x1.Args[1]
   25188 		mem := x1.Args[2]
   25189 		s0 := v.Args[1]
   25190 		if s0.Op != OpS390XSLDconst {
   25191 			break
   25192 		}
   25193 		j0 := s0.AuxInt
   25194 		x0 := s0.Args[0]
   25195 		if x0.Op != OpS390XMOVBZloadidx {
   25196 			break
   25197 		}
   25198 		i0 := x0.AuxInt
   25199 		if x0.Aux != s {
   25200 			break
   25201 		}
   25202 		_ = x0.Args[2]
   25203 		if p != x0.Args[0] {
   25204 			break
   25205 		}
   25206 		if idx != x0.Args[1] {
   25207 			break
   25208 		}
   25209 		if mem != x0.Args[2] {
   25210 			break
   25211 		}
   25212 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25213 			break
   25214 		}
   25215 		b = mergePoint(b, x0, x1)
   25216 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25217 		v.reset(OpCopy)
   25218 		v.AddArg(v0)
   25219 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25220 		v1.AuxInt = j1
   25221 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25222 		v2.AuxInt = i0
   25223 		v2.Aux = s
   25224 		v2.AddArg(p)
   25225 		v2.AddArg(idx)
   25226 		v2.AddArg(mem)
   25227 		v1.AddArg(v2)
   25228 		v0.AddArg(v1)
   25229 		v0.AddArg(y)
   25230 		return true
   25231 	}
   25232 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   25233 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25234 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25235 	for {
   25236 		_ = v.Args[1]
   25237 		or := v.Args[0]
   25238 		if or.Op != OpS390XOR {
   25239 			break
   25240 		}
   25241 		_ = or.Args[1]
   25242 		s1 := or.Args[0]
   25243 		if s1.Op != OpS390XSLDconst {
   25244 			break
   25245 		}
   25246 		j1 := s1.AuxInt
   25247 		x1 := s1.Args[0]
   25248 		if x1.Op != OpS390XMOVBZloadidx {
   25249 			break
   25250 		}
   25251 		i1 := x1.AuxInt
   25252 		s := x1.Aux
   25253 		_ = x1.Args[2]
   25254 		p := x1.Args[0]
   25255 		idx := x1.Args[1]
   25256 		mem := x1.Args[2]
   25257 		y := or.Args[1]
   25258 		s0 := v.Args[1]
   25259 		if s0.Op != OpS390XSLDconst {
   25260 			break
   25261 		}
   25262 		j0 := s0.AuxInt
   25263 		x0 := s0.Args[0]
   25264 		if x0.Op != OpS390XMOVBZloadidx {
   25265 			break
   25266 		}
   25267 		i0 := x0.AuxInt
   25268 		if x0.Aux != s {
   25269 			break
   25270 		}
   25271 		_ = x0.Args[2]
   25272 		if idx != x0.Args[0] {
   25273 			break
   25274 		}
   25275 		if p != x0.Args[1] {
   25276 			break
   25277 		}
   25278 		if mem != x0.Args[2] {
   25279 			break
   25280 		}
   25281 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25282 			break
   25283 		}
   25284 		b = mergePoint(b, x0, x1)
   25285 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25286 		v.reset(OpCopy)
   25287 		v.AddArg(v0)
   25288 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25289 		v1.AuxInt = j1
   25290 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25291 		v2.AuxInt = i0
   25292 		v2.Aux = s
   25293 		v2.AddArg(p)
   25294 		v2.AddArg(idx)
   25295 		v2.AddArg(mem)
   25296 		v1.AddArg(v2)
   25297 		v0.AddArg(v1)
   25298 		v0.AddArg(y)
   25299 		return true
   25300 	}
   25301 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   25302 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25303 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25304 	for {
   25305 		_ = v.Args[1]
   25306 		or := v.Args[0]
   25307 		if or.Op != OpS390XOR {
   25308 			break
   25309 		}
   25310 		_ = or.Args[1]
   25311 		s1 := or.Args[0]
   25312 		if s1.Op != OpS390XSLDconst {
   25313 			break
   25314 		}
   25315 		j1 := s1.AuxInt
   25316 		x1 := s1.Args[0]
   25317 		if x1.Op != OpS390XMOVBZloadidx {
   25318 			break
   25319 		}
   25320 		i1 := x1.AuxInt
   25321 		s := x1.Aux
   25322 		_ = x1.Args[2]
   25323 		idx := x1.Args[0]
   25324 		p := x1.Args[1]
   25325 		mem := x1.Args[2]
   25326 		y := or.Args[1]
   25327 		s0 := v.Args[1]
   25328 		if s0.Op != OpS390XSLDconst {
   25329 			break
   25330 		}
   25331 		j0 := s0.AuxInt
   25332 		x0 := s0.Args[0]
   25333 		if x0.Op != OpS390XMOVBZloadidx {
   25334 			break
   25335 		}
   25336 		i0 := x0.AuxInt
   25337 		if x0.Aux != s {
   25338 			break
   25339 		}
   25340 		_ = x0.Args[2]
   25341 		if idx != x0.Args[0] {
   25342 			break
   25343 		}
   25344 		if p != x0.Args[1] {
   25345 			break
   25346 		}
   25347 		if mem != x0.Args[2] {
   25348 			break
   25349 		}
   25350 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25351 			break
   25352 		}
   25353 		b = mergePoint(b, x0, x1)
   25354 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25355 		v.reset(OpCopy)
   25356 		v.AddArg(v0)
   25357 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25358 		v1.AuxInt = j1
   25359 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25360 		v2.AuxInt = i0
   25361 		v2.Aux = s
   25362 		v2.AddArg(p)
   25363 		v2.AddArg(idx)
   25364 		v2.AddArg(mem)
   25365 		v1.AddArg(v2)
   25366 		v0.AddArg(v1)
   25367 		v0.AddArg(y)
   25368 		return true
   25369 	}
   25370 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   25371 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25372 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25373 	for {
   25374 		_ = v.Args[1]
   25375 		or := v.Args[0]
   25376 		if or.Op != OpS390XOR {
   25377 			break
   25378 		}
   25379 		_ = or.Args[1]
   25380 		y := or.Args[0]
   25381 		s1 := or.Args[1]
   25382 		if s1.Op != OpS390XSLDconst {
   25383 			break
   25384 		}
   25385 		j1 := s1.AuxInt
   25386 		x1 := s1.Args[0]
   25387 		if x1.Op != OpS390XMOVBZloadidx {
   25388 			break
   25389 		}
   25390 		i1 := x1.AuxInt
   25391 		s := x1.Aux
   25392 		_ = x1.Args[2]
   25393 		p := x1.Args[0]
   25394 		idx := x1.Args[1]
   25395 		mem := x1.Args[2]
   25396 		s0 := v.Args[1]
   25397 		if s0.Op != OpS390XSLDconst {
   25398 			break
   25399 		}
   25400 		j0 := s0.AuxInt
   25401 		x0 := s0.Args[0]
   25402 		if x0.Op != OpS390XMOVBZloadidx {
   25403 			break
   25404 		}
   25405 		i0 := x0.AuxInt
   25406 		if x0.Aux != s {
   25407 			break
   25408 		}
   25409 		_ = x0.Args[2]
   25410 		if idx != x0.Args[0] {
   25411 			break
   25412 		}
   25413 		if p != x0.Args[1] {
   25414 			break
   25415 		}
   25416 		if mem != x0.Args[2] {
   25417 			break
   25418 		}
   25419 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25420 			break
   25421 		}
   25422 		b = mergePoint(b, x0, x1)
   25423 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25424 		v.reset(OpCopy)
   25425 		v.AddArg(v0)
   25426 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25427 		v1.AuxInt = j1
   25428 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25429 		v2.AuxInt = i0
   25430 		v2.Aux = s
   25431 		v2.AddArg(p)
   25432 		v2.AddArg(idx)
   25433 		v2.AddArg(mem)
   25434 		v1.AddArg(v2)
   25435 		v0.AddArg(v1)
   25436 		v0.AddArg(y)
   25437 		return true
   25438 	}
   25439 	return false
   25440 }
   25441 func rewriteValueS390X_OpS390XOR_70(v *Value) bool {
   25442 	b := v.Block
   25443 	_ = b
   25444 	typ := &b.Func.Config.Types
   25445 	_ = typ
   25446 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   25447 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25448 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   25449 	for {
   25450 		_ = v.Args[1]
   25451 		or := v.Args[0]
   25452 		if or.Op != OpS390XOR {
   25453 			break
   25454 		}
   25455 		_ = or.Args[1]
   25456 		y := or.Args[0]
   25457 		s1 := or.Args[1]
   25458 		if s1.Op != OpS390XSLDconst {
   25459 			break
   25460 		}
   25461 		j1 := s1.AuxInt
   25462 		x1 := s1.Args[0]
   25463 		if x1.Op != OpS390XMOVBZloadidx {
   25464 			break
   25465 		}
   25466 		i1 := x1.AuxInt
   25467 		s := x1.Aux
   25468 		_ = x1.Args[2]
   25469 		idx := x1.Args[0]
   25470 		p := x1.Args[1]
   25471 		mem := x1.Args[2]
   25472 		s0 := v.Args[1]
   25473 		if s0.Op != OpS390XSLDconst {
   25474 			break
   25475 		}
   25476 		j0 := s0.AuxInt
   25477 		x0 := s0.Args[0]
   25478 		if x0.Op != OpS390XMOVBZloadidx {
   25479 			break
   25480 		}
   25481 		i0 := x0.AuxInt
   25482 		if x0.Aux != s {
   25483 			break
   25484 		}
   25485 		_ = x0.Args[2]
   25486 		if idx != x0.Args[0] {
   25487 			break
   25488 		}
   25489 		if p != x0.Args[1] {
   25490 			break
   25491 		}
   25492 		if mem != x0.Args[2] {
   25493 			break
   25494 		}
   25495 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25496 			break
   25497 		}
   25498 		b = mergePoint(b, x0, x1)
   25499 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25500 		v.reset(OpCopy)
   25501 		v.AddArg(v0)
   25502 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25503 		v1.AuxInt = j1
   25504 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   25505 		v2.AuxInt = i0
   25506 		v2.Aux = s
   25507 		v2.AddArg(p)
   25508 		v2.AddArg(idx)
   25509 		v2.AddArg(mem)
   25510 		v1.AddArg(v2)
   25511 		v0.AddArg(v1)
   25512 		v0.AddArg(y)
   25513 		return true
   25514 	}
   25515 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y))
   25516 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25517 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25518 	for {
   25519 		_ = v.Args[1]
   25520 		s0 := v.Args[0]
   25521 		if s0.Op != OpS390XSLDconst {
   25522 			break
   25523 		}
   25524 		j0 := s0.AuxInt
   25525 		x0 := s0.Args[0]
   25526 		if x0.Op != OpS390XMOVHZloadidx {
   25527 			break
   25528 		}
   25529 		i0 := x0.AuxInt
   25530 		s := x0.Aux
   25531 		_ = x0.Args[2]
   25532 		p := x0.Args[0]
   25533 		idx := x0.Args[1]
   25534 		mem := x0.Args[2]
   25535 		or := v.Args[1]
   25536 		if or.Op != OpS390XOR {
   25537 			break
   25538 		}
   25539 		_ = or.Args[1]
   25540 		s1 := or.Args[0]
   25541 		if s1.Op != OpS390XSLDconst {
   25542 			break
   25543 		}
   25544 		j1 := s1.AuxInt
   25545 		x1 := s1.Args[0]
   25546 		if x1.Op != OpS390XMOVHZloadidx {
   25547 			break
   25548 		}
   25549 		i1 := x1.AuxInt
   25550 		if x1.Aux != s {
   25551 			break
   25552 		}
   25553 		_ = x1.Args[2]
   25554 		if p != x1.Args[0] {
   25555 			break
   25556 		}
   25557 		if idx != x1.Args[1] {
   25558 			break
   25559 		}
   25560 		if mem != x1.Args[2] {
   25561 			break
   25562 		}
   25563 		y := or.Args[1]
   25564 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25565 			break
   25566 		}
   25567 		b = mergePoint(b, x0, x1)
   25568 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25569 		v.reset(OpCopy)
   25570 		v.AddArg(v0)
   25571 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25572 		v1.AuxInt = j1
   25573 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25574 		v2.AuxInt = i0
   25575 		v2.Aux = s
   25576 		v2.AddArg(p)
   25577 		v2.AddArg(idx)
   25578 		v2.AddArg(mem)
   25579 		v1.AddArg(v2)
   25580 		v0.AddArg(v1)
   25581 		v0.AddArg(y)
   25582 		return true
   25583 	}
   25584 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y))
   25585 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25586 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25587 	for {
   25588 		_ = v.Args[1]
   25589 		s0 := v.Args[0]
   25590 		if s0.Op != OpS390XSLDconst {
   25591 			break
   25592 		}
   25593 		j0 := s0.AuxInt
   25594 		x0 := s0.Args[0]
   25595 		if x0.Op != OpS390XMOVHZloadidx {
   25596 			break
   25597 		}
   25598 		i0 := x0.AuxInt
   25599 		s := x0.Aux
   25600 		_ = x0.Args[2]
   25601 		idx := x0.Args[0]
   25602 		p := x0.Args[1]
   25603 		mem := x0.Args[2]
   25604 		or := v.Args[1]
   25605 		if or.Op != OpS390XOR {
   25606 			break
   25607 		}
   25608 		_ = or.Args[1]
   25609 		s1 := or.Args[0]
   25610 		if s1.Op != OpS390XSLDconst {
   25611 			break
   25612 		}
   25613 		j1 := s1.AuxInt
   25614 		x1 := s1.Args[0]
   25615 		if x1.Op != OpS390XMOVHZloadidx {
   25616 			break
   25617 		}
   25618 		i1 := x1.AuxInt
   25619 		if x1.Aux != s {
   25620 			break
   25621 		}
   25622 		_ = x1.Args[2]
   25623 		if p != x1.Args[0] {
   25624 			break
   25625 		}
   25626 		if idx != x1.Args[1] {
   25627 			break
   25628 		}
   25629 		if mem != x1.Args[2] {
   25630 			break
   25631 		}
   25632 		y := or.Args[1]
   25633 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25634 			break
   25635 		}
   25636 		b = mergePoint(b, x0, x1)
   25637 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25638 		v.reset(OpCopy)
   25639 		v.AddArg(v0)
   25640 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25641 		v1.AuxInt = j1
   25642 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25643 		v2.AuxInt = i0
   25644 		v2.Aux = s
   25645 		v2.AddArg(p)
   25646 		v2.AddArg(idx)
   25647 		v2.AddArg(mem)
   25648 		v1.AddArg(v2)
   25649 		v0.AddArg(v1)
   25650 		v0.AddArg(y)
   25651 		return true
   25652 	}
   25653 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y))
   25654 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25655 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25656 	for {
   25657 		_ = v.Args[1]
   25658 		s0 := v.Args[0]
   25659 		if s0.Op != OpS390XSLDconst {
   25660 			break
   25661 		}
   25662 		j0 := s0.AuxInt
   25663 		x0 := s0.Args[0]
   25664 		if x0.Op != OpS390XMOVHZloadidx {
   25665 			break
   25666 		}
   25667 		i0 := x0.AuxInt
   25668 		s := x0.Aux
   25669 		_ = x0.Args[2]
   25670 		p := x0.Args[0]
   25671 		idx := x0.Args[1]
   25672 		mem := x0.Args[2]
   25673 		or := v.Args[1]
   25674 		if or.Op != OpS390XOR {
   25675 			break
   25676 		}
   25677 		_ = or.Args[1]
   25678 		s1 := or.Args[0]
   25679 		if s1.Op != OpS390XSLDconst {
   25680 			break
   25681 		}
   25682 		j1 := s1.AuxInt
   25683 		x1 := s1.Args[0]
   25684 		if x1.Op != OpS390XMOVHZloadidx {
   25685 			break
   25686 		}
   25687 		i1 := x1.AuxInt
   25688 		if x1.Aux != s {
   25689 			break
   25690 		}
   25691 		_ = x1.Args[2]
   25692 		if idx != x1.Args[0] {
   25693 			break
   25694 		}
   25695 		if p != x1.Args[1] {
   25696 			break
   25697 		}
   25698 		if mem != x1.Args[2] {
   25699 			break
   25700 		}
   25701 		y := or.Args[1]
   25702 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25703 			break
   25704 		}
   25705 		b = mergePoint(b, x0, x1)
   25706 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25707 		v.reset(OpCopy)
   25708 		v.AddArg(v0)
   25709 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25710 		v1.AuxInt = j1
   25711 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25712 		v2.AuxInt = i0
   25713 		v2.Aux = s
   25714 		v2.AddArg(p)
   25715 		v2.AddArg(idx)
   25716 		v2.AddArg(mem)
   25717 		v1.AddArg(v2)
   25718 		v0.AddArg(v1)
   25719 		v0.AddArg(y)
   25720 		return true
   25721 	}
   25722 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y))
   25723 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25724 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25725 	for {
   25726 		_ = v.Args[1]
   25727 		s0 := v.Args[0]
   25728 		if s0.Op != OpS390XSLDconst {
   25729 			break
   25730 		}
   25731 		j0 := s0.AuxInt
   25732 		x0 := s0.Args[0]
   25733 		if x0.Op != OpS390XMOVHZloadidx {
   25734 			break
   25735 		}
   25736 		i0 := x0.AuxInt
   25737 		s := x0.Aux
   25738 		_ = x0.Args[2]
   25739 		idx := x0.Args[0]
   25740 		p := x0.Args[1]
   25741 		mem := x0.Args[2]
   25742 		or := v.Args[1]
   25743 		if or.Op != OpS390XOR {
   25744 			break
   25745 		}
   25746 		_ = or.Args[1]
   25747 		s1 := or.Args[0]
   25748 		if s1.Op != OpS390XSLDconst {
   25749 			break
   25750 		}
   25751 		j1 := s1.AuxInt
   25752 		x1 := s1.Args[0]
   25753 		if x1.Op != OpS390XMOVHZloadidx {
   25754 			break
   25755 		}
   25756 		i1 := x1.AuxInt
   25757 		if x1.Aux != s {
   25758 			break
   25759 		}
   25760 		_ = x1.Args[2]
   25761 		if idx != x1.Args[0] {
   25762 			break
   25763 		}
   25764 		if p != x1.Args[1] {
   25765 			break
   25766 		}
   25767 		if mem != x1.Args[2] {
   25768 			break
   25769 		}
   25770 		y := or.Args[1]
   25771 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25772 			break
   25773 		}
   25774 		b = mergePoint(b, x0, x1)
   25775 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25776 		v.reset(OpCopy)
   25777 		v.AddArg(v0)
   25778 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25779 		v1.AuxInt = j1
   25780 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25781 		v2.AuxInt = i0
   25782 		v2.Aux = s
   25783 		v2.AddArg(p)
   25784 		v2.AddArg(idx)
   25785 		v2.AddArg(mem)
   25786 		v1.AddArg(v2)
   25787 		v0.AddArg(v1)
   25788 		v0.AddArg(y)
   25789 		return true
   25790 	}
   25791 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
   25792 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25793 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25794 	for {
   25795 		_ = v.Args[1]
   25796 		s0 := v.Args[0]
   25797 		if s0.Op != OpS390XSLDconst {
   25798 			break
   25799 		}
   25800 		j0 := s0.AuxInt
   25801 		x0 := s0.Args[0]
   25802 		if x0.Op != OpS390XMOVHZloadidx {
   25803 			break
   25804 		}
   25805 		i0 := x0.AuxInt
   25806 		s := x0.Aux
   25807 		_ = x0.Args[2]
   25808 		p := x0.Args[0]
   25809 		idx := x0.Args[1]
   25810 		mem := x0.Args[2]
   25811 		or := v.Args[1]
   25812 		if or.Op != OpS390XOR {
   25813 			break
   25814 		}
   25815 		_ = or.Args[1]
   25816 		y := or.Args[0]
   25817 		s1 := or.Args[1]
   25818 		if s1.Op != OpS390XSLDconst {
   25819 			break
   25820 		}
   25821 		j1 := s1.AuxInt
   25822 		x1 := s1.Args[0]
   25823 		if x1.Op != OpS390XMOVHZloadidx {
   25824 			break
   25825 		}
   25826 		i1 := x1.AuxInt
   25827 		if x1.Aux != s {
   25828 			break
   25829 		}
   25830 		_ = x1.Args[2]
   25831 		if p != x1.Args[0] {
   25832 			break
   25833 		}
   25834 		if idx != x1.Args[1] {
   25835 			break
   25836 		}
   25837 		if mem != x1.Args[2] {
   25838 			break
   25839 		}
   25840 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25841 			break
   25842 		}
   25843 		b = mergePoint(b, x0, x1)
   25844 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25845 		v.reset(OpCopy)
   25846 		v.AddArg(v0)
   25847 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25848 		v1.AuxInt = j1
   25849 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25850 		v2.AuxInt = i0
   25851 		v2.Aux = s
   25852 		v2.AddArg(p)
   25853 		v2.AddArg(idx)
   25854 		v2.AddArg(mem)
   25855 		v1.AddArg(v2)
   25856 		v0.AddArg(v1)
   25857 		v0.AddArg(y)
   25858 		return true
   25859 	}
   25860 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
   25861 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25862 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25863 	for {
   25864 		_ = v.Args[1]
   25865 		s0 := v.Args[0]
   25866 		if s0.Op != OpS390XSLDconst {
   25867 			break
   25868 		}
   25869 		j0 := s0.AuxInt
   25870 		x0 := s0.Args[0]
   25871 		if x0.Op != OpS390XMOVHZloadidx {
   25872 			break
   25873 		}
   25874 		i0 := x0.AuxInt
   25875 		s := x0.Aux
   25876 		_ = x0.Args[2]
   25877 		idx := x0.Args[0]
   25878 		p := x0.Args[1]
   25879 		mem := x0.Args[2]
   25880 		or := v.Args[1]
   25881 		if or.Op != OpS390XOR {
   25882 			break
   25883 		}
   25884 		_ = or.Args[1]
   25885 		y := or.Args[0]
   25886 		s1 := or.Args[1]
   25887 		if s1.Op != OpS390XSLDconst {
   25888 			break
   25889 		}
   25890 		j1 := s1.AuxInt
   25891 		x1 := s1.Args[0]
   25892 		if x1.Op != OpS390XMOVHZloadidx {
   25893 			break
   25894 		}
   25895 		i1 := x1.AuxInt
   25896 		if x1.Aux != s {
   25897 			break
   25898 		}
   25899 		_ = x1.Args[2]
   25900 		if p != x1.Args[0] {
   25901 			break
   25902 		}
   25903 		if idx != x1.Args[1] {
   25904 			break
   25905 		}
   25906 		if mem != x1.Args[2] {
   25907 			break
   25908 		}
   25909 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25910 			break
   25911 		}
   25912 		b = mergePoint(b, x0, x1)
   25913 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25914 		v.reset(OpCopy)
   25915 		v.AddArg(v0)
   25916 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25917 		v1.AuxInt = j1
   25918 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25919 		v2.AuxInt = i0
   25920 		v2.Aux = s
   25921 		v2.AddArg(p)
   25922 		v2.AddArg(idx)
   25923 		v2.AddArg(mem)
   25924 		v1.AddArg(v2)
   25925 		v0.AddArg(v1)
   25926 		v0.AddArg(y)
   25927 		return true
   25928 	}
   25929 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))))
   25930 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   25931 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   25932 	for {
   25933 		_ = v.Args[1]
   25934 		s0 := v.Args[0]
   25935 		if s0.Op != OpS390XSLDconst {
   25936 			break
   25937 		}
   25938 		j0 := s0.AuxInt
   25939 		x0 := s0.Args[0]
   25940 		if x0.Op != OpS390XMOVHZloadidx {
   25941 			break
   25942 		}
   25943 		i0 := x0.AuxInt
   25944 		s := x0.Aux
   25945 		_ = x0.Args[2]
   25946 		p := x0.Args[0]
   25947 		idx := x0.Args[1]
   25948 		mem := x0.Args[2]
   25949 		or := v.Args[1]
   25950 		if or.Op != OpS390XOR {
   25951 			break
   25952 		}
   25953 		_ = or.Args[1]
   25954 		y := or.Args[0]
   25955 		s1 := or.Args[1]
   25956 		if s1.Op != OpS390XSLDconst {
   25957 			break
   25958 		}
   25959 		j1 := s1.AuxInt
   25960 		x1 := s1.Args[0]
   25961 		if x1.Op != OpS390XMOVHZloadidx {
   25962 			break
   25963 		}
   25964 		i1 := x1.AuxInt
   25965 		if x1.Aux != s {
   25966 			break
   25967 		}
   25968 		_ = x1.Args[2]
   25969 		if idx != x1.Args[0] {
   25970 			break
   25971 		}
   25972 		if p != x1.Args[1] {
   25973 			break
   25974 		}
   25975 		if mem != x1.Args[2] {
   25976 			break
   25977 		}
   25978 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   25979 			break
   25980 		}
   25981 		b = mergePoint(b, x0, x1)
   25982 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   25983 		v.reset(OpCopy)
   25984 		v.AddArg(v0)
   25985 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   25986 		v1.AuxInt = j1
   25987 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   25988 		v2.AuxInt = i0
   25989 		v2.Aux = s
   25990 		v2.AddArg(p)
   25991 		v2.AddArg(idx)
   25992 		v2.AddArg(mem)
   25993 		v1.AddArg(v2)
   25994 		v0.AddArg(v1)
   25995 		v0.AddArg(y)
   25996 		return true
   25997 	}
   25998 	// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))))
   25999 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26000 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26001 	for {
   26002 		_ = v.Args[1]
   26003 		s0 := v.Args[0]
   26004 		if s0.Op != OpS390XSLDconst {
   26005 			break
   26006 		}
   26007 		j0 := s0.AuxInt
   26008 		x0 := s0.Args[0]
   26009 		if x0.Op != OpS390XMOVHZloadidx {
   26010 			break
   26011 		}
   26012 		i0 := x0.AuxInt
   26013 		s := x0.Aux
   26014 		_ = x0.Args[2]
   26015 		idx := x0.Args[0]
   26016 		p := x0.Args[1]
   26017 		mem := x0.Args[2]
   26018 		or := v.Args[1]
   26019 		if or.Op != OpS390XOR {
   26020 			break
   26021 		}
   26022 		_ = or.Args[1]
   26023 		y := or.Args[0]
   26024 		s1 := or.Args[1]
   26025 		if s1.Op != OpS390XSLDconst {
   26026 			break
   26027 		}
   26028 		j1 := s1.AuxInt
   26029 		x1 := s1.Args[0]
   26030 		if x1.Op != OpS390XMOVHZloadidx {
   26031 			break
   26032 		}
   26033 		i1 := x1.AuxInt
   26034 		if x1.Aux != s {
   26035 			break
   26036 		}
   26037 		_ = x1.Args[2]
   26038 		if idx != x1.Args[0] {
   26039 			break
   26040 		}
   26041 		if p != x1.Args[1] {
   26042 			break
   26043 		}
   26044 		if mem != x1.Args[2] {
   26045 			break
   26046 		}
   26047 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26048 			break
   26049 		}
   26050 		b = mergePoint(b, x0, x1)
   26051 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26052 		v.reset(OpCopy)
   26053 		v.AddArg(v0)
   26054 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26055 		v1.AuxInt = j1
   26056 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26057 		v2.AuxInt = i0
   26058 		v2.Aux = s
   26059 		v2.AddArg(p)
   26060 		v2.AddArg(idx)
   26061 		v2.AddArg(mem)
   26062 		v1.AddArg(v2)
   26063 		v0.AddArg(v1)
   26064 		v0.AddArg(y)
   26065 		return true
   26066 	}
   26067 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   26068 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26069 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26070 	for {
   26071 		_ = v.Args[1]
   26072 		or := v.Args[0]
   26073 		if or.Op != OpS390XOR {
   26074 			break
   26075 		}
   26076 		_ = or.Args[1]
   26077 		s1 := or.Args[0]
   26078 		if s1.Op != OpS390XSLDconst {
   26079 			break
   26080 		}
   26081 		j1 := s1.AuxInt
   26082 		x1 := s1.Args[0]
   26083 		if x1.Op != OpS390XMOVHZloadidx {
   26084 			break
   26085 		}
   26086 		i1 := x1.AuxInt
   26087 		s := x1.Aux
   26088 		_ = x1.Args[2]
   26089 		p := x1.Args[0]
   26090 		idx := x1.Args[1]
   26091 		mem := x1.Args[2]
   26092 		y := or.Args[1]
   26093 		s0 := v.Args[1]
   26094 		if s0.Op != OpS390XSLDconst {
   26095 			break
   26096 		}
   26097 		j0 := s0.AuxInt
   26098 		x0 := s0.Args[0]
   26099 		if x0.Op != OpS390XMOVHZloadidx {
   26100 			break
   26101 		}
   26102 		i0 := x0.AuxInt
   26103 		if x0.Aux != s {
   26104 			break
   26105 		}
   26106 		_ = x0.Args[2]
   26107 		if p != x0.Args[0] {
   26108 			break
   26109 		}
   26110 		if idx != x0.Args[1] {
   26111 			break
   26112 		}
   26113 		if mem != x0.Args[2] {
   26114 			break
   26115 		}
   26116 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26117 			break
   26118 		}
   26119 		b = mergePoint(b, x0, x1)
   26120 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26121 		v.reset(OpCopy)
   26122 		v.AddArg(v0)
   26123 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26124 		v1.AuxInt = j1
   26125 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26126 		v2.AuxInt = i0
   26127 		v2.Aux = s
   26128 		v2.AddArg(p)
   26129 		v2.AddArg(idx)
   26130 		v2.AddArg(mem)
   26131 		v1.AddArg(v2)
   26132 		v0.AddArg(v1)
   26133 		v0.AddArg(y)
   26134 		return true
   26135 	}
   26136 	return false
   26137 }
   26138 func rewriteValueS390X_OpS390XOR_80(v *Value) bool {
   26139 	b := v.Block
   26140 	_ = b
   26141 	typ := &b.Func.Config.Types
   26142 	_ = typ
   26143 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   26144 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26145 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26146 	for {
   26147 		_ = v.Args[1]
   26148 		or := v.Args[0]
   26149 		if or.Op != OpS390XOR {
   26150 			break
   26151 		}
   26152 		_ = or.Args[1]
   26153 		s1 := or.Args[0]
   26154 		if s1.Op != OpS390XSLDconst {
   26155 			break
   26156 		}
   26157 		j1 := s1.AuxInt
   26158 		x1 := s1.Args[0]
   26159 		if x1.Op != OpS390XMOVHZloadidx {
   26160 			break
   26161 		}
   26162 		i1 := x1.AuxInt
   26163 		s := x1.Aux
   26164 		_ = x1.Args[2]
   26165 		idx := x1.Args[0]
   26166 		p := x1.Args[1]
   26167 		mem := x1.Args[2]
   26168 		y := or.Args[1]
   26169 		s0 := v.Args[1]
   26170 		if s0.Op != OpS390XSLDconst {
   26171 			break
   26172 		}
   26173 		j0 := s0.AuxInt
   26174 		x0 := s0.Args[0]
   26175 		if x0.Op != OpS390XMOVHZloadidx {
   26176 			break
   26177 		}
   26178 		i0 := x0.AuxInt
   26179 		if x0.Aux != s {
   26180 			break
   26181 		}
   26182 		_ = x0.Args[2]
   26183 		if p != x0.Args[0] {
   26184 			break
   26185 		}
   26186 		if idx != x0.Args[1] {
   26187 			break
   26188 		}
   26189 		if mem != x0.Args[2] {
   26190 			break
   26191 		}
   26192 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26193 			break
   26194 		}
   26195 		b = mergePoint(b, x0, x1)
   26196 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26197 		v.reset(OpCopy)
   26198 		v.AddArg(v0)
   26199 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26200 		v1.AuxInt = j1
   26201 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26202 		v2.AuxInt = i0
   26203 		v2.Aux = s
   26204 		v2.AddArg(p)
   26205 		v2.AddArg(idx)
   26206 		v2.AddArg(mem)
   26207 		v1.AddArg(v2)
   26208 		v0.AddArg(v1)
   26209 		v0.AddArg(y)
   26210 		return true
   26211 	}
   26212 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   26213 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26214 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26215 	for {
   26216 		_ = v.Args[1]
   26217 		or := v.Args[0]
   26218 		if or.Op != OpS390XOR {
   26219 			break
   26220 		}
   26221 		_ = or.Args[1]
   26222 		y := or.Args[0]
   26223 		s1 := or.Args[1]
   26224 		if s1.Op != OpS390XSLDconst {
   26225 			break
   26226 		}
   26227 		j1 := s1.AuxInt
   26228 		x1 := s1.Args[0]
   26229 		if x1.Op != OpS390XMOVHZloadidx {
   26230 			break
   26231 		}
   26232 		i1 := x1.AuxInt
   26233 		s := x1.Aux
   26234 		_ = x1.Args[2]
   26235 		p := x1.Args[0]
   26236 		idx := x1.Args[1]
   26237 		mem := x1.Args[2]
   26238 		s0 := v.Args[1]
   26239 		if s0.Op != OpS390XSLDconst {
   26240 			break
   26241 		}
   26242 		j0 := s0.AuxInt
   26243 		x0 := s0.Args[0]
   26244 		if x0.Op != OpS390XMOVHZloadidx {
   26245 			break
   26246 		}
   26247 		i0 := x0.AuxInt
   26248 		if x0.Aux != s {
   26249 			break
   26250 		}
   26251 		_ = x0.Args[2]
   26252 		if p != x0.Args[0] {
   26253 			break
   26254 		}
   26255 		if idx != x0.Args[1] {
   26256 			break
   26257 		}
   26258 		if mem != x0.Args[2] {
   26259 			break
   26260 		}
   26261 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26262 			break
   26263 		}
   26264 		b = mergePoint(b, x0, x1)
   26265 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26266 		v.reset(OpCopy)
   26267 		v.AddArg(v0)
   26268 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26269 		v1.AuxInt = j1
   26270 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26271 		v2.AuxInt = i0
   26272 		v2.Aux = s
   26273 		v2.AddArg(p)
   26274 		v2.AddArg(idx)
   26275 		v2.AddArg(mem)
   26276 		v1.AddArg(v2)
   26277 		v0.AddArg(v1)
   26278 		v0.AddArg(y)
   26279 		return true
   26280 	}
   26281 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   26282 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26283 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26284 	for {
   26285 		_ = v.Args[1]
   26286 		or := v.Args[0]
   26287 		if or.Op != OpS390XOR {
   26288 			break
   26289 		}
   26290 		_ = or.Args[1]
   26291 		y := or.Args[0]
   26292 		s1 := or.Args[1]
   26293 		if s1.Op != OpS390XSLDconst {
   26294 			break
   26295 		}
   26296 		j1 := s1.AuxInt
   26297 		x1 := s1.Args[0]
   26298 		if x1.Op != OpS390XMOVHZloadidx {
   26299 			break
   26300 		}
   26301 		i1 := x1.AuxInt
   26302 		s := x1.Aux
   26303 		_ = x1.Args[2]
   26304 		idx := x1.Args[0]
   26305 		p := x1.Args[1]
   26306 		mem := x1.Args[2]
   26307 		s0 := v.Args[1]
   26308 		if s0.Op != OpS390XSLDconst {
   26309 			break
   26310 		}
   26311 		j0 := s0.AuxInt
   26312 		x0 := s0.Args[0]
   26313 		if x0.Op != OpS390XMOVHZloadidx {
   26314 			break
   26315 		}
   26316 		i0 := x0.AuxInt
   26317 		if x0.Aux != s {
   26318 			break
   26319 		}
   26320 		_ = x0.Args[2]
   26321 		if p != x0.Args[0] {
   26322 			break
   26323 		}
   26324 		if idx != x0.Args[1] {
   26325 			break
   26326 		}
   26327 		if mem != x0.Args[2] {
   26328 			break
   26329 		}
   26330 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26331 			break
   26332 		}
   26333 		b = mergePoint(b, x0, x1)
   26334 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26335 		v.reset(OpCopy)
   26336 		v.AddArg(v0)
   26337 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26338 		v1.AuxInt = j1
   26339 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26340 		v2.AuxInt = i0
   26341 		v2.Aux = s
   26342 		v2.AddArg(p)
   26343 		v2.AddArg(idx)
   26344 		v2.AddArg(mem)
   26345 		v1.AddArg(v2)
   26346 		v0.AddArg(v1)
   26347 		v0.AddArg(y)
   26348 		return true
   26349 	}
   26350 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   26351 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26352 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26353 	for {
   26354 		_ = v.Args[1]
   26355 		or := v.Args[0]
   26356 		if or.Op != OpS390XOR {
   26357 			break
   26358 		}
   26359 		_ = or.Args[1]
   26360 		s1 := or.Args[0]
   26361 		if s1.Op != OpS390XSLDconst {
   26362 			break
   26363 		}
   26364 		j1 := s1.AuxInt
   26365 		x1 := s1.Args[0]
   26366 		if x1.Op != OpS390XMOVHZloadidx {
   26367 			break
   26368 		}
   26369 		i1 := x1.AuxInt
   26370 		s := x1.Aux
   26371 		_ = x1.Args[2]
   26372 		p := x1.Args[0]
   26373 		idx := x1.Args[1]
   26374 		mem := x1.Args[2]
   26375 		y := or.Args[1]
   26376 		s0 := v.Args[1]
   26377 		if s0.Op != OpS390XSLDconst {
   26378 			break
   26379 		}
   26380 		j0 := s0.AuxInt
   26381 		x0 := s0.Args[0]
   26382 		if x0.Op != OpS390XMOVHZloadidx {
   26383 			break
   26384 		}
   26385 		i0 := x0.AuxInt
   26386 		if x0.Aux != s {
   26387 			break
   26388 		}
   26389 		_ = x0.Args[2]
   26390 		if idx != x0.Args[0] {
   26391 			break
   26392 		}
   26393 		if p != x0.Args[1] {
   26394 			break
   26395 		}
   26396 		if mem != x0.Args[2] {
   26397 			break
   26398 		}
   26399 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26400 			break
   26401 		}
   26402 		b = mergePoint(b, x0, x1)
   26403 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26404 		v.reset(OpCopy)
   26405 		v.AddArg(v0)
   26406 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26407 		v1.AuxInt = j1
   26408 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26409 		v2.AuxInt = i0
   26410 		v2.Aux = s
   26411 		v2.AddArg(p)
   26412 		v2.AddArg(idx)
   26413 		v2.AddArg(mem)
   26414 		v1.AddArg(v2)
   26415 		v0.AddArg(v1)
   26416 		v0.AddArg(y)
   26417 		return true
   26418 	}
   26419 	// match: (OR or:(OR s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem)) y) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   26420 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26421 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26422 	for {
   26423 		_ = v.Args[1]
   26424 		or := v.Args[0]
   26425 		if or.Op != OpS390XOR {
   26426 			break
   26427 		}
   26428 		_ = or.Args[1]
   26429 		s1 := or.Args[0]
   26430 		if s1.Op != OpS390XSLDconst {
   26431 			break
   26432 		}
   26433 		j1 := s1.AuxInt
   26434 		x1 := s1.Args[0]
   26435 		if x1.Op != OpS390XMOVHZloadidx {
   26436 			break
   26437 		}
   26438 		i1 := x1.AuxInt
   26439 		s := x1.Aux
   26440 		_ = x1.Args[2]
   26441 		idx := x1.Args[0]
   26442 		p := x1.Args[1]
   26443 		mem := x1.Args[2]
   26444 		y := or.Args[1]
   26445 		s0 := v.Args[1]
   26446 		if s0.Op != OpS390XSLDconst {
   26447 			break
   26448 		}
   26449 		j0 := s0.AuxInt
   26450 		x0 := s0.Args[0]
   26451 		if x0.Op != OpS390XMOVHZloadidx {
   26452 			break
   26453 		}
   26454 		i0 := x0.AuxInt
   26455 		if x0.Aux != s {
   26456 			break
   26457 		}
   26458 		_ = x0.Args[2]
   26459 		if idx != x0.Args[0] {
   26460 			break
   26461 		}
   26462 		if p != x0.Args[1] {
   26463 			break
   26464 		}
   26465 		if mem != x0.Args[2] {
   26466 			break
   26467 		}
   26468 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26469 			break
   26470 		}
   26471 		b = mergePoint(b, x0, x1)
   26472 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26473 		v.reset(OpCopy)
   26474 		v.AddArg(v0)
   26475 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26476 		v1.AuxInt = j1
   26477 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26478 		v2.AuxInt = i0
   26479 		v2.Aux = s
   26480 		v2.AddArg(p)
   26481 		v2.AddArg(idx)
   26482 		v2.AddArg(mem)
   26483 		v1.AddArg(v2)
   26484 		v0.AddArg(v1)
   26485 		v0.AddArg(y)
   26486 		return true
   26487 	}
   26488 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   26489 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26490 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26491 	for {
   26492 		_ = v.Args[1]
   26493 		or := v.Args[0]
   26494 		if or.Op != OpS390XOR {
   26495 			break
   26496 		}
   26497 		_ = or.Args[1]
   26498 		y := or.Args[0]
   26499 		s1 := or.Args[1]
   26500 		if s1.Op != OpS390XSLDconst {
   26501 			break
   26502 		}
   26503 		j1 := s1.AuxInt
   26504 		x1 := s1.Args[0]
   26505 		if x1.Op != OpS390XMOVHZloadidx {
   26506 			break
   26507 		}
   26508 		i1 := x1.AuxInt
   26509 		s := x1.Aux
   26510 		_ = x1.Args[2]
   26511 		p := x1.Args[0]
   26512 		idx := x1.Args[1]
   26513 		mem := x1.Args[2]
   26514 		s0 := v.Args[1]
   26515 		if s0.Op != OpS390XSLDconst {
   26516 			break
   26517 		}
   26518 		j0 := s0.AuxInt
   26519 		x0 := s0.Args[0]
   26520 		if x0.Op != OpS390XMOVHZloadidx {
   26521 			break
   26522 		}
   26523 		i0 := x0.AuxInt
   26524 		if x0.Aux != s {
   26525 			break
   26526 		}
   26527 		_ = x0.Args[2]
   26528 		if idx != x0.Args[0] {
   26529 			break
   26530 		}
   26531 		if p != x0.Args[1] {
   26532 			break
   26533 		}
   26534 		if mem != x0.Args[2] {
   26535 			break
   26536 		}
   26537 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26538 			break
   26539 		}
   26540 		b = mergePoint(b, x0, x1)
   26541 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26542 		v.reset(OpCopy)
   26543 		v.AddArg(v0)
   26544 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26545 		v1.AuxInt = j1
   26546 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26547 		v2.AuxInt = i0
   26548 		v2.Aux = s
   26549 		v2.AddArg(p)
   26550 		v2.AddArg(idx)
   26551 		v2.AddArg(mem)
   26552 		v1.AddArg(v2)
   26553 		v0.AddArg(v1)
   26554 		v0.AddArg(y)
   26555 		return true
   26556 	}
   26557 	// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   26558 	// cond: i1 == i0+2   && j1 == j0-16   && j1 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26559 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
   26560 	for {
   26561 		_ = v.Args[1]
   26562 		or := v.Args[0]
   26563 		if or.Op != OpS390XOR {
   26564 			break
   26565 		}
   26566 		_ = or.Args[1]
   26567 		y := or.Args[0]
   26568 		s1 := or.Args[1]
   26569 		if s1.Op != OpS390XSLDconst {
   26570 			break
   26571 		}
   26572 		j1 := s1.AuxInt
   26573 		x1 := s1.Args[0]
   26574 		if x1.Op != OpS390XMOVHZloadidx {
   26575 			break
   26576 		}
   26577 		i1 := x1.AuxInt
   26578 		s := x1.Aux
   26579 		_ = x1.Args[2]
   26580 		idx := x1.Args[0]
   26581 		p := x1.Args[1]
   26582 		mem := x1.Args[2]
   26583 		s0 := v.Args[1]
   26584 		if s0.Op != OpS390XSLDconst {
   26585 			break
   26586 		}
   26587 		j0 := s0.AuxInt
   26588 		x0 := s0.Args[0]
   26589 		if x0.Op != OpS390XMOVHZloadidx {
   26590 			break
   26591 		}
   26592 		i0 := x0.AuxInt
   26593 		if x0.Aux != s {
   26594 			break
   26595 		}
   26596 		_ = x0.Args[2]
   26597 		if idx != x0.Args[0] {
   26598 			break
   26599 		}
   26600 		if p != x0.Args[1] {
   26601 			break
   26602 		}
   26603 		if mem != x0.Args[2] {
   26604 			break
   26605 		}
   26606 		if !(i1 == i0+2 && j1 == j0-16 && j1%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   26607 			break
   26608 		}
   26609 		b = mergePoint(b, x0, x1)
   26610 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   26611 		v.reset(OpCopy)
   26612 		v.AddArg(v0)
   26613 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   26614 		v1.AuxInt = j1
   26615 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   26616 		v2.AuxInt = i0
   26617 		v2.Aux = s
   26618 		v2.AddArg(p)
   26619 		v2.AddArg(idx)
   26620 		v2.AddArg(mem)
   26621 		v1.AddArg(v2)
   26622 		v0.AddArg(v1)
   26623 		v0.AddArg(y)
   26624 		return true
   26625 	}
   26626 	// match: (OR x0:(MOVBZload [i0] {s} p mem) sh:(SLDconst [8] x1:(MOVBZload [i1] {s} p mem)))
   26627 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   26628 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
   26629 	for {
   26630 		_ = v.Args[1]
   26631 		x0 := v.Args[0]
   26632 		if x0.Op != OpS390XMOVBZload {
   26633 			break
   26634 		}
   26635 		i0 := x0.AuxInt
   26636 		s := x0.Aux
   26637 		_ = x0.Args[1]
   26638 		p := x0.Args[0]
   26639 		mem := x0.Args[1]
   26640 		sh := v.Args[1]
   26641 		if sh.Op != OpS390XSLDconst {
   26642 			break
   26643 		}
   26644 		if sh.AuxInt != 8 {
   26645 			break
   26646 		}
   26647 		x1 := sh.Args[0]
   26648 		if x1.Op != OpS390XMOVBZload {
   26649 			break
   26650 		}
   26651 		i1 := x1.AuxInt
   26652 		if x1.Aux != s {
   26653 			break
   26654 		}
   26655 		_ = x1.Args[1]
   26656 		if p != x1.Args[0] {
   26657 			break
   26658 		}
   26659 		if mem != x1.Args[1] {
   26660 			break
   26661 		}
   26662 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   26663 			break
   26664 		}
   26665 		b = mergePoint(b, x0, x1)
   26666 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   26667 		v.reset(OpCopy)
   26668 		v.AddArg(v0)
   26669 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   26670 		v1.AuxInt = i0
   26671 		v1.Aux = s
   26672 		v1.AddArg(p)
   26673 		v1.AddArg(mem)
   26674 		v0.AddArg(v1)
   26675 		return true
   26676 	}
   26677 	// match: (OR sh:(SLDconst [8] x1:(MOVBZload [i1] {s} p mem)) x0:(MOVBZload [i0] {s} p mem))
   26678 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   26679 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
   26680 	for {
   26681 		_ = v.Args[1]
   26682 		sh := v.Args[0]
   26683 		if sh.Op != OpS390XSLDconst {
   26684 			break
   26685 		}
   26686 		if sh.AuxInt != 8 {
   26687 			break
   26688 		}
   26689 		x1 := sh.Args[0]
   26690 		if x1.Op != OpS390XMOVBZload {
   26691 			break
   26692 		}
   26693 		i1 := x1.AuxInt
   26694 		s := x1.Aux
   26695 		_ = x1.Args[1]
   26696 		p := x1.Args[0]
   26697 		mem := x1.Args[1]
   26698 		x0 := v.Args[1]
   26699 		if x0.Op != OpS390XMOVBZload {
   26700 			break
   26701 		}
   26702 		i0 := x0.AuxInt
   26703 		if x0.Aux != s {
   26704 			break
   26705 		}
   26706 		_ = x0.Args[1]
   26707 		if p != x0.Args[0] {
   26708 			break
   26709 		}
   26710 		if mem != x0.Args[1] {
   26711 			break
   26712 		}
   26713 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   26714 			break
   26715 		}
   26716 		b = mergePoint(b, x0, x1)
   26717 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   26718 		v.reset(OpCopy)
   26719 		v.AddArg(v0)
   26720 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   26721 		v1.AuxInt = i0
   26722 		v1.Aux = s
   26723 		v1.AddArg(p)
   26724 		v1.AddArg(mem)
   26725 		v0.AddArg(v1)
   26726 		return true
   26727 	}
   26728 	// match: (OR r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
   26729 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   26730 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRload [i0] {s} p mem))
   26731 	for {
   26732 		_ = v.Args[1]
   26733 		r0 := v.Args[0]
   26734 		if r0.Op != OpS390XMOVHZreg {
   26735 			break
   26736 		}
   26737 		x0 := r0.Args[0]
   26738 		if x0.Op != OpS390XMOVHBRload {
   26739 			break
   26740 		}
   26741 		i0 := x0.AuxInt
   26742 		s := x0.Aux
   26743 		_ = x0.Args[1]
   26744 		p := x0.Args[0]
   26745 		mem := x0.Args[1]
   26746 		sh := v.Args[1]
   26747 		if sh.Op != OpS390XSLDconst {
   26748 			break
   26749 		}
   26750 		if sh.AuxInt != 16 {
   26751 			break
   26752 		}
   26753 		r1 := sh.Args[0]
   26754 		if r1.Op != OpS390XMOVHZreg {
   26755 			break
   26756 		}
   26757 		x1 := r1.Args[0]
   26758 		if x1.Op != OpS390XMOVHBRload {
   26759 			break
   26760 		}
   26761 		i1 := x1.AuxInt
   26762 		if x1.Aux != s {
   26763 			break
   26764 		}
   26765 		_ = x1.Args[1]
   26766 		if p != x1.Args[0] {
   26767 			break
   26768 		}
   26769 		if mem != x1.Args[1] {
   26770 			break
   26771 		}
   26772 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   26773 			break
   26774 		}
   26775 		b = mergePoint(b, x0, x1)
   26776 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   26777 		v.reset(OpCopy)
   26778 		v.AddArg(v0)
   26779 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   26780 		v1.AuxInt = i0
   26781 		v1.Aux = s
   26782 		v1.AddArg(p)
   26783 		v1.AddArg(mem)
   26784 		v0.AddArg(v1)
   26785 		return true
   26786 	}
   26787 	return false
   26788 }
   26789 func rewriteValueS390X_OpS390XOR_90(v *Value) bool {
   26790 	b := v.Block
   26791 	_ = b
   26792 	typ := &b.Func.Config.Types
   26793 	_ = typ
   26794 	// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))
   26795 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   26796 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRload [i0] {s} p mem))
   26797 	for {
   26798 		_ = v.Args[1]
   26799 		sh := v.Args[0]
   26800 		if sh.Op != OpS390XSLDconst {
   26801 			break
   26802 		}
   26803 		if sh.AuxInt != 16 {
   26804 			break
   26805 		}
   26806 		r1 := sh.Args[0]
   26807 		if r1.Op != OpS390XMOVHZreg {
   26808 			break
   26809 		}
   26810 		x1 := r1.Args[0]
   26811 		if x1.Op != OpS390XMOVHBRload {
   26812 			break
   26813 		}
   26814 		i1 := x1.AuxInt
   26815 		s := x1.Aux
   26816 		_ = x1.Args[1]
   26817 		p := x1.Args[0]
   26818 		mem := x1.Args[1]
   26819 		r0 := v.Args[1]
   26820 		if r0.Op != OpS390XMOVHZreg {
   26821 			break
   26822 		}
   26823 		x0 := r0.Args[0]
   26824 		if x0.Op != OpS390XMOVHBRload {
   26825 			break
   26826 		}
   26827 		i0 := x0.AuxInt
   26828 		if x0.Aux != s {
   26829 			break
   26830 		}
   26831 		_ = x0.Args[1]
   26832 		if p != x0.Args[0] {
   26833 			break
   26834 		}
   26835 		if mem != x0.Args[1] {
   26836 			break
   26837 		}
   26838 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   26839 			break
   26840 		}
   26841 		b = mergePoint(b, x0, x1)
   26842 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   26843 		v.reset(OpCopy)
   26844 		v.AddArg(v0)
   26845 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   26846 		v1.AuxInt = i0
   26847 		v1.Aux = s
   26848 		v1.AddArg(p)
   26849 		v1.AddArg(mem)
   26850 		v0.AddArg(v1)
   26851 		return true
   26852 	}
   26853 	// match: (OR r0:(MOVWZreg x0:(MOVWBRload [i0] {s} p mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRload [i1] {s} p mem))))
   26854 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   26855 	// result: @mergePoint(b,x0,x1) (MOVDBRload [i0] {s} p mem)
   26856 	for {
   26857 		_ = v.Args[1]
   26858 		r0 := v.Args[0]
   26859 		if r0.Op != OpS390XMOVWZreg {
   26860 			break
   26861 		}
   26862 		x0 := r0.Args[0]
   26863 		if x0.Op != OpS390XMOVWBRload {
   26864 			break
   26865 		}
   26866 		i0 := x0.AuxInt
   26867 		s := x0.Aux
   26868 		_ = x0.Args[1]
   26869 		p := x0.Args[0]
   26870 		mem := x0.Args[1]
   26871 		sh := v.Args[1]
   26872 		if sh.Op != OpS390XSLDconst {
   26873 			break
   26874 		}
   26875 		if sh.AuxInt != 32 {
   26876 			break
   26877 		}
   26878 		r1 := sh.Args[0]
   26879 		if r1.Op != OpS390XMOVWZreg {
   26880 			break
   26881 		}
   26882 		x1 := r1.Args[0]
   26883 		if x1.Op != OpS390XMOVWBRload {
   26884 			break
   26885 		}
   26886 		i1 := x1.AuxInt
   26887 		if x1.Aux != s {
   26888 			break
   26889 		}
   26890 		_ = x1.Args[1]
   26891 		if p != x1.Args[0] {
   26892 			break
   26893 		}
   26894 		if mem != x1.Args[1] {
   26895 			break
   26896 		}
   26897 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   26898 			break
   26899 		}
   26900 		b = mergePoint(b, x0, x1)
   26901 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRload, typ.UInt64)
   26902 		v.reset(OpCopy)
   26903 		v.AddArg(v0)
   26904 		v0.AuxInt = i0
   26905 		v0.Aux = s
   26906 		v0.AddArg(p)
   26907 		v0.AddArg(mem)
   26908 		return true
   26909 	}
   26910 	// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRload [i1] {s} p mem))) r0:(MOVWZreg x0:(MOVWBRload [i0] {s} p mem)))
   26911 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   26912 	// result: @mergePoint(b,x0,x1) (MOVDBRload [i0] {s} p mem)
   26913 	for {
   26914 		_ = v.Args[1]
   26915 		sh := v.Args[0]
   26916 		if sh.Op != OpS390XSLDconst {
   26917 			break
   26918 		}
   26919 		if sh.AuxInt != 32 {
   26920 			break
   26921 		}
   26922 		r1 := sh.Args[0]
   26923 		if r1.Op != OpS390XMOVWZreg {
   26924 			break
   26925 		}
   26926 		x1 := r1.Args[0]
   26927 		if x1.Op != OpS390XMOVWBRload {
   26928 			break
   26929 		}
   26930 		i1 := x1.AuxInt
   26931 		s := x1.Aux
   26932 		_ = x1.Args[1]
   26933 		p := x1.Args[0]
   26934 		mem := x1.Args[1]
   26935 		r0 := v.Args[1]
   26936 		if r0.Op != OpS390XMOVWZreg {
   26937 			break
   26938 		}
   26939 		x0 := r0.Args[0]
   26940 		if x0.Op != OpS390XMOVWBRload {
   26941 			break
   26942 		}
   26943 		i0 := x0.AuxInt
   26944 		if x0.Aux != s {
   26945 			break
   26946 		}
   26947 		_ = x0.Args[1]
   26948 		if p != x0.Args[0] {
   26949 			break
   26950 		}
   26951 		if mem != x0.Args[1] {
   26952 			break
   26953 		}
   26954 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   26955 			break
   26956 		}
   26957 		b = mergePoint(b, x0, x1)
   26958 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRload, typ.UInt64)
   26959 		v.reset(OpCopy)
   26960 		v.AddArg(v0)
   26961 		v0.AuxInt = i0
   26962 		v0.Aux = s
   26963 		v0.AddArg(p)
   26964 		v0.AddArg(mem)
   26965 		return true
   26966 	}
   26967 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) y))
   26968 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   26969 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   26970 	for {
   26971 		_ = v.Args[1]
   26972 		s1 := v.Args[0]
   26973 		if s1.Op != OpS390XSLDconst {
   26974 			break
   26975 		}
   26976 		j1 := s1.AuxInt
   26977 		x1 := s1.Args[0]
   26978 		if x1.Op != OpS390XMOVBZload {
   26979 			break
   26980 		}
   26981 		i1 := x1.AuxInt
   26982 		s := x1.Aux
   26983 		_ = x1.Args[1]
   26984 		p := x1.Args[0]
   26985 		mem := x1.Args[1]
   26986 		or := v.Args[1]
   26987 		if or.Op != OpS390XOR {
   26988 			break
   26989 		}
   26990 		_ = or.Args[1]
   26991 		s0 := or.Args[0]
   26992 		if s0.Op != OpS390XSLDconst {
   26993 			break
   26994 		}
   26995 		j0 := s0.AuxInt
   26996 		x0 := s0.Args[0]
   26997 		if x0.Op != OpS390XMOVBZload {
   26998 			break
   26999 		}
   27000 		i0 := x0.AuxInt
   27001 		if x0.Aux != s {
   27002 			break
   27003 		}
   27004 		_ = x0.Args[1]
   27005 		if p != x0.Args[0] {
   27006 			break
   27007 		}
   27008 		if mem != x0.Args[1] {
   27009 			break
   27010 		}
   27011 		y := or.Args[1]
   27012 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27013 			break
   27014 		}
   27015 		b = mergePoint(b, x0, x1)
   27016 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27017 		v.reset(OpCopy)
   27018 		v.AddArg(v0)
   27019 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27020 		v1.AuxInt = j0
   27021 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27022 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   27023 		v3.AuxInt = i0
   27024 		v3.Aux = s
   27025 		v3.AddArg(p)
   27026 		v3.AddArg(mem)
   27027 		v2.AddArg(v3)
   27028 		v1.AddArg(v2)
   27029 		v0.AddArg(v1)
   27030 		v0.AddArg(y)
   27031 		return true
   27032 	}
   27033 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))))
   27034 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27035 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   27036 	for {
   27037 		_ = v.Args[1]
   27038 		s1 := v.Args[0]
   27039 		if s1.Op != OpS390XSLDconst {
   27040 			break
   27041 		}
   27042 		j1 := s1.AuxInt
   27043 		x1 := s1.Args[0]
   27044 		if x1.Op != OpS390XMOVBZload {
   27045 			break
   27046 		}
   27047 		i1 := x1.AuxInt
   27048 		s := x1.Aux
   27049 		_ = x1.Args[1]
   27050 		p := x1.Args[0]
   27051 		mem := x1.Args[1]
   27052 		or := v.Args[1]
   27053 		if or.Op != OpS390XOR {
   27054 			break
   27055 		}
   27056 		_ = or.Args[1]
   27057 		y := or.Args[0]
   27058 		s0 := or.Args[1]
   27059 		if s0.Op != OpS390XSLDconst {
   27060 			break
   27061 		}
   27062 		j0 := s0.AuxInt
   27063 		x0 := s0.Args[0]
   27064 		if x0.Op != OpS390XMOVBZload {
   27065 			break
   27066 		}
   27067 		i0 := x0.AuxInt
   27068 		if x0.Aux != s {
   27069 			break
   27070 		}
   27071 		_ = x0.Args[1]
   27072 		if p != x0.Args[0] {
   27073 			break
   27074 		}
   27075 		if mem != x0.Args[1] {
   27076 			break
   27077 		}
   27078 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27079 			break
   27080 		}
   27081 		b = mergePoint(b, x0, x1)
   27082 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27083 		v.reset(OpCopy)
   27084 		v.AddArg(v0)
   27085 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27086 		v1.AuxInt = j0
   27087 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27088 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   27089 		v3.AuxInt = i0
   27090 		v3.Aux = s
   27091 		v3.AddArg(p)
   27092 		v3.AddArg(mem)
   27093 		v2.AddArg(v3)
   27094 		v1.AddArg(v2)
   27095 		v0.AddArg(v1)
   27096 		v0.AddArg(y)
   27097 		return true
   27098 	}
   27099 	// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)) y) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
   27100 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27101 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   27102 	for {
   27103 		_ = v.Args[1]
   27104 		or := v.Args[0]
   27105 		if or.Op != OpS390XOR {
   27106 			break
   27107 		}
   27108 		_ = or.Args[1]
   27109 		s0 := or.Args[0]
   27110 		if s0.Op != OpS390XSLDconst {
   27111 			break
   27112 		}
   27113 		j0 := s0.AuxInt
   27114 		x0 := s0.Args[0]
   27115 		if x0.Op != OpS390XMOVBZload {
   27116 			break
   27117 		}
   27118 		i0 := x0.AuxInt
   27119 		s := x0.Aux
   27120 		_ = x0.Args[1]
   27121 		p := x0.Args[0]
   27122 		mem := x0.Args[1]
   27123 		y := or.Args[1]
   27124 		s1 := v.Args[1]
   27125 		if s1.Op != OpS390XSLDconst {
   27126 			break
   27127 		}
   27128 		j1 := s1.AuxInt
   27129 		x1 := s1.Args[0]
   27130 		if x1.Op != OpS390XMOVBZload {
   27131 			break
   27132 		}
   27133 		i1 := x1.AuxInt
   27134 		if x1.Aux != s {
   27135 			break
   27136 		}
   27137 		_ = x1.Args[1]
   27138 		if p != x1.Args[0] {
   27139 			break
   27140 		}
   27141 		if mem != x1.Args[1] {
   27142 			break
   27143 		}
   27144 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27145 			break
   27146 		}
   27147 		b = mergePoint(b, x0, x1)
   27148 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27149 		v.reset(OpCopy)
   27150 		v.AddArg(v0)
   27151 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27152 		v1.AuxInt = j0
   27153 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27154 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   27155 		v3.AuxInt = i0
   27156 		v3.Aux = s
   27157 		v3.AddArg(p)
   27158 		v3.AddArg(mem)
   27159 		v2.AddArg(v3)
   27160 		v1.AddArg(v2)
   27161 		v0.AddArg(v1)
   27162 		v0.AddArg(y)
   27163 		return true
   27164 	}
   27165 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
   27166 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27167 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   27168 	for {
   27169 		_ = v.Args[1]
   27170 		or := v.Args[0]
   27171 		if or.Op != OpS390XOR {
   27172 			break
   27173 		}
   27174 		_ = or.Args[1]
   27175 		y := or.Args[0]
   27176 		s0 := or.Args[1]
   27177 		if s0.Op != OpS390XSLDconst {
   27178 			break
   27179 		}
   27180 		j0 := s0.AuxInt
   27181 		x0 := s0.Args[0]
   27182 		if x0.Op != OpS390XMOVBZload {
   27183 			break
   27184 		}
   27185 		i0 := x0.AuxInt
   27186 		s := x0.Aux
   27187 		_ = x0.Args[1]
   27188 		p := x0.Args[0]
   27189 		mem := x0.Args[1]
   27190 		s1 := v.Args[1]
   27191 		if s1.Op != OpS390XSLDconst {
   27192 			break
   27193 		}
   27194 		j1 := s1.AuxInt
   27195 		x1 := s1.Args[0]
   27196 		if x1.Op != OpS390XMOVBZload {
   27197 			break
   27198 		}
   27199 		i1 := x1.AuxInt
   27200 		if x1.Aux != s {
   27201 			break
   27202 		}
   27203 		_ = x1.Args[1]
   27204 		if p != x1.Args[0] {
   27205 			break
   27206 		}
   27207 		if mem != x1.Args[1] {
   27208 			break
   27209 		}
   27210 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27211 			break
   27212 		}
   27213 		b = mergePoint(b, x0, x1)
   27214 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27215 		v.reset(OpCopy)
   27216 		v.AddArg(v0)
   27217 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27218 		v1.AuxInt = j0
   27219 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27220 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   27221 		v3.AuxInt = i0
   27222 		v3.Aux = s
   27223 		v3.AddArg(p)
   27224 		v3.AddArg(mem)
   27225 		v2.AddArg(v3)
   27226 		v1.AddArg(v2)
   27227 		v0.AddArg(v1)
   27228 		v0.AddArg(y)
   27229 		return true
   27230 	}
   27231 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem))) y))
   27232 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27233 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
   27234 	for {
   27235 		_ = v.Args[1]
   27236 		s1 := v.Args[0]
   27237 		if s1.Op != OpS390XSLDconst {
   27238 			break
   27239 		}
   27240 		j1 := s1.AuxInt
   27241 		r1 := s1.Args[0]
   27242 		if r1.Op != OpS390XMOVHZreg {
   27243 			break
   27244 		}
   27245 		x1 := r1.Args[0]
   27246 		if x1.Op != OpS390XMOVHBRload {
   27247 			break
   27248 		}
   27249 		i1 := x1.AuxInt
   27250 		s := x1.Aux
   27251 		_ = x1.Args[1]
   27252 		p := x1.Args[0]
   27253 		mem := x1.Args[1]
   27254 		or := v.Args[1]
   27255 		if or.Op != OpS390XOR {
   27256 			break
   27257 		}
   27258 		_ = or.Args[1]
   27259 		s0 := or.Args[0]
   27260 		if s0.Op != OpS390XSLDconst {
   27261 			break
   27262 		}
   27263 		j0 := s0.AuxInt
   27264 		r0 := s0.Args[0]
   27265 		if r0.Op != OpS390XMOVHZreg {
   27266 			break
   27267 		}
   27268 		x0 := r0.Args[0]
   27269 		if x0.Op != OpS390XMOVHBRload {
   27270 			break
   27271 		}
   27272 		i0 := x0.AuxInt
   27273 		if x0.Aux != s {
   27274 			break
   27275 		}
   27276 		_ = x0.Args[1]
   27277 		if p != x0.Args[0] {
   27278 			break
   27279 		}
   27280 		if mem != x0.Args[1] {
   27281 			break
   27282 		}
   27283 		y := or.Args[1]
   27284 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27285 			break
   27286 		}
   27287 		b = mergePoint(b, x0, x1)
   27288 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27289 		v.reset(OpCopy)
   27290 		v.AddArg(v0)
   27291 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27292 		v1.AuxInt = j0
   27293 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   27294 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   27295 		v3.AuxInt = i0
   27296 		v3.Aux = s
   27297 		v3.AddArg(p)
   27298 		v3.AddArg(mem)
   27299 		v2.AddArg(v3)
   27300 		v1.AddArg(v2)
   27301 		v0.AddArg(v1)
   27302 		v0.AddArg(y)
   27303 		return true
   27304 	}
   27305 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))))
   27306 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27307 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
   27308 	for {
   27309 		_ = v.Args[1]
   27310 		s1 := v.Args[0]
   27311 		if s1.Op != OpS390XSLDconst {
   27312 			break
   27313 		}
   27314 		j1 := s1.AuxInt
   27315 		r1 := s1.Args[0]
   27316 		if r1.Op != OpS390XMOVHZreg {
   27317 			break
   27318 		}
   27319 		x1 := r1.Args[0]
   27320 		if x1.Op != OpS390XMOVHBRload {
   27321 			break
   27322 		}
   27323 		i1 := x1.AuxInt
   27324 		s := x1.Aux
   27325 		_ = x1.Args[1]
   27326 		p := x1.Args[0]
   27327 		mem := x1.Args[1]
   27328 		or := v.Args[1]
   27329 		if or.Op != OpS390XOR {
   27330 			break
   27331 		}
   27332 		_ = or.Args[1]
   27333 		y := or.Args[0]
   27334 		s0 := or.Args[1]
   27335 		if s0.Op != OpS390XSLDconst {
   27336 			break
   27337 		}
   27338 		j0 := s0.AuxInt
   27339 		r0 := s0.Args[0]
   27340 		if r0.Op != OpS390XMOVHZreg {
   27341 			break
   27342 		}
   27343 		x0 := r0.Args[0]
   27344 		if x0.Op != OpS390XMOVHBRload {
   27345 			break
   27346 		}
   27347 		i0 := x0.AuxInt
   27348 		if x0.Aux != s {
   27349 			break
   27350 		}
   27351 		_ = x0.Args[1]
   27352 		if p != x0.Args[0] {
   27353 			break
   27354 		}
   27355 		if mem != x0.Args[1] {
   27356 			break
   27357 		}
   27358 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27359 			break
   27360 		}
   27361 		b = mergePoint(b, x0, x1)
   27362 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27363 		v.reset(OpCopy)
   27364 		v.AddArg(v0)
   27365 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27366 		v1.AuxInt = j0
   27367 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   27368 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   27369 		v3.AuxInt = i0
   27370 		v3.Aux = s
   27371 		v3.AddArg(p)
   27372 		v3.AddArg(mem)
   27373 		v2.AddArg(v3)
   27374 		v1.AddArg(v2)
   27375 		v0.AddArg(v1)
   27376 		v0.AddArg(y)
   27377 		return true
   27378 	}
   27379 	// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
   27380 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27381 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
   27382 	for {
   27383 		_ = v.Args[1]
   27384 		or := v.Args[0]
   27385 		if or.Op != OpS390XOR {
   27386 			break
   27387 		}
   27388 		_ = or.Args[1]
   27389 		s0 := or.Args[0]
   27390 		if s0.Op != OpS390XSLDconst {
   27391 			break
   27392 		}
   27393 		j0 := s0.AuxInt
   27394 		r0 := s0.Args[0]
   27395 		if r0.Op != OpS390XMOVHZreg {
   27396 			break
   27397 		}
   27398 		x0 := r0.Args[0]
   27399 		if x0.Op != OpS390XMOVHBRload {
   27400 			break
   27401 		}
   27402 		i0 := x0.AuxInt
   27403 		s := x0.Aux
   27404 		_ = x0.Args[1]
   27405 		p := x0.Args[0]
   27406 		mem := x0.Args[1]
   27407 		y := or.Args[1]
   27408 		s1 := v.Args[1]
   27409 		if s1.Op != OpS390XSLDconst {
   27410 			break
   27411 		}
   27412 		j1 := s1.AuxInt
   27413 		r1 := s1.Args[0]
   27414 		if r1.Op != OpS390XMOVHZreg {
   27415 			break
   27416 		}
   27417 		x1 := r1.Args[0]
   27418 		if x1.Op != OpS390XMOVHBRload {
   27419 			break
   27420 		}
   27421 		i1 := x1.AuxInt
   27422 		if x1.Aux != s {
   27423 			break
   27424 		}
   27425 		_ = x1.Args[1]
   27426 		if p != x1.Args[0] {
   27427 			break
   27428 		}
   27429 		if mem != x1.Args[1] {
   27430 			break
   27431 		}
   27432 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27433 			break
   27434 		}
   27435 		b = mergePoint(b, x0, x1)
   27436 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27437 		v.reset(OpCopy)
   27438 		v.AddArg(v0)
   27439 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27440 		v1.AuxInt = j0
   27441 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   27442 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   27443 		v3.AuxInt = i0
   27444 		v3.Aux = s
   27445 		v3.AddArg(p)
   27446 		v3.AddArg(mem)
   27447 		v2.AddArg(v3)
   27448 		v1.AddArg(v2)
   27449 		v0.AddArg(v1)
   27450 		v0.AddArg(y)
   27451 		return true
   27452 	}
   27453 	return false
   27454 }
   27455 func rewriteValueS390X_OpS390XOR_100(v *Value) bool {
   27456 	b := v.Block
   27457 	_ = b
   27458 	typ := &b.Func.Config.Types
   27459 	_ = typ
   27460 	// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
   27461 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   27462 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRload [i0] {s} p mem))) y)
   27463 	for {
   27464 		_ = v.Args[1]
   27465 		or := v.Args[0]
   27466 		if or.Op != OpS390XOR {
   27467 			break
   27468 		}
   27469 		_ = or.Args[1]
   27470 		y := or.Args[0]
   27471 		s0 := or.Args[1]
   27472 		if s0.Op != OpS390XSLDconst {
   27473 			break
   27474 		}
   27475 		j0 := s0.AuxInt
   27476 		r0 := s0.Args[0]
   27477 		if r0.Op != OpS390XMOVHZreg {
   27478 			break
   27479 		}
   27480 		x0 := r0.Args[0]
   27481 		if x0.Op != OpS390XMOVHBRload {
   27482 			break
   27483 		}
   27484 		i0 := x0.AuxInt
   27485 		s := x0.Aux
   27486 		_ = x0.Args[1]
   27487 		p := x0.Args[0]
   27488 		mem := x0.Args[1]
   27489 		s1 := v.Args[1]
   27490 		if s1.Op != OpS390XSLDconst {
   27491 			break
   27492 		}
   27493 		j1 := s1.AuxInt
   27494 		r1 := s1.Args[0]
   27495 		if r1.Op != OpS390XMOVHZreg {
   27496 			break
   27497 		}
   27498 		x1 := r1.Args[0]
   27499 		if x1.Op != OpS390XMOVHBRload {
   27500 			break
   27501 		}
   27502 		i1 := x1.AuxInt
   27503 		if x1.Aux != s {
   27504 			break
   27505 		}
   27506 		_ = x1.Args[1]
   27507 		if p != x1.Args[0] {
   27508 			break
   27509 		}
   27510 		if mem != x1.Args[1] {
   27511 			break
   27512 		}
   27513 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   27514 			break
   27515 		}
   27516 		b = mergePoint(b, x0, x1)
   27517 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   27518 		v.reset(OpCopy)
   27519 		v.AddArg(v0)
   27520 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   27521 		v1.AuxInt = j0
   27522 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   27523 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   27524 		v3.AuxInt = i0
   27525 		v3.Aux = s
   27526 		v3.AddArg(p)
   27527 		v3.AddArg(mem)
   27528 		v2.AddArg(v3)
   27529 		v1.AddArg(v2)
   27530 		v0.AddArg(v1)
   27531 		v0.AddArg(y)
   27532 		return true
   27533 	}
   27534 	// match: (OR x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   27535 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27536 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27537 	for {
   27538 		_ = v.Args[1]
   27539 		x0 := v.Args[0]
   27540 		if x0.Op != OpS390XMOVBZloadidx {
   27541 			break
   27542 		}
   27543 		i0 := x0.AuxInt
   27544 		s := x0.Aux
   27545 		_ = x0.Args[2]
   27546 		p := x0.Args[0]
   27547 		idx := x0.Args[1]
   27548 		mem := x0.Args[2]
   27549 		sh := v.Args[1]
   27550 		if sh.Op != OpS390XSLDconst {
   27551 			break
   27552 		}
   27553 		if sh.AuxInt != 8 {
   27554 			break
   27555 		}
   27556 		x1 := sh.Args[0]
   27557 		if x1.Op != OpS390XMOVBZloadidx {
   27558 			break
   27559 		}
   27560 		i1 := x1.AuxInt
   27561 		if x1.Aux != s {
   27562 			break
   27563 		}
   27564 		_ = x1.Args[2]
   27565 		if p != x1.Args[0] {
   27566 			break
   27567 		}
   27568 		if idx != x1.Args[1] {
   27569 			break
   27570 		}
   27571 		if mem != x1.Args[2] {
   27572 			break
   27573 		}
   27574 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27575 			break
   27576 		}
   27577 		b = mergePoint(b, x0, x1)
   27578 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27579 		v.reset(OpCopy)
   27580 		v.AddArg(v0)
   27581 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27582 		v1.AuxInt = i0
   27583 		v1.Aux = s
   27584 		v1.AddArg(p)
   27585 		v1.AddArg(idx)
   27586 		v1.AddArg(mem)
   27587 		v0.AddArg(v1)
   27588 		return true
   27589 	}
   27590 	// match: (OR x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   27591 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27592 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27593 	for {
   27594 		_ = v.Args[1]
   27595 		x0 := v.Args[0]
   27596 		if x0.Op != OpS390XMOVBZloadidx {
   27597 			break
   27598 		}
   27599 		i0 := x0.AuxInt
   27600 		s := x0.Aux
   27601 		_ = x0.Args[2]
   27602 		idx := x0.Args[0]
   27603 		p := x0.Args[1]
   27604 		mem := x0.Args[2]
   27605 		sh := v.Args[1]
   27606 		if sh.Op != OpS390XSLDconst {
   27607 			break
   27608 		}
   27609 		if sh.AuxInt != 8 {
   27610 			break
   27611 		}
   27612 		x1 := sh.Args[0]
   27613 		if x1.Op != OpS390XMOVBZloadidx {
   27614 			break
   27615 		}
   27616 		i1 := x1.AuxInt
   27617 		if x1.Aux != s {
   27618 			break
   27619 		}
   27620 		_ = x1.Args[2]
   27621 		if p != x1.Args[0] {
   27622 			break
   27623 		}
   27624 		if idx != x1.Args[1] {
   27625 			break
   27626 		}
   27627 		if mem != x1.Args[2] {
   27628 			break
   27629 		}
   27630 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27631 			break
   27632 		}
   27633 		b = mergePoint(b, x0, x1)
   27634 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27635 		v.reset(OpCopy)
   27636 		v.AddArg(v0)
   27637 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27638 		v1.AuxInt = i0
   27639 		v1.Aux = s
   27640 		v1.AddArg(p)
   27641 		v1.AddArg(idx)
   27642 		v1.AddArg(mem)
   27643 		v0.AddArg(v1)
   27644 		return true
   27645 	}
   27646 	// match: (OR x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   27647 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27648 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27649 	for {
   27650 		_ = v.Args[1]
   27651 		x0 := v.Args[0]
   27652 		if x0.Op != OpS390XMOVBZloadidx {
   27653 			break
   27654 		}
   27655 		i0 := x0.AuxInt
   27656 		s := x0.Aux
   27657 		_ = x0.Args[2]
   27658 		p := x0.Args[0]
   27659 		idx := x0.Args[1]
   27660 		mem := x0.Args[2]
   27661 		sh := v.Args[1]
   27662 		if sh.Op != OpS390XSLDconst {
   27663 			break
   27664 		}
   27665 		if sh.AuxInt != 8 {
   27666 			break
   27667 		}
   27668 		x1 := sh.Args[0]
   27669 		if x1.Op != OpS390XMOVBZloadidx {
   27670 			break
   27671 		}
   27672 		i1 := x1.AuxInt
   27673 		if x1.Aux != s {
   27674 			break
   27675 		}
   27676 		_ = x1.Args[2]
   27677 		if idx != x1.Args[0] {
   27678 			break
   27679 		}
   27680 		if p != x1.Args[1] {
   27681 			break
   27682 		}
   27683 		if mem != x1.Args[2] {
   27684 			break
   27685 		}
   27686 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27687 			break
   27688 		}
   27689 		b = mergePoint(b, x0, x1)
   27690 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27691 		v.reset(OpCopy)
   27692 		v.AddArg(v0)
   27693 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27694 		v1.AuxInt = i0
   27695 		v1.Aux = s
   27696 		v1.AddArg(p)
   27697 		v1.AddArg(idx)
   27698 		v1.AddArg(mem)
   27699 		v0.AddArg(v1)
   27700 		return true
   27701 	}
   27702 	// match: (OR x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   27703 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27704 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27705 	for {
   27706 		_ = v.Args[1]
   27707 		x0 := v.Args[0]
   27708 		if x0.Op != OpS390XMOVBZloadidx {
   27709 			break
   27710 		}
   27711 		i0 := x0.AuxInt
   27712 		s := x0.Aux
   27713 		_ = x0.Args[2]
   27714 		idx := x0.Args[0]
   27715 		p := x0.Args[1]
   27716 		mem := x0.Args[2]
   27717 		sh := v.Args[1]
   27718 		if sh.Op != OpS390XSLDconst {
   27719 			break
   27720 		}
   27721 		if sh.AuxInt != 8 {
   27722 			break
   27723 		}
   27724 		x1 := sh.Args[0]
   27725 		if x1.Op != OpS390XMOVBZloadidx {
   27726 			break
   27727 		}
   27728 		i1 := x1.AuxInt
   27729 		if x1.Aux != s {
   27730 			break
   27731 		}
   27732 		_ = x1.Args[2]
   27733 		if idx != x1.Args[0] {
   27734 			break
   27735 		}
   27736 		if p != x1.Args[1] {
   27737 			break
   27738 		}
   27739 		if mem != x1.Args[2] {
   27740 			break
   27741 		}
   27742 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27743 			break
   27744 		}
   27745 		b = mergePoint(b, x0, x1)
   27746 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27747 		v.reset(OpCopy)
   27748 		v.AddArg(v0)
   27749 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27750 		v1.AuxInt = i0
   27751 		v1.Aux = s
   27752 		v1.AddArg(p)
   27753 		v1.AddArg(idx)
   27754 		v1.AddArg(mem)
   27755 		v0.AddArg(v1)
   27756 		return true
   27757 	}
   27758 	// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
   27759 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27760 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27761 	for {
   27762 		_ = v.Args[1]
   27763 		sh := v.Args[0]
   27764 		if sh.Op != OpS390XSLDconst {
   27765 			break
   27766 		}
   27767 		if sh.AuxInt != 8 {
   27768 			break
   27769 		}
   27770 		x1 := sh.Args[0]
   27771 		if x1.Op != OpS390XMOVBZloadidx {
   27772 			break
   27773 		}
   27774 		i1 := x1.AuxInt
   27775 		s := x1.Aux
   27776 		_ = x1.Args[2]
   27777 		p := x1.Args[0]
   27778 		idx := x1.Args[1]
   27779 		mem := x1.Args[2]
   27780 		x0 := v.Args[1]
   27781 		if x0.Op != OpS390XMOVBZloadidx {
   27782 			break
   27783 		}
   27784 		i0 := x0.AuxInt
   27785 		if x0.Aux != s {
   27786 			break
   27787 		}
   27788 		_ = x0.Args[2]
   27789 		if p != x0.Args[0] {
   27790 			break
   27791 		}
   27792 		if idx != x0.Args[1] {
   27793 			break
   27794 		}
   27795 		if mem != x0.Args[2] {
   27796 			break
   27797 		}
   27798 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27799 			break
   27800 		}
   27801 		b = mergePoint(b, x0, x1)
   27802 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27803 		v.reset(OpCopy)
   27804 		v.AddArg(v0)
   27805 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27806 		v1.AuxInt = i0
   27807 		v1.Aux = s
   27808 		v1.AddArg(p)
   27809 		v1.AddArg(idx)
   27810 		v1.AddArg(mem)
   27811 		v0.AddArg(v1)
   27812 		return true
   27813 	}
   27814 	// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
   27815 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27816 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27817 	for {
   27818 		_ = v.Args[1]
   27819 		sh := v.Args[0]
   27820 		if sh.Op != OpS390XSLDconst {
   27821 			break
   27822 		}
   27823 		if sh.AuxInt != 8 {
   27824 			break
   27825 		}
   27826 		x1 := sh.Args[0]
   27827 		if x1.Op != OpS390XMOVBZloadidx {
   27828 			break
   27829 		}
   27830 		i1 := x1.AuxInt
   27831 		s := x1.Aux
   27832 		_ = x1.Args[2]
   27833 		idx := x1.Args[0]
   27834 		p := x1.Args[1]
   27835 		mem := x1.Args[2]
   27836 		x0 := v.Args[1]
   27837 		if x0.Op != OpS390XMOVBZloadidx {
   27838 			break
   27839 		}
   27840 		i0 := x0.AuxInt
   27841 		if x0.Aux != s {
   27842 			break
   27843 		}
   27844 		_ = x0.Args[2]
   27845 		if p != x0.Args[0] {
   27846 			break
   27847 		}
   27848 		if idx != x0.Args[1] {
   27849 			break
   27850 		}
   27851 		if mem != x0.Args[2] {
   27852 			break
   27853 		}
   27854 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27855 			break
   27856 		}
   27857 		b = mergePoint(b, x0, x1)
   27858 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27859 		v.reset(OpCopy)
   27860 		v.AddArg(v0)
   27861 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27862 		v1.AuxInt = i0
   27863 		v1.Aux = s
   27864 		v1.AddArg(p)
   27865 		v1.AddArg(idx)
   27866 		v1.AddArg(mem)
   27867 		v0.AddArg(v1)
   27868 		return true
   27869 	}
   27870 	// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
   27871 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27872 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27873 	for {
   27874 		_ = v.Args[1]
   27875 		sh := v.Args[0]
   27876 		if sh.Op != OpS390XSLDconst {
   27877 			break
   27878 		}
   27879 		if sh.AuxInt != 8 {
   27880 			break
   27881 		}
   27882 		x1 := sh.Args[0]
   27883 		if x1.Op != OpS390XMOVBZloadidx {
   27884 			break
   27885 		}
   27886 		i1 := x1.AuxInt
   27887 		s := x1.Aux
   27888 		_ = x1.Args[2]
   27889 		p := x1.Args[0]
   27890 		idx := x1.Args[1]
   27891 		mem := x1.Args[2]
   27892 		x0 := v.Args[1]
   27893 		if x0.Op != OpS390XMOVBZloadidx {
   27894 			break
   27895 		}
   27896 		i0 := x0.AuxInt
   27897 		if x0.Aux != s {
   27898 			break
   27899 		}
   27900 		_ = x0.Args[2]
   27901 		if idx != x0.Args[0] {
   27902 			break
   27903 		}
   27904 		if p != x0.Args[1] {
   27905 			break
   27906 		}
   27907 		if mem != x0.Args[2] {
   27908 			break
   27909 		}
   27910 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27911 			break
   27912 		}
   27913 		b = mergePoint(b, x0, x1)
   27914 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27915 		v.reset(OpCopy)
   27916 		v.AddArg(v0)
   27917 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27918 		v1.AuxInt = i0
   27919 		v1.Aux = s
   27920 		v1.AddArg(p)
   27921 		v1.AddArg(idx)
   27922 		v1.AddArg(mem)
   27923 		v0.AddArg(v1)
   27924 		return true
   27925 	}
   27926 	// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
   27927 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   27928 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   27929 	for {
   27930 		_ = v.Args[1]
   27931 		sh := v.Args[0]
   27932 		if sh.Op != OpS390XSLDconst {
   27933 			break
   27934 		}
   27935 		if sh.AuxInt != 8 {
   27936 			break
   27937 		}
   27938 		x1 := sh.Args[0]
   27939 		if x1.Op != OpS390XMOVBZloadidx {
   27940 			break
   27941 		}
   27942 		i1 := x1.AuxInt
   27943 		s := x1.Aux
   27944 		_ = x1.Args[2]
   27945 		idx := x1.Args[0]
   27946 		p := x1.Args[1]
   27947 		mem := x1.Args[2]
   27948 		x0 := v.Args[1]
   27949 		if x0.Op != OpS390XMOVBZloadidx {
   27950 			break
   27951 		}
   27952 		i0 := x0.AuxInt
   27953 		if x0.Aux != s {
   27954 			break
   27955 		}
   27956 		_ = x0.Args[2]
   27957 		if idx != x0.Args[0] {
   27958 			break
   27959 		}
   27960 		if p != x0.Args[1] {
   27961 			break
   27962 		}
   27963 		if mem != x0.Args[2] {
   27964 			break
   27965 		}
   27966 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   27967 			break
   27968 		}
   27969 		b = mergePoint(b, x0, x1)
   27970 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   27971 		v.reset(OpCopy)
   27972 		v.AddArg(v0)
   27973 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   27974 		v1.AuxInt = i0
   27975 		v1.Aux = s
   27976 		v1.AddArg(p)
   27977 		v1.AddArg(idx)
   27978 		v1.AddArg(mem)
   27979 		v0.AddArg(v1)
   27980 		return true
   27981 	}
   27982 	// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   27983 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   27984 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   27985 	for {
   27986 		_ = v.Args[1]
   27987 		r0 := v.Args[0]
   27988 		if r0.Op != OpS390XMOVHZreg {
   27989 			break
   27990 		}
   27991 		x0 := r0.Args[0]
   27992 		if x0.Op != OpS390XMOVHBRloadidx {
   27993 			break
   27994 		}
   27995 		i0 := x0.AuxInt
   27996 		s := x0.Aux
   27997 		_ = x0.Args[2]
   27998 		p := x0.Args[0]
   27999 		idx := x0.Args[1]
   28000 		mem := x0.Args[2]
   28001 		sh := v.Args[1]
   28002 		if sh.Op != OpS390XSLDconst {
   28003 			break
   28004 		}
   28005 		if sh.AuxInt != 16 {
   28006 			break
   28007 		}
   28008 		r1 := sh.Args[0]
   28009 		if r1.Op != OpS390XMOVHZreg {
   28010 			break
   28011 		}
   28012 		x1 := r1.Args[0]
   28013 		if x1.Op != OpS390XMOVHBRloadidx {
   28014 			break
   28015 		}
   28016 		i1 := x1.AuxInt
   28017 		if x1.Aux != s {
   28018 			break
   28019 		}
   28020 		_ = x1.Args[2]
   28021 		if p != x1.Args[0] {
   28022 			break
   28023 		}
   28024 		if idx != x1.Args[1] {
   28025 			break
   28026 		}
   28027 		if mem != x1.Args[2] {
   28028 			break
   28029 		}
   28030 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28031 			break
   28032 		}
   28033 		b = mergePoint(b, x0, x1)
   28034 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28035 		v.reset(OpCopy)
   28036 		v.AddArg(v0)
   28037 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28038 		v1.AuxInt = i0
   28039 		v1.Aux = s
   28040 		v1.AddArg(p)
   28041 		v1.AddArg(idx)
   28042 		v1.AddArg(mem)
   28043 		v0.AddArg(v1)
   28044 		return true
   28045 	}
   28046 	return false
   28047 }
   28048 func rewriteValueS390X_OpS390XOR_110(v *Value) bool {
   28049 	b := v.Block
   28050 	_ = b
   28051 	typ := &b.Func.Config.Types
   28052 	_ = typ
   28053 	// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   28054 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28055 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28056 	for {
   28057 		_ = v.Args[1]
   28058 		r0 := v.Args[0]
   28059 		if r0.Op != OpS390XMOVHZreg {
   28060 			break
   28061 		}
   28062 		x0 := r0.Args[0]
   28063 		if x0.Op != OpS390XMOVHBRloadidx {
   28064 			break
   28065 		}
   28066 		i0 := x0.AuxInt
   28067 		s := x0.Aux
   28068 		_ = x0.Args[2]
   28069 		idx := x0.Args[0]
   28070 		p := x0.Args[1]
   28071 		mem := x0.Args[2]
   28072 		sh := v.Args[1]
   28073 		if sh.Op != OpS390XSLDconst {
   28074 			break
   28075 		}
   28076 		if sh.AuxInt != 16 {
   28077 			break
   28078 		}
   28079 		r1 := sh.Args[0]
   28080 		if r1.Op != OpS390XMOVHZreg {
   28081 			break
   28082 		}
   28083 		x1 := r1.Args[0]
   28084 		if x1.Op != OpS390XMOVHBRloadidx {
   28085 			break
   28086 		}
   28087 		i1 := x1.AuxInt
   28088 		if x1.Aux != s {
   28089 			break
   28090 		}
   28091 		_ = x1.Args[2]
   28092 		if p != x1.Args[0] {
   28093 			break
   28094 		}
   28095 		if idx != x1.Args[1] {
   28096 			break
   28097 		}
   28098 		if mem != x1.Args[2] {
   28099 			break
   28100 		}
   28101 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28102 			break
   28103 		}
   28104 		b = mergePoint(b, x0, x1)
   28105 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28106 		v.reset(OpCopy)
   28107 		v.AddArg(v0)
   28108 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28109 		v1.AuxInt = i0
   28110 		v1.Aux = s
   28111 		v1.AddArg(p)
   28112 		v1.AddArg(idx)
   28113 		v1.AddArg(mem)
   28114 		v0.AddArg(v1)
   28115 		return true
   28116 	}
   28117 	// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   28118 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28119 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28120 	for {
   28121 		_ = v.Args[1]
   28122 		r0 := v.Args[0]
   28123 		if r0.Op != OpS390XMOVHZreg {
   28124 			break
   28125 		}
   28126 		x0 := r0.Args[0]
   28127 		if x0.Op != OpS390XMOVHBRloadidx {
   28128 			break
   28129 		}
   28130 		i0 := x0.AuxInt
   28131 		s := x0.Aux
   28132 		_ = x0.Args[2]
   28133 		p := x0.Args[0]
   28134 		idx := x0.Args[1]
   28135 		mem := x0.Args[2]
   28136 		sh := v.Args[1]
   28137 		if sh.Op != OpS390XSLDconst {
   28138 			break
   28139 		}
   28140 		if sh.AuxInt != 16 {
   28141 			break
   28142 		}
   28143 		r1 := sh.Args[0]
   28144 		if r1.Op != OpS390XMOVHZreg {
   28145 			break
   28146 		}
   28147 		x1 := r1.Args[0]
   28148 		if x1.Op != OpS390XMOVHBRloadidx {
   28149 			break
   28150 		}
   28151 		i1 := x1.AuxInt
   28152 		if x1.Aux != s {
   28153 			break
   28154 		}
   28155 		_ = x1.Args[2]
   28156 		if idx != x1.Args[0] {
   28157 			break
   28158 		}
   28159 		if p != x1.Args[1] {
   28160 			break
   28161 		}
   28162 		if mem != x1.Args[2] {
   28163 			break
   28164 		}
   28165 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28166 			break
   28167 		}
   28168 		b = mergePoint(b, x0, x1)
   28169 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28170 		v.reset(OpCopy)
   28171 		v.AddArg(v0)
   28172 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28173 		v1.AuxInt = i0
   28174 		v1.Aux = s
   28175 		v1.AddArg(p)
   28176 		v1.AddArg(idx)
   28177 		v1.AddArg(mem)
   28178 		v0.AddArg(v1)
   28179 		return true
   28180 	}
   28181 	// match: (OR r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   28182 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28183 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28184 	for {
   28185 		_ = v.Args[1]
   28186 		r0 := v.Args[0]
   28187 		if r0.Op != OpS390XMOVHZreg {
   28188 			break
   28189 		}
   28190 		x0 := r0.Args[0]
   28191 		if x0.Op != OpS390XMOVHBRloadidx {
   28192 			break
   28193 		}
   28194 		i0 := x0.AuxInt
   28195 		s := x0.Aux
   28196 		_ = x0.Args[2]
   28197 		idx := x0.Args[0]
   28198 		p := x0.Args[1]
   28199 		mem := x0.Args[2]
   28200 		sh := v.Args[1]
   28201 		if sh.Op != OpS390XSLDconst {
   28202 			break
   28203 		}
   28204 		if sh.AuxInt != 16 {
   28205 			break
   28206 		}
   28207 		r1 := sh.Args[0]
   28208 		if r1.Op != OpS390XMOVHZreg {
   28209 			break
   28210 		}
   28211 		x1 := r1.Args[0]
   28212 		if x1.Op != OpS390XMOVHBRloadidx {
   28213 			break
   28214 		}
   28215 		i1 := x1.AuxInt
   28216 		if x1.Aux != s {
   28217 			break
   28218 		}
   28219 		_ = x1.Args[2]
   28220 		if idx != x1.Args[0] {
   28221 			break
   28222 		}
   28223 		if p != x1.Args[1] {
   28224 			break
   28225 		}
   28226 		if mem != x1.Args[2] {
   28227 			break
   28228 		}
   28229 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28230 			break
   28231 		}
   28232 		b = mergePoint(b, x0, x1)
   28233 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28234 		v.reset(OpCopy)
   28235 		v.AddArg(v0)
   28236 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28237 		v1.AuxInt = i0
   28238 		v1.Aux = s
   28239 		v1.AddArg(p)
   28240 		v1.AddArg(idx)
   28241 		v1.AddArg(mem)
   28242 		v0.AddArg(v1)
   28243 		return true
   28244 	}
   28245 	// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
   28246 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28247 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28248 	for {
   28249 		_ = v.Args[1]
   28250 		sh := v.Args[0]
   28251 		if sh.Op != OpS390XSLDconst {
   28252 			break
   28253 		}
   28254 		if sh.AuxInt != 16 {
   28255 			break
   28256 		}
   28257 		r1 := sh.Args[0]
   28258 		if r1.Op != OpS390XMOVHZreg {
   28259 			break
   28260 		}
   28261 		x1 := r1.Args[0]
   28262 		if x1.Op != OpS390XMOVHBRloadidx {
   28263 			break
   28264 		}
   28265 		i1 := x1.AuxInt
   28266 		s := x1.Aux
   28267 		_ = x1.Args[2]
   28268 		p := x1.Args[0]
   28269 		idx := x1.Args[1]
   28270 		mem := x1.Args[2]
   28271 		r0 := v.Args[1]
   28272 		if r0.Op != OpS390XMOVHZreg {
   28273 			break
   28274 		}
   28275 		x0 := r0.Args[0]
   28276 		if x0.Op != OpS390XMOVHBRloadidx {
   28277 			break
   28278 		}
   28279 		i0 := x0.AuxInt
   28280 		if x0.Aux != s {
   28281 			break
   28282 		}
   28283 		_ = x0.Args[2]
   28284 		if p != x0.Args[0] {
   28285 			break
   28286 		}
   28287 		if idx != x0.Args[1] {
   28288 			break
   28289 		}
   28290 		if mem != x0.Args[2] {
   28291 			break
   28292 		}
   28293 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28294 			break
   28295 		}
   28296 		b = mergePoint(b, x0, x1)
   28297 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28298 		v.reset(OpCopy)
   28299 		v.AddArg(v0)
   28300 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28301 		v1.AuxInt = i0
   28302 		v1.Aux = s
   28303 		v1.AddArg(p)
   28304 		v1.AddArg(idx)
   28305 		v1.AddArg(mem)
   28306 		v0.AddArg(v1)
   28307 		return true
   28308 	}
   28309 	// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
   28310 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28311 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28312 	for {
   28313 		_ = v.Args[1]
   28314 		sh := v.Args[0]
   28315 		if sh.Op != OpS390XSLDconst {
   28316 			break
   28317 		}
   28318 		if sh.AuxInt != 16 {
   28319 			break
   28320 		}
   28321 		r1 := sh.Args[0]
   28322 		if r1.Op != OpS390XMOVHZreg {
   28323 			break
   28324 		}
   28325 		x1 := r1.Args[0]
   28326 		if x1.Op != OpS390XMOVHBRloadidx {
   28327 			break
   28328 		}
   28329 		i1 := x1.AuxInt
   28330 		s := x1.Aux
   28331 		_ = x1.Args[2]
   28332 		idx := x1.Args[0]
   28333 		p := x1.Args[1]
   28334 		mem := x1.Args[2]
   28335 		r0 := v.Args[1]
   28336 		if r0.Op != OpS390XMOVHZreg {
   28337 			break
   28338 		}
   28339 		x0 := r0.Args[0]
   28340 		if x0.Op != OpS390XMOVHBRloadidx {
   28341 			break
   28342 		}
   28343 		i0 := x0.AuxInt
   28344 		if x0.Aux != s {
   28345 			break
   28346 		}
   28347 		_ = x0.Args[2]
   28348 		if p != x0.Args[0] {
   28349 			break
   28350 		}
   28351 		if idx != x0.Args[1] {
   28352 			break
   28353 		}
   28354 		if mem != x0.Args[2] {
   28355 			break
   28356 		}
   28357 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28358 			break
   28359 		}
   28360 		b = mergePoint(b, x0, x1)
   28361 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28362 		v.reset(OpCopy)
   28363 		v.AddArg(v0)
   28364 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28365 		v1.AuxInt = i0
   28366 		v1.Aux = s
   28367 		v1.AddArg(p)
   28368 		v1.AddArg(idx)
   28369 		v1.AddArg(mem)
   28370 		v0.AddArg(v1)
   28371 		return true
   28372 	}
   28373 	// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
   28374 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28375 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28376 	for {
   28377 		_ = v.Args[1]
   28378 		sh := v.Args[0]
   28379 		if sh.Op != OpS390XSLDconst {
   28380 			break
   28381 		}
   28382 		if sh.AuxInt != 16 {
   28383 			break
   28384 		}
   28385 		r1 := sh.Args[0]
   28386 		if r1.Op != OpS390XMOVHZreg {
   28387 			break
   28388 		}
   28389 		x1 := r1.Args[0]
   28390 		if x1.Op != OpS390XMOVHBRloadidx {
   28391 			break
   28392 		}
   28393 		i1 := x1.AuxInt
   28394 		s := x1.Aux
   28395 		_ = x1.Args[2]
   28396 		p := x1.Args[0]
   28397 		idx := x1.Args[1]
   28398 		mem := x1.Args[2]
   28399 		r0 := v.Args[1]
   28400 		if r0.Op != OpS390XMOVHZreg {
   28401 			break
   28402 		}
   28403 		x0 := r0.Args[0]
   28404 		if x0.Op != OpS390XMOVHBRloadidx {
   28405 			break
   28406 		}
   28407 		i0 := x0.AuxInt
   28408 		if x0.Aux != s {
   28409 			break
   28410 		}
   28411 		_ = x0.Args[2]
   28412 		if idx != x0.Args[0] {
   28413 			break
   28414 		}
   28415 		if p != x0.Args[1] {
   28416 			break
   28417 		}
   28418 		if mem != x0.Args[2] {
   28419 			break
   28420 		}
   28421 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28422 			break
   28423 		}
   28424 		b = mergePoint(b, x0, x1)
   28425 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28426 		v.reset(OpCopy)
   28427 		v.AddArg(v0)
   28428 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28429 		v1.AuxInt = i0
   28430 		v1.Aux = s
   28431 		v1.AddArg(p)
   28432 		v1.AddArg(idx)
   28433 		v1.AddArg(mem)
   28434 		v0.AddArg(v1)
   28435 		return true
   28436 	}
   28437 	// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
   28438 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28439 	// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
   28440 	for {
   28441 		_ = v.Args[1]
   28442 		sh := v.Args[0]
   28443 		if sh.Op != OpS390XSLDconst {
   28444 			break
   28445 		}
   28446 		if sh.AuxInt != 16 {
   28447 			break
   28448 		}
   28449 		r1 := sh.Args[0]
   28450 		if r1.Op != OpS390XMOVHZreg {
   28451 			break
   28452 		}
   28453 		x1 := r1.Args[0]
   28454 		if x1.Op != OpS390XMOVHBRloadidx {
   28455 			break
   28456 		}
   28457 		i1 := x1.AuxInt
   28458 		s := x1.Aux
   28459 		_ = x1.Args[2]
   28460 		idx := x1.Args[0]
   28461 		p := x1.Args[1]
   28462 		mem := x1.Args[2]
   28463 		r0 := v.Args[1]
   28464 		if r0.Op != OpS390XMOVHZreg {
   28465 			break
   28466 		}
   28467 		x0 := r0.Args[0]
   28468 		if x0.Op != OpS390XMOVHBRloadidx {
   28469 			break
   28470 		}
   28471 		i0 := x0.AuxInt
   28472 		if x0.Aux != s {
   28473 			break
   28474 		}
   28475 		_ = x0.Args[2]
   28476 		if idx != x0.Args[0] {
   28477 			break
   28478 		}
   28479 		if p != x0.Args[1] {
   28480 			break
   28481 		}
   28482 		if mem != x0.Args[2] {
   28483 			break
   28484 		}
   28485 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28486 			break
   28487 		}
   28488 		b = mergePoint(b, x0, x1)
   28489 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   28490 		v.reset(OpCopy)
   28491 		v.AddArg(v0)
   28492 		v1 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   28493 		v1.AuxInt = i0
   28494 		v1.Aux = s
   28495 		v1.AddArg(p)
   28496 		v1.AddArg(idx)
   28497 		v1.AddArg(mem)
   28498 		v0.AddArg(v1)
   28499 		return true
   28500 	}
   28501 	// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))))
   28502 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28503 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28504 	for {
   28505 		_ = v.Args[1]
   28506 		r0 := v.Args[0]
   28507 		if r0.Op != OpS390XMOVWZreg {
   28508 			break
   28509 		}
   28510 		x0 := r0.Args[0]
   28511 		if x0.Op != OpS390XMOVWBRloadidx {
   28512 			break
   28513 		}
   28514 		i0 := x0.AuxInt
   28515 		s := x0.Aux
   28516 		_ = x0.Args[2]
   28517 		p := x0.Args[0]
   28518 		idx := x0.Args[1]
   28519 		mem := x0.Args[2]
   28520 		sh := v.Args[1]
   28521 		if sh.Op != OpS390XSLDconst {
   28522 			break
   28523 		}
   28524 		if sh.AuxInt != 32 {
   28525 			break
   28526 		}
   28527 		r1 := sh.Args[0]
   28528 		if r1.Op != OpS390XMOVWZreg {
   28529 			break
   28530 		}
   28531 		x1 := r1.Args[0]
   28532 		if x1.Op != OpS390XMOVWBRloadidx {
   28533 			break
   28534 		}
   28535 		i1 := x1.AuxInt
   28536 		if x1.Aux != s {
   28537 			break
   28538 		}
   28539 		_ = x1.Args[2]
   28540 		if p != x1.Args[0] {
   28541 			break
   28542 		}
   28543 		if idx != x1.Args[1] {
   28544 			break
   28545 		}
   28546 		if mem != x1.Args[2] {
   28547 			break
   28548 		}
   28549 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28550 			break
   28551 		}
   28552 		b = mergePoint(b, x0, x1)
   28553 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28554 		v.reset(OpCopy)
   28555 		v.AddArg(v0)
   28556 		v0.AuxInt = i0
   28557 		v0.Aux = s
   28558 		v0.AddArg(p)
   28559 		v0.AddArg(idx)
   28560 		v0.AddArg(mem)
   28561 		return true
   28562 	}
   28563 	// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))))
   28564 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28565 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28566 	for {
   28567 		_ = v.Args[1]
   28568 		r0 := v.Args[0]
   28569 		if r0.Op != OpS390XMOVWZreg {
   28570 			break
   28571 		}
   28572 		x0 := r0.Args[0]
   28573 		if x0.Op != OpS390XMOVWBRloadidx {
   28574 			break
   28575 		}
   28576 		i0 := x0.AuxInt
   28577 		s := x0.Aux
   28578 		_ = x0.Args[2]
   28579 		idx := x0.Args[0]
   28580 		p := x0.Args[1]
   28581 		mem := x0.Args[2]
   28582 		sh := v.Args[1]
   28583 		if sh.Op != OpS390XSLDconst {
   28584 			break
   28585 		}
   28586 		if sh.AuxInt != 32 {
   28587 			break
   28588 		}
   28589 		r1 := sh.Args[0]
   28590 		if r1.Op != OpS390XMOVWZreg {
   28591 			break
   28592 		}
   28593 		x1 := r1.Args[0]
   28594 		if x1.Op != OpS390XMOVWBRloadidx {
   28595 			break
   28596 		}
   28597 		i1 := x1.AuxInt
   28598 		if x1.Aux != s {
   28599 			break
   28600 		}
   28601 		_ = x1.Args[2]
   28602 		if p != x1.Args[0] {
   28603 			break
   28604 		}
   28605 		if idx != x1.Args[1] {
   28606 			break
   28607 		}
   28608 		if mem != x1.Args[2] {
   28609 			break
   28610 		}
   28611 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28612 			break
   28613 		}
   28614 		b = mergePoint(b, x0, x1)
   28615 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28616 		v.reset(OpCopy)
   28617 		v.AddArg(v0)
   28618 		v0.AuxInt = i0
   28619 		v0.Aux = s
   28620 		v0.AddArg(p)
   28621 		v0.AddArg(idx)
   28622 		v0.AddArg(mem)
   28623 		return true
   28624 	}
   28625 	// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))))
   28626 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28627 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28628 	for {
   28629 		_ = v.Args[1]
   28630 		r0 := v.Args[0]
   28631 		if r0.Op != OpS390XMOVWZreg {
   28632 			break
   28633 		}
   28634 		x0 := r0.Args[0]
   28635 		if x0.Op != OpS390XMOVWBRloadidx {
   28636 			break
   28637 		}
   28638 		i0 := x0.AuxInt
   28639 		s := x0.Aux
   28640 		_ = x0.Args[2]
   28641 		p := x0.Args[0]
   28642 		idx := x0.Args[1]
   28643 		mem := x0.Args[2]
   28644 		sh := v.Args[1]
   28645 		if sh.Op != OpS390XSLDconst {
   28646 			break
   28647 		}
   28648 		if sh.AuxInt != 32 {
   28649 			break
   28650 		}
   28651 		r1 := sh.Args[0]
   28652 		if r1.Op != OpS390XMOVWZreg {
   28653 			break
   28654 		}
   28655 		x1 := r1.Args[0]
   28656 		if x1.Op != OpS390XMOVWBRloadidx {
   28657 			break
   28658 		}
   28659 		i1 := x1.AuxInt
   28660 		if x1.Aux != s {
   28661 			break
   28662 		}
   28663 		_ = x1.Args[2]
   28664 		if idx != x1.Args[0] {
   28665 			break
   28666 		}
   28667 		if p != x1.Args[1] {
   28668 			break
   28669 		}
   28670 		if mem != x1.Args[2] {
   28671 			break
   28672 		}
   28673 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28674 			break
   28675 		}
   28676 		b = mergePoint(b, x0, x1)
   28677 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28678 		v.reset(OpCopy)
   28679 		v.AddArg(v0)
   28680 		v0.AuxInt = i0
   28681 		v0.Aux = s
   28682 		v0.AddArg(p)
   28683 		v0.AddArg(idx)
   28684 		v0.AddArg(mem)
   28685 		return true
   28686 	}
   28687 	return false
   28688 }
   28689 func rewriteValueS390X_OpS390XOR_120(v *Value) bool {
   28690 	b := v.Block
   28691 	_ = b
   28692 	typ := &b.Func.Config.Types
   28693 	_ = typ
   28694 	// match: (OR r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)) sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))))
   28695 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28696 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28697 	for {
   28698 		_ = v.Args[1]
   28699 		r0 := v.Args[0]
   28700 		if r0.Op != OpS390XMOVWZreg {
   28701 			break
   28702 		}
   28703 		x0 := r0.Args[0]
   28704 		if x0.Op != OpS390XMOVWBRloadidx {
   28705 			break
   28706 		}
   28707 		i0 := x0.AuxInt
   28708 		s := x0.Aux
   28709 		_ = x0.Args[2]
   28710 		idx := x0.Args[0]
   28711 		p := x0.Args[1]
   28712 		mem := x0.Args[2]
   28713 		sh := v.Args[1]
   28714 		if sh.Op != OpS390XSLDconst {
   28715 			break
   28716 		}
   28717 		if sh.AuxInt != 32 {
   28718 			break
   28719 		}
   28720 		r1 := sh.Args[0]
   28721 		if r1.Op != OpS390XMOVWZreg {
   28722 			break
   28723 		}
   28724 		x1 := r1.Args[0]
   28725 		if x1.Op != OpS390XMOVWBRloadidx {
   28726 			break
   28727 		}
   28728 		i1 := x1.AuxInt
   28729 		if x1.Aux != s {
   28730 			break
   28731 		}
   28732 		_ = x1.Args[2]
   28733 		if idx != x1.Args[0] {
   28734 			break
   28735 		}
   28736 		if p != x1.Args[1] {
   28737 			break
   28738 		}
   28739 		if mem != x1.Args[2] {
   28740 			break
   28741 		}
   28742 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28743 			break
   28744 		}
   28745 		b = mergePoint(b, x0, x1)
   28746 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28747 		v.reset(OpCopy)
   28748 		v.AddArg(v0)
   28749 		v0.AuxInt = i0
   28750 		v0.Aux = s
   28751 		v0.AddArg(p)
   28752 		v0.AddArg(idx)
   28753 		v0.AddArg(mem)
   28754 		return true
   28755 	}
   28756 	// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)))
   28757 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28758 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28759 	for {
   28760 		_ = v.Args[1]
   28761 		sh := v.Args[0]
   28762 		if sh.Op != OpS390XSLDconst {
   28763 			break
   28764 		}
   28765 		if sh.AuxInt != 32 {
   28766 			break
   28767 		}
   28768 		r1 := sh.Args[0]
   28769 		if r1.Op != OpS390XMOVWZreg {
   28770 			break
   28771 		}
   28772 		x1 := r1.Args[0]
   28773 		if x1.Op != OpS390XMOVWBRloadidx {
   28774 			break
   28775 		}
   28776 		i1 := x1.AuxInt
   28777 		s := x1.Aux
   28778 		_ = x1.Args[2]
   28779 		p := x1.Args[0]
   28780 		idx := x1.Args[1]
   28781 		mem := x1.Args[2]
   28782 		r0 := v.Args[1]
   28783 		if r0.Op != OpS390XMOVWZreg {
   28784 			break
   28785 		}
   28786 		x0 := r0.Args[0]
   28787 		if x0.Op != OpS390XMOVWBRloadidx {
   28788 			break
   28789 		}
   28790 		i0 := x0.AuxInt
   28791 		if x0.Aux != s {
   28792 			break
   28793 		}
   28794 		_ = x0.Args[2]
   28795 		if p != x0.Args[0] {
   28796 			break
   28797 		}
   28798 		if idx != x0.Args[1] {
   28799 			break
   28800 		}
   28801 		if mem != x0.Args[2] {
   28802 			break
   28803 		}
   28804 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28805 			break
   28806 		}
   28807 		b = mergePoint(b, x0, x1)
   28808 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28809 		v.reset(OpCopy)
   28810 		v.AddArg(v0)
   28811 		v0.AuxInt = i0
   28812 		v0.Aux = s
   28813 		v0.AddArg(p)
   28814 		v0.AddArg(idx)
   28815 		v0.AddArg(mem)
   28816 		return true
   28817 	}
   28818 	// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} p idx mem)))
   28819 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28820 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28821 	for {
   28822 		_ = v.Args[1]
   28823 		sh := v.Args[0]
   28824 		if sh.Op != OpS390XSLDconst {
   28825 			break
   28826 		}
   28827 		if sh.AuxInt != 32 {
   28828 			break
   28829 		}
   28830 		r1 := sh.Args[0]
   28831 		if r1.Op != OpS390XMOVWZreg {
   28832 			break
   28833 		}
   28834 		x1 := r1.Args[0]
   28835 		if x1.Op != OpS390XMOVWBRloadidx {
   28836 			break
   28837 		}
   28838 		i1 := x1.AuxInt
   28839 		s := x1.Aux
   28840 		_ = x1.Args[2]
   28841 		idx := x1.Args[0]
   28842 		p := x1.Args[1]
   28843 		mem := x1.Args[2]
   28844 		r0 := v.Args[1]
   28845 		if r0.Op != OpS390XMOVWZreg {
   28846 			break
   28847 		}
   28848 		x0 := r0.Args[0]
   28849 		if x0.Op != OpS390XMOVWBRloadidx {
   28850 			break
   28851 		}
   28852 		i0 := x0.AuxInt
   28853 		if x0.Aux != s {
   28854 			break
   28855 		}
   28856 		_ = x0.Args[2]
   28857 		if p != x0.Args[0] {
   28858 			break
   28859 		}
   28860 		if idx != x0.Args[1] {
   28861 			break
   28862 		}
   28863 		if mem != x0.Args[2] {
   28864 			break
   28865 		}
   28866 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28867 			break
   28868 		}
   28869 		b = mergePoint(b, x0, x1)
   28870 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28871 		v.reset(OpCopy)
   28872 		v.AddArg(v0)
   28873 		v0.AuxInt = i0
   28874 		v0.Aux = s
   28875 		v0.AddArg(p)
   28876 		v0.AddArg(idx)
   28877 		v0.AddArg(mem)
   28878 		return true
   28879 	}
   28880 	// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} p idx mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)))
   28881 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28882 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28883 	for {
   28884 		_ = v.Args[1]
   28885 		sh := v.Args[0]
   28886 		if sh.Op != OpS390XSLDconst {
   28887 			break
   28888 		}
   28889 		if sh.AuxInt != 32 {
   28890 			break
   28891 		}
   28892 		r1 := sh.Args[0]
   28893 		if r1.Op != OpS390XMOVWZreg {
   28894 			break
   28895 		}
   28896 		x1 := r1.Args[0]
   28897 		if x1.Op != OpS390XMOVWBRloadidx {
   28898 			break
   28899 		}
   28900 		i1 := x1.AuxInt
   28901 		s := x1.Aux
   28902 		_ = x1.Args[2]
   28903 		p := x1.Args[0]
   28904 		idx := x1.Args[1]
   28905 		mem := x1.Args[2]
   28906 		r0 := v.Args[1]
   28907 		if r0.Op != OpS390XMOVWZreg {
   28908 			break
   28909 		}
   28910 		x0 := r0.Args[0]
   28911 		if x0.Op != OpS390XMOVWBRloadidx {
   28912 			break
   28913 		}
   28914 		i0 := x0.AuxInt
   28915 		if x0.Aux != s {
   28916 			break
   28917 		}
   28918 		_ = x0.Args[2]
   28919 		if idx != x0.Args[0] {
   28920 			break
   28921 		}
   28922 		if p != x0.Args[1] {
   28923 			break
   28924 		}
   28925 		if mem != x0.Args[2] {
   28926 			break
   28927 		}
   28928 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28929 			break
   28930 		}
   28931 		b = mergePoint(b, x0, x1)
   28932 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28933 		v.reset(OpCopy)
   28934 		v.AddArg(v0)
   28935 		v0.AuxInt = i0
   28936 		v0.Aux = s
   28937 		v0.AddArg(p)
   28938 		v0.AddArg(idx)
   28939 		v0.AddArg(mem)
   28940 		return true
   28941 	}
   28942 	// match: (OR sh:(SLDconst [32] r1:(MOVWZreg x1:(MOVWBRloadidx [i1] {s} idx p mem))) r0:(MOVWZreg x0:(MOVWBRloadidx [i0] {s} idx p mem)))
   28943 	// cond: i1 == i0+4   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   28944 	// result: @mergePoint(b,x0,x1) (MOVDBRloadidx [i0] {s} p idx mem)
   28945 	for {
   28946 		_ = v.Args[1]
   28947 		sh := v.Args[0]
   28948 		if sh.Op != OpS390XSLDconst {
   28949 			break
   28950 		}
   28951 		if sh.AuxInt != 32 {
   28952 			break
   28953 		}
   28954 		r1 := sh.Args[0]
   28955 		if r1.Op != OpS390XMOVWZreg {
   28956 			break
   28957 		}
   28958 		x1 := r1.Args[0]
   28959 		if x1.Op != OpS390XMOVWBRloadidx {
   28960 			break
   28961 		}
   28962 		i1 := x1.AuxInt
   28963 		s := x1.Aux
   28964 		_ = x1.Args[2]
   28965 		idx := x1.Args[0]
   28966 		p := x1.Args[1]
   28967 		mem := x1.Args[2]
   28968 		r0 := v.Args[1]
   28969 		if r0.Op != OpS390XMOVWZreg {
   28970 			break
   28971 		}
   28972 		x0 := r0.Args[0]
   28973 		if x0.Op != OpS390XMOVWBRloadidx {
   28974 			break
   28975 		}
   28976 		i0 := x0.AuxInt
   28977 		if x0.Aux != s {
   28978 			break
   28979 		}
   28980 		_ = x0.Args[2]
   28981 		if idx != x0.Args[0] {
   28982 			break
   28983 		}
   28984 		if p != x0.Args[1] {
   28985 			break
   28986 		}
   28987 		if mem != x0.Args[2] {
   28988 			break
   28989 		}
   28990 		if !(i1 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   28991 			break
   28992 		}
   28993 		b = mergePoint(b, x0, x1)
   28994 		v0 := b.NewValue0(v.Pos, OpS390XMOVDBRloadidx, typ.Int64)
   28995 		v.reset(OpCopy)
   28996 		v.AddArg(v0)
   28997 		v0.AuxInt = i0
   28998 		v0.Aux = s
   28999 		v0.AddArg(p)
   29000 		v0.AddArg(idx)
   29001 		v0.AddArg(mem)
   29002 		return true
   29003 	}
   29004 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
   29005 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29006 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29007 	for {
   29008 		_ = v.Args[1]
   29009 		s1 := v.Args[0]
   29010 		if s1.Op != OpS390XSLDconst {
   29011 			break
   29012 		}
   29013 		j1 := s1.AuxInt
   29014 		x1 := s1.Args[0]
   29015 		if x1.Op != OpS390XMOVBZloadidx {
   29016 			break
   29017 		}
   29018 		i1 := x1.AuxInt
   29019 		s := x1.Aux
   29020 		_ = x1.Args[2]
   29021 		p := x1.Args[0]
   29022 		idx := x1.Args[1]
   29023 		mem := x1.Args[2]
   29024 		or := v.Args[1]
   29025 		if or.Op != OpS390XOR {
   29026 			break
   29027 		}
   29028 		_ = or.Args[1]
   29029 		s0 := or.Args[0]
   29030 		if s0.Op != OpS390XSLDconst {
   29031 			break
   29032 		}
   29033 		j0 := s0.AuxInt
   29034 		x0 := s0.Args[0]
   29035 		if x0.Op != OpS390XMOVBZloadidx {
   29036 			break
   29037 		}
   29038 		i0 := x0.AuxInt
   29039 		if x0.Aux != s {
   29040 			break
   29041 		}
   29042 		_ = x0.Args[2]
   29043 		if p != x0.Args[0] {
   29044 			break
   29045 		}
   29046 		if idx != x0.Args[1] {
   29047 			break
   29048 		}
   29049 		if mem != x0.Args[2] {
   29050 			break
   29051 		}
   29052 		y := or.Args[1]
   29053 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29054 			break
   29055 		}
   29056 		b = mergePoint(b, x0, x1)
   29057 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29058 		v.reset(OpCopy)
   29059 		v.AddArg(v0)
   29060 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29061 		v1.AuxInt = j0
   29062 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29063 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29064 		v3.AuxInt = i0
   29065 		v3.Aux = s
   29066 		v3.AddArg(p)
   29067 		v3.AddArg(idx)
   29068 		v3.AddArg(mem)
   29069 		v2.AddArg(v3)
   29070 		v1.AddArg(v2)
   29071 		v0.AddArg(v1)
   29072 		v0.AddArg(y)
   29073 		return true
   29074 	}
   29075 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
   29076 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29077 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29078 	for {
   29079 		_ = v.Args[1]
   29080 		s1 := v.Args[0]
   29081 		if s1.Op != OpS390XSLDconst {
   29082 			break
   29083 		}
   29084 		j1 := s1.AuxInt
   29085 		x1 := s1.Args[0]
   29086 		if x1.Op != OpS390XMOVBZloadidx {
   29087 			break
   29088 		}
   29089 		i1 := x1.AuxInt
   29090 		s := x1.Aux
   29091 		_ = x1.Args[2]
   29092 		idx := x1.Args[0]
   29093 		p := x1.Args[1]
   29094 		mem := x1.Args[2]
   29095 		or := v.Args[1]
   29096 		if or.Op != OpS390XOR {
   29097 			break
   29098 		}
   29099 		_ = or.Args[1]
   29100 		s0 := or.Args[0]
   29101 		if s0.Op != OpS390XSLDconst {
   29102 			break
   29103 		}
   29104 		j0 := s0.AuxInt
   29105 		x0 := s0.Args[0]
   29106 		if x0.Op != OpS390XMOVBZloadidx {
   29107 			break
   29108 		}
   29109 		i0 := x0.AuxInt
   29110 		if x0.Aux != s {
   29111 			break
   29112 		}
   29113 		_ = x0.Args[2]
   29114 		if p != x0.Args[0] {
   29115 			break
   29116 		}
   29117 		if idx != x0.Args[1] {
   29118 			break
   29119 		}
   29120 		if mem != x0.Args[2] {
   29121 			break
   29122 		}
   29123 		y := or.Args[1]
   29124 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29125 			break
   29126 		}
   29127 		b = mergePoint(b, x0, x1)
   29128 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29129 		v.reset(OpCopy)
   29130 		v.AddArg(v0)
   29131 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29132 		v1.AuxInt = j0
   29133 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29134 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29135 		v3.AuxInt = i0
   29136 		v3.Aux = s
   29137 		v3.AddArg(p)
   29138 		v3.AddArg(idx)
   29139 		v3.AddArg(mem)
   29140 		v2.AddArg(v3)
   29141 		v1.AddArg(v2)
   29142 		v0.AddArg(v1)
   29143 		v0.AddArg(y)
   29144 		return true
   29145 	}
   29146 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
   29147 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29148 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29149 	for {
   29150 		_ = v.Args[1]
   29151 		s1 := v.Args[0]
   29152 		if s1.Op != OpS390XSLDconst {
   29153 			break
   29154 		}
   29155 		j1 := s1.AuxInt
   29156 		x1 := s1.Args[0]
   29157 		if x1.Op != OpS390XMOVBZloadidx {
   29158 			break
   29159 		}
   29160 		i1 := x1.AuxInt
   29161 		s := x1.Aux
   29162 		_ = x1.Args[2]
   29163 		p := x1.Args[0]
   29164 		idx := x1.Args[1]
   29165 		mem := x1.Args[2]
   29166 		or := v.Args[1]
   29167 		if or.Op != OpS390XOR {
   29168 			break
   29169 		}
   29170 		_ = or.Args[1]
   29171 		s0 := or.Args[0]
   29172 		if s0.Op != OpS390XSLDconst {
   29173 			break
   29174 		}
   29175 		j0 := s0.AuxInt
   29176 		x0 := s0.Args[0]
   29177 		if x0.Op != OpS390XMOVBZloadidx {
   29178 			break
   29179 		}
   29180 		i0 := x0.AuxInt
   29181 		if x0.Aux != s {
   29182 			break
   29183 		}
   29184 		_ = x0.Args[2]
   29185 		if idx != x0.Args[0] {
   29186 			break
   29187 		}
   29188 		if p != x0.Args[1] {
   29189 			break
   29190 		}
   29191 		if mem != x0.Args[2] {
   29192 			break
   29193 		}
   29194 		y := or.Args[1]
   29195 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29196 			break
   29197 		}
   29198 		b = mergePoint(b, x0, x1)
   29199 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29200 		v.reset(OpCopy)
   29201 		v.AddArg(v0)
   29202 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29203 		v1.AuxInt = j0
   29204 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29205 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29206 		v3.AuxInt = i0
   29207 		v3.Aux = s
   29208 		v3.AddArg(p)
   29209 		v3.AddArg(idx)
   29210 		v3.AddArg(mem)
   29211 		v2.AddArg(v3)
   29212 		v1.AddArg(v2)
   29213 		v0.AddArg(v1)
   29214 		v0.AddArg(y)
   29215 		return true
   29216 	}
   29217 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
   29218 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29219 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29220 	for {
   29221 		_ = v.Args[1]
   29222 		s1 := v.Args[0]
   29223 		if s1.Op != OpS390XSLDconst {
   29224 			break
   29225 		}
   29226 		j1 := s1.AuxInt
   29227 		x1 := s1.Args[0]
   29228 		if x1.Op != OpS390XMOVBZloadidx {
   29229 			break
   29230 		}
   29231 		i1 := x1.AuxInt
   29232 		s := x1.Aux
   29233 		_ = x1.Args[2]
   29234 		idx := x1.Args[0]
   29235 		p := x1.Args[1]
   29236 		mem := x1.Args[2]
   29237 		or := v.Args[1]
   29238 		if or.Op != OpS390XOR {
   29239 			break
   29240 		}
   29241 		_ = or.Args[1]
   29242 		s0 := or.Args[0]
   29243 		if s0.Op != OpS390XSLDconst {
   29244 			break
   29245 		}
   29246 		j0 := s0.AuxInt
   29247 		x0 := s0.Args[0]
   29248 		if x0.Op != OpS390XMOVBZloadidx {
   29249 			break
   29250 		}
   29251 		i0 := x0.AuxInt
   29252 		if x0.Aux != s {
   29253 			break
   29254 		}
   29255 		_ = x0.Args[2]
   29256 		if idx != x0.Args[0] {
   29257 			break
   29258 		}
   29259 		if p != x0.Args[1] {
   29260 			break
   29261 		}
   29262 		if mem != x0.Args[2] {
   29263 			break
   29264 		}
   29265 		y := or.Args[1]
   29266 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29267 			break
   29268 		}
   29269 		b = mergePoint(b, x0, x1)
   29270 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29271 		v.reset(OpCopy)
   29272 		v.AddArg(v0)
   29273 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29274 		v1.AuxInt = j0
   29275 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29276 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29277 		v3.AuxInt = i0
   29278 		v3.Aux = s
   29279 		v3.AddArg(p)
   29280 		v3.AddArg(idx)
   29281 		v3.AddArg(mem)
   29282 		v2.AddArg(v3)
   29283 		v1.AddArg(v2)
   29284 		v0.AddArg(v1)
   29285 		v0.AddArg(y)
   29286 		return true
   29287 	}
   29288 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
   29289 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29290 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29291 	for {
   29292 		_ = v.Args[1]
   29293 		s1 := v.Args[0]
   29294 		if s1.Op != OpS390XSLDconst {
   29295 			break
   29296 		}
   29297 		j1 := s1.AuxInt
   29298 		x1 := s1.Args[0]
   29299 		if x1.Op != OpS390XMOVBZloadidx {
   29300 			break
   29301 		}
   29302 		i1 := x1.AuxInt
   29303 		s := x1.Aux
   29304 		_ = x1.Args[2]
   29305 		p := x1.Args[0]
   29306 		idx := x1.Args[1]
   29307 		mem := x1.Args[2]
   29308 		or := v.Args[1]
   29309 		if or.Op != OpS390XOR {
   29310 			break
   29311 		}
   29312 		_ = or.Args[1]
   29313 		y := or.Args[0]
   29314 		s0 := or.Args[1]
   29315 		if s0.Op != OpS390XSLDconst {
   29316 			break
   29317 		}
   29318 		j0 := s0.AuxInt
   29319 		x0 := s0.Args[0]
   29320 		if x0.Op != OpS390XMOVBZloadidx {
   29321 			break
   29322 		}
   29323 		i0 := x0.AuxInt
   29324 		if x0.Aux != s {
   29325 			break
   29326 		}
   29327 		_ = x0.Args[2]
   29328 		if p != x0.Args[0] {
   29329 			break
   29330 		}
   29331 		if idx != x0.Args[1] {
   29332 			break
   29333 		}
   29334 		if mem != x0.Args[2] {
   29335 			break
   29336 		}
   29337 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29338 			break
   29339 		}
   29340 		b = mergePoint(b, x0, x1)
   29341 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29342 		v.reset(OpCopy)
   29343 		v.AddArg(v0)
   29344 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29345 		v1.AuxInt = j0
   29346 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29347 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29348 		v3.AuxInt = i0
   29349 		v3.Aux = s
   29350 		v3.AddArg(p)
   29351 		v3.AddArg(idx)
   29352 		v3.AddArg(mem)
   29353 		v2.AddArg(v3)
   29354 		v1.AddArg(v2)
   29355 		v0.AddArg(v1)
   29356 		v0.AddArg(y)
   29357 		return true
   29358 	}
   29359 	return false
   29360 }
   29361 func rewriteValueS390X_OpS390XOR_130(v *Value) bool {
   29362 	b := v.Block
   29363 	_ = b
   29364 	typ := &b.Func.Config.Types
   29365 	_ = typ
   29366 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
   29367 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29368 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29369 	for {
   29370 		_ = v.Args[1]
   29371 		s1 := v.Args[0]
   29372 		if s1.Op != OpS390XSLDconst {
   29373 			break
   29374 		}
   29375 		j1 := s1.AuxInt
   29376 		x1 := s1.Args[0]
   29377 		if x1.Op != OpS390XMOVBZloadidx {
   29378 			break
   29379 		}
   29380 		i1 := x1.AuxInt
   29381 		s := x1.Aux
   29382 		_ = x1.Args[2]
   29383 		idx := x1.Args[0]
   29384 		p := x1.Args[1]
   29385 		mem := x1.Args[2]
   29386 		or := v.Args[1]
   29387 		if or.Op != OpS390XOR {
   29388 			break
   29389 		}
   29390 		_ = or.Args[1]
   29391 		y := or.Args[0]
   29392 		s0 := or.Args[1]
   29393 		if s0.Op != OpS390XSLDconst {
   29394 			break
   29395 		}
   29396 		j0 := s0.AuxInt
   29397 		x0 := s0.Args[0]
   29398 		if x0.Op != OpS390XMOVBZloadidx {
   29399 			break
   29400 		}
   29401 		i0 := x0.AuxInt
   29402 		if x0.Aux != s {
   29403 			break
   29404 		}
   29405 		_ = x0.Args[2]
   29406 		if p != x0.Args[0] {
   29407 			break
   29408 		}
   29409 		if idx != x0.Args[1] {
   29410 			break
   29411 		}
   29412 		if mem != x0.Args[2] {
   29413 			break
   29414 		}
   29415 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29416 			break
   29417 		}
   29418 		b = mergePoint(b, x0, x1)
   29419 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29420 		v.reset(OpCopy)
   29421 		v.AddArg(v0)
   29422 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29423 		v1.AuxInt = j0
   29424 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29425 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29426 		v3.AuxInt = i0
   29427 		v3.Aux = s
   29428 		v3.AddArg(p)
   29429 		v3.AddArg(idx)
   29430 		v3.AddArg(mem)
   29431 		v2.AddArg(v3)
   29432 		v1.AddArg(v2)
   29433 		v0.AddArg(v1)
   29434 		v0.AddArg(y)
   29435 		return true
   29436 	}
   29437 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
   29438 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29439 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29440 	for {
   29441 		_ = v.Args[1]
   29442 		s1 := v.Args[0]
   29443 		if s1.Op != OpS390XSLDconst {
   29444 			break
   29445 		}
   29446 		j1 := s1.AuxInt
   29447 		x1 := s1.Args[0]
   29448 		if x1.Op != OpS390XMOVBZloadidx {
   29449 			break
   29450 		}
   29451 		i1 := x1.AuxInt
   29452 		s := x1.Aux
   29453 		_ = x1.Args[2]
   29454 		p := x1.Args[0]
   29455 		idx := x1.Args[1]
   29456 		mem := x1.Args[2]
   29457 		or := v.Args[1]
   29458 		if or.Op != OpS390XOR {
   29459 			break
   29460 		}
   29461 		_ = or.Args[1]
   29462 		y := or.Args[0]
   29463 		s0 := or.Args[1]
   29464 		if s0.Op != OpS390XSLDconst {
   29465 			break
   29466 		}
   29467 		j0 := s0.AuxInt
   29468 		x0 := s0.Args[0]
   29469 		if x0.Op != OpS390XMOVBZloadidx {
   29470 			break
   29471 		}
   29472 		i0 := x0.AuxInt
   29473 		if x0.Aux != s {
   29474 			break
   29475 		}
   29476 		_ = x0.Args[2]
   29477 		if idx != x0.Args[0] {
   29478 			break
   29479 		}
   29480 		if p != x0.Args[1] {
   29481 			break
   29482 		}
   29483 		if mem != x0.Args[2] {
   29484 			break
   29485 		}
   29486 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29487 			break
   29488 		}
   29489 		b = mergePoint(b, x0, x1)
   29490 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29491 		v.reset(OpCopy)
   29492 		v.AddArg(v0)
   29493 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29494 		v1.AuxInt = j0
   29495 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29496 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29497 		v3.AuxInt = i0
   29498 		v3.Aux = s
   29499 		v3.AddArg(p)
   29500 		v3.AddArg(idx)
   29501 		v3.AddArg(mem)
   29502 		v2.AddArg(v3)
   29503 		v1.AddArg(v2)
   29504 		v0.AddArg(v1)
   29505 		v0.AddArg(y)
   29506 		return true
   29507 	}
   29508 	// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
   29509 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29510 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29511 	for {
   29512 		_ = v.Args[1]
   29513 		s1 := v.Args[0]
   29514 		if s1.Op != OpS390XSLDconst {
   29515 			break
   29516 		}
   29517 		j1 := s1.AuxInt
   29518 		x1 := s1.Args[0]
   29519 		if x1.Op != OpS390XMOVBZloadidx {
   29520 			break
   29521 		}
   29522 		i1 := x1.AuxInt
   29523 		s := x1.Aux
   29524 		_ = x1.Args[2]
   29525 		idx := x1.Args[0]
   29526 		p := x1.Args[1]
   29527 		mem := x1.Args[2]
   29528 		or := v.Args[1]
   29529 		if or.Op != OpS390XOR {
   29530 			break
   29531 		}
   29532 		_ = or.Args[1]
   29533 		y := or.Args[0]
   29534 		s0 := or.Args[1]
   29535 		if s0.Op != OpS390XSLDconst {
   29536 			break
   29537 		}
   29538 		j0 := s0.AuxInt
   29539 		x0 := s0.Args[0]
   29540 		if x0.Op != OpS390XMOVBZloadidx {
   29541 			break
   29542 		}
   29543 		i0 := x0.AuxInt
   29544 		if x0.Aux != s {
   29545 			break
   29546 		}
   29547 		_ = x0.Args[2]
   29548 		if idx != x0.Args[0] {
   29549 			break
   29550 		}
   29551 		if p != x0.Args[1] {
   29552 			break
   29553 		}
   29554 		if mem != x0.Args[2] {
   29555 			break
   29556 		}
   29557 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29558 			break
   29559 		}
   29560 		b = mergePoint(b, x0, x1)
   29561 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29562 		v.reset(OpCopy)
   29563 		v.AddArg(v0)
   29564 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29565 		v1.AuxInt = j0
   29566 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29567 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29568 		v3.AuxInt = i0
   29569 		v3.Aux = s
   29570 		v3.AddArg(p)
   29571 		v3.AddArg(idx)
   29572 		v3.AddArg(mem)
   29573 		v2.AddArg(v3)
   29574 		v1.AddArg(v2)
   29575 		v0.AddArg(v1)
   29576 		v0.AddArg(y)
   29577 		return true
   29578 	}
   29579 	// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   29580 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29581 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29582 	for {
   29583 		_ = v.Args[1]
   29584 		or := v.Args[0]
   29585 		if or.Op != OpS390XOR {
   29586 			break
   29587 		}
   29588 		_ = or.Args[1]
   29589 		s0 := or.Args[0]
   29590 		if s0.Op != OpS390XSLDconst {
   29591 			break
   29592 		}
   29593 		j0 := s0.AuxInt
   29594 		x0 := s0.Args[0]
   29595 		if x0.Op != OpS390XMOVBZloadidx {
   29596 			break
   29597 		}
   29598 		i0 := x0.AuxInt
   29599 		s := x0.Aux
   29600 		_ = x0.Args[2]
   29601 		p := x0.Args[0]
   29602 		idx := x0.Args[1]
   29603 		mem := x0.Args[2]
   29604 		y := or.Args[1]
   29605 		s1 := v.Args[1]
   29606 		if s1.Op != OpS390XSLDconst {
   29607 			break
   29608 		}
   29609 		j1 := s1.AuxInt
   29610 		x1 := s1.Args[0]
   29611 		if x1.Op != OpS390XMOVBZloadidx {
   29612 			break
   29613 		}
   29614 		i1 := x1.AuxInt
   29615 		if x1.Aux != s {
   29616 			break
   29617 		}
   29618 		_ = x1.Args[2]
   29619 		if p != x1.Args[0] {
   29620 			break
   29621 		}
   29622 		if idx != x1.Args[1] {
   29623 			break
   29624 		}
   29625 		if mem != x1.Args[2] {
   29626 			break
   29627 		}
   29628 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29629 			break
   29630 		}
   29631 		b = mergePoint(b, x0, x1)
   29632 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29633 		v.reset(OpCopy)
   29634 		v.AddArg(v0)
   29635 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29636 		v1.AuxInt = j0
   29637 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29638 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29639 		v3.AuxInt = i0
   29640 		v3.Aux = s
   29641 		v3.AddArg(p)
   29642 		v3.AddArg(idx)
   29643 		v3.AddArg(mem)
   29644 		v2.AddArg(v3)
   29645 		v1.AddArg(v2)
   29646 		v0.AddArg(v1)
   29647 		v0.AddArg(y)
   29648 		return true
   29649 	}
   29650 	// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   29651 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29652 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29653 	for {
   29654 		_ = v.Args[1]
   29655 		or := v.Args[0]
   29656 		if or.Op != OpS390XOR {
   29657 			break
   29658 		}
   29659 		_ = or.Args[1]
   29660 		s0 := or.Args[0]
   29661 		if s0.Op != OpS390XSLDconst {
   29662 			break
   29663 		}
   29664 		j0 := s0.AuxInt
   29665 		x0 := s0.Args[0]
   29666 		if x0.Op != OpS390XMOVBZloadidx {
   29667 			break
   29668 		}
   29669 		i0 := x0.AuxInt
   29670 		s := x0.Aux
   29671 		_ = x0.Args[2]
   29672 		idx := x0.Args[0]
   29673 		p := x0.Args[1]
   29674 		mem := x0.Args[2]
   29675 		y := or.Args[1]
   29676 		s1 := v.Args[1]
   29677 		if s1.Op != OpS390XSLDconst {
   29678 			break
   29679 		}
   29680 		j1 := s1.AuxInt
   29681 		x1 := s1.Args[0]
   29682 		if x1.Op != OpS390XMOVBZloadidx {
   29683 			break
   29684 		}
   29685 		i1 := x1.AuxInt
   29686 		if x1.Aux != s {
   29687 			break
   29688 		}
   29689 		_ = x1.Args[2]
   29690 		if p != x1.Args[0] {
   29691 			break
   29692 		}
   29693 		if idx != x1.Args[1] {
   29694 			break
   29695 		}
   29696 		if mem != x1.Args[2] {
   29697 			break
   29698 		}
   29699 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29700 			break
   29701 		}
   29702 		b = mergePoint(b, x0, x1)
   29703 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29704 		v.reset(OpCopy)
   29705 		v.AddArg(v0)
   29706 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29707 		v1.AuxInt = j0
   29708 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29709 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29710 		v3.AuxInt = i0
   29711 		v3.Aux = s
   29712 		v3.AddArg(p)
   29713 		v3.AddArg(idx)
   29714 		v3.AddArg(mem)
   29715 		v2.AddArg(v3)
   29716 		v1.AddArg(v2)
   29717 		v0.AddArg(v1)
   29718 		v0.AddArg(y)
   29719 		return true
   29720 	}
   29721 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   29722 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29723 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29724 	for {
   29725 		_ = v.Args[1]
   29726 		or := v.Args[0]
   29727 		if or.Op != OpS390XOR {
   29728 			break
   29729 		}
   29730 		_ = or.Args[1]
   29731 		y := or.Args[0]
   29732 		s0 := or.Args[1]
   29733 		if s0.Op != OpS390XSLDconst {
   29734 			break
   29735 		}
   29736 		j0 := s0.AuxInt
   29737 		x0 := s0.Args[0]
   29738 		if x0.Op != OpS390XMOVBZloadidx {
   29739 			break
   29740 		}
   29741 		i0 := x0.AuxInt
   29742 		s := x0.Aux
   29743 		_ = x0.Args[2]
   29744 		p := x0.Args[0]
   29745 		idx := x0.Args[1]
   29746 		mem := x0.Args[2]
   29747 		s1 := v.Args[1]
   29748 		if s1.Op != OpS390XSLDconst {
   29749 			break
   29750 		}
   29751 		j1 := s1.AuxInt
   29752 		x1 := s1.Args[0]
   29753 		if x1.Op != OpS390XMOVBZloadidx {
   29754 			break
   29755 		}
   29756 		i1 := x1.AuxInt
   29757 		if x1.Aux != s {
   29758 			break
   29759 		}
   29760 		_ = x1.Args[2]
   29761 		if p != x1.Args[0] {
   29762 			break
   29763 		}
   29764 		if idx != x1.Args[1] {
   29765 			break
   29766 		}
   29767 		if mem != x1.Args[2] {
   29768 			break
   29769 		}
   29770 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29771 			break
   29772 		}
   29773 		b = mergePoint(b, x0, x1)
   29774 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29775 		v.reset(OpCopy)
   29776 		v.AddArg(v0)
   29777 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29778 		v1.AuxInt = j0
   29779 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29780 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29781 		v3.AuxInt = i0
   29782 		v3.Aux = s
   29783 		v3.AddArg(p)
   29784 		v3.AddArg(idx)
   29785 		v3.AddArg(mem)
   29786 		v2.AddArg(v3)
   29787 		v1.AddArg(v2)
   29788 		v0.AddArg(v1)
   29789 		v0.AddArg(y)
   29790 		return true
   29791 	}
   29792 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   29793 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29794 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29795 	for {
   29796 		_ = v.Args[1]
   29797 		or := v.Args[0]
   29798 		if or.Op != OpS390XOR {
   29799 			break
   29800 		}
   29801 		_ = or.Args[1]
   29802 		y := or.Args[0]
   29803 		s0 := or.Args[1]
   29804 		if s0.Op != OpS390XSLDconst {
   29805 			break
   29806 		}
   29807 		j0 := s0.AuxInt
   29808 		x0 := s0.Args[0]
   29809 		if x0.Op != OpS390XMOVBZloadidx {
   29810 			break
   29811 		}
   29812 		i0 := x0.AuxInt
   29813 		s := x0.Aux
   29814 		_ = x0.Args[2]
   29815 		idx := x0.Args[0]
   29816 		p := x0.Args[1]
   29817 		mem := x0.Args[2]
   29818 		s1 := v.Args[1]
   29819 		if s1.Op != OpS390XSLDconst {
   29820 			break
   29821 		}
   29822 		j1 := s1.AuxInt
   29823 		x1 := s1.Args[0]
   29824 		if x1.Op != OpS390XMOVBZloadidx {
   29825 			break
   29826 		}
   29827 		i1 := x1.AuxInt
   29828 		if x1.Aux != s {
   29829 			break
   29830 		}
   29831 		_ = x1.Args[2]
   29832 		if p != x1.Args[0] {
   29833 			break
   29834 		}
   29835 		if idx != x1.Args[1] {
   29836 			break
   29837 		}
   29838 		if mem != x1.Args[2] {
   29839 			break
   29840 		}
   29841 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29842 			break
   29843 		}
   29844 		b = mergePoint(b, x0, x1)
   29845 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29846 		v.reset(OpCopy)
   29847 		v.AddArg(v0)
   29848 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29849 		v1.AuxInt = j0
   29850 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29851 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29852 		v3.AuxInt = i0
   29853 		v3.Aux = s
   29854 		v3.AddArg(p)
   29855 		v3.AddArg(idx)
   29856 		v3.AddArg(mem)
   29857 		v2.AddArg(v3)
   29858 		v1.AddArg(v2)
   29859 		v0.AddArg(v1)
   29860 		v0.AddArg(y)
   29861 		return true
   29862 	}
   29863 	// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   29864 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29865 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29866 	for {
   29867 		_ = v.Args[1]
   29868 		or := v.Args[0]
   29869 		if or.Op != OpS390XOR {
   29870 			break
   29871 		}
   29872 		_ = or.Args[1]
   29873 		s0 := or.Args[0]
   29874 		if s0.Op != OpS390XSLDconst {
   29875 			break
   29876 		}
   29877 		j0 := s0.AuxInt
   29878 		x0 := s0.Args[0]
   29879 		if x0.Op != OpS390XMOVBZloadidx {
   29880 			break
   29881 		}
   29882 		i0 := x0.AuxInt
   29883 		s := x0.Aux
   29884 		_ = x0.Args[2]
   29885 		p := x0.Args[0]
   29886 		idx := x0.Args[1]
   29887 		mem := x0.Args[2]
   29888 		y := or.Args[1]
   29889 		s1 := v.Args[1]
   29890 		if s1.Op != OpS390XSLDconst {
   29891 			break
   29892 		}
   29893 		j1 := s1.AuxInt
   29894 		x1 := s1.Args[0]
   29895 		if x1.Op != OpS390XMOVBZloadidx {
   29896 			break
   29897 		}
   29898 		i1 := x1.AuxInt
   29899 		if x1.Aux != s {
   29900 			break
   29901 		}
   29902 		_ = x1.Args[2]
   29903 		if idx != x1.Args[0] {
   29904 			break
   29905 		}
   29906 		if p != x1.Args[1] {
   29907 			break
   29908 		}
   29909 		if mem != x1.Args[2] {
   29910 			break
   29911 		}
   29912 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29913 			break
   29914 		}
   29915 		b = mergePoint(b, x0, x1)
   29916 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29917 		v.reset(OpCopy)
   29918 		v.AddArg(v0)
   29919 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29920 		v1.AuxInt = j0
   29921 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29922 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29923 		v3.AuxInt = i0
   29924 		v3.Aux = s
   29925 		v3.AddArg(p)
   29926 		v3.AddArg(idx)
   29927 		v3.AddArg(mem)
   29928 		v2.AddArg(v3)
   29929 		v1.AddArg(v2)
   29930 		v0.AddArg(v1)
   29931 		v0.AddArg(y)
   29932 		return true
   29933 	}
   29934 	// match: (OR or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   29935 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   29936 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   29937 	for {
   29938 		_ = v.Args[1]
   29939 		or := v.Args[0]
   29940 		if or.Op != OpS390XOR {
   29941 			break
   29942 		}
   29943 		_ = or.Args[1]
   29944 		s0 := or.Args[0]
   29945 		if s0.Op != OpS390XSLDconst {
   29946 			break
   29947 		}
   29948 		j0 := s0.AuxInt
   29949 		x0 := s0.Args[0]
   29950 		if x0.Op != OpS390XMOVBZloadidx {
   29951 			break
   29952 		}
   29953 		i0 := x0.AuxInt
   29954 		s := x0.Aux
   29955 		_ = x0.Args[2]
   29956 		idx := x0.Args[0]
   29957 		p := x0.Args[1]
   29958 		mem := x0.Args[2]
   29959 		y := or.Args[1]
   29960 		s1 := v.Args[1]
   29961 		if s1.Op != OpS390XSLDconst {
   29962 			break
   29963 		}
   29964 		j1 := s1.AuxInt
   29965 		x1 := s1.Args[0]
   29966 		if x1.Op != OpS390XMOVBZloadidx {
   29967 			break
   29968 		}
   29969 		i1 := x1.AuxInt
   29970 		if x1.Aux != s {
   29971 			break
   29972 		}
   29973 		_ = x1.Args[2]
   29974 		if idx != x1.Args[0] {
   29975 			break
   29976 		}
   29977 		if p != x1.Args[1] {
   29978 			break
   29979 		}
   29980 		if mem != x1.Args[2] {
   29981 			break
   29982 		}
   29983 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   29984 			break
   29985 		}
   29986 		b = mergePoint(b, x0, x1)
   29987 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   29988 		v.reset(OpCopy)
   29989 		v.AddArg(v0)
   29990 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   29991 		v1.AuxInt = j0
   29992 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   29993 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   29994 		v3.AuxInt = i0
   29995 		v3.Aux = s
   29996 		v3.AddArg(p)
   29997 		v3.AddArg(idx)
   29998 		v3.AddArg(mem)
   29999 		v2.AddArg(v3)
   30000 		v1.AddArg(v2)
   30001 		v0.AddArg(v1)
   30002 		v0.AddArg(y)
   30003 		return true
   30004 	}
   30005 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   30006 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30007 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   30008 	for {
   30009 		_ = v.Args[1]
   30010 		or := v.Args[0]
   30011 		if or.Op != OpS390XOR {
   30012 			break
   30013 		}
   30014 		_ = or.Args[1]
   30015 		y := or.Args[0]
   30016 		s0 := or.Args[1]
   30017 		if s0.Op != OpS390XSLDconst {
   30018 			break
   30019 		}
   30020 		j0 := s0.AuxInt
   30021 		x0 := s0.Args[0]
   30022 		if x0.Op != OpS390XMOVBZloadidx {
   30023 			break
   30024 		}
   30025 		i0 := x0.AuxInt
   30026 		s := x0.Aux
   30027 		_ = x0.Args[2]
   30028 		p := x0.Args[0]
   30029 		idx := x0.Args[1]
   30030 		mem := x0.Args[2]
   30031 		s1 := v.Args[1]
   30032 		if s1.Op != OpS390XSLDconst {
   30033 			break
   30034 		}
   30035 		j1 := s1.AuxInt
   30036 		x1 := s1.Args[0]
   30037 		if x1.Op != OpS390XMOVBZloadidx {
   30038 			break
   30039 		}
   30040 		i1 := x1.AuxInt
   30041 		if x1.Aux != s {
   30042 			break
   30043 		}
   30044 		_ = x1.Args[2]
   30045 		if idx != x1.Args[0] {
   30046 			break
   30047 		}
   30048 		if p != x1.Args[1] {
   30049 			break
   30050 		}
   30051 		if mem != x1.Args[2] {
   30052 			break
   30053 		}
   30054 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30055 			break
   30056 		}
   30057 		b = mergePoint(b, x0, x1)
   30058 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30059 		v.reset(OpCopy)
   30060 		v.AddArg(v0)
   30061 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30062 		v1.AuxInt = j0
   30063 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   30064 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   30065 		v3.AuxInt = i0
   30066 		v3.Aux = s
   30067 		v3.AddArg(p)
   30068 		v3.AddArg(idx)
   30069 		v3.AddArg(mem)
   30070 		v2.AddArg(v3)
   30071 		v1.AddArg(v2)
   30072 		v0.AddArg(v1)
   30073 		v0.AddArg(y)
   30074 		return true
   30075 	}
   30076 	return false
   30077 }
   30078 func rewriteValueS390X_OpS390XOR_140(v *Value) bool {
   30079 	b := v.Block
   30080 	_ = b
   30081 	typ := &b.Func.Config.Types
   30082 	_ = typ
   30083 	// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   30084 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30085 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   30086 	for {
   30087 		_ = v.Args[1]
   30088 		or := v.Args[0]
   30089 		if or.Op != OpS390XOR {
   30090 			break
   30091 		}
   30092 		_ = or.Args[1]
   30093 		y := or.Args[0]
   30094 		s0 := or.Args[1]
   30095 		if s0.Op != OpS390XSLDconst {
   30096 			break
   30097 		}
   30098 		j0 := s0.AuxInt
   30099 		x0 := s0.Args[0]
   30100 		if x0.Op != OpS390XMOVBZloadidx {
   30101 			break
   30102 		}
   30103 		i0 := x0.AuxInt
   30104 		s := x0.Aux
   30105 		_ = x0.Args[2]
   30106 		idx := x0.Args[0]
   30107 		p := x0.Args[1]
   30108 		mem := x0.Args[2]
   30109 		s1 := v.Args[1]
   30110 		if s1.Op != OpS390XSLDconst {
   30111 			break
   30112 		}
   30113 		j1 := s1.AuxInt
   30114 		x1 := s1.Args[0]
   30115 		if x1.Op != OpS390XMOVBZloadidx {
   30116 			break
   30117 		}
   30118 		i1 := x1.AuxInt
   30119 		if x1.Aux != s {
   30120 			break
   30121 		}
   30122 		_ = x1.Args[2]
   30123 		if idx != x1.Args[0] {
   30124 			break
   30125 		}
   30126 		if p != x1.Args[1] {
   30127 			break
   30128 		}
   30129 		if mem != x1.Args[2] {
   30130 			break
   30131 		}
   30132 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30133 			break
   30134 		}
   30135 		b = mergePoint(b, x0, x1)
   30136 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30137 		v.reset(OpCopy)
   30138 		v.AddArg(v0)
   30139 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30140 		v1.AuxInt = j0
   30141 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   30142 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   30143 		v3.AuxInt = i0
   30144 		v3.Aux = s
   30145 		v3.AddArg(p)
   30146 		v3.AddArg(idx)
   30147 		v3.AddArg(mem)
   30148 		v2.AddArg(v3)
   30149 		v1.AddArg(v2)
   30150 		v0.AddArg(v1)
   30151 		v0.AddArg(y)
   30152 		return true
   30153 	}
   30154 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y))
   30155 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30156 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30157 	for {
   30158 		_ = v.Args[1]
   30159 		s1 := v.Args[0]
   30160 		if s1.Op != OpS390XSLDconst {
   30161 			break
   30162 		}
   30163 		j1 := s1.AuxInt
   30164 		r1 := s1.Args[0]
   30165 		if r1.Op != OpS390XMOVHZreg {
   30166 			break
   30167 		}
   30168 		x1 := r1.Args[0]
   30169 		if x1.Op != OpS390XMOVHBRloadidx {
   30170 			break
   30171 		}
   30172 		i1 := x1.AuxInt
   30173 		s := x1.Aux
   30174 		_ = x1.Args[2]
   30175 		p := x1.Args[0]
   30176 		idx := x1.Args[1]
   30177 		mem := x1.Args[2]
   30178 		or := v.Args[1]
   30179 		if or.Op != OpS390XOR {
   30180 			break
   30181 		}
   30182 		_ = or.Args[1]
   30183 		s0 := or.Args[0]
   30184 		if s0.Op != OpS390XSLDconst {
   30185 			break
   30186 		}
   30187 		j0 := s0.AuxInt
   30188 		r0 := s0.Args[0]
   30189 		if r0.Op != OpS390XMOVHZreg {
   30190 			break
   30191 		}
   30192 		x0 := r0.Args[0]
   30193 		if x0.Op != OpS390XMOVHBRloadidx {
   30194 			break
   30195 		}
   30196 		i0 := x0.AuxInt
   30197 		if x0.Aux != s {
   30198 			break
   30199 		}
   30200 		_ = x0.Args[2]
   30201 		if p != x0.Args[0] {
   30202 			break
   30203 		}
   30204 		if idx != x0.Args[1] {
   30205 			break
   30206 		}
   30207 		if mem != x0.Args[2] {
   30208 			break
   30209 		}
   30210 		y := or.Args[1]
   30211 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30212 			break
   30213 		}
   30214 		b = mergePoint(b, x0, x1)
   30215 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30216 		v.reset(OpCopy)
   30217 		v.AddArg(v0)
   30218 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30219 		v1.AuxInt = j0
   30220 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30221 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30222 		v3.AuxInt = i0
   30223 		v3.Aux = s
   30224 		v3.AddArg(p)
   30225 		v3.AddArg(idx)
   30226 		v3.AddArg(mem)
   30227 		v2.AddArg(v3)
   30228 		v1.AddArg(v2)
   30229 		v0.AddArg(v1)
   30230 		v0.AddArg(y)
   30231 		return true
   30232 	}
   30233 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y))
   30234 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30235 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30236 	for {
   30237 		_ = v.Args[1]
   30238 		s1 := v.Args[0]
   30239 		if s1.Op != OpS390XSLDconst {
   30240 			break
   30241 		}
   30242 		j1 := s1.AuxInt
   30243 		r1 := s1.Args[0]
   30244 		if r1.Op != OpS390XMOVHZreg {
   30245 			break
   30246 		}
   30247 		x1 := r1.Args[0]
   30248 		if x1.Op != OpS390XMOVHBRloadidx {
   30249 			break
   30250 		}
   30251 		i1 := x1.AuxInt
   30252 		s := x1.Aux
   30253 		_ = x1.Args[2]
   30254 		idx := x1.Args[0]
   30255 		p := x1.Args[1]
   30256 		mem := x1.Args[2]
   30257 		or := v.Args[1]
   30258 		if or.Op != OpS390XOR {
   30259 			break
   30260 		}
   30261 		_ = or.Args[1]
   30262 		s0 := or.Args[0]
   30263 		if s0.Op != OpS390XSLDconst {
   30264 			break
   30265 		}
   30266 		j0 := s0.AuxInt
   30267 		r0 := s0.Args[0]
   30268 		if r0.Op != OpS390XMOVHZreg {
   30269 			break
   30270 		}
   30271 		x0 := r0.Args[0]
   30272 		if x0.Op != OpS390XMOVHBRloadidx {
   30273 			break
   30274 		}
   30275 		i0 := x0.AuxInt
   30276 		if x0.Aux != s {
   30277 			break
   30278 		}
   30279 		_ = x0.Args[2]
   30280 		if p != x0.Args[0] {
   30281 			break
   30282 		}
   30283 		if idx != x0.Args[1] {
   30284 			break
   30285 		}
   30286 		if mem != x0.Args[2] {
   30287 			break
   30288 		}
   30289 		y := or.Args[1]
   30290 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30291 			break
   30292 		}
   30293 		b = mergePoint(b, x0, x1)
   30294 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30295 		v.reset(OpCopy)
   30296 		v.AddArg(v0)
   30297 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30298 		v1.AuxInt = j0
   30299 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30300 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30301 		v3.AuxInt = i0
   30302 		v3.Aux = s
   30303 		v3.AddArg(p)
   30304 		v3.AddArg(idx)
   30305 		v3.AddArg(mem)
   30306 		v2.AddArg(v3)
   30307 		v1.AddArg(v2)
   30308 		v0.AddArg(v1)
   30309 		v0.AddArg(y)
   30310 		return true
   30311 	}
   30312 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y))
   30313 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30314 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30315 	for {
   30316 		_ = v.Args[1]
   30317 		s1 := v.Args[0]
   30318 		if s1.Op != OpS390XSLDconst {
   30319 			break
   30320 		}
   30321 		j1 := s1.AuxInt
   30322 		r1 := s1.Args[0]
   30323 		if r1.Op != OpS390XMOVHZreg {
   30324 			break
   30325 		}
   30326 		x1 := r1.Args[0]
   30327 		if x1.Op != OpS390XMOVHBRloadidx {
   30328 			break
   30329 		}
   30330 		i1 := x1.AuxInt
   30331 		s := x1.Aux
   30332 		_ = x1.Args[2]
   30333 		p := x1.Args[0]
   30334 		idx := x1.Args[1]
   30335 		mem := x1.Args[2]
   30336 		or := v.Args[1]
   30337 		if or.Op != OpS390XOR {
   30338 			break
   30339 		}
   30340 		_ = or.Args[1]
   30341 		s0 := or.Args[0]
   30342 		if s0.Op != OpS390XSLDconst {
   30343 			break
   30344 		}
   30345 		j0 := s0.AuxInt
   30346 		r0 := s0.Args[0]
   30347 		if r0.Op != OpS390XMOVHZreg {
   30348 			break
   30349 		}
   30350 		x0 := r0.Args[0]
   30351 		if x0.Op != OpS390XMOVHBRloadidx {
   30352 			break
   30353 		}
   30354 		i0 := x0.AuxInt
   30355 		if x0.Aux != s {
   30356 			break
   30357 		}
   30358 		_ = x0.Args[2]
   30359 		if idx != x0.Args[0] {
   30360 			break
   30361 		}
   30362 		if p != x0.Args[1] {
   30363 			break
   30364 		}
   30365 		if mem != x0.Args[2] {
   30366 			break
   30367 		}
   30368 		y := or.Args[1]
   30369 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30370 			break
   30371 		}
   30372 		b = mergePoint(b, x0, x1)
   30373 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30374 		v.reset(OpCopy)
   30375 		v.AddArg(v0)
   30376 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30377 		v1.AuxInt = j0
   30378 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30379 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30380 		v3.AuxInt = i0
   30381 		v3.Aux = s
   30382 		v3.AddArg(p)
   30383 		v3.AddArg(idx)
   30384 		v3.AddArg(mem)
   30385 		v2.AddArg(v3)
   30386 		v1.AddArg(v2)
   30387 		v0.AddArg(v1)
   30388 		v0.AddArg(y)
   30389 		return true
   30390 	}
   30391 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y))
   30392 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30393 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30394 	for {
   30395 		_ = v.Args[1]
   30396 		s1 := v.Args[0]
   30397 		if s1.Op != OpS390XSLDconst {
   30398 			break
   30399 		}
   30400 		j1 := s1.AuxInt
   30401 		r1 := s1.Args[0]
   30402 		if r1.Op != OpS390XMOVHZreg {
   30403 			break
   30404 		}
   30405 		x1 := r1.Args[0]
   30406 		if x1.Op != OpS390XMOVHBRloadidx {
   30407 			break
   30408 		}
   30409 		i1 := x1.AuxInt
   30410 		s := x1.Aux
   30411 		_ = x1.Args[2]
   30412 		idx := x1.Args[0]
   30413 		p := x1.Args[1]
   30414 		mem := x1.Args[2]
   30415 		or := v.Args[1]
   30416 		if or.Op != OpS390XOR {
   30417 			break
   30418 		}
   30419 		_ = or.Args[1]
   30420 		s0 := or.Args[0]
   30421 		if s0.Op != OpS390XSLDconst {
   30422 			break
   30423 		}
   30424 		j0 := s0.AuxInt
   30425 		r0 := s0.Args[0]
   30426 		if r0.Op != OpS390XMOVHZreg {
   30427 			break
   30428 		}
   30429 		x0 := r0.Args[0]
   30430 		if x0.Op != OpS390XMOVHBRloadidx {
   30431 			break
   30432 		}
   30433 		i0 := x0.AuxInt
   30434 		if x0.Aux != s {
   30435 			break
   30436 		}
   30437 		_ = x0.Args[2]
   30438 		if idx != x0.Args[0] {
   30439 			break
   30440 		}
   30441 		if p != x0.Args[1] {
   30442 			break
   30443 		}
   30444 		if mem != x0.Args[2] {
   30445 			break
   30446 		}
   30447 		y := or.Args[1]
   30448 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30449 			break
   30450 		}
   30451 		b = mergePoint(b, x0, x1)
   30452 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30453 		v.reset(OpCopy)
   30454 		v.AddArg(v0)
   30455 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30456 		v1.AuxInt = j0
   30457 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30458 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30459 		v3.AuxInt = i0
   30460 		v3.Aux = s
   30461 		v3.AddArg(p)
   30462 		v3.AddArg(idx)
   30463 		v3.AddArg(mem)
   30464 		v2.AddArg(v3)
   30465 		v1.AddArg(v2)
   30466 		v0.AddArg(v1)
   30467 		v0.AddArg(y)
   30468 		return true
   30469 	}
   30470 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
   30471 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30472 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30473 	for {
   30474 		_ = v.Args[1]
   30475 		s1 := v.Args[0]
   30476 		if s1.Op != OpS390XSLDconst {
   30477 			break
   30478 		}
   30479 		j1 := s1.AuxInt
   30480 		r1 := s1.Args[0]
   30481 		if r1.Op != OpS390XMOVHZreg {
   30482 			break
   30483 		}
   30484 		x1 := r1.Args[0]
   30485 		if x1.Op != OpS390XMOVHBRloadidx {
   30486 			break
   30487 		}
   30488 		i1 := x1.AuxInt
   30489 		s := x1.Aux
   30490 		_ = x1.Args[2]
   30491 		p := x1.Args[0]
   30492 		idx := x1.Args[1]
   30493 		mem := x1.Args[2]
   30494 		or := v.Args[1]
   30495 		if or.Op != OpS390XOR {
   30496 			break
   30497 		}
   30498 		_ = or.Args[1]
   30499 		y := or.Args[0]
   30500 		s0 := or.Args[1]
   30501 		if s0.Op != OpS390XSLDconst {
   30502 			break
   30503 		}
   30504 		j0 := s0.AuxInt
   30505 		r0 := s0.Args[0]
   30506 		if r0.Op != OpS390XMOVHZreg {
   30507 			break
   30508 		}
   30509 		x0 := r0.Args[0]
   30510 		if x0.Op != OpS390XMOVHBRloadidx {
   30511 			break
   30512 		}
   30513 		i0 := x0.AuxInt
   30514 		if x0.Aux != s {
   30515 			break
   30516 		}
   30517 		_ = x0.Args[2]
   30518 		if p != x0.Args[0] {
   30519 			break
   30520 		}
   30521 		if idx != x0.Args[1] {
   30522 			break
   30523 		}
   30524 		if mem != x0.Args[2] {
   30525 			break
   30526 		}
   30527 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30528 			break
   30529 		}
   30530 		b = mergePoint(b, x0, x1)
   30531 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30532 		v.reset(OpCopy)
   30533 		v.AddArg(v0)
   30534 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30535 		v1.AuxInt = j0
   30536 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30537 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30538 		v3.AuxInt = i0
   30539 		v3.Aux = s
   30540 		v3.AddArg(p)
   30541 		v3.AddArg(idx)
   30542 		v3.AddArg(mem)
   30543 		v2.AddArg(v3)
   30544 		v1.AddArg(v2)
   30545 		v0.AddArg(v1)
   30546 		v0.AddArg(y)
   30547 		return true
   30548 	}
   30549 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
   30550 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30551 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30552 	for {
   30553 		_ = v.Args[1]
   30554 		s1 := v.Args[0]
   30555 		if s1.Op != OpS390XSLDconst {
   30556 			break
   30557 		}
   30558 		j1 := s1.AuxInt
   30559 		r1 := s1.Args[0]
   30560 		if r1.Op != OpS390XMOVHZreg {
   30561 			break
   30562 		}
   30563 		x1 := r1.Args[0]
   30564 		if x1.Op != OpS390XMOVHBRloadidx {
   30565 			break
   30566 		}
   30567 		i1 := x1.AuxInt
   30568 		s := x1.Aux
   30569 		_ = x1.Args[2]
   30570 		idx := x1.Args[0]
   30571 		p := x1.Args[1]
   30572 		mem := x1.Args[2]
   30573 		or := v.Args[1]
   30574 		if or.Op != OpS390XOR {
   30575 			break
   30576 		}
   30577 		_ = or.Args[1]
   30578 		y := or.Args[0]
   30579 		s0 := or.Args[1]
   30580 		if s0.Op != OpS390XSLDconst {
   30581 			break
   30582 		}
   30583 		j0 := s0.AuxInt
   30584 		r0 := s0.Args[0]
   30585 		if r0.Op != OpS390XMOVHZreg {
   30586 			break
   30587 		}
   30588 		x0 := r0.Args[0]
   30589 		if x0.Op != OpS390XMOVHBRloadidx {
   30590 			break
   30591 		}
   30592 		i0 := x0.AuxInt
   30593 		if x0.Aux != s {
   30594 			break
   30595 		}
   30596 		_ = x0.Args[2]
   30597 		if p != x0.Args[0] {
   30598 			break
   30599 		}
   30600 		if idx != x0.Args[1] {
   30601 			break
   30602 		}
   30603 		if mem != x0.Args[2] {
   30604 			break
   30605 		}
   30606 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30607 			break
   30608 		}
   30609 		b = mergePoint(b, x0, x1)
   30610 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30611 		v.reset(OpCopy)
   30612 		v.AddArg(v0)
   30613 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30614 		v1.AuxInt = j0
   30615 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30616 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30617 		v3.AuxInt = i0
   30618 		v3.Aux = s
   30619 		v3.AddArg(p)
   30620 		v3.AddArg(idx)
   30621 		v3.AddArg(mem)
   30622 		v2.AddArg(v3)
   30623 		v1.AddArg(v2)
   30624 		v0.AddArg(v1)
   30625 		v0.AddArg(y)
   30626 		return true
   30627 	}
   30628 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))))
   30629 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30630 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30631 	for {
   30632 		_ = v.Args[1]
   30633 		s1 := v.Args[0]
   30634 		if s1.Op != OpS390XSLDconst {
   30635 			break
   30636 		}
   30637 		j1 := s1.AuxInt
   30638 		r1 := s1.Args[0]
   30639 		if r1.Op != OpS390XMOVHZreg {
   30640 			break
   30641 		}
   30642 		x1 := r1.Args[0]
   30643 		if x1.Op != OpS390XMOVHBRloadidx {
   30644 			break
   30645 		}
   30646 		i1 := x1.AuxInt
   30647 		s := x1.Aux
   30648 		_ = x1.Args[2]
   30649 		p := x1.Args[0]
   30650 		idx := x1.Args[1]
   30651 		mem := x1.Args[2]
   30652 		or := v.Args[1]
   30653 		if or.Op != OpS390XOR {
   30654 			break
   30655 		}
   30656 		_ = or.Args[1]
   30657 		y := or.Args[0]
   30658 		s0 := or.Args[1]
   30659 		if s0.Op != OpS390XSLDconst {
   30660 			break
   30661 		}
   30662 		j0 := s0.AuxInt
   30663 		r0 := s0.Args[0]
   30664 		if r0.Op != OpS390XMOVHZreg {
   30665 			break
   30666 		}
   30667 		x0 := r0.Args[0]
   30668 		if x0.Op != OpS390XMOVHBRloadidx {
   30669 			break
   30670 		}
   30671 		i0 := x0.AuxInt
   30672 		if x0.Aux != s {
   30673 			break
   30674 		}
   30675 		_ = x0.Args[2]
   30676 		if idx != x0.Args[0] {
   30677 			break
   30678 		}
   30679 		if p != x0.Args[1] {
   30680 			break
   30681 		}
   30682 		if mem != x0.Args[2] {
   30683 			break
   30684 		}
   30685 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30686 			break
   30687 		}
   30688 		b = mergePoint(b, x0, x1)
   30689 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30690 		v.reset(OpCopy)
   30691 		v.AddArg(v0)
   30692 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30693 		v1.AuxInt = j0
   30694 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30695 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30696 		v3.AuxInt = i0
   30697 		v3.Aux = s
   30698 		v3.AddArg(p)
   30699 		v3.AddArg(idx)
   30700 		v3.AddArg(mem)
   30701 		v2.AddArg(v3)
   30702 		v1.AddArg(v2)
   30703 		v0.AddArg(v1)
   30704 		v0.AddArg(y)
   30705 		return true
   30706 	}
   30707 	// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))))
   30708 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30709 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30710 	for {
   30711 		_ = v.Args[1]
   30712 		s1 := v.Args[0]
   30713 		if s1.Op != OpS390XSLDconst {
   30714 			break
   30715 		}
   30716 		j1 := s1.AuxInt
   30717 		r1 := s1.Args[0]
   30718 		if r1.Op != OpS390XMOVHZreg {
   30719 			break
   30720 		}
   30721 		x1 := r1.Args[0]
   30722 		if x1.Op != OpS390XMOVHBRloadidx {
   30723 			break
   30724 		}
   30725 		i1 := x1.AuxInt
   30726 		s := x1.Aux
   30727 		_ = x1.Args[2]
   30728 		idx := x1.Args[0]
   30729 		p := x1.Args[1]
   30730 		mem := x1.Args[2]
   30731 		or := v.Args[1]
   30732 		if or.Op != OpS390XOR {
   30733 			break
   30734 		}
   30735 		_ = or.Args[1]
   30736 		y := or.Args[0]
   30737 		s0 := or.Args[1]
   30738 		if s0.Op != OpS390XSLDconst {
   30739 			break
   30740 		}
   30741 		j0 := s0.AuxInt
   30742 		r0 := s0.Args[0]
   30743 		if r0.Op != OpS390XMOVHZreg {
   30744 			break
   30745 		}
   30746 		x0 := r0.Args[0]
   30747 		if x0.Op != OpS390XMOVHBRloadidx {
   30748 			break
   30749 		}
   30750 		i0 := x0.AuxInt
   30751 		if x0.Aux != s {
   30752 			break
   30753 		}
   30754 		_ = x0.Args[2]
   30755 		if idx != x0.Args[0] {
   30756 			break
   30757 		}
   30758 		if p != x0.Args[1] {
   30759 			break
   30760 		}
   30761 		if mem != x0.Args[2] {
   30762 			break
   30763 		}
   30764 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30765 			break
   30766 		}
   30767 		b = mergePoint(b, x0, x1)
   30768 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30769 		v.reset(OpCopy)
   30770 		v.AddArg(v0)
   30771 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30772 		v1.AuxInt = j0
   30773 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30774 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30775 		v3.AuxInt = i0
   30776 		v3.Aux = s
   30777 		v3.AddArg(p)
   30778 		v3.AddArg(idx)
   30779 		v3.AddArg(mem)
   30780 		v2.AddArg(v3)
   30781 		v1.AddArg(v2)
   30782 		v0.AddArg(v1)
   30783 		v0.AddArg(y)
   30784 		return true
   30785 	}
   30786 	// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   30787 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30788 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30789 	for {
   30790 		_ = v.Args[1]
   30791 		or := v.Args[0]
   30792 		if or.Op != OpS390XOR {
   30793 			break
   30794 		}
   30795 		_ = or.Args[1]
   30796 		s0 := or.Args[0]
   30797 		if s0.Op != OpS390XSLDconst {
   30798 			break
   30799 		}
   30800 		j0 := s0.AuxInt
   30801 		r0 := s0.Args[0]
   30802 		if r0.Op != OpS390XMOVHZreg {
   30803 			break
   30804 		}
   30805 		x0 := r0.Args[0]
   30806 		if x0.Op != OpS390XMOVHBRloadidx {
   30807 			break
   30808 		}
   30809 		i0 := x0.AuxInt
   30810 		s := x0.Aux
   30811 		_ = x0.Args[2]
   30812 		p := x0.Args[0]
   30813 		idx := x0.Args[1]
   30814 		mem := x0.Args[2]
   30815 		y := or.Args[1]
   30816 		s1 := v.Args[1]
   30817 		if s1.Op != OpS390XSLDconst {
   30818 			break
   30819 		}
   30820 		j1 := s1.AuxInt
   30821 		r1 := s1.Args[0]
   30822 		if r1.Op != OpS390XMOVHZreg {
   30823 			break
   30824 		}
   30825 		x1 := r1.Args[0]
   30826 		if x1.Op != OpS390XMOVHBRloadidx {
   30827 			break
   30828 		}
   30829 		i1 := x1.AuxInt
   30830 		if x1.Aux != s {
   30831 			break
   30832 		}
   30833 		_ = x1.Args[2]
   30834 		if p != x1.Args[0] {
   30835 			break
   30836 		}
   30837 		if idx != x1.Args[1] {
   30838 			break
   30839 		}
   30840 		if mem != x1.Args[2] {
   30841 			break
   30842 		}
   30843 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30844 			break
   30845 		}
   30846 		b = mergePoint(b, x0, x1)
   30847 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30848 		v.reset(OpCopy)
   30849 		v.AddArg(v0)
   30850 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30851 		v1.AuxInt = j0
   30852 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30853 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30854 		v3.AuxInt = i0
   30855 		v3.Aux = s
   30856 		v3.AddArg(p)
   30857 		v3.AddArg(idx)
   30858 		v3.AddArg(mem)
   30859 		v2.AddArg(v3)
   30860 		v1.AddArg(v2)
   30861 		v0.AddArg(v1)
   30862 		v0.AddArg(y)
   30863 		return true
   30864 	}
   30865 	return false
   30866 }
   30867 func rewriteValueS390X_OpS390XOR_150(v *Value) bool {
   30868 	b := v.Block
   30869 	_ = b
   30870 	typ := &b.Func.Config.Types
   30871 	_ = typ
   30872 	// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   30873 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30874 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30875 	for {
   30876 		_ = v.Args[1]
   30877 		or := v.Args[0]
   30878 		if or.Op != OpS390XOR {
   30879 			break
   30880 		}
   30881 		_ = or.Args[1]
   30882 		s0 := or.Args[0]
   30883 		if s0.Op != OpS390XSLDconst {
   30884 			break
   30885 		}
   30886 		j0 := s0.AuxInt
   30887 		r0 := s0.Args[0]
   30888 		if r0.Op != OpS390XMOVHZreg {
   30889 			break
   30890 		}
   30891 		x0 := r0.Args[0]
   30892 		if x0.Op != OpS390XMOVHBRloadidx {
   30893 			break
   30894 		}
   30895 		i0 := x0.AuxInt
   30896 		s := x0.Aux
   30897 		_ = x0.Args[2]
   30898 		idx := x0.Args[0]
   30899 		p := x0.Args[1]
   30900 		mem := x0.Args[2]
   30901 		y := or.Args[1]
   30902 		s1 := v.Args[1]
   30903 		if s1.Op != OpS390XSLDconst {
   30904 			break
   30905 		}
   30906 		j1 := s1.AuxInt
   30907 		r1 := s1.Args[0]
   30908 		if r1.Op != OpS390XMOVHZreg {
   30909 			break
   30910 		}
   30911 		x1 := r1.Args[0]
   30912 		if x1.Op != OpS390XMOVHBRloadidx {
   30913 			break
   30914 		}
   30915 		i1 := x1.AuxInt
   30916 		if x1.Aux != s {
   30917 			break
   30918 		}
   30919 		_ = x1.Args[2]
   30920 		if p != x1.Args[0] {
   30921 			break
   30922 		}
   30923 		if idx != x1.Args[1] {
   30924 			break
   30925 		}
   30926 		if mem != x1.Args[2] {
   30927 			break
   30928 		}
   30929 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   30930 			break
   30931 		}
   30932 		b = mergePoint(b, x0, x1)
   30933 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   30934 		v.reset(OpCopy)
   30935 		v.AddArg(v0)
   30936 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   30937 		v1.AuxInt = j0
   30938 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   30939 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   30940 		v3.AuxInt = i0
   30941 		v3.Aux = s
   30942 		v3.AddArg(p)
   30943 		v3.AddArg(idx)
   30944 		v3.AddArg(mem)
   30945 		v2.AddArg(v3)
   30946 		v1.AddArg(v2)
   30947 		v0.AddArg(v1)
   30948 		v0.AddArg(y)
   30949 		return true
   30950 	}
   30951 	// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   30952 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   30953 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   30954 	for {
   30955 		_ = v.Args[1]
   30956 		or := v.Args[0]
   30957 		if or.Op != OpS390XOR {
   30958 			break
   30959 		}
   30960 		_ = or.Args[1]
   30961 		y := or.Args[0]
   30962 		s0 := or.Args[1]
   30963 		if s0.Op != OpS390XSLDconst {
   30964 			break
   30965 		}
   30966 		j0 := s0.AuxInt
   30967 		r0 := s0.Args[0]
   30968 		if r0.Op != OpS390XMOVHZreg {
   30969 			break
   30970 		}
   30971 		x0 := r0.Args[0]
   30972 		if x0.Op != OpS390XMOVHBRloadidx {
   30973 			break
   30974 		}
   30975 		i0 := x0.AuxInt
   30976 		s := x0.Aux
   30977 		_ = x0.Args[2]
   30978 		p := x0.Args[0]
   30979 		idx := x0.Args[1]
   30980 		mem := x0.Args[2]
   30981 		s1 := v.Args[1]
   30982 		if s1.Op != OpS390XSLDconst {
   30983 			break
   30984 		}
   30985 		j1 := s1.AuxInt
   30986 		r1 := s1.Args[0]
   30987 		if r1.Op != OpS390XMOVHZreg {
   30988 			break
   30989 		}
   30990 		x1 := r1.Args[0]
   30991 		if x1.Op != OpS390XMOVHBRloadidx {
   30992 			break
   30993 		}
   30994 		i1 := x1.AuxInt
   30995 		if x1.Aux != s {
   30996 			break
   30997 		}
   30998 		_ = x1.Args[2]
   30999 		if p != x1.Args[0] {
   31000 			break
   31001 		}
   31002 		if idx != x1.Args[1] {
   31003 			break
   31004 		}
   31005 		if mem != x1.Args[2] {
   31006 			break
   31007 		}
   31008 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   31009 			break
   31010 		}
   31011 		b = mergePoint(b, x0, x1)
   31012 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   31013 		v.reset(OpCopy)
   31014 		v.AddArg(v0)
   31015 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   31016 		v1.AuxInt = j0
   31017 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   31018 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   31019 		v3.AuxInt = i0
   31020 		v3.Aux = s
   31021 		v3.AddArg(p)
   31022 		v3.AddArg(idx)
   31023 		v3.AddArg(mem)
   31024 		v2.AddArg(v3)
   31025 		v1.AddArg(v2)
   31026 		v0.AddArg(v1)
   31027 		v0.AddArg(y)
   31028 		return true
   31029 	}
   31030 	// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   31031 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   31032 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   31033 	for {
   31034 		_ = v.Args[1]
   31035 		or := v.Args[0]
   31036 		if or.Op != OpS390XOR {
   31037 			break
   31038 		}
   31039 		_ = or.Args[1]
   31040 		y := or.Args[0]
   31041 		s0 := or.Args[1]
   31042 		if s0.Op != OpS390XSLDconst {
   31043 			break
   31044 		}
   31045 		j0 := s0.AuxInt
   31046 		r0 := s0.Args[0]
   31047 		if r0.Op != OpS390XMOVHZreg {
   31048 			break
   31049 		}
   31050 		x0 := r0.Args[0]
   31051 		if x0.Op != OpS390XMOVHBRloadidx {
   31052 			break
   31053 		}
   31054 		i0 := x0.AuxInt
   31055 		s := x0.Aux
   31056 		_ = x0.Args[2]
   31057 		idx := x0.Args[0]
   31058 		p := x0.Args[1]
   31059 		mem := x0.Args[2]
   31060 		s1 := v.Args[1]
   31061 		if s1.Op != OpS390XSLDconst {
   31062 			break
   31063 		}
   31064 		j1 := s1.AuxInt
   31065 		r1 := s1.Args[0]
   31066 		if r1.Op != OpS390XMOVHZreg {
   31067 			break
   31068 		}
   31069 		x1 := r1.Args[0]
   31070 		if x1.Op != OpS390XMOVHBRloadidx {
   31071 			break
   31072 		}
   31073 		i1 := x1.AuxInt
   31074 		if x1.Aux != s {
   31075 			break
   31076 		}
   31077 		_ = x1.Args[2]
   31078 		if p != x1.Args[0] {
   31079 			break
   31080 		}
   31081 		if idx != x1.Args[1] {
   31082 			break
   31083 		}
   31084 		if mem != x1.Args[2] {
   31085 			break
   31086 		}
   31087 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   31088 			break
   31089 		}
   31090 		b = mergePoint(b, x0, x1)
   31091 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   31092 		v.reset(OpCopy)
   31093 		v.AddArg(v0)
   31094 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   31095 		v1.AuxInt = j0
   31096 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   31097 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   31098 		v3.AuxInt = i0
   31099 		v3.Aux = s
   31100 		v3.AddArg(p)
   31101 		v3.AddArg(idx)
   31102 		v3.AddArg(mem)
   31103 		v2.AddArg(v3)
   31104 		v1.AddArg(v2)
   31105 		v0.AddArg(v1)
   31106 		v0.AddArg(y)
   31107 		return true
   31108 	}
   31109 	// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   31110 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   31111 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   31112 	for {
   31113 		_ = v.Args[1]
   31114 		or := v.Args[0]
   31115 		if or.Op != OpS390XOR {
   31116 			break
   31117 		}
   31118 		_ = or.Args[1]
   31119 		s0 := or.Args[0]
   31120 		if s0.Op != OpS390XSLDconst {
   31121 			break
   31122 		}
   31123 		j0 := s0.AuxInt
   31124 		r0 := s0.Args[0]
   31125 		if r0.Op != OpS390XMOVHZreg {
   31126 			break
   31127 		}
   31128 		x0 := r0.Args[0]
   31129 		if x0.Op != OpS390XMOVHBRloadidx {
   31130 			break
   31131 		}
   31132 		i0 := x0.AuxInt
   31133 		s := x0.Aux
   31134 		_ = x0.Args[2]
   31135 		p := x0.Args[0]
   31136 		idx := x0.Args[1]
   31137 		mem := x0.Args[2]
   31138 		y := or.Args[1]
   31139 		s1 := v.Args[1]
   31140 		if s1.Op != OpS390XSLDconst {
   31141 			break
   31142 		}
   31143 		j1 := s1.AuxInt
   31144 		r1 := s1.Args[0]
   31145 		if r1.Op != OpS390XMOVHZreg {
   31146 			break
   31147 		}
   31148 		x1 := r1.Args[0]
   31149 		if x1.Op != OpS390XMOVHBRloadidx {
   31150 			break
   31151 		}
   31152 		i1 := x1.AuxInt
   31153 		if x1.Aux != s {
   31154 			break
   31155 		}
   31156 		_ = x1.Args[2]
   31157 		if idx != x1.Args[0] {
   31158 			break
   31159 		}
   31160 		if p != x1.Args[1] {
   31161 			break
   31162 		}
   31163 		if mem != x1.Args[2] {
   31164 			break
   31165 		}
   31166 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   31167 			break
   31168 		}
   31169 		b = mergePoint(b, x0, x1)
   31170 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   31171 		v.reset(OpCopy)
   31172 		v.AddArg(v0)
   31173 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   31174 		v1.AuxInt = j0
   31175 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   31176 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   31177 		v3.AuxInt = i0
   31178 		v3.Aux = s
   31179 		v3.AddArg(p)
   31180 		v3.AddArg(idx)
   31181 		v3.AddArg(mem)
   31182 		v2.AddArg(v3)
   31183 		v1.AddArg(v2)
   31184 		v0.AddArg(v1)
   31185 		v0.AddArg(y)
   31186 		return true
   31187 	}
   31188 	// match: (OR or:(OR s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) y) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   31189 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   31190 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   31191 	for {
   31192 		_ = v.Args[1]
   31193 		or := v.Args[0]
   31194 		if or.Op != OpS390XOR {
   31195 			break
   31196 		}
   31197 		_ = or.Args[1]
   31198 		s0 := or.Args[0]
   31199 		if s0.Op != OpS390XSLDconst {
   31200 			break
   31201 		}
   31202 		j0 := s0.AuxInt
   31203 		r0 := s0.Args[0]
   31204 		if r0.Op != OpS390XMOVHZreg {
   31205 			break
   31206 		}
   31207 		x0 := r0.Args[0]
   31208 		if x0.Op != OpS390XMOVHBRloadidx {
   31209 			break
   31210 		}
   31211 		i0 := x0.AuxInt
   31212 		s := x0.Aux
   31213 		_ = x0.Args[2]
   31214 		idx := x0.Args[0]
   31215 		p := x0.Args[1]
   31216 		mem := x0.Args[2]
   31217 		y := or.Args[1]
   31218 		s1 := v.Args[1]
   31219 		if s1.Op != OpS390XSLDconst {
   31220 			break
   31221 		}
   31222 		j1 := s1.AuxInt
   31223 		r1 := s1.Args[0]
   31224 		if r1.Op != OpS390XMOVHZreg {
   31225 			break
   31226 		}
   31227 		x1 := r1.Args[0]
   31228 		if x1.Op != OpS390XMOVHBRloadidx {
   31229 			break
   31230 		}
   31231 		i1 := x1.AuxInt
   31232 		if x1.Aux != s {
   31233 			break
   31234 		}
   31235 		_ = x1.Args[2]
   31236 		if idx != x1.Args[0] {
   31237 			break
   31238 		}
   31239 		if p != x1.Args[1] {
   31240 			break
   31241 		}
   31242 		if mem != x1.Args[2] {
   31243 			break
   31244 		}
   31245 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   31246 			break
   31247 		}
   31248 		b = mergePoint(b, x0, x1)
   31249 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   31250 		v.reset(OpCopy)
   31251 		v.AddArg(v0)
   31252 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   31253 		v1.AuxInt = j0
   31254 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   31255 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   31256 		v3.AuxInt = i0
   31257 		v3.Aux = s
   31258 		v3.AddArg(p)
   31259 		v3.AddArg(idx)
   31260 		v3.AddArg(mem)
   31261 		v2.AddArg(v3)
   31262 		v1.AddArg(v2)
   31263 		v0.AddArg(v1)
   31264 		v0.AddArg(y)
   31265 		return true
   31266 	}
   31267 	// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   31268 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   31269 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   31270 	for {
   31271 		_ = v.Args[1]
   31272 		or := v.Args[0]
   31273 		if or.Op != OpS390XOR {
   31274 			break
   31275 		}
   31276 		_ = or.Args[1]
   31277 		y := or.Args[0]
   31278 		s0 := or.Args[1]
   31279 		if s0.Op != OpS390XSLDconst {
   31280 			break
   31281 		}
   31282 		j0 := s0.AuxInt
   31283 		r0 := s0.Args[0]
   31284 		if r0.Op != OpS390XMOVHZreg {
   31285 			break
   31286 		}
   31287 		x0 := r0.Args[0]
   31288 		if x0.Op != OpS390XMOVHBRloadidx {
   31289 			break
   31290 		}
   31291 		i0 := x0.AuxInt
   31292 		s := x0.Aux
   31293 		_ = x0.Args[2]
   31294 		p := x0.Args[0]
   31295 		idx := x0.Args[1]
   31296 		mem := x0.Args[2]
   31297 		s1 := v.Args[1]
   31298 		if s1.Op != OpS390XSLDconst {
   31299 			break
   31300 		}
   31301 		j1 := s1.AuxInt
   31302 		r1 := s1.Args[0]
   31303 		if r1.Op != OpS390XMOVHZreg {
   31304 			break
   31305 		}
   31306 		x1 := r1.Args[0]
   31307 		if x1.Op != OpS390XMOVHBRloadidx {
   31308 			break
   31309 		}
   31310 		i1 := x1.AuxInt
   31311 		if x1.Aux != s {
   31312 			break
   31313 		}
   31314 		_ = x1.Args[2]
   31315 		if idx != x1.Args[0] {
   31316 			break
   31317 		}
   31318 		if p != x1.Args[1] {
   31319 			break
   31320 		}
   31321 		if mem != x1.Args[2] {
   31322 			break
   31323 		}
   31324 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   31325 			break
   31326 		}
   31327 		b = mergePoint(b, x0, x1)
   31328 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   31329 		v.reset(OpCopy)
   31330 		v.AddArg(v0)
   31331 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   31332 		v1.AuxInt = j0
   31333 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   31334 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   31335 		v3.AuxInt = i0
   31336 		v3.Aux = s
   31337 		v3.AddArg(p)
   31338 		v3.AddArg(idx)
   31339 		v3.AddArg(mem)
   31340 		v2.AddArg(v3)
   31341 		v1.AddArg(v2)
   31342 		v0.AddArg(v1)
   31343 		v0.AddArg(y)
   31344 		return true
   31345 	}
   31346 	// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   31347 	// cond: i1 == i0+2   && j1 == j0+16   && j0 % 32 == 0   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   31348 	// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
   31349 	for {
   31350 		_ = v.Args[1]
   31351 		or := v.Args[0]
   31352 		if or.Op != OpS390XOR {
   31353 			break
   31354 		}
   31355 		_ = or.Args[1]
   31356 		y := or.Args[0]
   31357 		s0 := or.Args[1]
   31358 		if s0.Op != OpS390XSLDconst {
   31359 			break
   31360 		}
   31361 		j0 := s0.AuxInt
   31362 		r0 := s0.Args[0]
   31363 		if r0.Op != OpS390XMOVHZreg {
   31364 			break
   31365 		}
   31366 		x0 := r0.Args[0]
   31367 		if x0.Op != OpS390XMOVHBRloadidx {
   31368 			break
   31369 		}
   31370 		i0 := x0.AuxInt
   31371 		s := x0.Aux
   31372 		_ = x0.Args[2]
   31373 		idx := x0.Args[0]
   31374 		p := x0.Args[1]
   31375 		mem := x0.Args[2]
   31376 		s1 := v.Args[1]
   31377 		if s1.Op != OpS390XSLDconst {
   31378 			break
   31379 		}
   31380 		j1 := s1.AuxInt
   31381 		r1 := s1.Args[0]
   31382 		if r1.Op != OpS390XMOVHZreg {
   31383 			break
   31384 		}
   31385 		x1 := r1.Args[0]
   31386 		if x1.Op != OpS390XMOVHBRloadidx {
   31387 			break
   31388 		}
   31389 		i1 := x1.AuxInt
   31390 		if x1.Aux != s {
   31391 			break
   31392 		}
   31393 		_ = x1.Args[2]
   31394 		if idx != x1.Args[0] {
   31395 			break
   31396 		}
   31397 		if p != x1.Args[1] {
   31398 			break
   31399 		}
   31400 		if mem != x1.Args[2] {
   31401 			break
   31402 		}
   31403 		if !(i1 == i0+2 && j1 == j0+16 && j0%32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)) {
   31404 			break
   31405 		}
   31406 		b = mergePoint(b, x0, x1)
   31407 		v0 := b.NewValue0(v.Pos, OpS390XOR, v.Type)
   31408 		v.reset(OpCopy)
   31409 		v.AddArg(v0)
   31410 		v1 := b.NewValue0(v.Pos, OpS390XSLDconst, v.Type)
   31411 		v1.AuxInt = j0
   31412 		v2 := b.NewValue0(v.Pos, OpS390XMOVWZreg, typ.UInt64)
   31413 		v3 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   31414 		v3.AuxInt = i0
   31415 		v3.Aux = s
   31416 		v3.AddArg(p)
   31417 		v3.AddArg(idx)
   31418 		v3.AddArg(mem)
   31419 		v2.AddArg(v3)
   31420 		v1.AddArg(v2)
   31421 		v0.AddArg(v1)
   31422 		v0.AddArg(y)
   31423 		return true
   31424 	}
   31425 	return false
   31426 }
   31427 func rewriteValueS390X_OpS390XORW_0(v *Value) bool {
   31428 	// match: (ORW x (MOVDconst [c]))
   31429 	// cond:
   31430 	// result: (ORWconst [int64(int32(c))] x)
   31431 	for {
   31432 		_ = v.Args[1]
   31433 		x := v.Args[0]
   31434 		v_1 := v.Args[1]
   31435 		if v_1.Op != OpS390XMOVDconst {
   31436 			break
   31437 		}
   31438 		c := v_1.AuxInt
   31439 		v.reset(OpS390XORWconst)
   31440 		v.AuxInt = int64(int32(c))
   31441 		v.AddArg(x)
   31442 		return true
   31443 	}
   31444 	// match: (ORW (MOVDconst [c]) x)
   31445 	// cond:
   31446 	// result: (ORWconst [int64(int32(c))] x)
   31447 	for {
   31448 		_ = v.Args[1]
   31449 		v_0 := v.Args[0]
   31450 		if v_0.Op != OpS390XMOVDconst {
   31451 			break
   31452 		}
   31453 		c := v_0.AuxInt
   31454 		x := v.Args[1]
   31455 		v.reset(OpS390XORWconst)
   31456 		v.AuxInt = int64(int32(c))
   31457 		v.AddArg(x)
   31458 		return true
   31459 	}
   31460 	// match: (ORW (SLWconst x [c]) (SRWconst x [d]))
   31461 	// cond: d == 32-c
   31462 	// result: (RLLconst [c] x)
   31463 	for {
   31464 		_ = v.Args[1]
   31465 		v_0 := v.Args[0]
   31466 		if v_0.Op != OpS390XSLWconst {
   31467 			break
   31468 		}
   31469 		c := v_0.AuxInt
   31470 		x := v_0.Args[0]
   31471 		v_1 := v.Args[1]
   31472 		if v_1.Op != OpS390XSRWconst {
   31473 			break
   31474 		}
   31475 		d := v_1.AuxInt
   31476 		if x != v_1.Args[0] {
   31477 			break
   31478 		}
   31479 		if !(d == 32-c) {
   31480 			break
   31481 		}
   31482 		v.reset(OpS390XRLLconst)
   31483 		v.AuxInt = c
   31484 		v.AddArg(x)
   31485 		return true
   31486 	}
   31487 	// match: (ORW (SRWconst x [d]) (SLWconst x [c]))
   31488 	// cond: d == 32-c
   31489 	// result: (RLLconst [c] x)
   31490 	for {
   31491 		_ = v.Args[1]
   31492 		v_0 := v.Args[0]
   31493 		if v_0.Op != OpS390XSRWconst {
   31494 			break
   31495 		}
   31496 		d := v_0.AuxInt
   31497 		x := v_0.Args[0]
   31498 		v_1 := v.Args[1]
   31499 		if v_1.Op != OpS390XSLWconst {
   31500 			break
   31501 		}
   31502 		c := v_1.AuxInt
   31503 		if x != v_1.Args[0] {
   31504 			break
   31505 		}
   31506 		if !(d == 32-c) {
   31507 			break
   31508 		}
   31509 		v.reset(OpS390XRLLconst)
   31510 		v.AuxInt = c
   31511 		v.AddArg(x)
   31512 		return true
   31513 	}
   31514 	// match: (ORW x x)
   31515 	// cond:
   31516 	// result: x
   31517 	for {
   31518 		_ = v.Args[1]
   31519 		x := v.Args[0]
   31520 		if x != v.Args[1] {
   31521 			break
   31522 		}
   31523 		v.reset(OpCopy)
   31524 		v.Type = x.Type
   31525 		v.AddArg(x)
   31526 		return true
   31527 	}
   31528 	// match: (ORW <t> x g:(MOVWload [off] {sym} ptr mem))
   31529 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31530 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31531 	for {
   31532 		t := v.Type
   31533 		_ = v.Args[1]
   31534 		x := v.Args[0]
   31535 		g := v.Args[1]
   31536 		if g.Op != OpS390XMOVWload {
   31537 			break
   31538 		}
   31539 		off := g.AuxInt
   31540 		sym := g.Aux
   31541 		_ = g.Args[1]
   31542 		ptr := g.Args[0]
   31543 		mem := g.Args[1]
   31544 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31545 			break
   31546 		}
   31547 		v.reset(OpS390XORWload)
   31548 		v.Type = t
   31549 		v.AuxInt = off
   31550 		v.Aux = sym
   31551 		v.AddArg(x)
   31552 		v.AddArg(ptr)
   31553 		v.AddArg(mem)
   31554 		return true
   31555 	}
   31556 	// match: (ORW <t> g:(MOVWload [off] {sym} ptr mem) x)
   31557 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31558 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31559 	for {
   31560 		t := v.Type
   31561 		_ = v.Args[1]
   31562 		g := v.Args[0]
   31563 		if g.Op != OpS390XMOVWload {
   31564 			break
   31565 		}
   31566 		off := g.AuxInt
   31567 		sym := g.Aux
   31568 		_ = g.Args[1]
   31569 		ptr := g.Args[0]
   31570 		mem := g.Args[1]
   31571 		x := v.Args[1]
   31572 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31573 			break
   31574 		}
   31575 		v.reset(OpS390XORWload)
   31576 		v.Type = t
   31577 		v.AuxInt = off
   31578 		v.Aux = sym
   31579 		v.AddArg(x)
   31580 		v.AddArg(ptr)
   31581 		v.AddArg(mem)
   31582 		return true
   31583 	}
   31584 	// match: (ORW <t> g:(MOVWload [off] {sym} ptr mem) x)
   31585 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31586 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31587 	for {
   31588 		t := v.Type
   31589 		_ = v.Args[1]
   31590 		g := v.Args[0]
   31591 		if g.Op != OpS390XMOVWload {
   31592 			break
   31593 		}
   31594 		off := g.AuxInt
   31595 		sym := g.Aux
   31596 		_ = g.Args[1]
   31597 		ptr := g.Args[0]
   31598 		mem := g.Args[1]
   31599 		x := v.Args[1]
   31600 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31601 			break
   31602 		}
   31603 		v.reset(OpS390XORWload)
   31604 		v.Type = t
   31605 		v.AuxInt = off
   31606 		v.Aux = sym
   31607 		v.AddArg(x)
   31608 		v.AddArg(ptr)
   31609 		v.AddArg(mem)
   31610 		return true
   31611 	}
   31612 	// match: (ORW <t> x g:(MOVWload [off] {sym} ptr mem))
   31613 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31614 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31615 	for {
   31616 		t := v.Type
   31617 		_ = v.Args[1]
   31618 		x := v.Args[0]
   31619 		g := v.Args[1]
   31620 		if g.Op != OpS390XMOVWload {
   31621 			break
   31622 		}
   31623 		off := g.AuxInt
   31624 		sym := g.Aux
   31625 		_ = g.Args[1]
   31626 		ptr := g.Args[0]
   31627 		mem := g.Args[1]
   31628 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31629 			break
   31630 		}
   31631 		v.reset(OpS390XORWload)
   31632 		v.Type = t
   31633 		v.AuxInt = off
   31634 		v.Aux = sym
   31635 		v.AddArg(x)
   31636 		v.AddArg(ptr)
   31637 		v.AddArg(mem)
   31638 		return true
   31639 	}
   31640 	// match: (ORW <t> x g:(MOVWZload [off] {sym} ptr mem))
   31641 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31642 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31643 	for {
   31644 		t := v.Type
   31645 		_ = v.Args[1]
   31646 		x := v.Args[0]
   31647 		g := v.Args[1]
   31648 		if g.Op != OpS390XMOVWZload {
   31649 			break
   31650 		}
   31651 		off := g.AuxInt
   31652 		sym := g.Aux
   31653 		_ = g.Args[1]
   31654 		ptr := g.Args[0]
   31655 		mem := g.Args[1]
   31656 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31657 			break
   31658 		}
   31659 		v.reset(OpS390XORWload)
   31660 		v.Type = t
   31661 		v.AuxInt = off
   31662 		v.Aux = sym
   31663 		v.AddArg(x)
   31664 		v.AddArg(ptr)
   31665 		v.AddArg(mem)
   31666 		return true
   31667 	}
   31668 	return false
   31669 }
   31670 func rewriteValueS390X_OpS390XORW_10(v *Value) bool {
   31671 	b := v.Block
   31672 	_ = b
   31673 	typ := &b.Func.Config.Types
   31674 	_ = typ
   31675 	// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   31676 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31677 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31678 	for {
   31679 		t := v.Type
   31680 		_ = v.Args[1]
   31681 		g := v.Args[0]
   31682 		if g.Op != OpS390XMOVWZload {
   31683 			break
   31684 		}
   31685 		off := g.AuxInt
   31686 		sym := g.Aux
   31687 		_ = g.Args[1]
   31688 		ptr := g.Args[0]
   31689 		mem := g.Args[1]
   31690 		x := v.Args[1]
   31691 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31692 			break
   31693 		}
   31694 		v.reset(OpS390XORWload)
   31695 		v.Type = t
   31696 		v.AuxInt = off
   31697 		v.Aux = sym
   31698 		v.AddArg(x)
   31699 		v.AddArg(ptr)
   31700 		v.AddArg(mem)
   31701 		return true
   31702 	}
   31703 	// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   31704 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31705 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31706 	for {
   31707 		t := v.Type
   31708 		_ = v.Args[1]
   31709 		g := v.Args[0]
   31710 		if g.Op != OpS390XMOVWZload {
   31711 			break
   31712 		}
   31713 		off := g.AuxInt
   31714 		sym := g.Aux
   31715 		_ = g.Args[1]
   31716 		ptr := g.Args[0]
   31717 		mem := g.Args[1]
   31718 		x := v.Args[1]
   31719 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31720 			break
   31721 		}
   31722 		v.reset(OpS390XORWload)
   31723 		v.Type = t
   31724 		v.AuxInt = off
   31725 		v.Aux = sym
   31726 		v.AddArg(x)
   31727 		v.AddArg(ptr)
   31728 		v.AddArg(mem)
   31729 		return true
   31730 	}
   31731 	// match: (ORW <t> x g:(MOVWZload [off] {sym} ptr mem))
   31732 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   31733 	// result: (ORWload <t> [off] {sym} x ptr mem)
   31734 	for {
   31735 		t := v.Type
   31736 		_ = v.Args[1]
   31737 		x := v.Args[0]
   31738 		g := v.Args[1]
   31739 		if g.Op != OpS390XMOVWZload {
   31740 			break
   31741 		}
   31742 		off := g.AuxInt
   31743 		sym := g.Aux
   31744 		_ = g.Args[1]
   31745 		ptr := g.Args[0]
   31746 		mem := g.Args[1]
   31747 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   31748 			break
   31749 		}
   31750 		v.reset(OpS390XORWload)
   31751 		v.Type = t
   31752 		v.AuxInt = off
   31753 		v.Aux = sym
   31754 		v.AddArg(x)
   31755 		v.AddArg(ptr)
   31756 		v.AddArg(mem)
   31757 		return true
   31758 	}
   31759 	// match: (ORW x1:(MOVBZload [i1] {s} p mem) sh:(SLWconst [8] x0:(MOVBZload [i0] {s} p mem)))
   31760 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   31761 	// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
   31762 	for {
   31763 		_ = v.Args[1]
   31764 		x1 := v.Args[0]
   31765 		if x1.Op != OpS390XMOVBZload {
   31766 			break
   31767 		}
   31768 		i1 := x1.AuxInt
   31769 		s := x1.Aux
   31770 		_ = x1.Args[1]
   31771 		p := x1.Args[0]
   31772 		mem := x1.Args[1]
   31773 		sh := v.Args[1]
   31774 		if sh.Op != OpS390XSLWconst {
   31775 			break
   31776 		}
   31777 		if sh.AuxInt != 8 {
   31778 			break
   31779 		}
   31780 		x0 := sh.Args[0]
   31781 		if x0.Op != OpS390XMOVBZload {
   31782 			break
   31783 		}
   31784 		i0 := x0.AuxInt
   31785 		if x0.Aux != s {
   31786 			break
   31787 		}
   31788 		_ = x0.Args[1]
   31789 		if p != x0.Args[0] {
   31790 			break
   31791 		}
   31792 		if mem != x0.Args[1] {
   31793 			break
   31794 		}
   31795 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   31796 			break
   31797 		}
   31798 		b = mergePoint(b, x0, x1)
   31799 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   31800 		v.reset(OpCopy)
   31801 		v.AddArg(v0)
   31802 		v0.AuxInt = i0
   31803 		v0.Aux = s
   31804 		v0.AddArg(p)
   31805 		v0.AddArg(mem)
   31806 		return true
   31807 	}
   31808 	// match: (ORW sh:(SLWconst [8] x0:(MOVBZload [i0] {s} p mem)) x1:(MOVBZload [i1] {s} p mem))
   31809 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   31810 	// result: @mergePoint(b,x0,x1) (MOVHZload [i0] {s} p mem)
   31811 	for {
   31812 		_ = v.Args[1]
   31813 		sh := v.Args[0]
   31814 		if sh.Op != OpS390XSLWconst {
   31815 			break
   31816 		}
   31817 		if sh.AuxInt != 8 {
   31818 			break
   31819 		}
   31820 		x0 := sh.Args[0]
   31821 		if x0.Op != OpS390XMOVBZload {
   31822 			break
   31823 		}
   31824 		i0 := x0.AuxInt
   31825 		s := x0.Aux
   31826 		_ = x0.Args[1]
   31827 		p := x0.Args[0]
   31828 		mem := x0.Args[1]
   31829 		x1 := v.Args[1]
   31830 		if x1.Op != OpS390XMOVBZload {
   31831 			break
   31832 		}
   31833 		i1 := x1.AuxInt
   31834 		if x1.Aux != s {
   31835 			break
   31836 		}
   31837 		_ = x1.Args[1]
   31838 		if p != x1.Args[0] {
   31839 			break
   31840 		}
   31841 		if mem != x1.Args[1] {
   31842 			break
   31843 		}
   31844 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   31845 			break
   31846 		}
   31847 		b = mergePoint(b, x0, x1)
   31848 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   31849 		v.reset(OpCopy)
   31850 		v.AddArg(v0)
   31851 		v0.AuxInt = i0
   31852 		v0.Aux = s
   31853 		v0.AddArg(p)
   31854 		v0.AddArg(mem)
   31855 		return true
   31856 	}
   31857 	// match: (ORW x1:(MOVHZload [i1] {s} p mem) sh:(SLWconst [16] x0:(MOVHZload [i0] {s} p mem)))
   31858 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   31859 	// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
   31860 	for {
   31861 		_ = v.Args[1]
   31862 		x1 := v.Args[0]
   31863 		if x1.Op != OpS390XMOVHZload {
   31864 			break
   31865 		}
   31866 		i1 := x1.AuxInt
   31867 		s := x1.Aux
   31868 		_ = x1.Args[1]
   31869 		p := x1.Args[0]
   31870 		mem := x1.Args[1]
   31871 		sh := v.Args[1]
   31872 		if sh.Op != OpS390XSLWconst {
   31873 			break
   31874 		}
   31875 		if sh.AuxInt != 16 {
   31876 			break
   31877 		}
   31878 		x0 := sh.Args[0]
   31879 		if x0.Op != OpS390XMOVHZload {
   31880 			break
   31881 		}
   31882 		i0 := x0.AuxInt
   31883 		if x0.Aux != s {
   31884 			break
   31885 		}
   31886 		_ = x0.Args[1]
   31887 		if p != x0.Args[0] {
   31888 			break
   31889 		}
   31890 		if mem != x0.Args[1] {
   31891 			break
   31892 		}
   31893 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   31894 			break
   31895 		}
   31896 		b = mergePoint(b, x0, x1)
   31897 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   31898 		v.reset(OpCopy)
   31899 		v.AddArg(v0)
   31900 		v0.AuxInt = i0
   31901 		v0.Aux = s
   31902 		v0.AddArg(p)
   31903 		v0.AddArg(mem)
   31904 		return true
   31905 	}
   31906 	// match: (ORW sh:(SLWconst [16] x0:(MOVHZload [i0] {s} p mem)) x1:(MOVHZload [i1] {s} p mem))
   31907 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   31908 	// result: @mergePoint(b,x0,x1) (MOVWZload [i0] {s} p mem)
   31909 	for {
   31910 		_ = v.Args[1]
   31911 		sh := v.Args[0]
   31912 		if sh.Op != OpS390XSLWconst {
   31913 			break
   31914 		}
   31915 		if sh.AuxInt != 16 {
   31916 			break
   31917 		}
   31918 		x0 := sh.Args[0]
   31919 		if x0.Op != OpS390XMOVHZload {
   31920 			break
   31921 		}
   31922 		i0 := x0.AuxInt
   31923 		s := x0.Aux
   31924 		_ = x0.Args[1]
   31925 		p := x0.Args[0]
   31926 		mem := x0.Args[1]
   31927 		x1 := v.Args[1]
   31928 		if x1.Op != OpS390XMOVHZload {
   31929 			break
   31930 		}
   31931 		i1 := x1.AuxInt
   31932 		if x1.Aux != s {
   31933 			break
   31934 		}
   31935 		_ = x1.Args[1]
   31936 		if p != x1.Args[0] {
   31937 			break
   31938 		}
   31939 		if mem != x1.Args[1] {
   31940 			break
   31941 		}
   31942 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   31943 			break
   31944 		}
   31945 		b = mergePoint(b, x0, x1)
   31946 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZload, typ.UInt32)
   31947 		v.reset(OpCopy)
   31948 		v.AddArg(v0)
   31949 		v0.AuxInt = i0
   31950 		v0.Aux = s
   31951 		v0.AddArg(p)
   31952 		v0.AddArg(mem)
   31953 		return true
   31954 	}
   31955 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) y))
   31956 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   31957 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   31958 	for {
   31959 		_ = v.Args[1]
   31960 		s0 := v.Args[0]
   31961 		if s0.Op != OpS390XSLWconst {
   31962 			break
   31963 		}
   31964 		j0 := s0.AuxInt
   31965 		x0 := s0.Args[0]
   31966 		if x0.Op != OpS390XMOVBZload {
   31967 			break
   31968 		}
   31969 		i0 := x0.AuxInt
   31970 		s := x0.Aux
   31971 		_ = x0.Args[1]
   31972 		p := x0.Args[0]
   31973 		mem := x0.Args[1]
   31974 		or := v.Args[1]
   31975 		if or.Op != OpS390XORW {
   31976 			break
   31977 		}
   31978 		_ = or.Args[1]
   31979 		s1 := or.Args[0]
   31980 		if s1.Op != OpS390XSLWconst {
   31981 			break
   31982 		}
   31983 		j1 := s1.AuxInt
   31984 		x1 := s1.Args[0]
   31985 		if x1.Op != OpS390XMOVBZload {
   31986 			break
   31987 		}
   31988 		i1 := x1.AuxInt
   31989 		if x1.Aux != s {
   31990 			break
   31991 		}
   31992 		_ = x1.Args[1]
   31993 		if p != x1.Args[0] {
   31994 			break
   31995 		}
   31996 		if mem != x1.Args[1] {
   31997 			break
   31998 		}
   31999 		y := or.Args[1]
   32000 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   32001 			break
   32002 		}
   32003 		b = mergePoint(b, x0, x1)
   32004 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   32005 		v.reset(OpCopy)
   32006 		v.AddArg(v0)
   32007 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   32008 		v1.AuxInt = j1
   32009 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   32010 		v2.AuxInt = i0
   32011 		v2.Aux = s
   32012 		v2.AddArg(p)
   32013 		v2.AddArg(mem)
   32014 		v1.AddArg(v2)
   32015 		v0.AddArg(v1)
   32016 		v0.AddArg(y)
   32017 		return true
   32018 	}
   32019 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))))
   32020 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   32021 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   32022 	for {
   32023 		_ = v.Args[1]
   32024 		s0 := v.Args[0]
   32025 		if s0.Op != OpS390XSLWconst {
   32026 			break
   32027 		}
   32028 		j0 := s0.AuxInt
   32029 		x0 := s0.Args[0]
   32030 		if x0.Op != OpS390XMOVBZload {
   32031 			break
   32032 		}
   32033 		i0 := x0.AuxInt
   32034 		s := x0.Aux
   32035 		_ = x0.Args[1]
   32036 		p := x0.Args[0]
   32037 		mem := x0.Args[1]
   32038 		or := v.Args[1]
   32039 		if or.Op != OpS390XORW {
   32040 			break
   32041 		}
   32042 		_ = or.Args[1]
   32043 		y := or.Args[0]
   32044 		s1 := or.Args[1]
   32045 		if s1.Op != OpS390XSLWconst {
   32046 			break
   32047 		}
   32048 		j1 := s1.AuxInt
   32049 		x1 := s1.Args[0]
   32050 		if x1.Op != OpS390XMOVBZload {
   32051 			break
   32052 		}
   32053 		i1 := x1.AuxInt
   32054 		if x1.Aux != s {
   32055 			break
   32056 		}
   32057 		_ = x1.Args[1]
   32058 		if p != x1.Args[0] {
   32059 			break
   32060 		}
   32061 		if mem != x1.Args[1] {
   32062 			break
   32063 		}
   32064 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   32065 			break
   32066 		}
   32067 		b = mergePoint(b, x0, x1)
   32068 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   32069 		v.reset(OpCopy)
   32070 		v.AddArg(v0)
   32071 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   32072 		v1.AuxInt = j1
   32073 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   32074 		v2.AuxInt = i0
   32075 		v2.Aux = s
   32076 		v2.AddArg(p)
   32077 		v2.AddArg(mem)
   32078 		v1.AddArg(v2)
   32079 		v0.AddArg(v1)
   32080 		v0.AddArg(y)
   32081 		return true
   32082 	}
   32083 	// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) y) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
   32084 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   32085 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   32086 	for {
   32087 		_ = v.Args[1]
   32088 		or := v.Args[0]
   32089 		if or.Op != OpS390XORW {
   32090 			break
   32091 		}
   32092 		_ = or.Args[1]
   32093 		s1 := or.Args[0]
   32094 		if s1.Op != OpS390XSLWconst {
   32095 			break
   32096 		}
   32097 		j1 := s1.AuxInt
   32098 		x1 := s1.Args[0]
   32099 		if x1.Op != OpS390XMOVBZload {
   32100 			break
   32101 		}
   32102 		i1 := x1.AuxInt
   32103 		s := x1.Aux
   32104 		_ = x1.Args[1]
   32105 		p := x1.Args[0]
   32106 		mem := x1.Args[1]
   32107 		y := or.Args[1]
   32108 		s0 := v.Args[1]
   32109 		if s0.Op != OpS390XSLWconst {
   32110 			break
   32111 		}
   32112 		j0 := s0.AuxInt
   32113 		x0 := s0.Args[0]
   32114 		if x0.Op != OpS390XMOVBZload {
   32115 			break
   32116 		}
   32117 		i0 := x0.AuxInt
   32118 		if x0.Aux != s {
   32119 			break
   32120 		}
   32121 		_ = x0.Args[1]
   32122 		if p != x0.Args[0] {
   32123 			break
   32124 		}
   32125 		if mem != x0.Args[1] {
   32126 			break
   32127 		}
   32128 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   32129 			break
   32130 		}
   32131 		b = mergePoint(b, x0, x1)
   32132 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   32133 		v.reset(OpCopy)
   32134 		v.AddArg(v0)
   32135 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   32136 		v1.AuxInt = j1
   32137 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   32138 		v2.AuxInt = i0
   32139 		v2.Aux = s
   32140 		v2.AddArg(p)
   32141 		v2.AddArg(mem)
   32142 		v1.AddArg(v2)
   32143 		v0.AddArg(v1)
   32144 		v0.AddArg(y)
   32145 		return true
   32146 	}
   32147 	return false
   32148 }
   32149 func rewriteValueS390X_OpS390XORW_20(v *Value) bool {
   32150 	b := v.Block
   32151 	_ = b
   32152 	typ := &b.Func.Config.Types
   32153 	_ = typ
   32154 	// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
   32155 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   32156 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
   32157 	for {
   32158 		_ = v.Args[1]
   32159 		or := v.Args[0]
   32160 		if or.Op != OpS390XORW {
   32161 			break
   32162 		}
   32163 		_ = or.Args[1]
   32164 		y := or.Args[0]
   32165 		s1 := or.Args[1]
   32166 		if s1.Op != OpS390XSLWconst {
   32167 			break
   32168 		}
   32169 		j1 := s1.AuxInt
   32170 		x1 := s1.Args[0]
   32171 		if x1.Op != OpS390XMOVBZload {
   32172 			break
   32173 		}
   32174 		i1 := x1.AuxInt
   32175 		s := x1.Aux
   32176 		_ = x1.Args[1]
   32177 		p := x1.Args[0]
   32178 		mem := x1.Args[1]
   32179 		s0 := v.Args[1]
   32180 		if s0.Op != OpS390XSLWconst {
   32181 			break
   32182 		}
   32183 		j0 := s0.AuxInt
   32184 		x0 := s0.Args[0]
   32185 		if x0.Op != OpS390XMOVBZload {
   32186 			break
   32187 		}
   32188 		i0 := x0.AuxInt
   32189 		if x0.Aux != s {
   32190 			break
   32191 		}
   32192 		_ = x0.Args[1]
   32193 		if p != x0.Args[0] {
   32194 			break
   32195 		}
   32196 		if mem != x0.Args[1] {
   32197 			break
   32198 		}
   32199 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   32200 			break
   32201 		}
   32202 		b = mergePoint(b, x0, x1)
   32203 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   32204 		v.reset(OpCopy)
   32205 		v.AddArg(v0)
   32206 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   32207 		v1.AuxInt = j1
   32208 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZload, typ.UInt16)
   32209 		v2.AuxInt = i0
   32210 		v2.Aux = s
   32211 		v2.AddArg(p)
   32212 		v2.AddArg(mem)
   32213 		v1.AddArg(v2)
   32214 		v0.AddArg(v1)
   32215 		v0.AddArg(y)
   32216 		return true
   32217 	}
   32218 	// match: (ORW x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   32219 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32220 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32221 	for {
   32222 		_ = v.Args[1]
   32223 		x1 := v.Args[0]
   32224 		if x1.Op != OpS390XMOVBZloadidx {
   32225 			break
   32226 		}
   32227 		i1 := x1.AuxInt
   32228 		s := x1.Aux
   32229 		_ = x1.Args[2]
   32230 		p := x1.Args[0]
   32231 		idx := x1.Args[1]
   32232 		mem := x1.Args[2]
   32233 		sh := v.Args[1]
   32234 		if sh.Op != OpS390XSLWconst {
   32235 			break
   32236 		}
   32237 		if sh.AuxInt != 8 {
   32238 			break
   32239 		}
   32240 		x0 := sh.Args[0]
   32241 		if x0.Op != OpS390XMOVBZloadidx {
   32242 			break
   32243 		}
   32244 		i0 := x0.AuxInt
   32245 		if x0.Aux != s {
   32246 			break
   32247 		}
   32248 		_ = x0.Args[2]
   32249 		if p != x0.Args[0] {
   32250 			break
   32251 		}
   32252 		if idx != x0.Args[1] {
   32253 			break
   32254 		}
   32255 		if mem != x0.Args[2] {
   32256 			break
   32257 		}
   32258 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32259 			break
   32260 		}
   32261 		b = mergePoint(b, x0, x1)
   32262 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32263 		v.reset(OpCopy)
   32264 		v.AddArg(v0)
   32265 		v0.AuxInt = i0
   32266 		v0.Aux = s
   32267 		v0.AddArg(p)
   32268 		v0.AddArg(idx)
   32269 		v0.AddArg(mem)
   32270 		return true
   32271 	}
   32272 	// match: (ORW x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   32273 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32274 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32275 	for {
   32276 		_ = v.Args[1]
   32277 		x1 := v.Args[0]
   32278 		if x1.Op != OpS390XMOVBZloadidx {
   32279 			break
   32280 		}
   32281 		i1 := x1.AuxInt
   32282 		s := x1.Aux
   32283 		_ = x1.Args[2]
   32284 		idx := x1.Args[0]
   32285 		p := x1.Args[1]
   32286 		mem := x1.Args[2]
   32287 		sh := v.Args[1]
   32288 		if sh.Op != OpS390XSLWconst {
   32289 			break
   32290 		}
   32291 		if sh.AuxInt != 8 {
   32292 			break
   32293 		}
   32294 		x0 := sh.Args[0]
   32295 		if x0.Op != OpS390XMOVBZloadidx {
   32296 			break
   32297 		}
   32298 		i0 := x0.AuxInt
   32299 		if x0.Aux != s {
   32300 			break
   32301 		}
   32302 		_ = x0.Args[2]
   32303 		if p != x0.Args[0] {
   32304 			break
   32305 		}
   32306 		if idx != x0.Args[1] {
   32307 			break
   32308 		}
   32309 		if mem != x0.Args[2] {
   32310 			break
   32311 		}
   32312 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32313 			break
   32314 		}
   32315 		b = mergePoint(b, x0, x1)
   32316 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32317 		v.reset(OpCopy)
   32318 		v.AddArg(v0)
   32319 		v0.AuxInt = i0
   32320 		v0.Aux = s
   32321 		v0.AddArg(p)
   32322 		v0.AddArg(idx)
   32323 		v0.AddArg(mem)
   32324 		return true
   32325 	}
   32326 	// match: (ORW x1:(MOVBZloadidx [i1] {s} p idx mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   32327 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32328 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32329 	for {
   32330 		_ = v.Args[1]
   32331 		x1 := v.Args[0]
   32332 		if x1.Op != OpS390XMOVBZloadidx {
   32333 			break
   32334 		}
   32335 		i1 := x1.AuxInt
   32336 		s := x1.Aux
   32337 		_ = x1.Args[2]
   32338 		p := x1.Args[0]
   32339 		idx := x1.Args[1]
   32340 		mem := x1.Args[2]
   32341 		sh := v.Args[1]
   32342 		if sh.Op != OpS390XSLWconst {
   32343 			break
   32344 		}
   32345 		if sh.AuxInt != 8 {
   32346 			break
   32347 		}
   32348 		x0 := sh.Args[0]
   32349 		if x0.Op != OpS390XMOVBZloadidx {
   32350 			break
   32351 		}
   32352 		i0 := x0.AuxInt
   32353 		if x0.Aux != s {
   32354 			break
   32355 		}
   32356 		_ = x0.Args[2]
   32357 		if idx != x0.Args[0] {
   32358 			break
   32359 		}
   32360 		if p != x0.Args[1] {
   32361 			break
   32362 		}
   32363 		if mem != x0.Args[2] {
   32364 			break
   32365 		}
   32366 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32367 			break
   32368 		}
   32369 		b = mergePoint(b, x0, x1)
   32370 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32371 		v.reset(OpCopy)
   32372 		v.AddArg(v0)
   32373 		v0.AuxInt = i0
   32374 		v0.Aux = s
   32375 		v0.AddArg(p)
   32376 		v0.AddArg(idx)
   32377 		v0.AddArg(mem)
   32378 		return true
   32379 	}
   32380 	// match: (ORW x1:(MOVBZloadidx [i1] {s} idx p mem) sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   32381 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32382 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32383 	for {
   32384 		_ = v.Args[1]
   32385 		x1 := v.Args[0]
   32386 		if x1.Op != OpS390XMOVBZloadidx {
   32387 			break
   32388 		}
   32389 		i1 := x1.AuxInt
   32390 		s := x1.Aux
   32391 		_ = x1.Args[2]
   32392 		idx := x1.Args[0]
   32393 		p := x1.Args[1]
   32394 		mem := x1.Args[2]
   32395 		sh := v.Args[1]
   32396 		if sh.Op != OpS390XSLWconst {
   32397 			break
   32398 		}
   32399 		if sh.AuxInt != 8 {
   32400 			break
   32401 		}
   32402 		x0 := sh.Args[0]
   32403 		if x0.Op != OpS390XMOVBZloadidx {
   32404 			break
   32405 		}
   32406 		i0 := x0.AuxInt
   32407 		if x0.Aux != s {
   32408 			break
   32409 		}
   32410 		_ = x0.Args[2]
   32411 		if idx != x0.Args[0] {
   32412 			break
   32413 		}
   32414 		if p != x0.Args[1] {
   32415 			break
   32416 		}
   32417 		if mem != x0.Args[2] {
   32418 			break
   32419 		}
   32420 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32421 			break
   32422 		}
   32423 		b = mergePoint(b, x0, x1)
   32424 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32425 		v.reset(OpCopy)
   32426 		v.AddArg(v0)
   32427 		v0.AuxInt = i0
   32428 		v0.Aux = s
   32429 		v0.AddArg(p)
   32430 		v0.AddArg(idx)
   32431 		v0.AddArg(mem)
   32432 		return true
   32433 	}
   32434 	// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
   32435 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32436 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32437 	for {
   32438 		_ = v.Args[1]
   32439 		sh := v.Args[0]
   32440 		if sh.Op != OpS390XSLWconst {
   32441 			break
   32442 		}
   32443 		if sh.AuxInt != 8 {
   32444 			break
   32445 		}
   32446 		x0 := sh.Args[0]
   32447 		if x0.Op != OpS390XMOVBZloadidx {
   32448 			break
   32449 		}
   32450 		i0 := x0.AuxInt
   32451 		s := x0.Aux
   32452 		_ = x0.Args[2]
   32453 		p := x0.Args[0]
   32454 		idx := x0.Args[1]
   32455 		mem := x0.Args[2]
   32456 		x1 := v.Args[1]
   32457 		if x1.Op != OpS390XMOVBZloadidx {
   32458 			break
   32459 		}
   32460 		i1 := x1.AuxInt
   32461 		if x1.Aux != s {
   32462 			break
   32463 		}
   32464 		_ = x1.Args[2]
   32465 		if p != x1.Args[0] {
   32466 			break
   32467 		}
   32468 		if idx != x1.Args[1] {
   32469 			break
   32470 		}
   32471 		if mem != x1.Args[2] {
   32472 			break
   32473 		}
   32474 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32475 			break
   32476 		}
   32477 		b = mergePoint(b, x0, x1)
   32478 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32479 		v.reset(OpCopy)
   32480 		v.AddArg(v0)
   32481 		v0.AuxInt = i0
   32482 		v0.Aux = s
   32483 		v0.AddArg(p)
   32484 		v0.AddArg(idx)
   32485 		v0.AddArg(mem)
   32486 		return true
   32487 	}
   32488 	// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
   32489 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32490 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32491 	for {
   32492 		_ = v.Args[1]
   32493 		sh := v.Args[0]
   32494 		if sh.Op != OpS390XSLWconst {
   32495 			break
   32496 		}
   32497 		if sh.AuxInt != 8 {
   32498 			break
   32499 		}
   32500 		x0 := sh.Args[0]
   32501 		if x0.Op != OpS390XMOVBZloadidx {
   32502 			break
   32503 		}
   32504 		i0 := x0.AuxInt
   32505 		s := x0.Aux
   32506 		_ = x0.Args[2]
   32507 		idx := x0.Args[0]
   32508 		p := x0.Args[1]
   32509 		mem := x0.Args[2]
   32510 		x1 := v.Args[1]
   32511 		if x1.Op != OpS390XMOVBZloadidx {
   32512 			break
   32513 		}
   32514 		i1 := x1.AuxInt
   32515 		if x1.Aux != s {
   32516 			break
   32517 		}
   32518 		_ = x1.Args[2]
   32519 		if p != x1.Args[0] {
   32520 			break
   32521 		}
   32522 		if idx != x1.Args[1] {
   32523 			break
   32524 		}
   32525 		if mem != x1.Args[2] {
   32526 			break
   32527 		}
   32528 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32529 			break
   32530 		}
   32531 		b = mergePoint(b, x0, x1)
   32532 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32533 		v.reset(OpCopy)
   32534 		v.AddArg(v0)
   32535 		v0.AuxInt = i0
   32536 		v0.Aux = s
   32537 		v0.AddArg(p)
   32538 		v0.AddArg(idx)
   32539 		v0.AddArg(mem)
   32540 		return true
   32541 	}
   32542 	// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} p idx mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
   32543 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32544 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32545 	for {
   32546 		_ = v.Args[1]
   32547 		sh := v.Args[0]
   32548 		if sh.Op != OpS390XSLWconst {
   32549 			break
   32550 		}
   32551 		if sh.AuxInt != 8 {
   32552 			break
   32553 		}
   32554 		x0 := sh.Args[0]
   32555 		if x0.Op != OpS390XMOVBZloadidx {
   32556 			break
   32557 		}
   32558 		i0 := x0.AuxInt
   32559 		s := x0.Aux
   32560 		_ = x0.Args[2]
   32561 		p := x0.Args[0]
   32562 		idx := x0.Args[1]
   32563 		mem := x0.Args[2]
   32564 		x1 := v.Args[1]
   32565 		if x1.Op != OpS390XMOVBZloadidx {
   32566 			break
   32567 		}
   32568 		i1 := x1.AuxInt
   32569 		if x1.Aux != s {
   32570 			break
   32571 		}
   32572 		_ = x1.Args[2]
   32573 		if idx != x1.Args[0] {
   32574 			break
   32575 		}
   32576 		if p != x1.Args[1] {
   32577 			break
   32578 		}
   32579 		if mem != x1.Args[2] {
   32580 			break
   32581 		}
   32582 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32583 			break
   32584 		}
   32585 		b = mergePoint(b, x0, x1)
   32586 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32587 		v.reset(OpCopy)
   32588 		v.AddArg(v0)
   32589 		v0.AuxInt = i0
   32590 		v0.Aux = s
   32591 		v0.AddArg(p)
   32592 		v0.AddArg(idx)
   32593 		v0.AddArg(mem)
   32594 		return true
   32595 	}
   32596 	// match: (ORW sh:(SLWconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} idx p mem))
   32597 	// cond: i1 == i0+1   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32598 	// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
   32599 	for {
   32600 		_ = v.Args[1]
   32601 		sh := v.Args[0]
   32602 		if sh.Op != OpS390XSLWconst {
   32603 			break
   32604 		}
   32605 		if sh.AuxInt != 8 {
   32606 			break
   32607 		}
   32608 		x0 := sh.Args[0]
   32609 		if x0.Op != OpS390XMOVBZloadidx {
   32610 			break
   32611 		}
   32612 		i0 := x0.AuxInt
   32613 		s := x0.Aux
   32614 		_ = x0.Args[2]
   32615 		idx := x0.Args[0]
   32616 		p := x0.Args[1]
   32617 		mem := x0.Args[2]
   32618 		x1 := v.Args[1]
   32619 		if x1.Op != OpS390XMOVBZloadidx {
   32620 			break
   32621 		}
   32622 		i1 := x1.AuxInt
   32623 		if x1.Aux != s {
   32624 			break
   32625 		}
   32626 		_ = x1.Args[2]
   32627 		if idx != x1.Args[0] {
   32628 			break
   32629 		}
   32630 		if p != x1.Args[1] {
   32631 			break
   32632 		}
   32633 		if mem != x1.Args[2] {
   32634 			break
   32635 		}
   32636 		if !(i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32637 			break
   32638 		}
   32639 		b = mergePoint(b, x0, x1)
   32640 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   32641 		v.reset(OpCopy)
   32642 		v.AddArg(v0)
   32643 		v0.AuxInt = i0
   32644 		v0.Aux = s
   32645 		v0.AddArg(p)
   32646 		v0.AddArg(idx)
   32647 		v0.AddArg(mem)
   32648 		return true
   32649 	}
   32650 	// match: (ORW x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   32651 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32652 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32653 	for {
   32654 		_ = v.Args[1]
   32655 		x1 := v.Args[0]
   32656 		if x1.Op != OpS390XMOVHZloadidx {
   32657 			break
   32658 		}
   32659 		i1 := x1.AuxInt
   32660 		s := x1.Aux
   32661 		_ = x1.Args[2]
   32662 		p := x1.Args[0]
   32663 		idx := x1.Args[1]
   32664 		mem := x1.Args[2]
   32665 		sh := v.Args[1]
   32666 		if sh.Op != OpS390XSLWconst {
   32667 			break
   32668 		}
   32669 		if sh.AuxInt != 16 {
   32670 			break
   32671 		}
   32672 		x0 := sh.Args[0]
   32673 		if x0.Op != OpS390XMOVHZloadidx {
   32674 			break
   32675 		}
   32676 		i0 := x0.AuxInt
   32677 		if x0.Aux != s {
   32678 			break
   32679 		}
   32680 		_ = x0.Args[2]
   32681 		if p != x0.Args[0] {
   32682 			break
   32683 		}
   32684 		if idx != x0.Args[1] {
   32685 			break
   32686 		}
   32687 		if mem != x0.Args[2] {
   32688 			break
   32689 		}
   32690 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32691 			break
   32692 		}
   32693 		b = mergePoint(b, x0, x1)
   32694 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   32695 		v.reset(OpCopy)
   32696 		v.AddArg(v0)
   32697 		v0.AuxInt = i0
   32698 		v0.Aux = s
   32699 		v0.AddArg(p)
   32700 		v0.AddArg(idx)
   32701 		v0.AddArg(mem)
   32702 		return true
   32703 	}
   32704 	return false
   32705 }
   32706 func rewriteValueS390X_OpS390XORW_30(v *Value) bool {
   32707 	b := v.Block
   32708 	_ = b
   32709 	typ := &b.Func.Config.Types
   32710 	_ = typ
   32711 	// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
   32712 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32713 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32714 	for {
   32715 		_ = v.Args[1]
   32716 		x1 := v.Args[0]
   32717 		if x1.Op != OpS390XMOVHZloadidx {
   32718 			break
   32719 		}
   32720 		i1 := x1.AuxInt
   32721 		s := x1.Aux
   32722 		_ = x1.Args[2]
   32723 		idx := x1.Args[0]
   32724 		p := x1.Args[1]
   32725 		mem := x1.Args[2]
   32726 		sh := v.Args[1]
   32727 		if sh.Op != OpS390XSLWconst {
   32728 			break
   32729 		}
   32730 		if sh.AuxInt != 16 {
   32731 			break
   32732 		}
   32733 		x0 := sh.Args[0]
   32734 		if x0.Op != OpS390XMOVHZloadidx {
   32735 			break
   32736 		}
   32737 		i0 := x0.AuxInt
   32738 		if x0.Aux != s {
   32739 			break
   32740 		}
   32741 		_ = x0.Args[2]
   32742 		if p != x0.Args[0] {
   32743 			break
   32744 		}
   32745 		if idx != x0.Args[1] {
   32746 			break
   32747 		}
   32748 		if mem != x0.Args[2] {
   32749 			break
   32750 		}
   32751 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32752 			break
   32753 		}
   32754 		b = mergePoint(b, x0, x1)
   32755 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   32756 		v.reset(OpCopy)
   32757 		v.AddArg(v0)
   32758 		v0.AuxInt = i0
   32759 		v0.Aux = s
   32760 		v0.AddArg(p)
   32761 		v0.AddArg(idx)
   32762 		v0.AddArg(mem)
   32763 		return true
   32764 	}
   32765 	// match: (ORW x1:(MOVHZloadidx [i1] {s} p idx mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   32766 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32767 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32768 	for {
   32769 		_ = v.Args[1]
   32770 		x1 := v.Args[0]
   32771 		if x1.Op != OpS390XMOVHZloadidx {
   32772 			break
   32773 		}
   32774 		i1 := x1.AuxInt
   32775 		s := x1.Aux
   32776 		_ = x1.Args[2]
   32777 		p := x1.Args[0]
   32778 		idx := x1.Args[1]
   32779 		mem := x1.Args[2]
   32780 		sh := v.Args[1]
   32781 		if sh.Op != OpS390XSLWconst {
   32782 			break
   32783 		}
   32784 		if sh.AuxInt != 16 {
   32785 			break
   32786 		}
   32787 		x0 := sh.Args[0]
   32788 		if x0.Op != OpS390XMOVHZloadidx {
   32789 			break
   32790 		}
   32791 		i0 := x0.AuxInt
   32792 		if x0.Aux != s {
   32793 			break
   32794 		}
   32795 		_ = x0.Args[2]
   32796 		if idx != x0.Args[0] {
   32797 			break
   32798 		}
   32799 		if p != x0.Args[1] {
   32800 			break
   32801 		}
   32802 		if mem != x0.Args[2] {
   32803 			break
   32804 		}
   32805 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32806 			break
   32807 		}
   32808 		b = mergePoint(b, x0, x1)
   32809 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   32810 		v.reset(OpCopy)
   32811 		v.AddArg(v0)
   32812 		v0.AuxInt = i0
   32813 		v0.Aux = s
   32814 		v0.AddArg(p)
   32815 		v0.AddArg(idx)
   32816 		v0.AddArg(mem)
   32817 		return true
   32818 	}
   32819 	// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)))
   32820 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32821 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32822 	for {
   32823 		_ = v.Args[1]
   32824 		x1 := v.Args[0]
   32825 		if x1.Op != OpS390XMOVHZloadidx {
   32826 			break
   32827 		}
   32828 		i1 := x1.AuxInt
   32829 		s := x1.Aux
   32830 		_ = x1.Args[2]
   32831 		idx := x1.Args[0]
   32832 		p := x1.Args[1]
   32833 		mem := x1.Args[2]
   32834 		sh := v.Args[1]
   32835 		if sh.Op != OpS390XSLWconst {
   32836 			break
   32837 		}
   32838 		if sh.AuxInt != 16 {
   32839 			break
   32840 		}
   32841 		x0 := sh.Args[0]
   32842 		if x0.Op != OpS390XMOVHZloadidx {
   32843 			break
   32844 		}
   32845 		i0 := x0.AuxInt
   32846 		if x0.Aux != s {
   32847 			break
   32848 		}
   32849 		_ = x0.Args[2]
   32850 		if idx != x0.Args[0] {
   32851 			break
   32852 		}
   32853 		if p != x0.Args[1] {
   32854 			break
   32855 		}
   32856 		if mem != x0.Args[2] {
   32857 			break
   32858 		}
   32859 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32860 			break
   32861 		}
   32862 		b = mergePoint(b, x0, x1)
   32863 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   32864 		v.reset(OpCopy)
   32865 		v.AddArg(v0)
   32866 		v0.AuxInt = i0
   32867 		v0.Aux = s
   32868 		v0.AddArg(p)
   32869 		v0.AddArg(idx)
   32870 		v0.AddArg(mem)
   32871 		return true
   32872 	}
   32873 	// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
   32874 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32875 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32876 	for {
   32877 		_ = v.Args[1]
   32878 		sh := v.Args[0]
   32879 		if sh.Op != OpS390XSLWconst {
   32880 			break
   32881 		}
   32882 		if sh.AuxInt != 16 {
   32883 			break
   32884 		}
   32885 		x0 := sh.Args[0]
   32886 		if x0.Op != OpS390XMOVHZloadidx {
   32887 			break
   32888 		}
   32889 		i0 := x0.AuxInt
   32890 		s := x0.Aux
   32891 		_ = x0.Args[2]
   32892 		p := x0.Args[0]
   32893 		idx := x0.Args[1]
   32894 		mem := x0.Args[2]
   32895 		x1 := v.Args[1]
   32896 		if x1.Op != OpS390XMOVHZloadidx {
   32897 			break
   32898 		}
   32899 		i1 := x1.AuxInt
   32900 		if x1.Aux != s {
   32901 			break
   32902 		}
   32903 		_ = x1.Args[2]
   32904 		if p != x1.Args[0] {
   32905 			break
   32906 		}
   32907 		if idx != x1.Args[1] {
   32908 			break
   32909 		}
   32910 		if mem != x1.Args[2] {
   32911 			break
   32912 		}
   32913 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32914 			break
   32915 		}
   32916 		b = mergePoint(b, x0, x1)
   32917 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   32918 		v.reset(OpCopy)
   32919 		v.AddArg(v0)
   32920 		v0.AuxInt = i0
   32921 		v0.Aux = s
   32922 		v0.AddArg(p)
   32923 		v0.AddArg(idx)
   32924 		v0.AddArg(mem)
   32925 		return true
   32926 	}
   32927 	// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} p idx mem))
   32928 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32929 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32930 	for {
   32931 		_ = v.Args[1]
   32932 		sh := v.Args[0]
   32933 		if sh.Op != OpS390XSLWconst {
   32934 			break
   32935 		}
   32936 		if sh.AuxInt != 16 {
   32937 			break
   32938 		}
   32939 		x0 := sh.Args[0]
   32940 		if x0.Op != OpS390XMOVHZloadidx {
   32941 			break
   32942 		}
   32943 		i0 := x0.AuxInt
   32944 		s := x0.Aux
   32945 		_ = x0.Args[2]
   32946 		idx := x0.Args[0]
   32947 		p := x0.Args[1]
   32948 		mem := x0.Args[2]
   32949 		x1 := v.Args[1]
   32950 		if x1.Op != OpS390XMOVHZloadidx {
   32951 			break
   32952 		}
   32953 		i1 := x1.AuxInt
   32954 		if x1.Aux != s {
   32955 			break
   32956 		}
   32957 		_ = x1.Args[2]
   32958 		if p != x1.Args[0] {
   32959 			break
   32960 		}
   32961 		if idx != x1.Args[1] {
   32962 			break
   32963 		}
   32964 		if mem != x1.Args[2] {
   32965 			break
   32966 		}
   32967 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   32968 			break
   32969 		}
   32970 		b = mergePoint(b, x0, x1)
   32971 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   32972 		v.reset(OpCopy)
   32973 		v.AddArg(v0)
   32974 		v0.AuxInt = i0
   32975 		v0.Aux = s
   32976 		v0.AddArg(p)
   32977 		v0.AddArg(idx)
   32978 		v0.AddArg(mem)
   32979 		return true
   32980 	}
   32981 	// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
   32982 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   32983 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   32984 	for {
   32985 		_ = v.Args[1]
   32986 		sh := v.Args[0]
   32987 		if sh.Op != OpS390XSLWconst {
   32988 			break
   32989 		}
   32990 		if sh.AuxInt != 16 {
   32991 			break
   32992 		}
   32993 		x0 := sh.Args[0]
   32994 		if x0.Op != OpS390XMOVHZloadidx {
   32995 			break
   32996 		}
   32997 		i0 := x0.AuxInt
   32998 		s := x0.Aux
   32999 		_ = x0.Args[2]
   33000 		p := x0.Args[0]
   33001 		idx := x0.Args[1]
   33002 		mem := x0.Args[2]
   33003 		x1 := v.Args[1]
   33004 		if x1.Op != OpS390XMOVHZloadidx {
   33005 			break
   33006 		}
   33007 		i1 := x1.AuxInt
   33008 		if x1.Aux != s {
   33009 			break
   33010 		}
   33011 		_ = x1.Args[2]
   33012 		if idx != x1.Args[0] {
   33013 			break
   33014 		}
   33015 		if p != x1.Args[1] {
   33016 			break
   33017 		}
   33018 		if mem != x1.Args[2] {
   33019 			break
   33020 		}
   33021 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   33022 			break
   33023 		}
   33024 		b = mergePoint(b, x0, x1)
   33025 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   33026 		v.reset(OpCopy)
   33027 		v.AddArg(v0)
   33028 		v0.AuxInt = i0
   33029 		v0.Aux = s
   33030 		v0.AddArg(p)
   33031 		v0.AddArg(idx)
   33032 		v0.AddArg(mem)
   33033 		return true
   33034 	}
   33035 	// match: (ORW sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
   33036 	// cond: i1 == i0+2   && p.Op != OpSB   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   33037 	// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
   33038 	for {
   33039 		_ = v.Args[1]
   33040 		sh := v.Args[0]
   33041 		if sh.Op != OpS390XSLWconst {
   33042 			break
   33043 		}
   33044 		if sh.AuxInt != 16 {
   33045 			break
   33046 		}
   33047 		x0 := sh.Args[0]
   33048 		if x0.Op != OpS390XMOVHZloadidx {
   33049 			break
   33050 		}
   33051 		i0 := x0.AuxInt
   33052 		s := x0.Aux
   33053 		_ = x0.Args[2]
   33054 		idx := x0.Args[0]
   33055 		p := x0.Args[1]
   33056 		mem := x0.Args[2]
   33057 		x1 := v.Args[1]
   33058 		if x1.Op != OpS390XMOVHZloadidx {
   33059 			break
   33060 		}
   33061 		i1 := x1.AuxInt
   33062 		if x1.Aux != s {
   33063 			break
   33064 		}
   33065 		_ = x1.Args[2]
   33066 		if idx != x1.Args[0] {
   33067 			break
   33068 		}
   33069 		if p != x1.Args[1] {
   33070 			break
   33071 		}
   33072 		if mem != x1.Args[2] {
   33073 			break
   33074 		}
   33075 		if !(i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   33076 			break
   33077 		}
   33078 		b = mergePoint(b, x0, x1)
   33079 		v0 := b.NewValue0(v.Pos, OpS390XMOVWZloadidx, typ.UInt32)
   33080 		v.reset(OpCopy)
   33081 		v.AddArg(v0)
   33082 		v0.AuxInt = i0
   33083 		v0.Aux = s
   33084 		v0.AddArg(p)
   33085 		v0.AddArg(idx)
   33086 		v0.AddArg(mem)
   33087 		return true
   33088 	}
   33089 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
   33090 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33091 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33092 	for {
   33093 		_ = v.Args[1]
   33094 		s0 := v.Args[0]
   33095 		if s0.Op != OpS390XSLWconst {
   33096 			break
   33097 		}
   33098 		j0 := s0.AuxInt
   33099 		x0 := s0.Args[0]
   33100 		if x0.Op != OpS390XMOVBZloadidx {
   33101 			break
   33102 		}
   33103 		i0 := x0.AuxInt
   33104 		s := x0.Aux
   33105 		_ = x0.Args[2]
   33106 		p := x0.Args[0]
   33107 		idx := x0.Args[1]
   33108 		mem := x0.Args[2]
   33109 		or := v.Args[1]
   33110 		if or.Op != OpS390XORW {
   33111 			break
   33112 		}
   33113 		_ = or.Args[1]
   33114 		s1 := or.Args[0]
   33115 		if s1.Op != OpS390XSLWconst {
   33116 			break
   33117 		}
   33118 		j1 := s1.AuxInt
   33119 		x1 := s1.Args[0]
   33120 		if x1.Op != OpS390XMOVBZloadidx {
   33121 			break
   33122 		}
   33123 		i1 := x1.AuxInt
   33124 		if x1.Aux != s {
   33125 			break
   33126 		}
   33127 		_ = x1.Args[2]
   33128 		if p != x1.Args[0] {
   33129 			break
   33130 		}
   33131 		if idx != x1.Args[1] {
   33132 			break
   33133 		}
   33134 		if mem != x1.Args[2] {
   33135 			break
   33136 		}
   33137 		y := or.Args[1]
   33138 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33139 			break
   33140 		}
   33141 		b = mergePoint(b, x0, x1)
   33142 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33143 		v.reset(OpCopy)
   33144 		v.AddArg(v0)
   33145 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33146 		v1.AuxInt = j1
   33147 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33148 		v2.AuxInt = i0
   33149 		v2.Aux = s
   33150 		v2.AddArg(p)
   33151 		v2.AddArg(idx)
   33152 		v2.AddArg(mem)
   33153 		v1.AddArg(v2)
   33154 		v0.AddArg(v1)
   33155 		v0.AddArg(y)
   33156 		return true
   33157 	}
   33158 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
   33159 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33160 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33161 	for {
   33162 		_ = v.Args[1]
   33163 		s0 := v.Args[0]
   33164 		if s0.Op != OpS390XSLWconst {
   33165 			break
   33166 		}
   33167 		j0 := s0.AuxInt
   33168 		x0 := s0.Args[0]
   33169 		if x0.Op != OpS390XMOVBZloadidx {
   33170 			break
   33171 		}
   33172 		i0 := x0.AuxInt
   33173 		s := x0.Aux
   33174 		_ = x0.Args[2]
   33175 		idx := x0.Args[0]
   33176 		p := x0.Args[1]
   33177 		mem := x0.Args[2]
   33178 		or := v.Args[1]
   33179 		if or.Op != OpS390XORW {
   33180 			break
   33181 		}
   33182 		_ = or.Args[1]
   33183 		s1 := or.Args[0]
   33184 		if s1.Op != OpS390XSLWconst {
   33185 			break
   33186 		}
   33187 		j1 := s1.AuxInt
   33188 		x1 := s1.Args[0]
   33189 		if x1.Op != OpS390XMOVBZloadidx {
   33190 			break
   33191 		}
   33192 		i1 := x1.AuxInt
   33193 		if x1.Aux != s {
   33194 			break
   33195 		}
   33196 		_ = x1.Args[2]
   33197 		if p != x1.Args[0] {
   33198 			break
   33199 		}
   33200 		if idx != x1.Args[1] {
   33201 			break
   33202 		}
   33203 		if mem != x1.Args[2] {
   33204 			break
   33205 		}
   33206 		y := or.Args[1]
   33207 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33208 			break
   33209 		}
   33210 		b = mergePoint(b, x0, x1)
   33211 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33212 		v.reset(OpCopy)
   33213 		v.AddArg(v0)
   33214 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33215 		v1.AuxInt = j1
   33216 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33217 		v2.AuxInt = i0
   33218 		v2.Aux = s
   33219 		v2.AddArg(p)
   33220 		v2.AddArg(idx)
   33221 		v2.AddArg(mem)
   33222 		v1.AddArg(v2)
   33223 		v0.AddArg(v1)
   33224 		v0.AddArg(y)
   33225 		return true
   33226 	}
   33227 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
   33228 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33229 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33230 	for {
   33231 		_ = v.Args[1]
   33232 		s0 := v.Args[0]
   33233 		if s0.Op != OpS390XSLWconst {
   33234 			break
   33235 		}
   33236 		j0 := s0.AuxInt
   33237 		x0 := s0.Args[0]
   33238 		if x0.Op != OpS390XMOVBZloadidx {
   33239 			break
   33240 		}
   33241 		i0 := x0.AuxInt
   33242 		s := x0.Aux
   33243 		_ = x0.Args[2]
   33244 		p := x0.Args[0]
   33245 		idx := x0.Args[1]
   33246 		mem := x0.Args[2]
   33247 		or := v.Args[1]
   33248 		if or.Op != OpS390XORW {
   33249 			break
   33250 		}
   33251 		_ = or.Args[1]
   33252 		s1 := or.Args[0]
   33253 		if s1.Op != OpS390XSLWconst {
   33254 			break
   33255 		}
   33256 		j1 := s1.AuxInt
   33257 		x1 := s1.Args[0]
   33258 		if x1.Op != OpS390XMOVBZloadidx {
   33259 			break
   33260 		}
   33261 		i1 := x1.AuxInt
   33262 		if x1.Aux != s {
   33263 			break
   33264 		}
   33265 		_ = x1.Args[2]
   33266 		if idx != x1.Args[0] {
   33267 			break
   33268 		}
   33269 		if p != x1.Args[1] {
   33270 			break
   33271 		}
   33272 		if mem != x1.Args[2] {
   33273 			break
   33274 		}
   33275 		y := or.Args[1]
   33276 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33277 			break
   33278 		}
   33279 		b = mergePoint(b, x0, x1)
   33280 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33281 		v.reset(OpCopy)
   33282 		v.AddArg(v0)
   33283 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33284 		v1.AuxInt = j1
   33285 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33286 		v2.AuxInt = i0
   33287 		v2.Aux = s
   33288 		v2.AddArg(p)
   33289 		v2.AddArg(idx)
   33290 		v2.AddArg(mem)
   33291 		v1.AddArg(v2)
   33292 		v0.AddArg(v1)
   33293 		v0.AddArg(y)
   33294 		return true
   33295 	}
   33296 	return false
   33297 }
   33298 func rewriteValueS390X_OpS390XORW_40(v *Value) bool {
   33299 	b := v.Block
   33300 	_ = b
   33301 	typ := &b.Func.Config.Types
   33302 	_ = typ
   33303 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
   33304 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33305 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33306 	for {
   33307 		_ = v.Args[1]
   33308 		s0 := v.Args[0]
   33309 		if s0.Op != OpS390XSLWconst {
   33310 			break
   33311 		}
   33312 		j0 := s0.AuxInt
   33313 		x0 := s0.Args[0]
   33314 		if x0.Op != OpS390XMOVBZloadidx {
   33315 			break
   33316 		}
   33317 		i0 := x0.AuxInt
   33318 		s := x0.Aux
   33319 		_ = x0.Args[2]
   33320 		idx := x0.Args[0]
   33321 		p := x0.Args[1]
   33322 		mem := x0.Args[2]
   33323 		or := v.Args[1]
   33324 		if or.Op != OpS390XORW {
   33325 			break
   33326 		}
   33327 		_ = or.Args[1]
   33328 		s1 := or.Args[0]
   33329 		if s1.Op != OpS390XSLWconst {
   33330 			break
   33331 		}
   33332 		j1 := s1.AuxInt
   33333 		x1 := s1.Args[0]
   33334 		if x1.Op != OpS390XMOVBZloadidx {
   33335 			break
   33336 		}
   33337 		i1 := x1.AuxInt
   33338 		if x1.Aux != s {
   33339 			break
   33340 		}
   33341 		_ = x1.Args[2]
   33342 		if idx != x1.Args[0] {
   33343 			break
   33344 		}
   33345 		if p != x1.Args[1] {
   33346 			break
   33347 		}
   33348 		if mem != x1.Args[2] {
   33349 			break
   33350 		}
   33351 		y := or.Args[1]
   33352 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33353 			break
   33354 		}
   33355 		b = mergePoint(b, x0, x1)
   33356 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33357 		v.reset(OpCopy)
   33358 		v.AddArg(v0)
   33359 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33360 		v1.AuxInt = j1
   33361 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33362 		v2.AuxInt = i0
   33363 		v2.Aux = s
   33364 		v2.AddArg(p)
   33365 		v2.AddArg(idx)
   33366 		v2.AddArg(mem)
   33367 		v1.AddArg(v2)
   33368 		v0.AddArg(v1)
   33369 		v0.AddArg(y)
   33370 		return true
   33371 	}
   33372 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
   33373 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33374 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33375 	for {
   33376 		_ = v.Args[1]
   33377 		s0 := v.Args[0]
   33378 		if s0.Op != OpS390XSLWconst {
   33379 			break
   33380 		}
   33381 		j0 := s0.AuxInt
   33382 		x0 := s0.Args[0]
   33383 		if x0.Op != OpS390XMOVBZloadidx {
   33384 			break
   33385 		}
   33386 		i0 := x0.AuxInt
   33387 		s := x0.Aux
   33388 		_ = x0.Args[2]
   33389 		p := x0.Args[0]
   33390 		idx := x0.Args[1]
   33391 		mem := x0.Args[2]
   33392 		or := v.Args[1]
   33393 		if or.Op != OpS390XORW {
   33394 			break
   33395 		}
   33396 		_ = or.Args[1]
   33397 		y := or.Args[0]
   33398 		s1 := or.Args[1]
   33399 		if s1.Op != OpS390XSLWconst {
   33400 			break
   33401 		}
   33402 		j1 := s1.AuxInt
   33403 		x1 := s1.Args[0]
   33404 		if x1.Op != OpS390XMOVBZloadidx {
   33405 			break
   33406 		}
   33407 		i1 := x1.AuxInt
   33408 		if x1.Aux != s {
   33409 			break
   33410 		}
   33411 		_ = x1.Args[2]
   33412 		if p != x1.Args[0] {
   33413 			break
   33414 		}
   33415 		if idx != x1.Args[1] {
   33416 			break
   33417 		}
   33418 		if mem != x1.Args[2] {
   33419 			break
   33420 		}
   33421 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33422 			break
   33423 		}
   33424 		b = mergePoint(b, x0, x1)
   33425 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33426 		v.reset(OpCopy)
   33427 		v.AddArg(v0)
   33428 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33429 		v1.AuxInt = j1
   33430 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33431 		v2.AuxInt = i0
   33432 		v2.Aux = s
   33433 		v2.AddArg(p)
   33434 		v2.AddArg(idx)
   33435 		v2.AddArg(mem)
   33436 		v1.AddArg(v2)
   33437 		v0.AddArg(v1)
   33438 		v0.AddArg(y)
   33439 		return true
   33440 	}
   33441 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))))
   33442 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33443 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33444 	for {
   33445 		_ = v.Args[1]
   33446 		s0 := v.Args[0]
   33447 		if s0.Op != OpS390XSLWconst {
   33448 			break
   33449 		}
   33450 		j0 := s0.AuxInt
   33451 		x0 := s0.Args[0]
   33452 		if x0.Op != OpS390XMOVBZloadidx {
   33453 			break
   33454 		}
   33455 		i0 := x0.AuxInt
   33456 		s := x0.Aux
   33457 		_ = x0.Args[2]
   33458 		idx := x0.Args[0]
   33459 		p := x0.Args[1]
   33460 		mem := x0.Args[2]
   33461 		or := v.Args[1]
   33462 		if or.Op != OpS390XORW {
   33463 			break
   33464 		}
   33465 		_ = or.Args[1]
   33466 		y := or.Args[0]
   33467 		s1 := or.Args[1]
   33468 		if s1.Op != OpS390XSLWconst {
   33469 			break
   33470 		}
   33471 		j1 := s1.AuxInt
   33472 		x1 := s1.Args[0]
   33473 		if x1.Op != OpS390XMOVBZloadidx {
   33474 			break
   33475 		}
   33476 		i1 := x1.AuxInt
   33477 		if x1.Aux != s {
   33478 			break
   33479 		}
   33480 		_ = x1.Args[2]
   33481 		if p != x1.Args[0] {
   33482 			break
   33483 		}
   33484 		if idx != x1.Args[1] {
   33485 			break
   33486 		}
   33487 		if mem != x1.Args[2] {
   33488 			break
   33489 		}
   33490 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33491 			break
   33492 		}
   33493 		b = mergePoint(b, x0, x1)
   33494 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33495 		v.reset(OpCopy)
   33496 		v.AddArg(v0)
   33497 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33498 		v1.AuxInt = j1
   33499 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33500 		v2.AuxInt = i0
   33501 		v2.Aux = s
   33502 		v2.AddArg(p)
   33503 		v2.AddArg(idx)
   33504 		v2.AddArg(mem)
   33505 		v1.AddArg(v2)
   33506 		v0.AddArg(v1)
   33507 		v0.AddArg(y)
   33508 		return true
   33509 	}
   33510 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
   33511 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33512 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33513 	for {
   33514 		_ = v.Args[1]
   33515 		s0 := v.Args[0]
   33516 		if s0.Op != OpS390XSLWconst {
   33517 			break
   33518 		}
   33519 		j0 := s0.AuxInt
   33520 		x0 := s0.Args[0]
   33521 		if x0.Op != OpS390XMOVBZloadidx {
   33522 			break
   33523 		}
   33524 		i0 := x0.AuxInt
   33525 		s := x0.Aux
   33526 		_ = x0.Args[2]
   33527 		p := x0.Args[0]
   33528 		idx := x0.Args[1]
   33529 		mem := x0.Args[2]
   33530 		or := v.Args[1]
   33531 		if or.Op != OpS390XORW {
   33532 			break
   33533 		}
   33534 		_ = or.Args[1]
   33535 		y := or.Args[0]
   33536 		s1 := or.Args[1]
   33537 		if s1.Op != OpS390XSLWconst {
   33538 			break
   33539 		}
   33540 		j1 := s1.AuxInt
   33541 		x1 := s1.Args[0]
   33542 		if x1.Op != OpS390XMOVBZloadidx {
   33543 			break
   33544 		}
   33545 		i1 := x1.AuxInt
   33546 		if x1.Aux != s {
   33547 			break
   33548 		}
   33549 		_ = x1.Args[2]
   33550 		if idx != x1.Args[0] {
   33551 			break
   33552 		}
   33553 		if p != x1.Args[1] {
   33554 			break
   33555 		}
   33556 		if mem != x1.Args[2] {
   33557 			break
   33558 		}
   33559 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33560 			break
   33561 		}
   33562 		b = mergePoint(b, x0, x1)
   33563 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33564 		v.reset(OpCopy)
   33565 		v.AddArg(v0)
   33566 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33567 		v1.AuxInt = j1
   33568 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33569 		v2.AuxInt = i0
   33570 		v2.Aux = s
   33571 		v2.AddArg(p)
   33572 		v2.AddArg(idx)
   33573 		v2.AddArg(mem)
   33574 		v1.AddArg(v2)
   33575 		v0.AddArg(v1)
   33576 		v0.AddArg(y)
   33577 		return true
   33578 	}
   33579 	// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))))
   33580 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33581 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33582 	for {
   33583 		_ = v.Args[1]
   33584 		s0 := v.Args[0]
   33585 		if s0.Op != OpS390XSLWconst {
   33586 			break
   33587 		}
   33588 		j0 := s0.AuxInt
   33589 		x0 := s0.Args[0]
   33590 		if x0.Op != OpS390XMOVBZloadidx {
   33591 			break
   33592 		}
   33593 		i0 := x0.AuxInt
   33594 		s := x0.Aux
   33595 		_ = x0.Args[2]
   33596 		idx := x0.Args[0]
   33597 		p := x0.Args[1]
   33598 		mem := x0.Args[2]
   33599 		or := v.Args[1]
   33600 		if or.Op != OpS390XORW {
   33601 			break
   33602 		}
   33603 		_ = or.Args[1]
   33604 		y := or.Args[0]
   33605 		s1 := or.Args[1]
   33606 		if s1.Op != OpS390XSLWconst {
   33607 			break
   33608 		}
   33609 		j1 := s1.AuxInt
   33610 		x1 := s1.Args[0]
   33611 		if x1.Op != OpS390XMOVBZloadidx {
   33612 			break
   33613 		}
   33614 		i1 := x1.AuxInt
   33615 		if x1.Aux != s {
   33616 			break
   33617 		}
   33618 		_ = x1.Args[2]
   33619 		if idx != x1.Args[0] {
   33620 			break
   33621 		}
   33622 		if p != x1.Args[1] {
   33623 			break
   33624 		}
   33625 		if mem != x1.Args[2] {
   33626 			break
   33627 		}
   33628 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33629 			break
   33630 		}
   33631 		b = mergePoint(b, x0, x1)
   33632 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33633 		v.reset(OpCopy)
   33634 		v.AddArg(v0)
   33635 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33636 		v1.AuxInt = j1
   33637 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33638 		v2.AuxInt = i0
   33639 		v2.Aux = s
   33640 		v2.AddArg(p)
   33641 		v2.AddArg(idx)
   33642 		v2.AddArg(mem)
   33643 		v1.AddArg(v2)
   33644 		v0.AddArg(v1)
   33645 		v0.AddArg(y)
   33646 		return true
   33647 	}
   33648 	// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   33649 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33650 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33651 	for {
   33652 		_ = v.Args[1]
   33653 		or := v.Args[0]
   33654 		if or.Op != OpS390XORW {
   33655 			break
   33656 		}
   33657 		_ = or.Args[1]
   33658 		s1 := or.Args[0]
   33659 		if s1.Op != OpS390XSLWconst {
   33660 			break
   33661 		}
   33662 		j1 := s1.AuxInt
   33663 		x1 := s1.Args[0]
   33664 		if x1.Op != OpS390XMOVBZloadidx {
   33665 			break
   33666 		}
   33667 		i1 := x1.AuxInt
   33668 		s := x1.Aux
   33669 		_ = x1.Args[2]
   33670 		p := x1.Args[0]
   33671 		idx := x1.Args[1]
   33672 		mem := x1.Args[2]
   33673 		y := or.Args[1]
   33674 		s0 := v.Args[1]
   33675 		if s0.Op != OpS390XSLWconst {
   33676 			break
   33677 		}
   33678 		j0 := s0.AuxInt
   33679 		x0 := s0.Args[0]
   33680 		if x0.Op != OpS390XMOVBZloadidx {
   33681 			break
   33682 		}
   33683 		i0 := x0.AuxInt
   33684 		if x0.Aux != s {
   33685 			break
   33686 		}
   33687 		_ = x0.Args[2]
   33688 		if p != x0.Args[0] {
   33689 			break
   33690 		}
   33691 		if idx != x0.Args[1] {
   33692 			break
   33693 		}
   33694 		if mem != x0.Args[2] {
   33695 			break
   33696 		}
   33697 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33698 			break
   33699 		}
   33700 		b = mergePoint(b, x0, x1)
   33701 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33702 		v.reset(OpCopy)
   33703 		v.AddArg(v0)
   33704 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33705 		v1.AuxInt = j1
   33706 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33707 		v2.AuxInt = i0
   33708 		v2.Aux = s
   33709 		v2.AddArg(p)
   33710 		v2.AddArg(idx)
   33711 		v2.AddArg(mem)
   33712 		v1.AddArg(v2)
   33713 		v0.AddArg(v1)
   33714 		v0.AddArg(y)
   33715 		return true
   33716 	}
   33717 	// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   33718 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33719 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33720 	for {
   33721 		_ = v.Args[1]
   33722 		or := v.Args[0]
   33723 		if or.Op != OpS390XORW {
   33724 			break
   33725 		}
   33726 		_ = or.Args[1]
   33727 		s1 := or.Args[0]
   33728 		if s1.Op != OpS390XSLWconst {
   33729 			break
   33730 		}
   33731 		j1 := s1.AuxInt
   33732 		x1 := s1.Args[0]
   33733 		if x1.Op != OpS390XMOVBZloadidx {
   33734 			break
   33735 		}
   33736 		i1 := x1.AuxInt
   33737 		s := x1.Aux
   33738 		_ = x1.Args[2]
   33739 		idx := x1.Args[0]
   33740 		p := x1.Args[1]
   33741 		mem := x1.Args[2]
   33742 		y := or.Args[1]
   33743 		s0 := v.Args[1]
   33744 		if s0.Op != OpS390XSLWconst {
   33745 			break
   33746 		}
   33747 		j0 := s0.AuxInt
   33748 		x0 := s0.Args[0]
   33749 		if x0.Op != OpS390XMOVBZloadidx {
   33750 			break
   33751 		}
   33752 		i0 := x0.AuxInt
   33753 		if x0.Aux != s {
   33754 			break
   33755 		}
   33756 		_ = x0.Args[2]
   33757 		if p != x0.Args[0] {
   33758 			break
   33759 		}
   33760 		if idx != x0.Args[1] {
   33761 			break
   33762 		}
   33763 		if mem != x0.Args[2] {
   33764 			break
   33765 		}
   33766 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33767 			break
   33768 		}
   33769 		b = mergePoint(b, x0, x1)
   33770 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33771 		v.reset(OpCopy)
   33772 		v.AddArg(v0)
   33773 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33774 		v1.AuxInt = j1
   33775 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33776 		v2.AuxInt = i0
   33777 		v2.Aux = s
   33778 		v2.AddArg(p)
   33779 		v2.AddArg(idx)
   33780 		v2.AddArg(mem)
   33781 		v1.AddArg(v2)
   33782 		v0.AddArg(v1)
   33783 		v0.AddArg(y)
   33784 		return true
   33785 	}
   33786 	// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   33787 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33788 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33789 	for {
   33790 		_ = v.Args[1]
   33791 		or := v.Args[0]
   33792 		if or.Op != OpS390XORW {
   33793 			break
   33794 		}
   33795 		_ = or.Args[1]
   33796 		y := or.Args[0]
   33797 		s1 := or.Args[1]
   33798 		if s1.Op != OpS390XSLWconst {
   33799 			break
   33800 		}
   33801 		j1 := s1.AuxInt
   33802 		x1 := s1.Args[0]
   33803 		if x1.Op != OpS390XMOVBZloadidx {
   33804 			break
   33805 		}
   33806 		i1 := x1.AuxInt
   33807 		s := x1.Aux
   33808 		_ = x1.Args[2]
   33809 		p := x1.Args[0]
   33810 		idx := x1.Args[1]
   33811 		mem := x1.Args[2]
   33812 		s0 := v.Args[1]
   33813 		if s0.Op != OpS390XSLWconst {
   33814 			break
   33815 		}
   33816 		j0 := s0.AuxInt
   33817 		x0 := s0.Args[0]
   33818 		if x0.Op != OpS390XMOVBZloadidx {
   33819 			break
   33820 		}
   33821 		i0 := x0.AuxInt
   33822 		if x0.Aux != s {
   33823 			break
   33824 		}
   33825 		_ = x0.Args[2]
   33826 		if p != x0.Args[0] {
   33827 			break
   33828 		}
   33829 		if idx != x0.Args[1] {
   33830 			break
   33831 		}
   33832 		if mem != x0.Args[2] {
   33833 			break
   33834 		}
   33835 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33836 			break
   33837 		}
   33838 		b = mergePoint(b, x0, x1)
   33839 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33840 		v.reset(OpCopy)
   33841 		v.AddArg(v0)
   33842 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33843 		v1.AuxInt = j1
   33844 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33845 		v2.AuxInt = i0
   33846 		v2.Aux = s
   33847 		v2.AddArg(p)
   33848 		v2.AddArg(idx)
   33849 		v2.AddArg(mem)
   33850 		v1.AddArg(v2)
   33851 		v0.AddArg(v1)
   33852 		v0.AddArg(y)
   33853 		return true
   33854 	}
   33855 	// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
   33856 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33857 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33858 	for {
   33859 		_ = v.Args[1]
   33860 		or := v.Args[0]
   33861 		if or.Op != OpS390XORW {
   33862 			break
   33863 		}
   33864 		_ = or.Args[1]
   33865 		y := or.Args[0]
   33866 		s1 := or.Args[1]
   33867 		if s1.Op != OpS390XSLWconst {
   33868 			break
   33869 		}
   33870 		j1 := s1.AuxInt
   33871 		x1 := s1.Args[0]
   33872 		if x1.Op != OpS390XMOVBZloadidx {
   33873 			break
   33874 		}
   33875 		i1 := x1.AuxInt
   33876 		s := x1.Aux
   33877 		_ = x1.Args[2]
   33878 		idx := x1.Args[0]
   33879 		p := x1.Args[1]
   33880 		mem := x1.Args[2]
   33881 		s0 := v.Args[1]
   33882 		if s0.Op != OpS390XSLWconst {
   33883 			break
   33884 		}
   33885 		j0 := s0.AuxInt
   33886 		x0 := s0.Args[0]
   33887 		if x0.Op != OpS390XMOVBZloadidx {
   33888 			break
   33889 		}
   33890 		i0 := x0.AuxInt
   33891 		if x0.Aux != s {
   33892 			break
   33893 		}
   33894 		_ = x0.Args[2]
   33895 		if p != x0.Args[0] {
   33896 			break
   33897 		}
   33898 		if idx != x0.Args[1] {
   33899 			break
   33900 		}
   33901 		if mem != x0.Args[2] {
   33902 			break
   33903 		}
   33904 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33905 			break
   33906 		}
   33907 		b = mergePoint(b, x0, x1)
   33908 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33909 		v.reset(OpCopy)
   33910 		v.AddArg(v0)
   33911 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33912 		v1.AuxInt = j1
   33913 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33914 		v2.AuxInt = i0
   33915 		v2.Aux = s
   33916 		v2.AddArg(p)
   33917 		v2.AddArg(idx)
   33918 		v2.AddArg(mem)
   33919 		v1.AddArg(v2)
   33920 		v0.AddArg(v1)
   33921 		v0.AddArg(y)
   33922 		return true
   33923 	}
   33924 	// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   33925 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   33926 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   33927 	for {
   33928 		_ = v.Args[1]
   33929 		or := v.Args[0]
   33930 		if or.Op != OpS390XORW {
   33931 			break
   33932 		}
   33933 		_ = or.Args[1]
   33934 		s1 := or.Args[0]
   33935 		if s1.Op != OpS390XSLWconst {
   33936 			break
   33937 		}
   33938 		j1 := s1.AuxInt
   33939 		x1 := s1.Args[0]
   33940 		if x1.Op != OpS390XMOVBZloadidx {
   33941 			break
   33942 		}
   33943 		i1 := x1.AuxInt
   33944 		s := x1.Aux
   33945 		_ = x1.Args[2]
   33946 		p := x1.Args[0]
   33947 		idx := x1.Args[1]
   33948 		mem := x1.Args[2]
   33949 		y := or.Args[1]
   33950 		s0 := v.Args[1]
   33951 		if s0.Op != OpS390XSLWconst {
   33952 			break
   33953 		}
   33954 		j0 := s0.AuxInt
   33955 		x0 := s0.Args[0]
   33956 		if x0.Op != OpS390XMOVBZloadidx {
   33957 			break
   33958 		}
   33959 		i0 := x0.AuxInt
   33960 		if x0.Aux != s {
   33961 			break
   33962 		}
   33963 		_ = x0.Args[2]
   33964 		if idx != x0.Args[0] {
   33965 			break
   33966 		}
   33967 		if p != x0.Args[1] {
   33968 			break
   33969 		}
   33970 		if mem != x0.Args[2] {
   33971 			break
   33972 		}
   33973 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   33974 			break
   33975 		}
   33976 		b = mergePoint(b, x0, x1)
   33977 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   33978 		v.reset(OpCopy)
   33979 		v.AddArg(v0)
   33980 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   33981 		v1.AuxInt = j1
   33982 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   33983 		v2.AuxInt = i0
   33984 		v2.Aux = s
   33985 		v2.AddArg(p)
   33986 		v2.AddArg(idx)
   33987 		v2.AddArg(mem)
   33988 		v1.AddArg(v2)
   33989 		v0.AddArg(v1)
   33990 		v0.AddArg(y)
   33991 		return true
   33992 	}
   33993 	return false
   33994 }
   33995 func rewriteValueS390X_OpS390XORW_50(v *Value) bool {
   33996 	b := v.Block
   33997 	_ = b
   33998 	typ := &b.Func.Config.Types
   33999 	_ = typ
   34000 	// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   34001 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34002 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   34003 	for {
   34004 		_ = v.Args[1]
   34005 		or := v.Args[0]
   34006 		if or.Op != OpS390XORW {
   34007 			break
   34008 		}
   34009 		_ = or.Args[1]
   34010 		s1 := or.Args[0]
   34011 		if s1.Op != OpS390XSLWconst {
   34012 			break
   34013 		}
   34014 		j1 := s1.AuxInt
   34015 		x1 := s1.Args[0]
   34016 		if x1.Op != OpS390XMOVBZloadidx {
   34017 			break
   34018 		}
   34019 		i1 := x1.AuxInt
   34020 		s := x1.Aux
   34021 		_ = x1.Args[2]
   34022 		idx := x1.Args[0]
   34023 		p := x1.Args[1]
   34024 		mem := x1.Args[2]
   34025 		y := or.Args[1]
   34026 		s0 := v.Args[1]
   34027 		if s0.Op != OpS390XSLWconst {
   34028 			break
   34029 		}
   34030 		j0 := s0.AuxInt
   34031 		x0 := s0.Args[0]
   34032 		if x0.Op != OpS390XMOVBZloadidx {
   34033 			break
   34034 		}
   34035 		i0 := x0.AuxInt
   34036 		if x0.Aux != s {
   34037 			break
   34038 		}
   34039 		_ = x0.Args[2]
   34040 		if idx != x0.Args[0] {
   34041 			break
   34042 		}
   34043 		if p != x0.Args[1] {
   34044 			break
   34045 		}
   34046 		if mem != x0.Args[2] {
   34047 			break
   34048 		}
   34049 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34050 			break
   34051 		}
   34052 		b = mergePoint(b, x0, x1)
   34053 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34054 		v.reset(OpCopy)
   34055 		v.AddArg(v0)
   34056 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34057 		v1.AuxInt = j1
   34058 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   34059 		v2.AuxInt = i0
   34060 		v2.Aux = s
   34061 		v2.AddArg(p)
   34062 		v2.AddArg(idx)
   34063 		v2.AddArg(mem)
   34064 		v1.AddArg(v2)
   34065 		v0.AddArg(v1)
   34066 		v0.AddArg(y)
   34067 		return true
   34068 	}
   34069 	// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   34070 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34071 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   34072 	for {
   34073 		_ = v.Args[1]
   34074 		or := v.Args[0]
   34075 		if or.Op != OpS390XORW {
   34076 			break
   34077 		}
   34078 		_ = or.Args[1]
   34079 		y := or.Args[0]
   34080 		s1 := or.Args[1]
   34081 		if s1.Op != OpS390XSLWconst {
   34082 			break
   34083 		}
   34084 		j1 := s1.AuxInt
   34085 		x1 := s1.Args[0]
   34086 		if x1.Op != OpS390XMOVBZloadidx {
   34087 			break
   34088 		}
   34089 		i1 := x1.AuxInt
   34090 		s := x1.Aux
   34091 		_ = x1.Args[2]
   34092 		p := x1.Args[0]
   34093 		idx := x1.Args[1]
   34094 		mem := x1.Args[2]
   34095 		s0 := v.Args[1]
   34096 		if s0.Op != OpS390XSLWconst {
   34097 			break
   34098 		}
   34099 		j0 := s0.AuxInt
   34100 		x0 := s0.Args[0]
   34101 		if x0.Op != OpS390XMOVBZloadidx {
   34102 			break
   34103 		}
   34104 		i0 := x0.AuxInt
   34105 		if x0.Aux != s {
   34106 			break
   34107 		}
   34108 		_ = x0.Args[2]
   34109 		if idx != x0.Args[0] {
   34110 			break
   34111 		}
   34112 		if p != x0.Args[1] {
   34113 			break
   34114 		}
   34115 		if mem != x0.Args[2] {
   34116 			break
   34117 		}
   34118 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34119 			break
   34120 		}
   34121 		b = mergePoint(b, x0, x1)
   34122 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34123 		v.reset(OpCopy)
   34124 		v.AddArg(v0)
   34125 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34126 		v1.AuxInt = j1
   34127 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   34128 		v2.AuxInt = i0
   34129 		v2.Aux = s
   34130 		v2.AddArg(p)
   34131 		v2.AddArg(idx)
   34132 		v2.AddArg(mem)
   34133 		v1.AddArg(v2)
   34134 		v0.AddArg(v1)
   34135 		v0.AddArg(y)
   34136 		return true
   34137 	}
   34138 	// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
   34139 	// cond: i1 == i0+1   && j1 == j0-8   && j1 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34140 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
   34141 	for {
   34142 		_ = v.Args[1]
   34143 		or := v.Args[0]
   34144 		if or.Op != OpS390XORW {
   34145 			break
   34146 		}
   34147 		_ = or.Args[1]
   34148 		y := or.Args[0]
   34149 		s1 := or.Args[1]
   34150 		if s1.Op != OpS390XSLWconst {
   34151 			break
   34152 		}
   34153 		j1 := s1.AuxInt
   34154 		x1 := s1.Args[0]
   34155 		if x1.Op != OpS390XMOVBZloadidx {
   34156 			break
   34157 		}
   34158 		i1 := x1.AuxInt
   34159 		s := x1.Aux
   34160 		_ = x1.Args[2]
   34161 		idx := x1.Args[0]
   34162 		p := x1.Args[1]
   34163 		mem := x1.Args[2]
   34164 		s0 := v.Args[1]
   34165 		if s0.Op != OpS390XSLWconst {
   34166 			break
   34167 		}
   34168 		j0 := s0.AuxInt
   34169 		x0 := s0.Args[0]
   34170 		if x0.Op != OpS390XMOVBZloadidx {
   34171 			break
   34172 		}
   34173 		i0 := x0.AuxInt
   34174 		if x0.Aux != s {
   34175 			break
   34176 		}
   34177 		_ = x0.Args[2]
   34178 		if idx != x0.Args[0] {
   34179 			break
   34180 		}
   34181 		if p != x0.Args[1] {
   34182 			break
   34183 		}
   34184 		if mem != x0.Args[2] {
   34185 			break
   34186 		}
   34187 		if !(i1 == i0+1 && j1 == j0-8 && j1%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34188 			break
   34189 		}
   34190 		b = mergePoint(b, x0, x1)
   34191 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34192 		v.reset(OpCopy)
   34193 		v.AddArg(v0)
   34194 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34195 		v1.AuxInt = j1
   34196 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZloadidx, typ.UInt16)
   34197 		v2.AuxInt = i0
   34198 		v2.Aux = s
   34199 		v2.AddArg(p)
   34200 		v2.AddArg(idx)
   34201 		v2.AddArg(mem)
   34202 		v1.AddArg(v2)
   34203 		v0.AddArg(v1)
   34204 		v0.AddArg(y)
   34205 		return true
   34206 	}
   34207 	// match: (ORW x0:(MOVBZload [i0] {s} p mem) sh:(SLWconst [8] x1:(MOVBZload [i1] {s} p mem)))
   34208 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34209 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
   34210 	for {
   34211 		_ = v.Args[1]
   34212 		x0 := v.Args[0]
   34213 		if x0.Op != OpS390XMOVBZload {
   34214 			break
   34215 		}
   34216 		i0 := x0.AuxInt
   34217 		s := x0.Aux
   34218 		_ = x0.Args[1]
   34219 		p := x0.Args[0]
   34220 		mem := x0.Args[1]
   34221 		sh := v.Args[1]
   34222 		if sh.Op != OpS390XSLWconst {
   34223 			break
   34224 		}
   34225 		if sh.AuxInt != 8 {
   34226 			break
   34227 		}
   34228 		x1 := sh.Args[0]
   34229 		if x1.Op != OpS390XMOVBZload {
   34230 			break
   34231 		}
   34232 		i1 := x1.AuxInt
   34233 		if x1.Aux != s {
   34234 			break
   34235 		}
   34236 		_ = x1.Args[1]
   34237 		if p != x1.Args[0] {
   34238 			break
   34239 		}
   34240 		if mem != x1.Args[1] {
   34241 			break
   34242 		}
   34243 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34244 			break
   34245 		}
   34246 		b = mergePoint(b, x0, x1)
   34247 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34248 		v.reset(OpCopy)
   34249 		v.AddArg(v0)
   34250 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   34251 		v1.AuxInt = i0
   34252 		v1.Aux = s
   34253 		v1.AddArg(p)
   34254 		v1.AddArg(mem)
   34255 		v0.AddArg(v1)
   34256 		return true
   34257 	}
   34258 	// match: (ORW sh:(SLWconst [8] x1:(MOVBZload [i1] {s} p mem)) x0:(MOVBZload [i0] {s} p mem))
   34259 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34260 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRload [i0] {s} p mem))
   34261 	for {
   34262 		_ = v.Args[1]
   34263 		sh := v.Args[0]
   34264 		if sh.Op != OpS390XSLWconst {
   34265 			break
   34266 		}
   34267 		if sh.AuxInt != 8 {
   34268 			break
   34269 		}
   34270 		x1 := sh.Args[0]
   34271 		if x1.Op != OpS390XMOVBZload {
   34272 			break
   34273 		}
   34274 		i1 := x1.AuxInt
   34275 		s := x1.Aux
   34276 		_ = x1.Args[1]
   34277 		p := x1.Args[0]
   34278 		mem := x1.Args[1]
   34279 		x0 := v.Args[1]
   34280 		if x0.Op != OpS390XMOVBZload {
   34281 			break
   34282 		}
   34283 		i0 := x0.AuxInt
   34284 		if x0.Aux != s {
   34285 			break
   34286 		}
   34287 		_ = x0.Args[1]
   34288 		if p != x0.Args[0] {
   34289 			break
   34290 		}
   34291 		if mem != x0.Args[1] {
   34292 			break
   34293 		}
   34294 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34295 			break
   34296 		}
   34297 		b = mergePoint(b, x0, x1)
   34298 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34299 		v.reset(OpCopy)
   34300 		v.AddArg(v0)
   34301 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   34302 		v1.AuxInt = i0
   34303 		v1.Aux = s
   34304 		v1.AddArg(p)
   34305 		v1.AddArg(mem)
   34306 		v0.AddArg(v1)
   34307 		return true
   34308 	}
   34309 	// match: (ORW r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))))
   34310 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   34311 	// result: @mergePoint(b,x0,x1) (MOVWBRload [i0] {s} p mem)
   34312 	for {
   34313 		_ = v.Args[1]
   34314 		r0 := v.Args[0]
   34315 		if r0.Op != OpS390XMOVHZreg {
   34316 			break
   34317 		}
   34318 		x0 := r0.Args[0]
   34319 		if x0.Op != OpS390XMOVHBRload {
   34320 			break
   34321 		}
   34322 		i0 := x0.AuxInt
   34323 		s := x0.Aux
   34324 		_ = x0.Args[1]
   34325 		p := x0.Args[0]
   34326 		mem := x0.Args[1]
   34327 		sh := v.Args[1]
   34328 		if sh.Op != OpS390XSLWconst {
   34329 			break
   34330 		}
   34331 		if sh.AuxInt != 16 {
   34332 			break
   34333 		}
   34334 		r1 := sh.Args[0]
   34335 		if r1.Op != OpS390XMOVHZreg {
   34336 			break
   34337 		}
   34338 		x1 := r1.Args[0]
   34339 		if x1.Op != OpS390XMOVHBRload {
   34340 			break
   34341 		}
   34342 		i1 := x1.AuxInt
   34343 		if x1.Aux != s {
   34344 			break
   34345 		}
   34346 		_ = x1.Args[1]
   34347 		if p != x1.Args[0] {
   34348 			break
   34349 		}
   34350 		if mem != x1.Args[1] {
   34351 			break
   34352 		}
   34353 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   34354 			break
   34355 		}
   34356 		b = mergePoint(b, x0, x1)
   34357 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   34358 		v.reset(OpCopy)
   34359 		v.AddArg(v0)
   34360 		v0.AuxInt = i0
   34361 		v0.Aux = s
   34362 		v0.AddArg(p)
   34363 		v0.AddArg(mem)
   34364 		return true
   34365 	}
   34366 	// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRload [i1] {s} p mem))) r0:(MOVHZreg x0:(MOVHBRload [i0] {s} p mem)))
   34367 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   34368 	// result: @mergePoint(b,x0,x1) (MOVWBRload [i0] {s} p mem)
   34369 	for {
   34370 		_ = v.Args[1]
   34371 		sh := v.Args[0]
   34372 		if sh.Op != OpS390XSLWconst {
   34373 			break
   34374 		}
   34375 		if sh.AuxInt != 16 {
   34376 			break
   34377 		}
   34378 		r1 := sh.Args[0]
   34379 		if r1.Op != OpS390XMOVHZreg {
   34380 			break
   34381 		}
   34382 		x1 := r1.Args[0]
   34383 		if x1.Op != OpS390XMOVHBRload {
   34384 			break
   34385 		}
   34386 		i1 := x1.AuxInt
   34387 		s := x1.Aux
   34388 		_ = x1.Args[1]
   34389 		p := x1.Args[0]
   34390 		mem := x1.Args[1]
   34391 		r0 := v.Args[1]
   34392 		if r0.Op != OpS390XMOVHZreg {
   34393 			break
   34394 		}
   34395 		x0 := r0.Args[0]
   34396 		if x0.Op != OpS390XMOVHBRload {
   34397 			break
   34398 		}
   34399 		i0 := x0.AuxInt
   34400 		if x0.Aux != s {
   34401 			break
   34402 		}
   34403 		_ = x0.Args[1]
   34404 		if p != x0.Args[0] {
   34405 			break
   34406 		}
   34407 		if mem != x0.Args[1] {
   34408 			break
   34409 		}
   34410 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   34411 			break
   34412 		}
   34413 		b = mergePoint(b, x0, x1)
   34414 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRload, typ.UInt32)
   34415 		v.reset(OpCopy)
   34416 		v.AddArg(v0)
   34417 		v0.AuxInt = i0
   34418 		v0.Aux = s
   34419 		v0.AddArg(p)
   34420 		v0.AddArg(mem)
   34421 		return true
   34422 	}
   34423 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) y))
   34424 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34425 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   34426 	for {
   34427 		_ = v.Args[1]
   34428 		s1 := v.Args[0]
   34429 		if s1.Op != OpS390XSLWconst {
   34430 			break
   34431 		}
   34432 		j1 := s1.AuxInt
   34433 		x1 := s1.Args[0]
   34434 		if x1.Op != OpS390XMOVBZload {
   34435 			break
   34436 		}
   34437 		i1 := x1.AuxInt
   34438 		s := x1.Aux
   34439 		_ = x1.Args[1]
   34440 		p := x1.Args[0]
   34441 		mem := x1.Args[1]
   34442 		or := v.Args[1]
   34443 		if or.Op != OpS390XORW {
   34444 			break
   34445 		}
   34446 		_ = or.Args[1]
   34447 		s0 := or.Args[0]
   34448 		if s0.Op != OpS390XSLWconst {
   34449 			break
   34450 		}
   34451 		j0 := s0.AuxInt
   34452 		x0 := s0.Args[0]
   34453 		if x0.Op != OpS390XMOVBZload {
   34454 			break
   34455 		}
   34456 		i0 := x0.AuxInt
   34457 		if x0.Aux != s {
   34458 			break
   34459 		}
   34460 		_ = x0.Args[1]
   34461 		if p != x0.Args[0] {
   34462 			break
   34463 		}
   34464 		if mem != x0.Args[1] {
   34465 			break
   34466 		}
   34467 		y := or.Args[1]
   34468 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34469 			break
   34470 		}
   34471 		b = mergePoint(b, x0, x1)
   34472 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34473 		v.reset(OpCopy)
   34474 		v.AddArg(v0)
   34475 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34476 		v1.AuxInt = j0
   34477 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34478 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   34479 		v3.AuxInt = i0
   34480 		v3.Aux = s
   34481 		v3.AddArg(p)
   34482 		v3.AddArg(mem)
   34483 		v2.AddArg(v3)
   34484 		v1.AddArg(v2)
   34485 		v0.AddArg(v1)
   34486 		v0.AddArg(y)
   34487 		return true
   34488 	}
   34489 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))))
   34490 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34491 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   34492 	for {
   34493 		_ = v.Args[1]
   34494 		s1 := v.Args[0]
   34495 		if s1.Op != OpS390XSLWconst {
   34496 			break
   34497 		}
   34498 		j1 := s1.AuxInt
   34499 		x1 := s1.Args[0]
   34500 		if x1.Op != OpS390XMOVBZload {
   34501 			break
   34502 		}
   34503 		i1 := x1.AuxInt
   34504 		s := x1.Aux
   34505 		_ = x1.Args[1]
   34506 		p := x1.Args[0]
   34507 		mem := x1.Args[1]
   34508 		or := v.Args[1]
   34509 		if or.Op != OpS390XORW {
   34510 			break
   34511 		}
   34512 		_ = or.Args[1]
   34513 		y := or.Args[0]
   34514 		s0 := or.Args[1]
   34515 		if s0.Op != OpS390XSLWconst {
   34516 			break
   34517 		}
   34518 		j0 := s0.AuxInt
   34519 		x0 := s0.Args[0]
   34520 		if x0.Op != OpS390XMOVBZload {
   34521 			break
   34522 		}
   34523 		i0 := x0.AuxInt
   34524 		if x0.Aux != s {
   34525 			break
   34526 		}
   34527 		_ = x0.Args[1]
   34528 		if p != x0.Args[0] {
   34529 			break
   34530 		}
   34531 		if mem != x0.Args[1] {
   34532 			break
   34533 		}
   34534 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34535 			break
   34536 		}
   34537 		b = mergePoint(b, x0, x1)
   34538 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34539 		v.reset(OpCopy)
   34540 		v.AddArg(v0)
   34541 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34542 		v1.AuxInt = j0
   34543 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34544 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   34545 		v3.AuxInt = i0
   34546 		v3.Aux = s
   34547 		v3.AddArg(p)
   34548 		v3.AddArg(mem)
   34549 		v2.AddArg(v3)
   34550 		v1.AddArg(v2)
   34551 		v0.AddArg(v1)
   34552 		v0.AddArg(y)
   34553 		return true
   34554 	}
   34555 	// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)) y) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
   34556 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34557 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   34558 	for {
   34559 		_ = v.Args[1]
   34560 		or := v.Args[0]
   34561 		if or.Op != OpS390XORW {
   34562 			break
   34563 		}
   34564 		_ = or.Args[1]
   34565 		s0 := or.Args[0]
   34566 		if s0.Op != OpS390XSLWconst {
   34567 			break
   34568 		}
   34569 		j0 := s0.AuxInt
   34570 		x0 := s0.Args[0]
   34571 		if x0.Op != OpS390XMOVBZload {
   34572 			break
   34573 		}
   34574 		i0 := x0.AuxInt
   34575 		s := x0.Aux
   34576 		_ = x0.Args[1]
   34577 		p := x0.Args[0]
   34578 		mem := x0.Args[1]
   34579 		y := or.Args[1]
   34580 		s1 := v.Args[1]
   34581 		if s1.Op != OpS390XSLWconst {
   34582 			break
   34583 		}
   34584 		j1 := s1.AuxInt
   34585 		x1 := s1.Args[0]
   34586 		if x1.Op != OpS390XMOVBZload {
   34587 			break
   34588 		}
   34589 		i1 := x1.AuxInt
   34590 		if x1.Aux != s {
   34591 			break
   34592 		}
   34593 		_ = x1.Args[1]
   34594 		if p != x1.Args[0] {
   34595 			break
   34596 		}
   34597 		if mem != x1.Args[1] {
   34598 			break
   34599 		}
   34600 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34601 			break
   34602 		}
   34603 		b = mergePoint(b, x0, x1)
   34604 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34605 		v.reset(OpCopy)
   34606 		v.AddArg(v0)
   34607 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34608 		v1.AuxInt = j0
   34609 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34610 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   34611 		v3.AuxInt = i0
   34612 		v3.Aux = s
   34613 		v3.AddArg(p)
   34614 		v3.AddArg(mem)
   34615 		v2.AddArg(v3)
   34616 		v1.AddArg(v2)
   34617 		v0.AddArg(v1)
   34618 		v0.AddArg(y)
   34619 		return true
   34620 	}
   34621 	return false
   34622 }
   34623 func rewriteValueS390X_OpS390XORW_60(v *Value) bool {
   34624 	b := v.Block
   34625 	_ = b
   34626 	typ := &b.Func.Config.Types
   34627 	_ = typ
   34628 	// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
   34629 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   34630 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
   34631 	for {
   34632 		_ = v.Args[1]
   34633 		or := v.Args[0]
   34634 		if or.Op != OpS390XORW {
   34635 			break
   34636 		}
   34637 		_ = or.Args[1]
   34638 		y := or.Args[0]
   34639 		s0 := or.Args[1]
   34640 		if s0.Op != OpS390XSLWconst {
   34641 			break
   34642 		}
   34643 		j0 := s0.AuxInt
   34644 		x0 := s0.Args[0]
   34645 		if x0.Op != OpS390XMOVBZload {
   34646 			break
   34647 		}
   34648 		i0 := x0.AuxInt
   34649 		s := x0.Aux
   34650 		_ = x0.Args[1]
   34651 		p := x0.Args[0]
   34652 		mem := x0.Args[1]
   34653 		s1 := v.Args[1]
   34654 		if s1.Op != OpS390XSLWconst {
   34655 			break
   34656 		}
   34657 		j1 := s1.AuxInt
   34658 		x1 := s1.Args[0]
   34659 		if x1.Op != OpS390XMOVBZload {
   34660 			break
   34661 		}
   34662 		i1 := x1.AuxInt
   34663 		if x1.Aux != s {
   34664 			break
   34665 		}
   34666 		_ = x1.Args[1]
   34667 		if p != x1.Args[0] {
   34668 			break
   34669 		}
   34670 		if mem != x1.Args[1] {
   34671 			break
   34672 		}
   34673 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   34674 			break
   34675 		}
   34676 		b = mergePoint(b, x0, x1)
   34677 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   34678 		v.reset(OpCopy)
   34679 		v.AddArg(v0)
   34680 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   34681 		v1.AuxInt = j0
   34682 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34683 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRload, typ.UInt16)
   34684 		v3.AuxInt = i0
   34685 		v3.Aux = s
   34686 		v3.AddArg(p)
   34687 		v3.AddArg(mem)
   34688 		v2.AddArg(v3)
   34689 		v1.AddArg(v2)
   34690 		v0.AddArg(v1)
   34691 		v0.AddArg(y)
   34692 		return true
   34693 	}
   34694 	// match: (ORW x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   34695 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34696 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   34697 	for {
   34698 		_ = v.Args[1]
   34699 		x0 := v.Args[0]
   34700 		if x0.Op != OpS390XMOVBZloadidx {
   34701 			break
   34702 		}
   34703 		i0 := x0.AuxInt
   34704 		s := x0.Aux
   34705 		_ = x0.Args[2]
   34706 		p := x0.Args[0]
   34707 		idx := x0.Args[1]
   34708 		mem := x0.Args[2]
   34709 		sh := v.Args[1]
   34710 		if sh.Op != OpS390XSLWconst {
   34711 			break
   34712 		}
   34713 		if sh.AuxInt != 8 {
   34714 			break
   34715 		}
   34716 		x1 := sh.Args[0]
   34717 		if x1.Op != OpS390XMOVBZloadidx {
   34718 			break
   34719 		}
   34720 		i1 := x1.AuxInt
   34721 		if x1.Aux != s {
   34722 			break
   34723 		}
   34724 		_ = x1.Args[2]
   34725 		if p != x1.Args[0] {
   34726 			break
   34727 		}
   34728 		if idx != x1.Args[1] {
   34729 			break
   34730 		}
   34731 		if mem != x1.Args[2] {
   34732 			break
   34733 		}
   34734 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34735 			break
   34736 		}
   34737 		b = mergePoint(b, x0, x1)
   34738 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34739 		v.reset(OpCopy)
   34740 		v.AddArg(v0)
   34741 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   34742 		v1.AuxInt = i0
   34743 		v1.Aux = s
   34744 		v1.AddArg(p)
   34745 		v1.AddArg(idx)
   34746 		v1.AddArg(mem)
   34747 		v0.AddArg(v1)
   34748 		return true
   34749 	}
   34750 	// match: (ORW x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   34751 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34752 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   34753 	for {
   34754 		_ = v.Args[1]
   34755 		x0 := v.Args[0]
   34756 		if x0.Op != OpS390XMOVBZloadidx {
   34757 			break
   34758 		}
   34759 		i0 := x0.AuxInt
   34760 		s := x0.Aux
   34761 		_ = x0.Args[2]
   34762 		idx := x0.Args[0]
   34763 		p := x0.Args[1]
   34764 		mem := x0.Args[2]
   34765 		sh := v.Args[1]
   34766 		if sh.Op != OpS390XSLWconst {
   34767 			break
   34768 		}
   34769 		if sh.AuxInt != 8 {
   34770 			break
   34771 		}
   34772 		x1 := sh.Args[0]
   34773 		if x1.Op != OpS390XMOVBZloadidx {
   34774 			break
   34775 		}
   34776 		i1 := x1.AuxInt
   34777 		if x1.Aux != s {
   34778 			break
   34779 		}
   34780 		_ = x1.Args[2]
   34781 		if p != x1.Args[0] {
   34782 			break
   34783 		}
   34784 		if idx != x1.Args[1] {
   34785 			break
   34786 		}
   34787 		if mem != x1.Args[2] {
   34788 			break
   34789 		}
   34790 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34791 			break
   34792 		}
   34793 		b = mergePoint(b, x0, x1)
   34794 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34795 		v.reset(OpCopy)
   34796 		v.AddArg(v0)
   34797 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   34798 		v1.AuxInt = i0
   34799 		v1.Aux = s
   34800 		v1.AddArg(p)
   34801 		v1.AddArg(idx)
   34802 		v1.AddArg(mem)
   34803 		v0.AddArg(v1)
   34804 		return true
   34805 	}
   34806 	// match: (ORW x0:(MOVBZloadidx [i0] {s} p idx mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   34807 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34808 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   34809 	for {
   34810 		_ = v.Args[1]
   34811 		x0 := v.Args[0]
   34812 		if x0.Op != OpS390XMOVBZloadidx {
   34813 			break
   34814 		}
   34815 		i0 := x0.AuxInt
   34816 		s := x0.Aux
   34817 		_ = x0.Args[2]
   34818 		p := x0.Args[0]
   34819 		idx := x0.Args[1]
   34820 		mem := x0.Args[2]
   34821 		sh := v.Args[1]
   34822 		if sh.Op != OpS390XSLWconst {
   34823 			break
   34824 		}
   34825 		if sh.AuxInt != 8 {
   34826 			break
   34827 		}
   34828 		x1 := sh.Args[0]
   34829 		if x1.Op != OpS390XMOVBZloadidx {
   34830 			break
   34831 		}
   34832 		i1 := x1.AuxInt
   34833 		if x1.Aux != s {
   34834 			break
   34835 		}
   34836 		_ = x1.Args[2]
   34837 		if idx != x1.Args[0] {
   34838 			break
   34839 		}
   34840 		if p != x1.Args[1] {
   34841 			break
   34842 		}
   34843 		if mem != x1.Args[2] {
   34844 			break
   34845 		}
   34846 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34847 			break
   34848 		}
   34849 		b = mergePoint(b, x0, x1)
   34850 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34851 		v.reset(OpCopy)
   34852 		v.AddArg(v0)
   34853 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   34854 		v1.AuxInt = i0
   34855 		v1.Aux = s
   34856 		v1.AddArg(p)
   34857 		v1.AddArg(idx)
   34858 		v1.AddArg(mem)
   34859 		v0.AddArg(v1)
   34860 		return true
   34861 	}
   34862 	// match: (ORW x0:(MOVBZloadidx [i0] {s} idx p mem) sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   34863 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34864 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   34865 	for {
   34866 		_ = v.Args[1]
   34867 		x0 := v.Args[0]
   34868 		if x0.Op != OpS390XMOVBZloadidx {
   34869 			break
   34870 		}
   34871 		i0 := x0.AuxInt
   34872 		s := x0.Aux
   34873 		_ = x0.Args[2]
   34874 		idx := x0.Args[0]
   34875 		p := x0.Args[1]
   34876 		mem := x0.Args[2]
   34877 		sh := v.Args[1]
   34878 		if sh.Op != OpS390XSLWconst {
   34879 			break
   34880 		}
   34881 		if sh.AuxInt != 8 {
   34882 			break
   34883 		}
   34884 		x1 := sh.Args[0]
   34885 		if x1.Op != OpS390XMOVBZloadidx {
   34886 			break
   34887 		}
   34888 		i1 := x1.AuxInt
   34889 		if x1.Aux != s {
   34890 			break
   34891 		}
   34892 		_ = x1.Args[2]
   34893 		if idx != x1.Args[0] {
   34894 			break
   34895 		}
   34896 		if p != x1.Args[1] {
   34897 			break
   34898 		}
   34899 		if mem != x1.Args[2] {
   34900 			break
   34901 		}
   34902 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34903 			break
   34904 		}
   34905 		b = mergePoint(b, x0, x1)
   34906 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34907 		v.reset(OpCopy)
   34908 		v.AddArg(v0)
   34909 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   34910 		v1.AuxInt = i0
   34911 		v1.Aux = s
   34912 		v1.AddArg(p)
   34913 		v1.AddArg(idx)
   34914 		v1.AddArg(mem)
   34915 		v0.AddArg(v1)
   34916 		return true
   34917 	}
   34918 	// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
   34919 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34920 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   34921 	for {
   34922 		_ = v.Args[1]
   34923 		sh := v.Args[0]
   34924 		if sh.Op != OpS390XSLWconst {
   34925 			break
   34926 		}
   34927 		if sh.AuxInt != 8 {
   34928 			break
   34929 		}
   34930 		x1 := sh.Args[0]
   34931 		if x1.Op != OpS390XMOVBZloadidx {
   34932 			break
   34933 		}
   34934 		i1 := x1.AuxInt
   34935 		s := x1.Aux
   34936 		_ = x1.Args[2]
   34937 		p := x1.Args[0]
   34938 		idx := x1.Args[1]
   34939 		mem := x1.Args[2]
   34940 		x0 := v.Args[1]
   34941 		if x0.Op != OpS390XMOVBZloadidx {
   34942 			break
   34943 		}
   34944 		i0 := x0.AuxInt
   34945 		if x0.Aux != s {
   34946 			break
   34947 		}
   34948 		_ = x0.Args[2]
   34949 		if p != x0.Args[0] {
   34950 			break
   34951 		}
   34952 		if idx != x0.Args[1] {
   34953 			break
   34954 		}
   34955 		if mem != x0.Args[2] {
   34956 			break
   34957 		}
   34958 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   34959 			break
   34960 		}
   34961 		b = mergePoint(b, x0, x1)
   34962 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   34963 		v.reset(OpCopy)
   34964 		v.AddArg(v0)
   34965 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   34966 		v1.AuxInt = i0
   34967 		v1.Aux = s
   34968 		v1.AddArg(p)
   34969 		v1.AddArg(idx)
   34970 		v1.AddArg(mem)
   34971 		v0.AddArg(v1)
   34972 		return true
   34973 	}
   34974 	// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
   34975 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   34976 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   34977 	for {
   34978 		_ = v.Args[1]
   34979 		sh := v.Args[0]
   34980 		if sh.Op != OpS390XSLWconst {
   34981 			break
   34982 		}
   34983 		if sh.AuxInt != 8 {
   34984 			break
   34985 		}
   34986 		x1 := sh.Args[0]
   34987 		if x1.Op != OpS390XMOVBZloadidx {
   34988 			break
   34989 		}
   34990 		i1 := x1.AuxInt
   34991 		s := x1.Aux
   34992 		_ = x1.Args[2]
   34993 		idx := x1.Args[0]
   34994 		p := x1.Args[1]
   34995 		mem := x1.Args[2]
   34996 		x0 := v.Args[1]
   34997 		if x0.Op != OpS390XMOVBZloadidx {
   34998 			break
   34999 		}
   35000 		i0 := x0.AuxInt
   35001 		if x0.Aux != s {
   35002 			break
   35003 		}
   35004 		_ = x0.Args[2]
   35005 		if p != x0.Args[0] {
   35006 			break
   35007 		}
   35008 		if idx != x0.Args[1] {
   35009 			break
   35010 		}
   35011 		if mem != x0.Args[2] {
   35012 			break
   35013 		}
   35014 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   35015 			break
   35016 		}
   35017 		b = mergePoint(b, x0, x1)
   35018 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35019 		v.reset(OpCopy)
   35020 		v.AddArg(v0)
   35021 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35022 		v1.AuxInt = i0
   35023 		v1.Aux = s
   35024 		v1.AddArg(p)
   35025 		v1.AddArg(idx)
   35026 		v1.AddArg(mem)
   35027 		v0.AddArg(v1)
   35028 		return true
   35029 	}
   35030 	// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} p idx mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
   35031 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   35032 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   35033 	for {
   35034 		_ = v.Args[1]
   35035 		sh := v.Args[0]
   35036 		if sh.Op != OpS390XSLWconst {
   35037 			break
   35038 		}
   35039 		if sh.AuxInt != 8 {
   35040 			break
   35041 		}
   35042 		x1 := sh.Args[0]
   35043 		if x1.Op != OpS390XMOVBZloadidx {
   35044 			break
   35045 		}
   35046 		i1 := x1.AuxInt
   35047 		s := x1.Aux
   35048 		_ = x1.Args[2]
   35049 		p := x1.Args[0]
   35050 		idx := x1.Args[1]
   35051 		mem := x1.Args[2]
   35052 		x0 := v.Args[1]
   35053 		if x0.Op != OpS390XMOVBZloadidx {
   35054 			break
   35055 		}
   35056 		i0 := x0.AuxInt
   35057 		if x0.Aux != s {
   35058 			break
   35059 		}
   35060 		_ = x0.Args[2]
   35061 		if idx != x0.Args[0] {
   35062 			break
   35063 		}
   35064 		if p != x0.Args[1] {
   35065 			break
   35066 		}
   35067 		if mem != x0.Args[2] {
   35068 			break
   35069 		}
   35070 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   35071 			break
   35072 		}
   35073 		b = mergePoint(b, x0, x1)
   35074 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35075 		v.reset(OpCopy)
   35076 		v.AddArg(v0)
   35077 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35078 		v1.AuxInt = i0
   35079 		v1.Aux = s
   35080 		v1.AddArg(p)
   35081 		v1.AddArg(idx)
   35082 		v1.AddArg(mem)
   35083 		v0.AddArg(v1)
   35084 		return true
   35085 	}
   35086 	// match: (ORW sh:(SLWconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} idx p mem))
   35087 	// cond: p.Op != OpSB   && i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(sh)
   35088 	// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
   35089 	for {
   35090 		_ = v.Args[1]
   35091 		sh := v.Args[0]
   35092 		if sh.Op != OpS390XSLWconst {
   35093 			break
   35094 		}
   35095 		if sh.AuxInt != 8 {
   35096 			break
   35097 		}
   35098 		x1 := sh.Args[0]
   35099 		if x1.Op != OpS390XMOVBZloadidx {
   35100 			break
   35101 		}
   35102 		i1 := x1.AuxInt
   35103 		s := x1.Aux
   35104 		_ = x1.Args[2]
   35105 		idx := x1.Args[0]
   35106 		p := x1.Args[1]
   35107 		mem := x1.Args[2]
   35108 		x0 := v.Args[1]
   35109 		if x0.Op != OpS390XMOVBZloadidx {
   35110 			break
   35111 		}
   35112 		i0 := x0.AuxInt
   35113 		if x0.Aux != s {
   35114 			break
   35115 		}
   35116 		_ = x0.Args[2]
   35117 		if idx != x0.Args[0] {
   35118 			break
   35119 		}
   35120 		if p != x0.Args[1] {
   35121 			break
   35122 		}
   35123 		if mem != x0.Args[2] {
   35124 			break
   35125 		}
   35126 		if !(p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)) {
   35127 			break
   35128 		}
   35129 		b = mergePoint(b, x0, x1)
   35130 		v0 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35131 		v.reset(OpCopy)
   35132 		v.AddArg(v0)
   35133 		v1 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35134 		v1.AuxInt = i0
   35135 		v1.Aux = s
   35136 		v1.AddArg(p)
   35137 		v1.AddArg(idx)
   35138 		v1.AddArg(mem)
   35139 		v0.AddArg(v1)
   35140 		return true
   35141 	}
   35142 	// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   35143 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35144 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35145 	for {
   35146 		_ = v.Args[1]
   35147 		r0 := v.Args[0]
   35148 		if r0.Op != OpS390XMOVHZreg {
   35149 			break
   35150 		}
   35151 		x0 := r0.Args[0]
   35152 		if x0.Op != OpS390XMOVHBRloadidx {
   35153 			break
   35154 		}
   35155 		i0 := x0.AuxInt
   35156 		s := x0.Aux
   35157 		_ = x0.Args[2]
   35158 		p := x0.Args[0]
   35159 		idx := x0.Args[1]
   35160 		mem := x0.Args[2]
   35161 		sh := v.Args[1]
   35162 		if sh.Op != OpS390XSLWconst {
   35163 			break
   35164 		}
   35165 		if sh.AuxInt != 16 {
   35166 			break
   35167 		}
   35168 		r1 := sh.Args[0]
   35169 		if r1.Op != OpS390XMOVHZreg {
   35170 			break
   35171 		}
   35172 		x1 := r1.Args[0]
   35173 		if x1.Op != OpS390XMOVHBRloadidx {
   35174 			break
   35175 		}
   35176 		i1 := x1.AuxInt
   35177 		if x1.Aux != s {
   35178 			break
   35179 		}
   35180 		_ = x1.Args[2]
   35181 		if p != x1.Args[0] {
   35182 			break
   35183 		}
   35184 		if idx != x1.Args[1] {
   35185 			break
   35186 		}
   35187 		if mem != x1.Args[2] {
   35188 			break
   35189 		}
   35190 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35191 			break
   35192 		}
   35193 		b = mergePoint(b, x0, x1)
   35194 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35195 		v.reset(OpCopy)
   35196 		v.AddArg(v0)
   35197 		v0.AuxInt = i0
   35198 		v0.Aux = s
   35199 		v0.AddArg(p)
   35200 		v0.AddArg(idx)
   35201 		v0.AddArg(mem)
   35202 		return true
   35203 	}
   35204 	return false
   35205 }
   35206 func rewriteValueS390X_OpS390XORW_70(v *Value) bool {
   35207 	b := v.Block
   35208 	_ = b
   35209 	typ := &b.Func.Config.Types
   35210 	_ = typ
   35211 	// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
   35212 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35213 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35214 	for {
   35215 		_ = v.Args[1]
   35216 		r0 := v.Args[0]
   35217 		if r0.Op != OpS390XMOVHZreg {
   35218 			break
   35219 		}
   35220 		x0 := r0.Args[0]
   35221 		if x0.Op != OpS390XMOVHBRloadidx {
   35222 			break
   35223 		}
   35224 		i0 := x0.AuxInt
   35225 		s := x0.Aux
   35226 		_ = x0.Args[2]
   35227 		idx := x0.Args[0]
   35228 		p := x0.Args[1]
   35229 		mem := x0.Args[2]
   35230 		sh := v.Args[1]
   35231 		if sh.Op != OpS390XSLWconst {
   35232 			break
   35233 		}
   35234 		if sh.AuxInt != 16 {
   35235 			break
   35236 		}
   35237 		r1 := sh.Args[0]
   35238 		if r1.Op != OpS390XMOVHZreg {
   35239 			break
   35240 		}
   35241 		x1 := r1.Args[0]
   35242 		if x1.Op != OpS390XMOVHBRloadidx {
   35243 			break
   35244 		}
   35245 		i1 := x1.AuxInt
   35246 		if x1.Aux != s {
   35247 			break
   35248 		}
   35249 		_ = x1.Args[2]
   35250 		if p != x1.Args[0] {
   35251 			break
   35252 		}
   35253 		if idx != x1.Args[1] {
   35254 			break
   35255 		}
   35256 		if mem != x1.Args[2] {
   35257 			break
   35258 		}
   35259 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35260 			break
   35261 		}
   35262 		b = mergePoint(b, x0, x1)
   35263 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35264 		v.reset(OpCopy)
   35265 		v.AddArg(v0)
   35266 		v0.AuxInt = i0
   35267 		v0.Aux = s
   35268 		v0.AddArg(p)
   35269 		v0.AddArg(idx)
   35270 		v0.AddArg(mem)
   35271 		return true
   35272 	}
   35273 	// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   35274 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35275 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35276 	for {
   35277 		_ = v.Args[1]
   35278 		r0 := v.Args[0]
   35279 		if r0.Op != OpS390XMOVHZreg {
   35280 			break
   35281 		}
   35282 		x0 := r0.Args[0]
   35283 		if x0.Op != OpS390XMOVHBRloadidx {
   35284 			break
   35285 		}
   35286 		i0 := x0.AuxInt
   35287 		s := x0.Aux
   35288 		_ = x0.Args[2]
   35289 		p := x0.Args[0]
   35290 		idx := x0.Args[1]
   35291 		mem := x0.Args[2]
   35292 		sh := v.Args[1]
   35293 		if sh.Op != OpS390XSLWconst {
   35294 			break
   35295 		}
   35296 		if sh.AuxInt != 16 {
   35297 			break
   35298 		}
   35299 		r1 := sh.Args[0]
   35300 		if r1.Op != OpS390XMOVHZreg {
   35301 			break
   35302 		}
   35303 		x1 := r1.Args[0]
   35304 		if x1.Op != OpS390XMOVHBRloadidx {
   35305 			break
   35306 		}
   35307 		i1 := x1.AuxInt
   35308 		if x1.Aux != s {
   35309 			break
   35310 		}
   35311 		_ = x1.Args[2]
   35312 		if idx != x1.Args[0] {
   35313 			break
   35314 		}
   35315 		if p != x1.Args[1] {
   35316 			break
   35317 		}
   35318 		if mem != x1.Args[2] {
   35319 			break
   35320 		}
   35321 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35322 			break
   35323 		}
   35324 		b = mergePoint(b, x0, x1)
   35325 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35326 		v.reset(OpCopy)
   35327 		v.AddArg(v0)
   35328 		v0.AuxInt = i0
   35329 		v0.Aux = s
   35330 		v0.AddArg(p)
   35331 		v0.AddArg(idx)
   35332 		v0.AddArg(mem)
   35333 		return true
   35334 	}
   35335 	// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
   35336 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35337 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35338 	for {
   35339 		_ = v.Args[1]
   35340 		r0 := v.Args[0]
   35341 		if r0.Op != OpS390XMOVHZreg {
   35342 			break
   35343 		}
   35344 		x0 := r0.Args[0]
   35345 		if x0.Op != OpS390XMOVHBRloadidx {
   35346 			break
   35347 		}
   35348 		i0 := x0.AuxInt
   35349 		s := x0.Aux
   35350 		_ = x0.Args[2]
   35351 		idx := x0.Args[0]
   35352 		p := x0.Args[1]
   35353 		mem := x0.Args[2]
   35354 		sh := v.Args[1]
   35355 		if sh.Op != OpS390XSLWconst {
   35356 			break
   35357 		}
   35358 		if sh.AuxInt != 16 {
   35359 			break
   35360 		}
   35361 		r1 := sh.Args[0]
   35362 		if r1.Op != OpS390XMOVHZreg {
   35363 			break
   35364 		}
   35365 		x1 := r1.Args[0]
   35366 		if x1.Op != OpS390XMOVHBRloadidx {
   35367 			break
   35368 		}
   35369 		i1 := x1.AuxInt
   35370 		if x1.Aux != s {
   35371 			break
   35372 		}
   35373 		_ = x1.Args[2]
   35374 		if idx != x1.Args[0] {
   35375 			break
   35376 		}
   35377 		if p != x1.Args[1] {
   35378 			break
   35379 		}
   35380 		if mem != x1.Args[2] {
   35381 			break
   35382 		}
   35383 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35384 			break
   35385 		}
   35386 		b = mergePoint(b, x0, x1)
   35387 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35388 		v.reset(OpCopy)
   35389 		v.AddArg(v0)
   35390 		v0.AuxInt = i0
   35391 		v0.Aux = s
   35392 		v0.AddArg(p)
   35393 		v0.AddArg(idx)
   35394 		v0.AddArg(mem)
   35395 		return true
   35396 	}
   35397 	// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
   35398 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35399 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35400 	for {
   35401 		_ = v.Args[1]
   35402 		sh := v.Args[0]
   35403 		if sh.Op != OpS390XSLWconst {
   35404 			break
   35405 		}
   35406 		if sh.AuxInt != 16 {
   35407 			break
   35408 		}
   35409 		r1 := sh.Args[0]
   35410 		if r1.Op != OpS390XMOVHZreg {
   35411 			break
   35412 		}
   35413 		x1 := r1.Args[0]
   35414 		if x1.Op != OpS390XMOVHBRloadidx {
   35415 			break
   35416 		}
   35417 		i1 := x1.AuxInt
   35418 		s := x1.Aux
   35419 		_ = x1.Args[2]
   35420 		p := x1.Args[0]
   35421 		idx := x1.Args[1]
   35422 		mem := x1.Args[2]
   35423 		r0 := v.Args[1]
   35424 		if r0.Op != OpS390XMOVHZreg {
   35425 			break
   35426 		}
   35427 		x0 := r0.Args[0]
   35428 		if x0.Op != OpS390XMOVHBRloadidx {
   35429 			break
   35430 		}
   35431 		i0 := x0.AuxInt
   35432 		if x0.Aux != s {
   35433 			break
   35434 		}
   35435 		_ = x0.Args[2]
   35436 		if p != x0.Args[0] {
   35437 			break
   35438 		}
   35439 		if idx != x0.Args[1] {
   35440 			break
   35441 		}
   35442 		if mem != x0.Args[2] {
   35443 			break
   35444 		}
   35445 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35446 			break
   35447 		}
   35448 		b = mergePoint(b, x0, x1)
   35449 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35450 		v.reset(OpCopy)
   35451 		v.AddArg(v0)
   35452 		v0.AuxInt = i0
   35453 		v0.Aux = s
   35454 		v0.AddArg(p)
   35455 		v0.AddArg(idx)
   35456 		v0.AddArg(mem)
   35457 		return true
   35458 	}
   35459 	// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))
   35460 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35461 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35462 	for {
   35463 		_ = v.Args[1]
   35464 		sh := v.Args[0]
   35465 		if sh.Op != OpS390XSLWconst {
   35466 			break
   35467 		}
   35468 		if sh.AuxInt != 16 {
   35469 			break
   35470 		}
   35471 		r1 := sh.Args[0]
   35472 		if r1.Op != OpS390XMOVHZreg {
   35473 			break
   35474 		}
   35475 		x1 := r1.Args[0]
   35476 		if x1.Op != OpS390XMOVHBRloadidx {
   35477 			break
   35478 		}
   35479 		i1 := x1.AuxInt
   35480 		s := x1.Aux
   35481 		_ = x1.Args[2]
   35482 		idx := x1.Args[0]
   35483 		p := x1.Args[1]
   35484 		mem := x1.Args[2]
   35485 		r0 := v.Args[1]
   35486 		if r0.Op != OpS390XMOVHZreg {
   35487 			break
   35488 		}
   35489 		x0 := r0.Args[0]
   35490 		if x0.Op != OpS390XMOVHBRloadidx {
   35491 			break
   35492 		}
   35493 		i0 := x0.AuxInt
   35494 		if x0.Aux != s {
   35495 			break
   35496 		}
   35497 		_ = x0.Args[2]
   35498 		if p != x0.Args[0] {
   35499 			break
   35500 		}
   35501 		if idx != x0.Args[1] {
   35502 			break
   35503 		}
   35504 		if mem != x0.Args[2] {
   35505 			break
   35506 		}
   35507 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35508 			break
   35509 		}
   35510 		b = mergePoint(b, x0, x1)
   35511 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35512 		v.reset(OpCopy)
   35513 		v.AddArg(v0)
   35514 		v0.AuxInt = i0
   35515 		v0.Aux = s
   35516 		v0.AddArg(p)
   35517 		v0.AddArg(idx)
   35518 		v0.AddArg(mem)
   35519 		return true
   35520 	}
   35521 	// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
   35522 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35523 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35524 	for {
   35525 		_ = v.Args[1]
   35526 		sh := v.Args[0]
   35527 		if sh.Op != OpS390XSLWconst {
   35528 			break
   35529 		}
   35530 		if sh.AuxInt != 16 {
   35531 			break
   35532 		}
   35533 		r1 := sh.Args[0]
   35534 		if r1.Op != OpS390XMOVHZreg {
   35535 			break
   35536 		}
   35537 		x1 := r1.Args[0]
   35538 		if x1.Op != OpS390XMOVHBRloadidx {
   35539 			break
   35540 		}
   35541 		i1 := x1.AuxInt
   35542 		s := x1.Aux
   35543 		_ = x1.Args[2]
   35544 		p := x1.Args[0]
   35545 		idx := x1.Args[1]
   35546 		mem := x1.Args[2]
   35547 		r0 := v.Args[1]
   35548 		if r0.Op != OpS390XMOVHZreg {
   35549 			break
   35550 		}
   35551 		x0 := r0.Args[0]
   35552 		if x0.Op != OpS390XMOVHBRloadidx {
   35553 			break
   35554 		}
   35555 		i0 := x0.AuxInt
   35556 		if x0.Aux != s {
   35557 			break
   35558 		}
   35559 		_ = x0.Args[2]
   35560 		if idx != x0.Args[0] {
   35561 			break
   35562 		}
   35563 		if p != x0.Args[1] {
   35564 			break
   35565 		}
   35566 		if mem != x0.Args[2] {
   35567 			break
   35568 		}
   35569 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35570 			break
   35571 		}
   35572 		b = mergePoint(b, x0, x1)
   35573 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35574 		v.reset(OpCopy)
   35575 		v.AddArg(v0)
   35576 		v0.AuxInt = i0
   35577 		v0.Aux = s
   35578 		v0.AddArg(p)
   35579 		v0.AddArg(idx)
   35580 		v0.AddArg(mem)
   35581 		return true
   35582 	}
   35583 	// match: (ORW sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
   35584 	// cond: i1 == i0+2   && x0.Uses == 1   && x1.Uses == 1   && r0.Uses == 1   && r1.Uses == 1   && sh.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(r0)   && clobber(r1)   && clobber(sh)
   35585 	// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
   35586 	for {
   35587 		_ = v.Args[1]
   35588 		sh := v.Args[0]
   35589 		if sh.Op != OpS390XSLWconst {
   35590 			break
   35591 		}
   35592 		if sh.AuxInt != 16 {
   35593 			break
   35594 		}
   35595 		r1 := sh.Args[0]
   35596 		if r1.Op != OpS390XMOVHZreg {
   35597 			break
   35598 		}
   35599 		x1 := r1.Args[0]
   35600 		if x1.Op != OpS390XMOVHBRloadidx {
   35601 			break
   35602 		}
   35603 		i1 := x1.AuxInt
   35604 		s := x1.Aux
   35605 		_ = x1.Args[2]
   35606 		idx := x1.Args[0]
   35607 		p := x1.Args[1]
   35608 		mem := x1.Args[2]
   35609 		r0 := v.Args[1]
   35610 		if r0.Op != OpS390XMOVHZreg {
   35611 			break
   35612 		}
   35613 		x0 := r0.Args[0]
   35614 		if x0.Op != OpS390XMOVHBRloadidx {
   35615 			break
   35616 		}
   35617 		i0 := x0.AuxInt
   35618 		if x0.Aux != s {
   35619 			break
   35620 		}
   35621 		_ = x0.Args[2]
   35622 		if idx != x0.Args[0] {
   35623 			break
   35624 		}
   35625 		if p != x0.Args[1] {
   35626 			break
   35627 		}
   35628 		if mem != x0.Args[2] {
   35629 			break
   35630 		}
   35631 		if !(i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)) {
   35632 			break
   35633 		}
   35634 		b = mergePoint(b, x0, x1)
   35635 		v0 := b.NewValue0(v.Pos, OpS390XMOVWBRloadidx, typ.Int32)
   35636 		v.reset(OpCopy)
   35637 		v.AddArg(v0)
   35638 		v0.AuxInt = i0
   35639 		v0.Aux = s
   35640 		v0.AddArg(p)
   35641 		v0.AddArg(idx)
   35642 		v0.AddArg(mem)
   35643 		return true
   35644 	}
   35645 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
   35646 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   35647 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   35648 	for {
   35649 		_ = v.Args[1]
   35650 		s1 := v.Args[0]
   35651 		if s1.Op != OpS390XSLWconst {
   35652 			break
   35653 		}
   35654 		j1 := s1.AuxInt
   35655 		x1 := s1.Args[0]
   35656 		if x1.Op != OpS390XMOVBZloadidx {
   35657 			break
   35658 		}
   35659 		i1 := x1.AuxInt
   35660 		s := x1.Aux
   35661 		_ = x1.Args[2]
   35662 		p := x1.Args[0]
   35663 		idx := x1.Args[1]
   35664 		mem := x1.Args[2]
   35665 		or := v.Args[1]
   35666 		if or.Op != OpS390XORW {
   35667 			break
   35668 		}
   35669 		_ = or.Args[1]
   35670 		s0 := or.Args[0]
   35671 		if s0.Op != OpS390XSLWconst {
   35672 			break
   35673 		}
   35674 		j0 := s0.AuxInt
   35675 		x0 := s0.Args[0]
   35676 		if x0.Op != OpS390XMOVBZloadidx {
   35677 			break
   35678 		}
   35679 		i0 := x0.AuxInt
   35680 		if x0.Aux != s {
   35681 			break
   35682 		}
   35683 		_ = x0.Args[2]
   35684 		if p != x0.Args[0] {
   35685 			break
   35686 		}
   35687 		if idx != x0.Args[1] {
   35688 			break
   35689 		}
   35690 		if mem != x0.Args[2] {
   35691 			break
   35692 		}
   35693 		y := or.Args[1]
   35694 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   35695 			break
   35696 		}
   35697 		b = mergePoint(b, x0, x1)
   35698 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   35699 		v.reset(OpCopy)
   35700 		v.AddArg(v0)
   35701 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   35702 		v1.AuxInt = j0
   35703 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35704 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35705 		v3.AuxInt = i0
   35706 		v3.Aux = s
   35707 		v3.AddArg(p)
   35708 		v3.AddArg(idx)
   35709 		v3.AddArg(mem)
   35710 		v2.AddArg(v3)
   35711 		v1.AddArg(v2)
   35712 		v0.AddArg(v1)
   35713 		v0.AddArg(y)
   35714 		return true
   35715 	}
   35716 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
   35717 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   35718 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   35719 	for {
   35720 		_ = v.Args[1]
   35721 		s1 := v.Args[0]
   35722 		if s1.Op != OpS390XSLWconst {
   35723 			break
   35724 		}
   35725 		j1 := s1.AuxInt
   35726 		x1 := s1.Args[0]
   35727 		if x1.Op != OpS390XMOVBZloadidx {
   35728 			break
   35729 		}
   35730 		i1 := x1.AuxInt
   35731 		s := x1.Aux
   35732 		_ = x1.Args[2]
   35733 		idx := x1.Args[0]
   35734 		p := x1.Args[1]
   35735 		mem := x1.Args[2]
   35736 		or := v.Args[1]
   35737 		if or.Op != OpS390XORW {
   35738 			break
   35739 		}
   35740 		_ = or.Args[1]
   35741 		s0 := or.Args[0]
   35742 		if s0.Op != OpS390XSLWconst {
   35743 			break
   35744 		}
   35745 		j0 := s0.AuxInt
   35746 		x0 := s0.Args[0]
   35747 		if x0.Op != OpS390XMOVBZloadidx {
   35748 			break
   35749 		}
   35750 		i0 := x0.AuxInt
   35751 		if x0.Aux != s {
   35752 			break
   35753 		}
   35754 		_ = x0.Args[2]
   35755 		if p != x0.Args[0] {
   35756 			break
   35757 		}
   35758 		if idx != x0.Args[1] {
   35759 			break
   35760 		}
   35761 		if mem != x0.Args[2] {
   35762 			break
   35763 		}
   35764 		y := or.Args[1]
   35765 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   35766 			break
   35767 		}
   35768 		b = mergePoint(b, x0, x1)
   35769 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   35770 		v.reset(OpCopy)
   35771 		v.AddArg(v0)
   35772 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   35773 		v1.AuxInt = j0
   35774 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35775 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35776 		v3.AuxInt = i0
   35777 		v3.Aux = s
   35778 		v3.AddArg(p)
   35779 		v3.AddArg(idx)
   35780 		v3.AddArg(mem)
   35781 		v2.AddArg(v3)
   35782 		v1.AddArg(v2)
   35783 		v0.AddArg(v1)
   35784 		v0.AddArg(y)
   35785 		return true
   35786 	}
   35787 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
   35788 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   35789 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   35790 	for {
   35791 		_ = v.Args[1]
   35792 		s1 := v.Args[0]
   35793 		if s1.Op != OpS390XSLWconst {
   35794 			break
   35795 		}
   35796 		j1 := s1.AuxInt
   35797 		x1 := s1.Args[0]
   35798 		if x1.Op != OpS390XMOVBZloadidx {
   35799 			break
   35800 		}
   35801 		i1 := x1.AuxInt
   35802 		s := x1.Aux
   35803 		_ = x1.Args[2]
   35804 		p := x1.Args[0]
   35805 		idx := x1.Args[1]
   35806 		mem := x1.Args[2]
   35807 		or := v.Args[1]
   35808 		if or.Op != OpS390XORW {
   35809 			break
   35810 		}
   35811 		_ = or.Args[1]
   35812 		s0 := or.Args[0]
   35813 		if s0.Op != OpS390XSLWconst {
   35814 			break
   35815 		}
   35816 		j0 := s0.AuxInt
   35817 		x0 := s0.Args[0]
   35818 		if x0.Op != OpS390XMOVBZloadidx {
   35819 			break
   35820 		}
   35821 		i0 := x0.AuxInt
   35822 		if x0.Aux != s {
   35823 			break
   35824 		}
   35825 		_ = x0.Args[2]
   35826 		if idx != x0.Args[0] {
   35827 			break
   35828 		}
   35829 		if p != x0.Args[1] {
   35830 			break
   35831 		}
   35832 		if mem != x0.Args[2] {
   35833 			break
   35834 		}
   35835 		y := or.Args[1]
   35836 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   35837 			break
   35838 		}
   35839 		b = mergePoint(b, x0, x1)
   35840 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   35841 		v.reset(OpCopy)
   35842 		v.AddArg(v0)
   35843 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   35844 		v1.AuxInt = j0
   35845 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35846 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35847 		v3.AuxInt = i0
   35848 		v3.Aux = s
   35849 		v3.AddArg(p)
   35850 		v3.AddArg(idx)
   35851 		v3.AddArg(mem)
   35852 		v2.AddArg(v3)
   35853 		v1.AddArg(v2)
   35854 		v0.AddArg(v1)
   35855 		v0.AddArg(y)
   35856 		return true
   35857 	}
   35858 	return false
   35859 }
   35860 func rewriteValueS390X_OpS390XORW_80(v *Value) bool {
   35861 	b := v.Block
   35862 	_ = b
   35863 	typ := &b.Func.Config.Types
   35864 	_ = typ
   35865 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
   35866 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   35867 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   35868 	for {
   35869 		_ = v.Args[1]
   35870 		s1 := v.Args[0]
   35871 		if s1.Op != OpS390XSLWconst {
   35872 			break
   35873 		}
   35874 		j1 := s1.AuxInt
   35875 		x1 := s1.Args[0]
   35876 		if x1.Op != OpS390XMOVBZloadidx {
   35877 			break
   35878 		}
   35879 		i1 := x1.AuxInt
   35880 		s := x1.Aux
   35881 		_ = x1.Args[2]
   35882 		idx := x1.Args[0]
   35883 		p := x1.Args[1]
   35884 		mem := x1.Args[2]
   35885 		or := v.Args[1]
   35886 		if or.Op != OpS390XORW {
   35887 			break
   35888 		}
   35889 		_ = or.Args[1]
   35890 		s0 := or.Args[0]
   35891 		if s0.Op != OpS390XSLWconst {
   35892 			break
   35893 		}
   35894 		j0 := s0.AuxInt
   35895 		x0 := s0.Args[0]
   35896 		if x0.Op != OpS390XMOVBZloadidx {
   35897 			break
   35898 		}
   35899 		i0 := x0.AuxInt
   35900 		if x0.Aux != s {
   35901 			break
   35902 		}
   35903 		_ = x0.Args[2]
   35904 		if idx != x0.Args[0] {
   35905 			break
   35906 		}
   35907 		if p != x0.Args[1] {
   35908 			break
   35909 		}
   35910 		if mem != x0.Args[2] {
   35911 			break
   35912 		}
   35913 		y := or.Args[1]
   35914 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   35915 			break
   35916 		}
   35917 		b = mergePoint(b, x0, x1)
   35918 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   35919 		v.reset(OpCopy)
   35920 		v.AddArg(v0)
   35921 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   35922 		v1.AuxInt = j0
   35923 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35924 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35925 		v3.AuxInt = i0
   35926 		v3.Aux = s
   35927 		v3.AddArg(p)
   35928 		v3.AddArg(idx)
   35929 		v3.AddArg(mem)
   35930 		v2.AddArg(v3)
   35931 		v1.AddArg(v2)
   35932 		v0.AddArg(v1)
   35933 		v0.AddArg(y)
   35934 		return true
   35935 	}
   35936 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
   35937 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   35938 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   35939 	for {
   35940 		_ = v.Args[1]
   35941 		s1 := v.Args[0]
   35942 		if s1.Op != OpS390XSLWconst {
   35943 			break
   35944 		}
   35945 		j1 := s1.AuxInt
   35946 		x1 := s1.Args[0]
   35947 		if x1.Op != OpS390XMOVBZloadidx {
   35948 			break
   35949 		}
   35950 		i1 := x1.AuxInt
   35951 		s := x1.Aux
   35952 		_ = x1.Args[2]
   35953 		p := x1.Args[0]
   35954 		idx := x1.Args[1]
   35955 		mem := x1.Args[2]
   35956 		or := v.Args[1]
   35957 		if or.Op != OpS390XORW {
   35958 			break
   35959 		}
   35960 		_ = or.Args[1]
   35961 		y := or.Args[0]
   35962 		s0 := or.Args[1]
   35963 		if s0.Op != OpS390XSLWconst {
   35964 			break
   35965 		}
   35966 		j0 := s0.AuxInt
   35967 		x0 := s0.Args[0]
   35968 		if x0.Op != OpS390XMOVBZloadidx {
   35969 			break
   35970 		}
   35971 		i0 := x0.AuxInt
   35972 		if x0.Aux != s {
   35973 			break
   35974 		}
   35975 		_ = x0.Args[2]
   35976 		if p != x0.Args[0] {
   35977 			break
   35978 		}
   35979 		if idx != x0.Args[1] {
   35980 			break
   35981 		}
   35982 		if mem != x0.Args[2] {
   35983 			break
   35984 		}
   35985 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   35986 			break
   35987 		}
   35988 		b = mergePoint(b, x0, x1)
   35989 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   35990 		v.reset(OpCopy)
   35991 		v.AddArg(v0)
   35992 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   35993 		v1.AuxInt = j0
   35994 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   35995 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   35996 		v3.AuxInt = i0
   35997 		v3.Aux = s
   35998 		v3.AddArg(p)
   35999 		v3.AddArg(idx)
   36000 		v3.AddArg(mem)
   36001 		v2.AddArg(v3)
   36002 		v1.AddArg(v2)
   36003 		v0.AddArg(v1)
   36004 		v0.AddArg(y)
   36005 		return true
   36006 	}
   36007 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))))
   36008 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36009 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36010 	for {
   36011 		_ = v.Args[1]
   36012 		s1 := v.Args[0]
   36013 		if s1.Op != OpS390XSLWconst {
   36014 			break
   36015 		}
   36016 		j1 := s1.AuxInt
   36017 		x1 := s1.Args[0]
   36018 		if x1.Op != OpS390XMOVBZloadidx {
   36019 			break
   36020 		}
   36021 		i1 := x1.AuxInt
   36022 		s := x1.Aux
   36023 		_ = x1.Args[2]
   36024 		idx := x1.Args[0]
   36025 		p := x1.Args[1]
   36026 		mem := x1.Args[2]
   36027 		or := v.Args[1]
   36028 		if or.Op != OpS390XORW {
   36029 			break
   36030 		}
   36031 		_ = or.Args[1]
   36032 		y := or.Args[0]
   36033 		s0 := or.Args[1]
   36034 		if s0.Op != OpS390XSLWconst {
   36035 			break
   36036 		}
   36037 		j0 := s0.AuxInt
   36038 		x0 := s0.Args[0]
   36039 		if x0.Op != OpS390XMOVBZloadidx {
   36040 			break
   36041 		}
   36042 		i0 := x0.AuxInt
   36043 		if x0.Aux != s {
   36044 			break
   36045 		}
   36046 		_ = x0.Args[2]
   36047 		if p != x0.Args[0] {
   36048 			break
   36049 		}
   36050 		if idx != x0.Args[1] {
   36051 			break
   36052 		}
   36053 		if mem != x0.Args[2] {
   36054 			break
   36055 		}
   36056 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36057 			break
   36058 		}
   36059 		b = mergePoint(b, x0, x1)
   36060 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36061 		v.reset(OpCopy)
   36062 		v.AddArg(v0)
   36063 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36064 		v1.AuxInt = j0
   36065 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36066 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36067 		v3.AuxInt = i0
   36068 		v3.Aux = s
   36069 		v3.AddArg(p)
   36070 		v3.AddArg(idx)
   36071 		v3.AddArg(mem)
   36072 		v2.AddArg(v3)
   36073 		v1.AddArg(v2)
   36074 		v0.AddArg(v1)
   36075 		v0.AddArg(y)
   36076 		return true
   36077 	}
   36078 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
   36079 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36080 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36081 	for {
   36082 		_ = v.Args[1]
   36083 		s1 := v.Args[0]
   36084 		if s1.Op != OpS390XSLWconst {
   36085 			break
   36086 		}
   36087 		j1 := s1.AuxInt
   36088 		x1 := s1.Args[0]
   36089 		if x1.Op != OpS390XMOVBZloadidx {
   36090 			break
   36091 		}
   36092 		i1 := x1.AuxInt
   36093 		s := x1.Aux
   36094 		_ = x1.Args[2]
   36095 		p := x1.Args[0]
   36096 		idx := x1.Args[1]
   36097 		mem := x1.Args[2]
   36098 		or := v.Args[1]
   36099 		if or.Op != OpS390XORW {
   36100 			break
   36101 		}
   36102 		_ = or.Args[1]
   36103 		y := or.Args[0]
   36104 		s0 := or.Args[1]
   36105 		if s0.Op != OpS390XSLWconst {
   36106 			break
   36107 		}
   36108 		j0 := s0.AuxInt
   36109 		x0 := s0.Args[0]
   36110 		if x0.Op != OpS390XMOVBZloadidx {
   36111 			break
   36112 		}
   36113 		i0 := x0.AuxInt
   36114 		if x0.Aux != s {
   36115 			break
   36116 		}
   36117 		_ = x0.Args[2]
   36118 		if idx != x0.Args[0] {
   36119 			break
   36120 		}
   36121 		if p != x0.Args[1] {
   36122 			break
   36123 		}
   36124 		if mem != x0.Args[2] {
   36125 			break
   36126 		}
   36127 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36128 			break
   36129 		}
   36130 		b = mergePoint(b, x0, x1)
   36131 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36132 		v.reset(OpCopy)
   36133 		v.AddArg(v0)
   36134 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36135 		v1.AuxInt = j0
   36136 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36137 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36138 		v3.AuxInt = i0
   36139 		v3.Aux = s
   36140 		v3.AddArg(p)
   36141 		v3.AddArg(idx)
   36142 		v3.AddArg(mem)
   36143 		v2.AddArg(v3)
   36144 		v1.AddArg(v2)
   36145 		v0.AddArg(v1)
   36146 		v0.AddArg(y)
   36147 		return true
   36148 	}
   36149 	// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))))
   36150 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36151 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36152 	for {
   36153 		_ = v.Args[1]
   36154 		s1 := v.Args[0]
   36155 		if s1.Op != OpS390XSLWconst {
   36156 			break
   36157 		}
   36158 		j1 := s1.AuxInt
   36159 		x1 := s1.Args[0]
   36160 		if x1.Op != OpS390XMOVBZloadidx {
   36161 			break
   36162 		}
   36163 		i1 := x1.AuxInt
   36164 		s := x1.Aux
   36165 		_ = x1.Args[2]
   36166 		idx := x1.Args[0]
   36167 		p := x1.Args[1]
   36168 		mem := x1.Args[2]
   36169 		or := v.Args[1]
   36170 		if or.Op != OpS390XORW {
   36171 			break
   36172 		}
   36173 		_ = or.Args[1]
   36174 		y := or.Args[0]
   36175 		s0 := or.Args[1]
   36176 		if s0.Op != OpS390XSLWconst {
   36177 			break
   36178 		}
   36179 		j0 := s0.AuxInt
   36180 		x0 := s0.Args[0]
   36181 		if x0.Op != OpS390XMOVBZloadidx {
   36182 			break
   36183 		}
   36184 		i0 := x0.AuxInt
   36185 		if x0.Aux != s {
   36186 			break
   36187 		}
   36188 		_ = x0.Args[2]
   36189 		if idx != x0.Args[0] {
   36190 			break
   36191 		}
   36192 		if p != x0.Args[1] {
   36193 			break
   36194 		}
   36195 		if mem != x0.Args[2] {
   36196 			break
   36197 		}
   36198 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36199 			break
   36200 		}
   36201 		b = mergePoint(b, x0, x1)
   36202 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36203 		v.reset(OpCopy)
   36204 		v.AddArg(v0)
   36205 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36206 		v1.AuxInt = j0
   36207 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36208 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36209 		v3.AuxInt = i0
   36210 		v3.Aux = s
   36211 		v3.AddArg(p)
   36212 		v3.AddArg(idx)
   36213 		v3.AddArg(mem)
   36214 		v2.AddArg(v3)
   36215 		v1.AddArg(v2)
   36216 		v0.AddArg(v1)
   36217 		v0.AddArg(y)
   36218 		return true
   36219 	}
   36220 	// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   36221 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36222 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36223 	for {
   36224 		_ = v.Args[1]
   36225 		or := v.Args[0]
   36226 		if or.Op != OpS390XORW {
   36227 			break
   36228 		}
   36229 		_ = or.Args[1]
   36230 		s0 := or.Args[0]
   36231 		if s0.Op != OpS390XSLWconst {
   36232 			break
   36233 		}
   36234 		j0 := s0.AuxInt
   36235 		x0 := s0.Args[0]
   36236 		if x0.Op != OpS390XMOVBZloadidx {
   36237 			break
   36238 		}
   36239 		i0 := x0.AuxInt
   36240 		s := x0.Aux
   36241 		_ = x0.Args[2]
   36242 		p := x0.Args[0]
   36243 		idx := x0.Args[1]
   36244 		mem := x0.Args[2]
   36245 		y := or.Args[1]
   36246 		s1 := v.Args[1]
   36247 		if s1.Op != OpS390XSLWconst {
   36248 			break
   36249 		}
   36250 		j1 := s1.AuxInt
   36251 		x1 := s1.Args[0]
   36252 		if x1.Op != OpS390XMOVBZloadidx {
   36253 			break
   36254 		}
   36255 		i1 := x1.AuxInt
   36256 		if x1.Aux != s {
   36257 			break
   36258 		}
   36259 		_ = x1.Args[2]
   36260 		if p != x1.Args[0] {
   36261 			break
   36262 		}
   36263 		if idx != x1.Args[1] {
   36264 			break
   36265 		}
   36266 		if mem != x1.Args[2] {
   36267 			break
   36268 		}
   36269 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36270 			break
   36271 		}
   36272 		b = mergePoint(b, x0, x1)
   36273 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36274 		v.reset(OpCopy)
   36275 		v.AddArg(v0)
   36276 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36277 		v1.AuxInt = j0
   36278 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36279 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36280 		v3.AuxInt = i0
   36281 		v3.Aux = s
   36282 		v3.AddArg(p)
   36283 		v3.AddArg(idx)
   36284 		v3.AddArg(mem)
   36285 		v2.AddArg(v3)
   36286 		v1.AddArg(v2)
   36287 		v0.AddArg(v1)
   36288 		v0.AddArg(y)
   36289 		return true
   36290 	}
   36291 	// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   36292 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36293 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36294 	for {
   36295 		_ = v.Args[1]
   36296 		or := v.Args[0]
   36297 		if or.Op != OpS390XORW {
   36298 			break
   36299 		}
   36300 		_ = or.Args[1]
   36301 		s0 := or.Args[0]
   36302 		if s0.Op != OpS390XSLWconst {
   36303 			break
   36304 		}
   36305 		j0 := s0.AuxInt
   36306 		x0 := s0.Args[0]
   36307 		if x0.Op != OpS390XMOVBZloadidx {
   36308 			break
   36309 		}
   36310 		i0 := x0.AuxInt
   36311 		s := x0.Aux
   36312 		_ = x0.Args[2]
   36313 		idx := x0.Args[0]
   36314 		p := x0.Args[1]
   36315 		mem := x0.Args[2]
   36316 		y := or.Args[1]
   36317 		s1 := v.Args[1]
   36318 		if s1.Op != OpS390XSLWconst {
   36319 			break
   36320 		}
   36321 		j1 := s1.AuxInt
   36322 		x1 := s1.Args[0]
   36323 		if x1.Op != OpS390XMOVBZloadidx {
   36324 			break
   36325 		}
   36326 		i1 := x1.AuxInt
   36327 		if x1.Aux != s {
   36328 			break
   36329 		}
   36330 		_ = x1.Args[2]
   36331 		if p != x1.Args[0] {
   36332 			break
   36333 		}
   36334 		if idx != x1.Args[1] {
   36335 			break
   36336 		}
   36337 		if mem != x1.Args[2] {
   36338 			break
   36339 		}
   36340 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36341 			break
   36342 		}
   36343 		b = mergePoint(b, x0, x1)
   36344 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36345 		v.reset(OpCopy)
   36346 		v.AddArg(v0)
   36347 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36348 		v1.AuxInt = j0
   36349 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36350 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36351 		v3.AuxInt = i0
   36352 		v3.Aux = s
   36353 		v3.AddArg(p)
   36354 		v3.AddArg(idx)
   36355 		v3.AddArg(mem)
   36356 		v2.AddArg(v3)
   36357 		v1.AddArg(v2)
   36358 		v0.AddArg(v1)
   36359 		v0.AddArg(y)
   36360 		return true
   36361 	}
   36362 	// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   36363 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36364 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36365 	for {
   36366 		_ = v.Args[1]
   36367 		or := v.Args[0]
   36368 		if or.Op != OpS390XORW {
   36369 			break
   36370 		}
   36371 		_ = or.Args[1]
   36372 		y := or.Args[0]
   36373 		s0 := or.Args[1]
   36374 		if s0.Op != OpS390XSLWconst {
   36375 			break
   36376 		}
   36377 		j0 := s0.AuxInt
   36378 		x0 := s0.Args[0]
   36379 		if x0.Op != OpS390XMOVBZloadidx {
   36380 			break
   36381 		}
   36382 		i0 := x0.AuxInt
   36383 		s := x0.Aux
   36384 		_ = x0.Args[2]
   36385 		p := x0.Args[0]
   36386 		idx := x0.Args[1]
   36387 		mem := x0.Args[2]
   36388 		s1 := v.Args[1]
   36389 		if s1.Op != OpS390XSLWconst {
   36390 			break
   36391 		}
   36392 		j1 := s1.AuxInt
   36393 		x1 := s1.Args[0]
   36394 		if x1.Op != OpS390XMOVBZloadidx {
   36395 			break
   36396 		}
   36397 		i1 := x1.AuxInt
   36398 		if x1.Aux != s {
   36399 			break
   36400 		}
   36401 		_ = x1.Args[2]
   36402 		if p != x1.Args[0] {
   36403 			break
   36404 		}
   36405 		if idx != x1.Args[1] {
   36406 			break
   36407 		}
   36408 		if mem != x1.Args[2] {
   36409 			break
   36410 		}
   36411 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36412 			break
   36413 		}
   36414 		b = mergePoint(b, x0, x1)
   36415 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36416 		v.reset(OpCopy)
   36417 		v.AddArg(v0)
   36418 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36419 		v1.AuxInt = j0
   36420 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36421 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36422 		v3.AuxInt = i0
   36423 		v3.Aux = s
   36424 		v3.AddArg(p)
   36425 		v3.AddArg(idx)
   36426 		v3.AddArg(mem)
   36427 		v2.AddArg(v3)
   36428 		v1.AddArg(v2)
   36429 		v0.AddArg(v1)
   36430 		v0.AddArg(y)
   36431 		return true
   36432 	}
   36433 	// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
   36434 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36435 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36436 	for {
   36437 		_ = v.Args[1]
   36438 		or := v.Args[0]
   36439 		if or.Op != OpS390XORW {
   36440 			break
   36441 		}
   36442 		_ = or.Args[1]
   36443 		y := or.Args[0]
   36444 		s0 := or.Args[1]
   36445 		if s0.Op != OpS390XSLWconst {
   36446 			break
   36447 		}
   36448 		j0 := s0.AuxInt
   36449 		x0 := s0.Args[0]
   36450 		if x0.Op != OpS390XMOVBZloadidx {
   36451 			break
   36452 		}
   36453 		i0 := x0.AuxInt
   36454 		s := x0.Aux
   36455 		_ = x0.Args[2]
   36456 		idx := x0.Args[0]
   36457 		p := x0.Args[1]
   36458 		mem := x0.Args[2]
   36459 		s1 := v.Args[1]
   36460 		if s1.Op != OpS390XSLWconst {
   36461 			break
   36462 		}
   36463 		j1 := s1.AuxInt
   36464 		x1 := s1.Args[0]
   36465 		if x1.Op != OpS390XMOVBZloadidx {
   36466 			break
   36467 		}
   36468 		i1 := x1.AuxInt
   36469 		if x1.Aux != s {
   36470 			break
   36471 		}
   36472 		_ = x1.Args[2]
   36473 		if p != x1.Args[0] {
   36474 			break
   36475 		}
   36476 		if idx != x1.Args[1] {
   36477 			break
   36478 		}
   36479 		if mem != x1.Args[2] {
   36480 			break
   36481 		}
   36482 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36483 			break
   36484 		}
   36485 		b = mergePoint(b, x0, x1)
   36486 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36487 		v.reset(OpCopy)
   36488 		v.AddArg(v0)
   36489 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36490 		v1.AuxInt = j0
   36491 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36492 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36493 		v3.AuxInt = i0
   36494 		v3.Aux = s
   36495 		v3.AddArg(p)
   36496 		v3.AddArg(idx)
   36497 		v3.AddArg(mem)
   36498 		v2.AddArg(v3)
   36499 		v1.AddArg(v2)
   36500 		v0.AddArg(v1)
   36501 		v0.AddArg(y)
   36502 		return true
   36503 	}
   36504 	// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   36505 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36506 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36507 	for {
   36508 		_ = v.Args[1]
   36509 		or := v.Args[0]
   36510 		if or.Op != OpS390XORW {
   36511 			break
   36512 		}
   36513 		_ = or.Args[1]
   36514 		s0 := or.Args[0]
   36515 		if s0.Op != OpS390XSLWconst {
   36516 			break
   36517 		}
   36518 		j0 := s0.AuxInt
   36519 		x0 := s0.Args[0]
   36520 		if x0.Op != OpS390XMOVBZloadidx {
   36521 			break
   36522 		}
   36523 		i0 := x0.AuxInt
   36524 		s := x0.Aux
   36525 		_ = x0.Args[2]
   36526 		p := x0.Args[0]
   36527 		idx := x0.Args[1]
   36528 		mem := x0.Args[2]
   36529 		y := or.Args[1]
   36530 		s1 := v.Args[1]
   36531 		if s1.Op != OpS390XSLWconst {
   36532 			break
   36533 		}
   36534 		j1 := s1.AuxInt
   36535 		x1 := s1.Args[0]
   36536 		if x1.Op != OpS390XMOVBZloadidx {
   36537 			break
   36538 		}
   36539 		i1 := x1.AuxInt
   36540 		if x1.Aux != s {
   36541 			break
   36542 		}
   36543 		_ = x1.Args[2]
   36544 		if idx != x1.Args[0] {
   36545 			break
   36546 		}
   36547 		if p != x1.Args[1] {
   36548 			break
   36549 		}
   36550 		if mem != x1.Args[2] {
   36551 			break
   36552 		}
   36553 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36554 			break
   36555 		}
   36556 		b = mergePoint(b, x0, x1)
   36557 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36558 		v.reset(OpCopy)
   36559 		v.AddArg(v0)
   36560 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36561 		v1.AuxInt = j0
   36562 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36563 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36564 		v3.AuxInt = i0
   36565 		v3.Aux = s
   36566 		v3.AddArg(p)
   36567 		v3.AddArg(idx)
   36568 		v3.AddArg(mem)
   36569 		v2.AddArg(v3)
   36570 		v1.AddArg(v2)
   36571 		v0.AddArg(v1)
   36572 		v0.AddArg(y)
   36573 		return true
   36574 	}
   36575 	return false
   36576 }
   36577 func rewriteValueS390X_OpS390XORW_90(v *Value) bool {
   36578 	b := v.Block
   36579 	_ = b
   36580 	typ := &b.Func.Config.Types
   36581 	_ = typ
   36582 	// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   36583 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36584 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36585 	for {
   36586 		_ = v.Args[1]
   36587 		or := v.Args[0]
   36588 		if or.Op != OpS390XORW {
   36589 			break
   36590 		}
   36591 		_ = or.Args[1]
   36592 		s0 := or.Args[0]
   36593 		if s0.Op != OpS390XSLWconst {
   36594 			break
   36595 		}
   36596 		j0 := s0.AuxInt
   36597 		x0 := s0.Args[0]
   36598 		if x0.Op != OpS390XMOVBZloadidx {
   36599 			break
   36600 		}
   36601 		i0 := x0.AuxInt
   36602 		s := x0.Aux
   36603 		_ = x0.Args[2]
   36604 		idx := x0.Args[0]
   36605 		p := x0.Args[1]
   36606 		mem := x0.Args[2]
   36607 		y := or.Args[1]
   36608 		s1 := v.Args[1]
   36609 		if s1.Op != OpS390XSLWconst {
   36610 			break
   36611 		}
   36612 		j1 := s1.AuxInt
   36613 		x1 := s1.Args[0]
   36614 		if x1.Op != OpS390XMOVBZloadidx {
   36615 			break
   36616 		}
   36617 		i1 := x1.AuxInt
   36618 		if x1.Aux != s {
   36619 			break
   36620 		}
   36621 		_ = x1.Args[2]
   36622 		if idx != x1.Args[0] {
   36623 			break
   36624 		}
   36625 		if p != x1.Args[1] {
   36626 			break
   36627 		}
   36628 		if mem != x1.Args[2] {
   36629 			break
   36630 		}
   36631 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36632 			break
   36633 		}
   36634 		b = mergePoint(b, x0, x1)
   36635 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36636 		v.reset(OpCopy)
   36637 		v.AddArg(v0)
   36638 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36639 		v1.AuxInt = j0
   36640 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36641 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36642 		v3.AuxInt = i0
   36643 		v3.Aux = s
   36644 		v3.AddArg(p)
   36645 		v3.AddArg(idx)
   36646 		v3.AddArg(mem)
   36647 		v2.AddArg(v3)
   36648 		v1.AddArg(v2)
   36649 		v0.AddArg(v1)
   36650 		v0.AddArg(y)
   36651 		return true
   36652 	}
   36653 	// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   36654 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36655 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36656 	for {
   36657 		_ = v.Args[1]
   36658 		or := v.Args[0]
   36659 		if or.Op != OpS390XORW {
   36660 			break
   36661 		}
   36662 		_ = or.Args[1]
   36663 		y := or.Args[0]
   36664 		s0 := or.Args[1]
   36665 		if s0.Op != OpS390XSLWconst {
   36666 			break
   36667 		}
   36668 		j0 := s0.AuxInt
   36669 		x0 := s0.Args[0]
   36670 		if x0.Op != OpS390XMOVBZloadidx {
   36671 			break
   36672 		}
   36673 		i0 := x0.AuxInt
   36674 		s := x0.Aux
   36675 		_ = x0.Args[2]
   36676 		p := x0.Args[0]
   36677 		idx := x0.Args[1]
   36678 		mem := x0.Args[2]
   36679 		s1 := v.Args[1]
   36680 		if s1.Op != OpS390XSLWconst {
   36681 			break
   36682 		}
   36683 		j1 := s1.AuxInt
   36684 		x1 := s1.Args[0]
   36685 		if x1.Op != OpS390XMOVBZloadidx {
   36686 			break
   36687 		}
   36688 		i1 := x1.AuxInt
   36689 		if x1.Aux != s {
   36690 			break
   36691 		}
   36692 		_ = x1.Args[2]
   36693 		if idx != x1.Args[0] {
   36694 			break
   36695 		}
   36696 		if p != x1.Args[1] {
   36697 			break
   36698 		}
   36699 		if mem != x1.Args[2] {
   36700 			break
   36701 		}
   36702 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36703 			break
   36704 		}
   36705 		b = mergePoint(b, x0, x1)
   36706 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36707 		v.reset(OpCopy)
   36708 		v.AddArg(v0)
   36709 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36710 		v1.AuxInt = j0
   36711 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36712 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36713 		v3.AuxInt = i0
   36714 		v3.Aux = s
   36715 		v3.AddArg(p)
   36716 		v3.AddArg(idx)
   36717 		v3.AddArg(mem)
   36718 		v2.AddArg(v3)
   36719 		v1.AddArg(v2)
   36720 		v0.AddArg(v1)
   36721 		v0.AddArg(y)
   36722 		return true
   36723 	}
   36724 	// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
   36725 	// cond: p.Op != OpSB   && i1 == i0+1   && j1 == j0+8   && j0 % 16 == 0   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && or.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)   && clobber(s1)   && clobber(or)
   36726 	// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
   36727 	for {
   36728 		_ = v.Args[1]
   36729 		or := v.Args[0]
   36730 		if or.Op != OpS390XORW {
   36731 			break
   36732 		}
   36733 		_ = or.Args[1]
   36734 		y := or.Args[0]
   36735 		s0 := or.Args[1]
   36736 		if s0.Op != OpS390XSLWconst {
   36737 			break
   36738 		}
   36739 		j0 := s0.AuxInt
   36740 		x0 := s0.Args[0]
   36741 		if x0.Op != OpS390XMOVBZloadidx {
   36742 			break
   36743 		}
   36744 		i0 := x0.AuxInt
   36745 		s := x0.Aux
   36746 		_ = x0.Args[2]
   36747 		idx := x0.Args[0]
   36748 		p := x0.Args[1]
   36749 		mem := x0.Args[2]
   36750 		s1 := v.Args[1]
   36751 		if s1.Op != OpS390XSLWconst {
   36752 			break
   36753 		}
   36754 		j1 := s1.AuxInt
   36755 		x1 := s1.Args[0]
   36756 		if x1.Op != OpS390XMOVBZloadidx {
   36757 			break
   36758 		}
   36759 		i1 := x1.AuxInt
   36760 		if x1.Aux != s {
   36761 			break
   36762 		}
   36763 		_ = x1.Args[2]
   36764 		if idx != x1.Args[0] {
   36765 			break
   36766 		}
   36767 		if p != x1.Args[1] {
   36768 			break
   36769 		}
   36770 		if mem != x1.Args[2] {
   36771 			break
   36772 		}
   36773 		if !(p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0%16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)) {
   36774 			break
   36775 		}
   36776 		b = mergePoint(b, x0, x1)
   36777 		v0 := b.NewValue0(v.Pos, OpS390XORW, v.Type)
   36778 		v.reset(OpCopy)
   36779 		v.AddArg(v0)
   36780 		v1 := b.NewValue0(v.Pos, OpS390XSLWconst, v.Type)
   36781 		v1.AuxInt = j0
   36782 		v2 := b.NewValue0(v.Pos, OpS390XMOVHZreg, typ.UInt64)
   36783 		v3 := b.NewValue0(v.Pos, OpS390XMOVHBRloadidx, typ.Int16)
   36784 		v3.AuxInt = i0
   36785 		v3.Aux = s
   36786 		v3.AddArg(p)
   36787 		v3.AddArg(idx)
   36788 		v3.AddArg(mem)
   36789 		v2.AddArg(v3)
   36790 		v1.AddArg(v2)
   36791 		v0.AddArg(v1)
   36792 		v0.AddArg(y)
   36793 		return true
   36794 	}
   36795 	return false
   36796 }
   36797 func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool {
   36798 	// match: (ORWconst [c] x)
   36799 	// cond: int32(c)==0
   36800 	// result: x
   36801 	for {
   36802 		c := v.AuxInt
   36803 		x := v.Args[0]
   36804 		if !(int32(c) == 0) {
   36805 			break
   36806 		}
   36807 		v.reset(OpCopy)
   36808 		v.Type = x.Type
   36809 		v.AddArg(x)
   36810 		return true
   36811 	}
   36812 	// match: (ORWconst [c] _)
   36813 	// cond: int32(c)==-1
   36814 	// result: (MOVDconst [-1])
   36815 	for {
   36816 		c := v.AuxInt
   36817 		if !(int32(c) == -1) {
   36818 			break
   36819 		}
   36820 		v.reset(OpS390XMOVDconst)
   36821 		v.AuxInt = -1
   36822 		return true
   36823 	}
   36824 	// match: (ORWconst [c] (MOVDconst [d]))
   36825 	// cond:
   36826 	// result: (MOVDconst [c|d])
   36827 	for {
   36828 		c := v.AuxInt
   36829 		v_0 := v.Args[0]
   36830 		if v_0.Op != OpS390XMOVDconst {
   36831 			break
   36832 		}
   36833 		d := v_0.AuxInt
   36834 		v.reset(OpS390XMOVDconst)
   36835 		v.AuxInt = c | d
   36836 		return true
   36837 	}
   36838 	return false
   36839 }
   36840 func rewriteValueS390X_OpS390XORWload_0(v *Value) bool {
   36841 	// match: (ORWload [off1] {sym} x (ADDconst [off2] ptr) mem)
   36842 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   36843 	// result: (ORWload   [off1+off2] {sym} x ptr mem)
   36844 	for {
   36845 		off1 := v.AuxInt
   36846 		sym := v.Aux
   36847 		_ = v.Args[2]
   36848 		x := v.Args[0]
   36849 		v_1 := v.Args[1]
   36850 		if v_1.Op != OpS390XADDconst {
   36851 			break
   36852 		}
   36853 		off2 := v_1.AuxInt
   36854 		ptr := v_1.Args[0]
   36855 		mem := v.Args[2]
   36856 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   36857 			break
   36858 		}
   36859 		v.reset(OpS390XORWload)
   36860 		v.AuxInt = off1 + off2
   36861 		v.Aux = sym
   36862 		v.AddArg(x)
   36863 		v.AddArg(ptr)
   36864 		v.AddArg(mem)
   36865 		return true
   36866 	}
   36867 	// match: (ORWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   36868 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   36869 	// result: (ORWload   [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   36870 	for {
   36871 		o1 := v.AuxInt
   36872 		s1 := v.Aux
   36873 		_ = v.Args[2]
   36874 		x := v.Args[0]
   36875 		v_1 := v.Args[1]
   36876 		if v_1.Op != OpS390XMOVDaddr {
   36877 			break
   36878 		}
   36879 		o2 := v_1.AuxInt
   36880 		s2 := v_1.Aux
   36881 		ptr := v_1.Args[0]
   36882 		mem := v.Args[2]
   36883 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   36884 			break
   36885 		}
   36886 		v.reset(OpS390XORWload)
   36887 		v.AuxInt = o1 + o2
   36888 		v.Aux = mergeSym(s1, s2)
   36889 		v.AddArg(x)
   36890 		v.AddArg(ptr)
   36891 		v.AddArg(mem)
   36892 		return true
   36893 	}
   36894 	return false
   36895 }
   36896 func rewriteValueS390X_OpS390XORconst_0(v *Value) bool {
   36897 	// match: (ORconst [0] x)
   36898 	// cond:
   36899 	// result: x
   36900 	for {
   36901 		if v.AuxInt != 0 {
   36902 			break
   36903 		}
   36904 		x := v.Args[0]
   36905 		v.reset(OpCopy)
   36906 		v.Type = x.Type
   36907 		v.AddArg(x)
   36908 		return true
   36909 	}
   36910 	// match: (ORconst [-1] _)
   36911 	// cond:
   36912 	// result: (MOVDconst [-1])
   36913 	for {
   36914 		if v.AuxInt != -1 {
   36915 			break
   36916 		}
   36917 		v.reset(OpS390XMOVDconst)
   36918 		v.AuxInt = -1
   36919 		return true
   36920 	}
   36921 	// match: (ORconst [c] (MOVDconst [d]))
   36922 	// cond:
   36923 	// result: (MOVDconst [c|d])
   36924 	for {
   36925 		c := v.AuxInt
   36926 		v_0 := v.Args[0]
   36927 		if v_0.Op != OpS390XMOVDconst {
   36928 			break
   36929 		}
   36930 		d := v_0.AuxInt
   36931 		v.reset(OpS390XMOVDconst)
   36932 		v.AuxInt = c | d
   36933 		return true
   36934 	}
   36935 	return false
   36936 }
   36937 func rewriteValueS390X_OpS390XORload_0(v *Value) bool {
   36938 	b := v.Block
   36939 	_ = b
   36940 	// match: (ORload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
   36941 	// cond: isSamePtr(ptr1, ptr2)
   36942 	// result: (OR    x (LGDR <t> y))
   36943 	for {
   36944 		t := v.Type
   36945 		off := v.AuxInt
   36946 		sym := v.Aux
   36947 		_ = v.Args[2]
   36948 		x := v.Args[0]
   36949 		ptr1 := v.Args[1]
   36950 		v_2 := v.Args[2]
   36951 		if v_2.Op != OpS390XFMOVDstore {
   36952 			break
   36953 		}
   36954 		if v_2.AuxInt != off {
   36955 			break
   36956 		}
   36957 		if v_2.Aux != sym {
   36958 			break
   36959 		}
   36960 		_ = v_2.Args[2]
   36961 		ptr2 := v_2.Args[0]
   36962 		y := v_2.Args[1]
   36963 		if !(isSamePtr(ptr1, ptr2)) {
   36964 			break
   36965 		}
   36966 		v.reset(OpS390XOR)
   36967 		v.AddArg(x)
   36968 		v0 := b.NewValue0(v.Pos, OpS390XLGDR, t)
   36969 		v0.AddArg(y)
   36970 		v.AddArg(v0)
   36971 		return true
   36972 	}
   36973 	// match: (ORload [off1] {sym} x (ADDconst [off2] ptr) mem)
   36974 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   36975 	// result: (ORload    [off1+off2] {sym} x ptr mem)
   36976 	for {
   36977 		off1 := v.AuxInt
   36978 		sym := v.Aux
   36979 		_ = v.Args[2]
   36980 		x := v.Args[0]
   36981 		v_1 := v.Args[1]
   36982 		if v_1.Op != OpS390XADDconst {
   36983 			break
   36984 		}
   36985 		off2 := v_1.AuxInt
   36986 		ptr := v_1.Args[0]
   36987 		mem := v.Args[2]
   36988 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   36989 			break
   36990 		}
   36991 		v.reset(OpS390XORload)
   36992 		v.AuxInt = off1 + off2
   36993 		v.Aux = sym
   36994 		v.AddArg(x)
   36995 		v.AddArg(ptr)
   36996 		v.AddArg(mem)
   36997 		return true
   36998 	}
   36999 	// match: (ORload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   37000 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   37001 	// result: (ORload    [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   37002 	for {
   37003 		o1 := v.AuxInt
   37004 		s1 := v.Aux
   37005 		_ = v.Args[2]
   37006 		x := v.Args[0]
   37007 		v_1 := v.Args[1]
   37008 		if v_1.Op != OpS390XMOVDaddr {
   37009 			break
   37010 		}
   37011 		o2 := v_1.AuxInt
   37012 		s2 := v_1.Aux
   37013 		ptr := v_1.Args[0]
   37014 		mem := v.Args[2]
   37015 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   37016 			break
   37017 		}
   37018 		v.reset(OpS390XORload)
   37019 		v.AuxInt = o1 + o2
   37020 		v.Aux = mergeSym(s1, s2)
   37021 		v.AddArg(x)
   37022 		v.AddArg(ptr)
   37023 		v.AddArg(mem)
   37024 		return true
   37025 	}
   37026 	return false
   37027 }
   37028 func rewriteValueS390X_OpS390XSLD_0(v *Value) bool {
   37029 	// match: (SLD x (MOVDconst [c]))
   37030 	// cond:
   37031 	// result: (SLDconst [c&63] x)
   37032 	for {
   37033 		_ = v.Args[1]
   37034 		x := v.Args[0]
   37035 		v_1 := v.Args[1]
   37036 		if v_1.Op != OpS390XMOVDconst {
   37037 			break
   37038 		}
   37039 		c := v_1.AuxInt
   37040 		v.reset(OpS390XSLDconst)
   37041 		v.AuxInt = c & 63
   37042 		v.AddArg(x)
   37043 		return true
   37044 	}
   37045 	// match: (SLD x (ANDconst [63] y))
   37046 	// cond:
   37047 	// result: (SLD x y)
   37048 	for {
   37049 		_ = v.Args[1]
   37050 		x := v.Args[0]
   37051 		v_1 := v.Args[1]
   37052 		if v_1.Op != OpS390XANDconst {
   37053 			break
   37054 		}
   37055 		if v_1.AuxInt != 63 {
   37056 			break
   37057 		}
   37058 		y := v_1.Args[0]
   37059 		v.reset(OpS390XSLD)
   37060 		v.AddArg(x)
   37061 		v.AddArg(y)
   37062 		return true
   37063 	}
   37064 	return false
   37065 }
   37066 func rewriteValueS390X_OpS390XSLW_0(v *Value) bool {
   37067 	// match: (SLW x (MOVDconst [c]))
   37068 	// cond:
   37069 	// result: (SLWconst [c&63] x)
   37070 	for {
   37071 		_ = v.Args[1]
   37072 		x := v.Args[0]
   37073 		v_1 := v.Args[1]
   37074 		if v_1.Op != OpS390XMOVDconst {
   37075 			break
   37076 		}
   37077 		c := v_1.AuxInt
   37078 		v.reset(OpS390XSLWconst)
   37079 		v.AuxInt = c & 63
   37080 		v.AddArg(x)
   37081 		return true
   37082 	}
   37083 	// match: (SLW x (ANDWconst [63] y))
   37084 	// cond:
   37085 	// result: (SLW x y)
   37086 	for {
   37087 		_ = v.Args[1]
   37088 		x := v.Args[0]
   37089 		v_1 := v.Args[1]
   37090 		if v_1.Op != OpS390XANDWconst {
   37091 			break
   37092 		}
   37093 		if v_1.AuxInt != 63 {
   37094 			break
   37095 		}
   37096 		y := v_1.Args[0]
   37097 		v.reset(OpS390XSLW)
   37098 		v.AddArg(x)
   37099 		v.AddArg(y)
   37100 		return true
   37101 	}
   37102 	return false
   37103 }
   37104 func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool {
   37105 	// match: (SRAD x (MOVDconst [c]))
   37106 	// cond:
   37107 	// result: (SRADconst [c&63] x)
   37108 	for {
   37109 		_ = v.Args[1]
   37110 		x := v.Args[0]
   37111 		v_1 := v.Args[1]
   37112 		if v_1.Op != OpS390XMOVDconst {
   37113 			break
   37114 		}
   37115 		c := v_1.AuxInt
   37116 		v.reset(OpS390XSRADconst)
   37117 		v.AuxInt = c & 63
   37118 		v.AddArg(x)
   37119 		return true
   37120 	}
   37121 	// match: (SRAD x (ANDconst [63] y))
   37122 	// cond:
   37123 	// result: (SRAD x y)
   37124 	for {
   37125 		_ = v.Args[1]
   37126 		x := v.Args[0]
   37127 		v_1 := v.Args[1]
   37128 		if v_1.Op != OpS390XANDconst {
   37129 			break
   37130 		}
   37131 		if v_1.AuxInt != 63 {
   37132 			break
   37133 		}
   37134 		y := v_1.Args[0]
   37135 		v.reset(OpS390XSRAD)
   37136 		v.AddArg(x)
   37137 		v.AddArg(y)
   37138 		return true
   37139 	}
   37140 	return false
   37141 }
   37142 func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool {
   37143 	// match: (SRADconst [c] (MOVDconst [d]))
   37144 	// cond:
   37145 	// result: (MOVDconst [d>>uint64(c)])
   37146 	for {
   37147 		c := v.AuxInt
   37148 		v_0 := v.Args[0]
   37149 		if v_0.Op != OpS390XMOVDconst {
   37150 			break
   37151 		}
   37152 		d := v_0.AuxInt
   37153 		v.reset(OpS390XMOVDconst)
   37154 		v.AuxInt = d >> uint64(c)
   37155 		return true
   37156 	}
   37157 	return false
   37158 }
   37159 func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool {
   37160 	// match: (SRAW x (MOVDconst [c]))
   37161 	// cond:
   37162 	// result: (SRAWconst [c&63] x)
   37163 	for {
   37164 		_ = v.Args[1]
   37165 		x := v.Args[0]
   37166 		v_1 := v.Args[1]
   37167 		if v_1.Op != OpS390XMOVDconst {
   37168 			break
   37169 		}
   37170 		c := v_1.AuxInt
   37171 		v.reset(OpS390XSRAWconst)
   37172 		v.AuxInt = c & 63
   37173 		v.AddArg(x)
   37174 		return true
   37175 	}
   37176 	// match: (SRAW x (ANDWconst [63] y))
   37177 	// cond:
   37178 	// result: (SRAW x y)
   37179 	for {
   37180 		_ = v.Args[1]
   37181 		x := v.Args[0]
   37182 		v_1 := v.Args[1]
   37183 		if v_1.Op != OpS390XANDWconst {
   37184 			break
   37185 		}
   37186 		if v_1.AuxInt != 63 {
   37187 			break
   37188 		}
   37189 		y := v_1.Args[0]
   37190 		v.reset(OpS390XSRAW)
   37191 		v.AddArg(x)
   37192 		v.AddArg(y)
   37193 		return true
   37194 	}
   37195 	return false
   37196 }
   37197 func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool {
   37198 	// match: (SRAWconst [c] (MOVDconst [d]))
   37199 	// cond:
   37200 	// result: (MOVDconst [int64(int32(d))>>uint64(c)])
   37201 	for {
   37202 		c := v.AuxInt
   37203 		v_0 := v.Args[0]
   37204 		if v_0.Op != OpS390XMOVDconst {
   37205 			break
   37206 		}
   37207 		d := v_0.AuxInt
   37208 		v.reset(OpS390XMOVDconst)
   37209 		v.AuxInt = int64(int32(d)) >> uint64(c)
   37210 		return true
   37211 	}
   37212 	return false
   37213 }
   37214 func rewriteValueS390X_OpS390XSRD_0(v *Value) bool {
   37215 	// match: (SRD x (MOVDconst [c]))
   37216 	// cond:
   37217 	// result: (SRDconst [c&63] x)
   37218 	for {
   37219 		_ = v.Args[1]
   37220 		x := v.Args[0]
   37221 		v_1 := v.Args[1]
   37222 		if v_1.Op != OpS390XMOVDconst {
   37223 			break
   37224 		}
   37225 		c := v_1.AuxInt
   37226 		v.reset(OpS390XSRDconst)
   37227 		v.AuxInt = c & 63
   37228 		v.AddArg(x)
   37229 		return true
   37230 	}
   37231 	// match: (SRD x (ANDconst [63] y))
   37232 	// cond:
   37233 	// result: (SRD x y)
   37234 	for {
   37235 		_ = v.Args[1]
   37236 		x := v.Args[0]
   37237 		v_1 := v.Args[1]
   37238 		if v_1.Op != OpS390XANDconst {
   37239 			break
   37240 		}
   37241 		if v_1.AuxInt != 63 {
   37242 			break
   37243 		}
   37244 		y := v_1.Args[0]
   37245 		v.reset(OpS390XSRD)
   37246 		v.AddArg(x)
   37247 		v.AddArg(y)
   37248 		return true
   37249 	}
   37250 	return false
   37251 }
   37252 func rewriteValueS390X_OpS390XSRDconst_0(v *Value) bool {
   37253 	b := v.Block
   37254 	_ = b
   37255 	// match: (SRDconst [1] (SLDconst [1] (LGDR <t> x)))
   37256 	// cond:
   37257 	// result: (LGDR <t> (LPDFR <x.Type> x))
   37258 	for {
   37259 		if v.AuxInt != 1 {
   37260 			break
   37261 		}
   37262 		v_0 := v.Args[0]
   37263 		if v_0.Op != OpS390XSLDconst {
   37264 			break
   37265 		}
   37266 		if v_0.AuxInt != 1 {
   37267 			break
   37268 		}
   37269 		v_0_0 := v_0.Args[0]
   37270 		if v_0_0.Op != OpS390XLGDR {
   37271 			break
   37272 		}
   37273 		t := v_0_0.Type
   37274 		x := v_0_0.Args[0]
   37275 		v.reset(OpS390XLGDR)
   37276 		v.Type = t
   37277 		v0 := b.NewValue0(v.Pos, OpS390XLPDFR, x.Type)
   37278 		v0.AddArg(x)
   37279 		v.AddArg(v0)
   37280 		return true
   37281 	}
   37282 	return false
   37283 }
   37284 func rewriteValueS390X_OpS390XSRW_0(v *Value) bool {
   37285 	// match: (SRW x (MOVDconst [c]))
   37286 	// cond:
   37287 	// result: (SRWconst [c&63] x)
   37288 	for {
   37289 		_ = v.Args[1]
   37290 		x := v.Args[0]
   37291 		v_1 := v.Args[1]
   37292 		if v_1.Op != OpS390XMOVDconst {
   37293 			break
   37294 		}
   37295 		c := v_1.AuxInt
   37296 		v.reset(OpS390XSRWconst)
   37297 		v.AuxInt = c & 63
   37298 		v.AddArg(x)
   37299 		return true
   37300 	}
   37301 	// match: (SRW x (ANDWconst [63] y))
   37302 	// cond:
   37303 	// result: (SRW x y)
   37304 	for {
   37305 		_ = v.Args[1]
   37306 		x := v.Args[0]
   37307 		v_1 := v.Args[1]
   37308 		if v_1.Op != OpS390XANDWconst {
   37309 			break
   37310 		}
   37311 		if v_1.AuxInt != 63 {
   37312 			break
   37313 		}
   37314 		y := v_1.Args[0]
   37315 		v.reset(OpS390XSRW)
   37316 		v.AddArg(x)
   37317 		v.AddArg(y)
   37318 		return true
   37319 	}
   37320 	return false
   37321 }
   37322 func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool {
   37323 	// match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem))
   37324 	// cond: x.Uses == 1   && is20Bit(i-8)   && clobber(x)
   37325 	// result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem)
   37326 	for {
   37327 		i := v.AuxInt
   37328 		s := v.Aux
   37329 		_ = v.Args[3]
   37330 		p := v.Args[0]
   37331 		w2 := v.Args[1]
   37332 		w3 := v.Args[2]
   37333 		x := v.Args[3]
   37334 		if x.Op != OpS390XSTM2 {
   37335 			break
   37336 		}
   37337 		if x.AuxInt != i-8 {
   37338 			break
   37339 		}
   37340 		if x.Aux != s {
   37341 			break
   37342 		}
   37343 		_ = x.Args[3]
   37344 		if p != x.Args[0] {
   37345 			break
   37346 		}
   37347 		w0 := x.Args[1]
   37348 		w1 := x.Args[2]
   37349 		mem := x.Args[3]
   37350 		if !(x.Uses == 1 && is20Bit(i-8) && clobber(x)) {
   37351 			break
   37352 		}
   37353 		v.reset(OpS390XSTM4)
   37354 		v.AuxInt = i - 8
   37355 		v.Aux = s
   37356 		v.AddArg(p)
   37357 		v.AddArg(w0)
   37358 		v.AddArg(w1)
   37359 		v.AddArg(w2)
   37360 		v.AddArg(w3)
   37361 		v.AddArg(mem)
   37362 		return true
   37363 	}
   37364 	// match: (STM2 [i] {s} p (SRDconst [32] x) x mem)
   37365 	// cond:
   37366 	// result: (MOVDstore [i] {s} p x mem)
   37367 	for {
   37368 		i := v.AuxInt
   37369 		s := v.Aux
   37370 		_ = v.Args[3]
   37371 		p := v.Args[0]
   37372 		v_1 := v.Args[1]
   37373 		if v_1.Op != OpS390XSRDconst {
   37374 			break
   37375 		}
   37376 		if v_1.AuxInt != 32 {
   37377 			break
   37378 		}
   37379 		x := v_1.Args[0]
   37380 		if x != v.Args[2] {
   37381 			break
   37382 		}
   37383 		mem := v.Args[3]
   37384 		v.reset(OpS390XMOVDstore)
   37385 		v.AuxInt = i
   37386 		v.Aux = s
   37387 		v.AddArg(p)
   37388 		v.AddArg(x)
   37389 		v.AddArg(mem)
   37390 		return true
   37391 	}
   37392 	return false
   37393 }
   37394 func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool {
   37395 	// match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem))
   37396 	// cond: x.Uses == 1   && is20Bit(i-16)   && clobber(x)
   37397 	// result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem)
   37398 	for {
   37399 		i := v.AuxInt
   37400 		s := v.Aux
   37401 		_ = v.Args[3]
   37402 		p := v.Args[0]
   37403 		w2 := v.Args[1]
   37404 		w3 := v.Args[2]
   37405 		x := v.Args[3]
   37406 		if x.Op != OpS390XSTMG2 {
   37407 			break
   37408 		}
   37409 		if x.AuxInt != i-16 {
   37410 			break
   37411 		}
   37412 		if x.Aux != s {
   37413 			break
   37414 		}
   37415 		_ = x.Args[3]
   37416 		if p != x.Args[0] {
   37417 			break
   37418 		}
   37419 		w0 := x.Args[1]
   37420 		w1 := x.Args[2]
   37421 		mem := x.Args[3]
   37422 		if !(x.Uses == 1 && is20Bit(i-16) && clobber(x)) {
   37423 			break
   37424 		}
   37425 		v.reset(OpS390XSTMG4)
   37426 		v.AuxInt = i - 16
   37427 		v.Aux = s
   37428 		v.AddArg(p)
   37429 		v.AddArg(w0)
   37430 		v.AddArg(w1)
   37431 		v.AddArg(w2)
   37432 		v.AddArg(w3)
   37433 		v.AddArg(mem)
   37434 		return true
   37435 	}
   37436 	return false
   37437 }
   37438 func rewriteValueS390X_OpS390XSUB_0(v *Value) bool {
   37439 	b := v.Block
   37440 	_ = b
   37441 	// match: (SUB x (MOVDconst [c]))
   37442 	// cond: is32Bit(c)
   37443 	// result: (SUBconst x [c])
   37444 	for {
   37445 		_ = v.Args[1]
   37446 		x := v.Args[0]
   37447 		v_1 := v.Args[1]
   37448 		if v_1.Op != OpS390XMOVDconst {
   37449 			break
   37450 		}
   37451 		c := v_1.AuxInt
   37452 		if !(is32Bit(c)) {
   37453 			break
   37454 		}
   37455 		v.reset(OpS390XSUBconst)
   37456 		v.AuxInt = c
   37457 		v.AddArg(x)
   37458 		return true
   37459 	}
   37460 	// match: (SUB (MOVDconst [c]) x)
   37461 	// cond: is32Bit(c)
   37462 	// result: (NEG (SUBconst <v.Type> x [c]))
   37463 	for {
   37464 		_ = v.Args[1]
   37465 		v_0 := v.Args[0]
   37466 		if v_0.Op != OpS390XMOVDconst {
   37467 			break
   37468 		}
   37469 		c := v_0.AuxInt
   37470 		x := v.Args[1]
   37471 		if !(is32Bit(c)) {
   37472 			break
   37473 		}
   37474 		v.reset(OpS390XNEG)
   37475 		v0 := b.NewValue0(v.Pos, OpS390XSUBconst, v.Type)
   37476 		v0.AuxInt = c
   37477 		v0.AddArg(x)
   37478 		v.AddArg(v0)
   37479 		return true
   37480 	}
   37481 	// match: (SUB x x)
   37482 	// cond:
   37483 	// result: (MOVDconst [0])
   37484 	for {
   37485 		_ = v.Args[1]
   37486 		x := v.Args[0]
   37487 		if x != v.Args[1] {
   37488 			break
   37489 		}
   37490 		v.reset(OpS390XMOVDconst)
   37491 		v.AuxInt = 0
   37492 		return true
   37493 	}
   37494 	// match: (SUB <t> x g:(MOVDload [off] {sym} ptr mem))
   37495 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   37496 	// result: (SUBload <t> [off] {sym} x ptr mem)
   37497 	for {
   37498 		t := v.Type
   37499 		_ = v.Args[1]
   37500 		x := v.Args[0]
   37501 		g := v.Args[1]
   37502 		if g.Op != OpS390XMOVDload {
   37503 			break
   37504 		}
   37505 		off := g.AuxInt
   37506 		sym := g.Aux
   37507 		_ = g.Args[1]
   37508 		ptr := g.Args[0]
   37509 		mem := g.Args[1]
   37510 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   37511 			break
   37512 		}
   37513 		v.reset(OpS390XSUBload)
   37514 		v.Type = t
   37515 		v.AuxInt = off
   37516 		v.Aux = sym
   37517 		v.AddArg(x)
   37518 		v.AddArg(ptr)
   37519 		v.AddArg(mem)
   37520 		return true
   37521 	}
   37522 	return false
   37523 }
   37524 func rewriteValueS390X_OpS390XSUBEWcarrymask_0(v *Value) bool {
   37525 	// match: (SUBEWcarrymask (FlagEQ))
   37526 	// cond:
   37527 	// result: (MOVDconst [-1])
   37528 	for {
   37529 		v_0 := v.Args[0]
   37530 		if v_0.Op != OpS390XFlagEQ {
   37531 			break
   37532 		}
   37533 		v.reset(OpS390XMOVDconst)
   37534 		v.AuxInt = -1
   37535 		return true
   37536 	}
   37537 	// match: (SUBEWcarrymask (FlagLT))
   37538 	// cond:
   37539 	// result: (MOVDconst [-1])
   37540 	for {
   37541 		v_0 := v.Args[0]
   37542 		if v_0.Op != OpS390XFlagLT {
   37543 			break
   37544 		}
   37545 		v.reset(OpS390XMOVDconst)
   37546 		v.AuxInt = -1
   37547 		return true
   37548 	}
   37549 	// match: (SUBEWcarrymask (FlagGT))
   37550 	// cond:
   37551 	// result: (MOVDconst [0])
   37552 	for {
   37553 		v_0 := v.Args[0]
   37554 		if v_0.Op != OpS390XFlagGT {
   37555 			break
   37556 		}
   37557 		v.reset(OpS390XMOVDconst)
   37558 		v.AuxInt = 0
   37559 		return true
   37560 	}
   37561 	return false
   37562 }
   37563 func rewriteValueS390X_OpS390XSUBEcarrymask_0(v *Value) bool {
   37564 	// match: (SUBEcarrymask (FlagEQ))
   37565 	// cond:
   37566 	// result: (MOVDconst [-1])
   37567 	for {
   37568 		v_0 := v.Args[0]
   37569 		if v_0.Op != OpS390XFlagEQ {
   37570 			break
   37571 		}
   37572 		v.reset(OpS390XMOVDconst)
   37573 		v.AuxInt = -1
   37574 		return true
   37575 	}
   37576 	// match: (SUBEcarrymask (FlagLT))
   37577 	// cond:
   37578 	// result: (MOVDconst [-1])
   37579 	for {
   37580 		v_0 := v.Args[0]
   37581 		if v_0.Op != OpS390XFlagLT {
   37582 			break
   37583 		}
   37584 		v.reset(OpS390XMOVDconst)
   37585 		v.AuxInt = -1
   37586 		return true
   37587 	}
   37588 	// match: (SUBEcarrymask (FlagGT))
   37589 	// cond:
   37590 	// result: (MOVDconst [0])
   37591 	for {
   37592 		v_0 := v.Args[0]
   37593 		if v_0.Op != OpS390XFlagGT {
   37594 			break
   37595 		}
   37596 		v.reset(OpS390XMOVDconst)
   37597 		v.AuxInt = 0
   37598 		return true
   37599 	}
   37600 	return false
   37601 }
   37602 func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool {
   37603 	b := v.Block
   37604 	_ = b
   37605 	// match: (SUBW x (MOVDconst [c]))
   37606 	// cond:
   37607 	// result: (SUBWconst x [int64(int32(c))])
   37608 	for {
   37609 		_ = v.Args[1]
   37610 		x := v.Args[0]
   37611 		v_1 := v.Args[1]
   37612 		if v_1.Op != OpS390XMOVDconst {
   37613 			break
   37614 		}
   37615 		c := v_1.AuxInt
   37616 		v.reset(OpS390XSUBWconst)
   37617 		v.AuxInt = int64(int32(c))
   37618 		v.AddArg(x)
   37619 		return true
   37620 	}
   37621 	// match: (SUBW (MOVDconst [c]) x)
   37622 	// cond:
   37623 	// result: (NEGW (SUBWconst <v.Type> x [int64(int32(c))]))
   37624 	for {
   37625 		_ = v.Args[1]
   37626 		v_0 := v.Args[0]
   37627 		if v_0.Op != OpS390XMOVDconst {
   37628 			break
   37629 		}
   37630 		c := v_0.AuxInt
   37631 		x := v.Args[1]
   37632 		v.reset(OpS390XNEGW)
   37633 		v0 := b.NewValue0(v.Pos, OpS390XSUBWconst, v.Type)
   37634 		v0.AuxInt = int64(int32(c))
   37635 		v0.AddArg(x)
   37636 		v.AddArg(v0)
   37637 		return true
   37638 	}
   37639 	// match: (SUBW x x)
   37640 	// cond:
   37641 	// result: (MOVDconst [0])
   37642 	for {
   37643 		_ = v.Args[1]
   37644 		x := v.Args[0]
   37645 		if x != v.Args[1] {
   37646 			break
   37647 		}
   37648 		v.reset(OpS390XMOVDconst)
   37649 		v.AuxInt = 0
   37650 		return true
   37651 	}
   37652 	// match: (SUBW <t> x g:(MOVWload [off] {sym} ptr mem))
   37653 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   37654 	// result: (SUBWload <t> [off] {sym} x ptr mem)
   37655 	for {
   37656 		t := v.Type
   37657 		_ = v.Args[1]
   37658 		x := v.Args[0]
   37659 		g := v.Args[1]
   37660 		if g.Op != OpS390XMOVWload {
   37661 			break
   37662 		}
   37663 		off := g.AuxInt
   37664 		sym := g.Aux
   37665 		_ = g.Args[1]
   37666 		ptr := g.Args[0]
   37667 		mem := g.Args[1]
   37668 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   37669 			break
   37670 		}
   37671 		v.reset(OpS390XSUBWload)
   37672 		v.Type = t
   37673 		v.AuxInt = off
   37674 		v.Aux = sym
   37675 		v.AddArg(x)
   37676 		v.AddArg(ptr)
   37677 		v.AddArg(mem)
   37678 		return true
   37679 	}
   37680 	// match: (SUBW <t> x g:(MOVWZload [off] {sym} ptr mem))
   37681 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   37682 	// result: (SUBWload <t> [off] {sym} x ptr mem)
   37683 	for {
   37684 		t := v.Type
   37685 		_ = v.Args[1]
   37686 		x := v.Args[0]
   37687 		g := v.Args[1]
   37688 		if g.Op != OpS390XMOVWZload {
   37689 			break
   37690 		}
   37691 		off := g.AuxInt
   37692 		sym := g.Aux
   37693 		_ = g.Args[1]
   37694 		ptr := g.Args[0]
   37695 		mem := g.Args[1]
   37696 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   37697 			break
   37698 		}
   37699 		v.reset(OpS390XSUBWload)
   37700 		v.Type = t
   37701 		v.AuxInt = off
   37702 		v.Aux = sym
   37703 		v.AddArg(x)
   37704 		v.AddArg(ptr)
   37705 		v.AddArg(mem)
   37706 		return true
   37707 	}
   37708 	return false
   37709 }
   37710 func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool {
   37711 	// match: (SUBWconst [c] x)
   37712 	// cond: int32(c) == 0
   37713 	// result: x
   37714 	for {
   37715 		c := v.AuxInt
   37716 		x := v.Args[0]
   37717 		if !(int32(c) == 0) {
   37718 			break
   37719 		}
   37720 		v.reset(OpCopy)
   37721 		v.Type = x.Type
   37722 		v.AddArg(x)
   37723 		return true
   37724 	}
   37725 	// match: (SUBWconst [c] x)
   37726 	// cond:
   37727 	// result: (ADDWconst [int64(int32(-c))] x)
   37728 	for {
   37729 		c := v.AuxInt
   37730 		x := v.Args[0]
   37731 		v.reset(OpS390XADDWconst)
   37732 		v.AuxInt = int64(int32(-c))
   37733 		v.AddArg(x)
   37734 		return true
   37735 	}
   37736 }
   37737 func rewriteValueS390X_OpS390XSUBWload_0(v *Value) bool {
   37738 	// match: (SUBWload [off1] {sym} x (ADDconst [off2] ptr) mem)
   37739 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   37740 	// result: (SUBWload  [off1+off2] {sym} x ptr mem)
   37741 	for {
   37742 		off1 := v.AuxInt
   37743 		sym := v.Aux
   37744 		_ = v.Args[2]
   37745 		x := v.Args[0]
   37746 		v_1 := v.Args[1]
   37747 		if v_1.Op != OpS390XADDconst {
   37748 			break
   37749 		}
   37750 		off2 := v_1.AuxInt
   37751 		ptr := v_1.Args[0]
   37752 		mem := v.Args[2]
   37753 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   37754 			break
   37755 		}
   37756 		v.reset(OpS390XSUBWload)
   37757 		v.AuxInt = off1 + off2
   37758 		v.Aux = sym
   37759 		v.AddArg(x)
   37760 		v.AddArg(ptr)
   37761 		v.AddArg(mem)
   37762 		return true
   37763 	}
   37764 	// match: (SUBWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   37765 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   37766 	// result: (SUBWload  [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   37767 	for {
   37768 		o1 := v.AuxInt
   37769 		s1 := v.Aux
   37770 		_ = v.Args[2]
   37771 		x := v.Args[0]
   37772 		v_1 := v.Args[1]
   37773 		if v_1.Op != OpS390XMOVDaddr {
   37774 			break
   37775 		}
   37776 		o2 := v_1.AuxInt
   37777 		s2 := v_1.Aux
   37778 		ptr := v_1.Args[0]
   37779 		mem := v.Args[2]
   37780 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   37781 			break
   37782 		}
   37783 		v.reset(OpS390XSUBWload)
   37784 		v.AuxInt = o1 + o2
   37785 		v.Aux = mergeSym(s1, s2)
   37786 		v.AddArg(x)
   37787 		v.AddArg(ptr)
   37788 		v.AddArg(mem)
   37789 		return true
   37790 	}
   37791 	return false
   37792 }
   37793 func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool {
   37794 	// match: (SUBconst [0] x)
   37795 	// cond:
   37796 	// result: x
   37797 	for {
   37798 		if v.AuxInt != 0 {
   37799 			break
   37800 		}
   37801 		x := v.Args[0]
   37802 		v.reset(OpCopy)
   37803 		v.Type = x.Type
   37804 		v.AddArg(x)
   37805 		return true
   37806 	}
   37807 	// match: (SUBconst [c] x)
   37808 	// cond: c != -(1<<31)
   37809 	// result: (ADDconst [-c] x)
   37810 	for {
   37811 		c := v.AuxInt
   37812 		x := v.Args[0]
   37813 		if !(c != -(1 << 31)) {
   37814 			break
   37815 		}
   37816 		v.reset(OpS390XADDconst)
   37817 		v.AuxInt = -c
   37818 		v.AddArg(x)
   37819 		return true
   37820 	}
   37821 	// match: (SUBconst (MOVDconst [d]) [c])
   37822 	// cond:
   37823 	// result: (MOVDconst [d-c])
   37824 	for {
   37825 		c := v.AuxInt
   37826 		v_0 := v.Args[0]
   37827 		if v_0.Op != OpS390XMOVDconst {
   37828 			break
   37829 		}
   37830 		d := v_0.AuxInt
   37831 		v.reset(OpS390XMOVDconst)
   37832 		v.AuxInt = d - c
   37833 		return true
   37834 	}
   37835 	// match: (SUBconst (SUBconst x [d]) [c])
   37836 	// cond: is32Bit(-c-d)
   37837 	// result: (ADDconst [-c-d] x)
   37838 	for {
   37839 		c := v.AuxInt
   37840 		v_0 := v.Args[0]
   37841 		if v_0.Op != OpS390XSUBconst {
   37842 			break
   37843 		}
   37844 		d := v_0.AuxInt
   37845 		x := v_0.Args[0]
   37846 		if !(is32Bit(-c - d)) {
   37847 			break
   37848 		}
   37849 		v.reset(OpS390XADDconst)
   37850 		v.AuxInt = -c - d
   37851 		v.AddArg(x)
   37852 		return true
   37853 	}
   37854 	return false
   37855 }
   37856 func rewriteValueS390X_OpS390XSUBload_0(v *Value) bool {
   37857 	b := v.Block
   37858 	_ = b
   37859 	// match: (SUBload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
   37860 	// cond: isSamePtr(ptr1, ptr2)
   37861 	// result: (SUB   x (LGDR <t> y))
   37862 	for {
   37863 		t := v.Type
   37864 		off := v.AuxInt
   37865 		sym := v.Aux
   37866 		_ = v.Args[2]
   37867 		x := v.Args[0]
   37868 		ptr1 := v.Args[1]
   37869 		v_2 := v.Args[2]
   37870 		if v_2.Op != OpS390XFMOVDstore {
   37871 			break
   37872 		}
   37873 		if v_2.AuxInt != off {
   37874 			break
   37875 		}
   37876 		if v_2.Aux != sym {
   37877 			break
   37878 		}
   37879 		_ = v_2.Args[2]
   37880 		ptr2 := v_2.Args[0]
   37881 		y := v_2.Args[1]
   37882 		if !(isSamePtr(ptr1, ptr2)) {
   37883 			break
   37884 		}
   37885 		v.reset(OpS390XSUB)
   37886 		v.AddArg(x)
   37887 		v0 := b.NewValue0(v.Pos, OpS390XLGDR, t)
   37888 		v0.AddArg(y)
   37889 		v.AddArg(v0)
   37890 		return true
   37891 	}
   37892 	// match: (SUBload [off1] {sym} x (ADDconst [off2] ptr) mem)
   37893 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   37894 	// result: (SUBload   [off1+off2] {sym} x ptr mem)
   37895 	for {
   37896 		off1 := v.AuxInt
   37897 		sym := v.Aux
   37898 		_ = v.Args[2]
   37899 		x := v.Args[0]
   37900 		v_1 := v.Args[1]
   37901 		if v_1.Op != OpS390XADDconst {
   37902 			break
   37903 		}
   37904 		off2 := v_1.AuxInt
   37905 		ptr := v_1.Args[0]
   37906 		mem := v.Args[2]
   37907 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   37908 			break
   37909 		}
   37910 		v.reset(OpS390XSUBload)
   37911 		v.AuxInt = off1 + off2
   37912 		v.Aux = sym
   37913 		v.AddArg(x)
   37914 		v.AddArg(ptr)
   37915 		v.AddArg(mem)
   37916 		return true
   37917 	}
   37918 	// match: (SUBload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   37919 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   37920 	// result: (SUBload   [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   37921 	for {
   37922 		o1 := v.AuxInt
   37923 		s1 := v.Aux
   37924 		_ = v.Args[2]
   37925 		x := v.Args[0]
   37926 		v_1 := v.Args[1]
   37927 		if v_1.Op != OpS390XMOVDaddr {
   37928 			break
   37929 		}
   37930 		o2 := v_1.AuxInt
   37931 		s2 := v_1.Aux
   37932 		ptr := v_1.Args[0]
   37933 		mem := v.Args[2]
   37934 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   37935 			break
   37936 		}
   37937 		v.reset(OpS390XSUBload)
   37938 		v.AuxInt = o1 + o2
   37939 		v.Aux = mergeSym(s1, s2)
   37940 		v.AddArg(x)
   37941 		v.AddArg(ptr)
   37942 		v.AddArg(mem)
   37943 		return true
   37944 	}
   37945 	return false
   37946 }
   37947 func rewriteValueS390X_OpS390XXOR_0(v *Value) bool {
   37948 	// match: (XOR x (MOVDconst [c]))
   37949 	// cond: isU32Bit(c)
   37950 	// result: (XORconst [c] x)
   37951 	for {
   37952 		_ = v.Args[1]
   37953 		x := v.Args[0]
   37954 		v_1 := v.Args[1]
   37955 		if v_1.Op != OpS390XMOVDconst {
   37956 			break
   37957 		}
   37958 		c := v_1.AuxInt
   37959 		if !(isU32Bit(c)) {
   37960 			break
   37961 		}
   37962 		v.reset(OpS390XXORconst)
   37963 		v.AuxInt = c
   37964 		v.AddArg(x)
   37965 		return true
   37966 	}
   37967 	// match: (XOR (MOVDconst [c]) x)
   37968 	// cond: isU32Bit(c)
   37969 	// result: (XORconst [c] x)
   37970 	for {
   37971 		_ = v.Args[1]
   37972 		v_0 := v.Args[0]
   37973 		if v_0.Op != OpS390XMOVDconst {
   37974 			break
   37975 		}
   37976 		c := v_0.AuxInt
   37977 		x := v.Args[1]
   37978 		if !(isU32Bit(c)) {
   37979 			break
   37980 		}
   37981 		v.reset(OpS390XXORconst)
   37982 		v.AuxInt = c
   37983 		v.AddArg(x)
   37984 		return true
   37985 	}
   37986 	// match: (XOR (SLDconst x [c]) (SRDconst x [d]))
   37987 	// cond: d == 64-c
   37988 	// result: (RLLGconst [c] x)
   37989 	for {
   37990 		_ = v.Args[1]
   37991 		v_0 := v.Args[0]
   37992 		if v_0.Op != OpS390XSLDconst {
   37993 			break
   37994 		}
   37995 		c := v_0.AuxInt
   37996 		x := v_0.Args[0]
   37997 		v_1 := v.Args[1]
   37998 		if v_1.Op != OpS390XSRDconst {
   37999 			break
   38000 		}
   38001 		d := v_1.AuxInt
   38002 		if x != v_1.Args[0] {
   38003 			break
   38004 		}
   38005 		if !(d == 64-c) {
   38006 			break
   38007 		}
   38008 		v.reset(OpS390XRLLGconst)
   38009 		v.AuxInt = c
   38010 		v.AddArg(x)
   38011 		return true
   38012 	}
   38013 	// match: (XOR (SRDconst x [d]) (SLDconst x [c]))
   38014 	// cond: d == 64-c
   38015 	// result: (RLLGconst [c] x)
   38016 	for {
   38017 		_ = v.Args[1]
   38018 		v_0 := v.Args[0]
   38019 		if v_0.Op != OpS390XSRDconst {
   38020 			break
   38021 		}
   38022 		d := v_0.AuxInt
   38023 		x := v_0.Args[0]
   38024 		v_1 := v.Args[1]
   38025 		if v_1.Op != OpS390XSLDconst {
   38026 			break
   38027 		}
   38028 		c := v_1.AuxInt
   38029 		if x != v_1.Args[0] {
   38030 			break
   38031 		}
   38032 		if !(d == 64-c) {
   38033 			break
   38034 		}
   38035 		v.reset(OpS390XRLLGconst)
   38036 		v.AuxInt = c
   38037 		v.AddArg(x)
   38038 		return true
   38039 	}
   38040 	// match: (XOR (MOVDconst [c]) (MOVDconst [d]))
   38041 	// cond:
   38042 	// result: (MOVDconst [c^d])
   38043 	for {
   38044 		_ = v.Args[1]
   38045 		v_0 := v.Args[0]
   38046 		if v_0.Op != OpS390XMOVDconst {
   38047 			break
   38048 		}
   38049 		c := v_0.AuxInt
   38050 		v_1 := v.Args[1]
   38051 		if v_1.Op != OpS390XMOVDconst {
   38052 			break
   38053 		}
   38054 		d := v_1.AuxInt
   38055 		v.reset(OpS390XMOVDconst)
   38056 		v.AuxInt = c ^ d
   38057 		return true
   38058 	}
   38059 	// match: (XOR (MOVDconst [d]) (MOVDconst [c]))
   38060 	// cond:
   38061 	// result: (MOVDconst [c^d])
   38062 	for {
   38063 		_ = v.Args[1]
   38064 		v_0 := v.Args[0]
   38065 		if v_0.Op != OpS390XMOVDconst {
   38066 			break
   38067 		}
   38068 		d := v_0.AuxInt
   38069 		v_1 := v.Args[1]
   38070 		if v_1.Op != OpS390XMOVDconst {
   38071 			break
   38072 		}
   38073 		c := v_1.AuxInt
   38074 		v.reset(OpS390XMOVDconst)
   38075 		v.AuxInt = c ^ d
   38076 		return true
   38077 	}
   38078 	// match: (XOR x x)
   38079 	// cond:
   38080 	// result: (MOVDconst [0])
   38081 	for {
   38082 		_ = v.Args[1]
   38083 		x := v.Args[0]
   38084 		if x != v.Args[1] {
   38085 			break
   38086 		}
   38087 		v.reset(OpS390XMOVDconst)
   38088 		v.AuxInt = 0
   38089 		return true
   38090 	}
   38091 	// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
   38092 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38093 	// result: (XORload <t> [off] {sym} x ptr mem)
   38094 	for {
   38095 		t := v.Type
   38096 		_ = v.Args[1]
   38097 		x := v.Args[0]
   38098 		g := v.Args[1]
   38099 		if g.Op != OpS390XMOVDload {
   38100 			break
   38101 		}
   38102 		off := g.AuxInt
   38103 		sym := g.Aux
   38104 		_ = g.Args[1]
   38105 		ptr := g.Args[0]
   38106 		mem := g.Args[1]
   38107 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38108 			break
   38109 		}
   38110 		v.reset(OpS390XXORload)
   38111 		v.Type = t
   38112 		v.AuxInt = off
   38113 		v.Aux = sym
   38114 		v.AddArg(x)
   38115 		v.AddArg(ptr)
   38116 		v.AddArg(mem)
   38117 		return true
   38118 	}
   38119 	// match: (XOR <t> g:(MOVDload [off] {sym} ptr mem) x)
   38120 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38121 	// result: (XORload <t> [off] {sym} x ptr mem)
   38122 	for {
   38123 		t := v.Type
   38124 		_ = v.Args[1]
   38125 		g := v.Args[0]
   38126 		if g.Op != OpS390XMOVDload {
   38127 			break
   38128 		}
   38129 		off := g.AuxInt
   38130 		sym := g.Aux
   38131 		_ = g.Args[1]
   38132 		ptr := g.Args[0]
   38133 		mem := g.Args[1]
   38134 		x := v.Args[1]
   38135 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38136 			break
   38137 		}
   38138 		v.reset(OpS390XXORload)
   38139 		v.Type = t
   38140 		v.AuxInt = off
   38141 		v.Aux = sym
   38142 		v.AddArg(x)
   38143 		v.AddArg(ptr)
   38144 		v.AddArg(mem)
   38145 		return true
   38146 	}
   38147 	// match: (XOR <t> g:(MOVDload [off] {sym} ptr mem) x)
   38148 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38149 	// result: (XORload <t> [off] {sym} x ptr mem)
   38150 	for {
   38151 		t := v.Type
   38152 		_ = v.Args[1]
   38153 		g := v.Args[0]
   38154 		if g.Op != OpS390XMOVDload {
   38155 			break
   38156 		}
   38157 		off := g.AuxInt
   38158 		sym := g.Aux
   38159 		_ = g.Args[1]
   38160 		ptr := g.Args[0]
   38161 		mem := g.Args[1]
   38162 		x := v.Args[1]
   38163 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38164 			break
   38165 		}
   38166 		v.reset(OpS390XXORload)
   38167 		v.Type = t
   38168 		v.AuxInt = off
   38169 		v.Aux = sym
   38170 		v.AddArg(x)
   38171 		v.AddArg(ptr)
   38172 		v.AddArg(mem)
   38173 		return true
   38174 	}
   38175 	return false
   38176 }
   38177 func rewriteValueS390X_OpS390XXOR_10(v *Value) bool {
   38178 	// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
   38179 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38180 	// result: (XORload <t> [off] {sym} x ptr mem)
   38181 	for {
   38182 		t := v.Type
   38183 		_ = v.Args[1]
   38184 		x := v.Args[0]
   38185 		g := v.Args[1]
   38186 		if g.Op != OpS390XMOVDload {
   38187 			break
   38188 		}
   38189 		off := g.AuxInt
   38190 		sym := g.Aux
   38191 		_ = g.Args[1]
   38192 		ptr := g.Args[0]
   38193 		mem := g.Args[1]
   38194 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38195 			break
   38196 		}
   38197 		v.reset(OpS390XXORload)
   38198 		v.Type = t
   38199 		v.AuxInt = off
   38200 		v.Aux = sym
   38201 		v.AddArg(x)
   38202 		v.AddArg(ptr)
   38203 		v.AddArg(mem)
   38204 		return true
   38205 	}
   38206 	return false
   38207 }
   38208 func rewriteValueS390X_OpS390XXORW_0(v *Value) bool {
   38209 	// match: (XORW x (MOVDconst [c]))
   38210 	// cond:
   38211 	// result: (XORWconst [int64(int32(c))] x)
   38212 	for {
   38213 		_ = v.Args[1]
   38214 		x := v.Args[0]
   38215 		v_1 := v.Args[1]
   38216 		if v_1.Op != OpS390XMOVDconst {
   38217 			break
   38218 		}
   38219 		c := v_1.AuxInt
   38220 		v.reset(OpS390XXORWconst)
   38221 		v.AuxInt = int64(int32(c))
   38222 		v.AddArg(x)
   38223 		return true
   38224 	}
   38225 	// match: (XORW (MOVDconst [c]) x)
   38226 	// cond:
   38227 	// result: (XORWconst [int64(int32(c))] x)
   38228 	for {
   38229 		_ = v.Args[1]
   38230 		v_0 := v.Args[0]
   38231 		if v_0.Op != OpS390XMOVDconst {
   38232 			break
   38233 		}
   38234 		c := v_0.AuxInt
   38235 		x := v.Args[1]
   38236 		v.reset(OpS390XXORWconst)
   38237 		v.AuxInt = int64(int32(c))
   38238 		v.AddArg(x)
   38239 		return true
   38240 	}
   38241 	// match: (XORW (SLWconst x [c]) (SRWconst x [d]))
   38242 	// cond: d == 32-c
   38243 	// result: (RLLconst [c] x)
   38244 	for {
   38245 		_ = v.Args[1]
   38246 		v_0 := v.Args[0]
   38247 		if v_0.Op != OpS390XSLWconst {
   38248 			break
   38249 		}
   38250 		c := v_0.AuxInt
   38251 		x := v_0.Args[0]
   38252 		v_1 := v.Args[1]
   38253 		if v_1.Op != OpS390XSRWconst {
   38254 			break
   38255 		}
   38256 		d := v_1.AuxInt
   38257 		if x != v_1.Args[0] {
   38258 			break
   38259 		}
   38260 		if !(d == 32-c) {
   38261 			break
   38262 		}
   38263 		v.reset(OpS390XRLLconst)
   38264 		v.AuxInt = c
   38265 		v.AddArg(x)
   38266 		return true
   38267 	}
   38268 	// match: (XORW (SRWconst x [d]) (SLWconst x [c]))
   38269 	// cond: d == 32-c
   38270 	// result: (RLLconst [c] x)
   38271 	for {
   38272 		_ = v.Args[1]
   38273 		v_0 := v.Args[0]
   38274 		if v_0.Op != OpS390XSRWconst {
   38275 			break
   38276 		}
   38277 		d := v_0.AuxInt
   38278 		x := v_0.Args[0]
   38279 		v_1 := v.Args[1]
   38280 		if v_1.Op != OpS390XSLWconst {
   38281 			break
   38282 		}
   38283 		c := v_1.AuxInt
   38284 		if x != v_1.Args[0] {
   38285 			break
   38286 		}
   38287 		if !(d == 32-c) {
   38288 			break
   38289 		}
   38290 		v.reset(OpS390XRLLconst)
   38291 		v.AuxInt = c
   38292 		v.AddArg(x)
   38293 		return true
   38294 	}
   38295 	// match: (XORW x x)
   38296 	// cond:
   38297 	// result: (MOVDconst [0])
   38298 	for {
   38299 		_ = v.Args[1]
   38300 		x := v.Args[0]
   38301 		if x != v.Args[1] {
   38302 			break
   38303 		}
   38304 		v.reset(OpS390XMOVDconst)
   38305 		v.AuxInt = 0
   38306 		return true
   38307 	}
   38308 	// match: (XORW <t> x g:(MOVWload [off] {sym} ptr mem))
   38309 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38310 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38311 	for {
   38312 		t := v.Type
   38313 		_ = v.Args[1]
   38314 		x := v.Args[0]
   38315 		g := v.Args[1]
   38316 		if g.Op != OpS390XMOVWload {
   38317 			break
   38318 		}
   38319 		off := g.AuxInt
   38320 		sym := g.Aux
   38321 		_ = g.Args[1]
   38322 		ptr := g.Args[0]
   38323 		mem := g.Args[1]
   38324 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38325 			break
   38326 		}
   38327 		v.reset(OpS390XXORWload)
   38328 		v.Type = t
   38329 		v.AuxInt = off
   38330 		v.Aux = sym
   38331 		v.AddArg(x)
   38332 		v.AddArg(ptr)
   38333 		v.AddArg(mem)
   38334 		return true
   38335 	}
   38336 	// match: (XORW <t> g:(MOVWload [off] {sym} ptr mem) x)
   38337 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38338 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38339 	for {
   38340 		t := v.Type
   38341 		_ = v.Args[1]
   38342 		g := v.Args[0]
   38343 		if g.Op != OpS390XMOVWload {
   38344 			break
   38345 		}
   38346 		off := g.AuxInt
   38347 		sym := g.Aux
   38348 		_ = g.Args[1]
   38349 		ptr := g.Args[0]
   38350 		mem := g.Args[1]
   38351 		x := v.Args[1]
   38352 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38353 			break
   38354 		}
   38355 		v.reset(OpS390XXORWload)
   38356 		v.Type = t
   38357 		v.AuxInt = off
   38358 		v.Aux = sym
   38359 		v.AddArg(x)
   38360 		v.AddArg(ptr)
   38361 		v.AddArg(mem)
   38362 		return true
   38363 	}
   38364 	// match: (XORW <t> g:(MOVWload [off] {sym} ptr mem) x)
   38365 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38366 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38367 	for {
   38368 		t := v.Type
   38369 		_ = v.Args[1]
   38370 		g := v.Args[0]
   38371 		if g.Op != OpS390XMOVWload {
   38372 			break
   38373 		}
   38374 		off := g.AuxInt
   38375 		sym := g.Aux
   38376 		_ = g.Args[1]
   38377 		ptr := g.Args[0]
   38378 		mem := g.Args[1]
   38379 		x := v.Args[1]
   38380 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38381 			break
   38382 		}
   38383 		v.reset(OpS390XXORWload)
   38384 		v.Type = t
   38385 		v.AuxInt = off
   38386 		v.Aux = sym
   38387 		v.AddArg(x)
   38388 		v.AddArg(ptr)
   38389 		v.AddArg(mem)
   38390 		return true
   38391 	}
   38392 	// match: (XORW <t> x g:(MOVWload [off] {sym} ptr mem))
   38393 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38394 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38395 	for {
   38396 		t := v.Type
   38397 		_ = v.Args[1]
   38398 		x := v.Args[0]
   38399 		g := v.Args[1]
   38400 		if g.Op != OpS390XMOVWload {
   38401 			break
   38402 		}
   38403 		off := g.AuxInt
   38404 		sym := g.Aux
   38405 		_ = g.Args[1]
   38406 		ptr := g.Args[0]
   38407 		mem := g.Args[1]
   38408 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38409 			break
   38410 		}
   38411 		v.reset(OpS390XXORWload)
   38412 		v.Type = t
   38413 		v.AuxInt = off
   38414 		v.Aux = sym
   38415 		v.AddArg(x)
   38416 		v.AddArg(ptr)
   38417 		v.AddArg(mem)
   38418 		return true
   38419 	}
   38420 	// match: (XORW <t> x g:(MOVWZload [off] {sym} ptr mem))
   38421 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38422 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38423 	for {
   38424 		t := v.Type
   38425 		_ = v.Args[1]
   38426 		x := v.Args[0]
   38427 		g := v.Args[1]
   38428 		if g.Op != OpS390XMOVWZload {
   38429 			break
   38430 		}
   38431 		off := g.AuxInt
   38432 		sym := g.Aux
   38433 		_ = g.Args[1]
   38434 		ptr := g.Args[0]
   38435 		mem := g.Args[1]
   38436 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38437 			break
   38438 		}
   38439 		v.reset(OpS390XXORWload)
   38440 		v.Type = t
   38441 		v.AuxInt = off
   38442 		v.Aux = sym
   38443 		v.AddArg(x)
   38444 		v.AddArg(ptr)
   38445 		v.AddArg(mem)
   38446 		return true
   38447 	}
   38448 	return false
   38449 }
   38450 func rewriteValueS390X_OpS390XXORW_10(v *Value) bool {
   38451 	// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   38452 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38453 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38454 	for {
   38455 		t := v.Type
   38456 		_ = v.Args[1]
   38457 		g := v.Args[0]
   38458 		if g.Op != OpS390XMOVWZload {
   38459 			break
   38460 		}
   38461 		off := g.AuxInt
   38462 		sym := g.Aux
   38463 		_ = g.Args[1]
   38464 		ptr := g.Args[0]
   38465 		mem := g.Args[1]
   38466 		x := v.Args[1]
   38467 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38468 			break
   38469 		}
   38470 		v.reset(OpS390XXORWload)
   38471 		v.Type = t
   38472 		v.AuxInt = off
   38473 		v.Aux = sym
   38474 		v.AddArg(x)
   38475 		v.AddArg(ptr)
   38476 		v.AddArg(mem)
   38477 		return true
   38478 	}
   38479 	// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
   38480 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38481 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38482 	for {
   38483 		t := v.Type
   38484 		_ = v.Args[1]
   38485 		g := v.Args[0]
   38486 		if g.Op != OpS390XMOVWZload {
   38487 			break
   38488 		}
   38489 		off := g.AuxInt
   38490 		sym := g.Aux
   38491 		_ = g.Args[1]
   38492 		ptr := g.Args[0]
   38493 		mem := g.Args[1]
   38494 		x := v.Args[1]
   38495 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38496 			break
   38497 		}
   38498 		v.reset(OpS390XXORWload)
   38499 		v.Type = t
   38500 		v.AuxInt = off
   38501 		v.Aux = sym
   38502 		v.AddArg(x)
   38503 		v.AddArg(ptr)
   38504 		v.AddArg(mem)
   38505 		return true
   38506 	}
   38507 	// match: (XORW <t> x g:(MOVWZload [off] {sym} ptr mem))
   38508 	// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
   38509 	// result: (XORWload <t> [off] {sym} x ptr mem)
   38510 	for {
   38511 		t := v.Type
   38512 		_ = v.Args[1]
   38513 		x := v.Args[0]
   38514 		g := v.Args[1]
   38515 		if g.Op != OpS390XMOVWZload {
   38516 			break
   38517 		}
   38518 		off := g.AuxInt
   38519 		sym := g.Aux
   38520 		_ = g.Args[1]
   38521 		ptr := g.Args[0]
   38522 		mem := g.Args[1]
   38523 		if !(ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)) {
   38524 			break
   38525 		}
   38526 		v.reset(OpS390XXORWload)
   38527 		v.Type = t
   38528 		v.AuxInt = off
   38529 		v.Aux = sym
   38530 		v.AddArg(x)
   38531 		v.AddArg(ptr)
   38532 		v.AddArg(mem)
   38533 		return true
   38534 	}
   38535 	return false
   38536 }
   38537 func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool {
   38538 	// match: (XORWconst [c] x)
   38539 	// cond: int32(c)==0
   38540 	// result: x
   38541 	for {
   38542 		c := v.AuxInt
   38543 		x := v.Args[0]
   38544 		if !(int32(c) == 0) {
   38545 			break
   38546 		}
   38547 		v.reset(OpCopy)
   38548 		v.Type = x.Type
   38549 		v.AddArg(x)
   38550 		return true
   38551 	}
   38552 	// match: (XORWconst [c] (MOVDconst [d]))
   38553 	// cond:
   38554 	// result: (MOVDconst [c^d])
   38555 	for {
   38556 		c := v.AuxInt
   38557 		v_0 := v.Args[0]
   38558 		if v_0.Op != OpS390XMOVDconst {
   38559 			break
   38560 		}
   38561 		d := v_0.AuxInt
   38562 		v.reset(OpS390XMOVDconst)
   38563 		v.AuxInt = c ^ d
   38564 		return true
   38565 	}
   38566 	return false
   38567 }
   38568 func rewriteValueS390X_OpS390XXORWload_0(v *Value) bool {
   38569 	// match: (XORWload [off1] {sym} x (ADDconst [off2] ptr) mem)
   38570 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   38571 	// result: (XORWload  [off1+off2] {sym} x ptr mem)
   38572 	for {
   38573 		off1 := v.AuxInt
   38574 		sym := v.Aux
   38575 		_ = v.Args[2]
   38576 		x := v.Args[0]
   38577 		v_1 := v.Args[1]
   38578 		if v_1.Op != OpS390XADDconst {
   38579 			break
   38580 		}
   38581 		off2 := v_1.AuxInt
   38582 		ptr := v_1.Args[0]
   38583 		mem := v.Args[2]
   38584 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   38585 			break
   38586 		}
   38587 		v.reset(OpS390XXORWload)
   38588 		v.AuxInt = off1 + off2
   38589 		v.Aux = sym
   38590 		v.AddArg(x)
   38591 		v.AddArg(ptr)
   38592 		v.AddArg(mem)
   38593 		return true
   38594 	}
   38595 	// match: (XORWload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   38596 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   38597 	// result: (XORWload  [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   38598 	for {
   38599 		o1 := v.AuxInt
   38600 		s1 := v.Aux
   38601 		_ = v.Args[2]
   38602 		x := v.Args[0]
   38603 		v_1 := v.Args[1]
   38604 		if v_1.Op != OpS390XMOVDaddr {
   38605 			break
   38606 		}
   38607 		o2 := v_1.AuxInt
   38608 		s2 := v_1.Aux
   38609 		ptr := v_1.Args[0]
   38610 		mem := v.Args[2]
   38611 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   38612 			break
   38613 		}
   38614 		v.reset(OpS390XXORWload)
   38615 		v.AuxInt = o1 + o2
   38616 		v.Aux = mergeSym(s1, s2)
   38617 		v.AddArg(x)
   38618 		v.AddArg(ptr)
   38619 		v.AddArg(mem)
   38620 		return true
   38621 	}
   38622 	return false
   38623 }
   38624 func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool {
   38625 	// match: (XORconst [0] x)
   38626 	// cond:
   38627 	// result: x
   38628 	for {
   38629 		if v.AuxInt != 0 {
   38630 			break
   38631 		}
   38632 		x := v.Args[0]
   38633 		v.reset(OpCopy)
   38634 		v.Type = x.Type
   38635 		v.AddArg(x)
   38636 		return true
   38637 	}
   38638 	// match: (XORconst [c] (MOVDconst [d]))
   38639 	// cond:
   38640 	// result: (MOVDconst [c^d])
   38641 	for {
   38642 		c := v.AuxInt
   38643 		v_0 := v.Args[0]
   38644 		if v_0.Op != OpS390XMOVDconst {
   38645 			break
   38646 		}
   38647 		d := v_0.AuxInt
   38648 		v.reset(OpS390XMOVDconst)
   38649 		v.AuxInt = c ^ d
   38650 		return true
   38651 	}
   38652 	return false
   38653 }
   38654 func rewriteValueS390X_OpS390XXORload_0(v *Value) bool {
   38655 	b := v.Block
   38656 	_ = b
   38657 	// match: (XORload <t> [off] {sym} x ptr1 (FMOVDstore [off] {sym} ptr2 y _))
   38658 	// cond: isSamePtr(ptr1, ptr2)
   38659 	// result: (XOR   x (LGDR <t> y))
   38660 	for {
   38661 		t := v.Type
   38662 		off := v.AuxInt
   38663 		sym := v.Aux
   38664 		_ = v.Args[2]
   38665 		x := v.Args[0]
   38666 		ptr1 := v.Args[1]
   38667 		v_2 := v.Args[2]
   38668 		if v_2.Op != OpS390XFMOVDstore {
   38669 			break
   38670 		}
   38671 		if v_2.AuxInt != off {
   38672 			break
   38673 		}
   38674 		if v_2.Aux != sym {
   38675 			break
   38676 		}
   38677 		_ = v_2.Args[2]
   38678 		ptr2 := v_2.Args[0]
   38679 		y := v_2.Args[1]
   38680 		if !(isSamePtr(ptr1, ptr2)) {
   38681 			break
   38682 		}
   38683 		v.reset(OpS390XXOR)
   38684 		v.AddArg(x)
   38685 		v0 := b.NewValue0(v.Pos, OpS390XLGDR, t)
   38686 		v0.AddArg(y)
   38687 		v.AddArg(v0)
   38688 		return true
   38689 	}
   38690 	// match: (XORload [off1] {sym} x (ADDconst [off2] ptr) mem)
   38691 	// cond: ptr.Op != OpSB && is20Bit(off1+off2)
   38692 	// result: (XORload   [off1+off2] {sym} x ptr mem)
   38693 	for {
   38694 		off1 := v.AuxInt
   38695 		sym := v.Aux
   38696 		_ = v.Args[2]
   38697 		x := v.Args[0]
   38698 		v_1 := v.Args[1]
   38699 		if v_1.Op != OpS390XADDconst {
   38700 			break
   38701 		}
   38702 		off2 := v_1.AuxInt
   38703 		ptr := v_1.Args[0]
   38704 		mem := v.Args[2]
   38705 		if !(ptr.Op != OpSB && is20Bit(off1+off2)) {
   38706 			break
   38707 		}
   38708 		v.reset(OpS390XXORload)
   38709 		v.AuxInt = off1 + off2
   38710 		v.Aux = sym
   38711 		v.AddArg(x)
   38712 		v.AddArg(ptr)
   38713 		v.AddArg(mem)
   38714 		return true
   38715 	}
   38716 	// match: (XORload [o1] {s1} x (MOVDaddr [o2] {s2} ptr) mem)
   38717 	// cond: ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)
   38718 	// result: (XORload   [o1+o2] {mergeSym(s1, s2)} x ptr mem)
   38719 	for {
   38720 		o1 := v.AuxInt
   38721 		s1 := v.Aux
   38722 		_ = v.Args[2]
   38723 		x := v.Args[0]
   38724 		v_1 := v.Args[1]
   38725 		if v_1.Op != OpS390XMOVDaddr {
   38726 			break
   38727 		}
   38728 		o2 := v_1.AuxInt
   38729 		s2 := v_1.Aux
   38730 		ptr := v_1.Args[0]
   38731 		mem := v.Args[2]
   38732 		if !(ptr.Op != OpSB && is20Bit(o1+o2) && canMergeSym(s1, s2)) {
   38733 			break
   38734 		}
   38735 		v.reset(OpS390XXORload)
   38736 		v.AuxInt = o1 + o2
   38737 		v.Aux = mergeSym(s1, s2)
   38738 		v.AddArg(x)
   38739 		v.AddArg(ptr)
   38740 		v.AddArg(mem)
   38741 		return true
   38742 	}
   38743 	return false
   38744 }
   38745 func rewriteValueS390X_OpSelect0_0(v *Value) bool {
   38746 	b := v.Block
   38747 	_ = b
   38748 	// match: (Select0 <t> (AddTupleFirst32 val tuple))
   38749 	// cond:
   38750 	// result: (ADDW val (Select0 <t> tuple))
   38751 	for {
   38752 		t := v.Type
   38753 		v_0 := v.Args[0]
   38754 		if v_0.Op != OpS390XAddTupleFirst32 {
   38755 			break
   38756 		}
   38757 		_ = v_0.Args[1]
   38758 		val := v_0.Args[0]
   38759 		tuple := v_0.Args[1]
   38760 		v.reset(OpS390XADDW)
   38761 		v.AddArg(val)
   38762 		v0 := b.NewValue0(v.Pos, OpSelect0, t)
   38763 		v0.AddArg(tuple)
   38764 		v.AddArg(v0)
   38765 		return true
   38766 	}
   38767 	// match: (Select0 <t> (AddTupleFirst64 val tuple))
   38768 	// cond:
   38769 	// result: (ADD val (Select0 <t> tuple))
   38770 	for {
   38771 		t := v.Type
   38772 		v_0 := v.Args[0]
   38773 		if v_0.Op != OpS390XAddTupleFirst64 {
   38774 			break
   38775 		}
   38776 		_ = v_0.Args[1]
   38777 		val := v_0.Args[0]
   38778 		tuple := v_0.Args[1]
   38779 		v.reset(OpS390XADD)
   38780 		v.AddArg(val)
   38781 		v0 := b.NewValue0(v.Pos, OpSelect0, t)
   38782 		v0.AddArg(tuple)
   38783 		v.AddArg(v0)
   38784 		return true
   38785 	}
   38786 	return false
   38787 }
   38788 func rewriteValueS390X_OpSelect1_0(v *Value) bool {
   38789 	// match: (Select1 (AddTupleFirst32 _ tuple))
   38790 	// cond:
   38791 	// result: (Select1 tuple)
   38792 	for {
   38793 		v_0 := v.Args[0]
   38794 		if v_0.Op != OpS390XAddTupleFirst32 {
   38795 			break
   38796 		}
   38797 		_ = v_0.Args[1]
   38798 		tuple := v_0.Args[1]
   38799 		v.reset(OpSelect1)
   38800 		v.AddArg(tuple)
   38801 		return true
   38802 	}
   38803 	// match: (Select1 (AddTupleFirst64 _ tuple))
   38804 	// cond:
   38805 	// result: (Select1 tuple)
   38806 	for {
   38807 		v_0 := v.Args[0]
   38808 		if v_0.Op != OpS390XAddTupleFirst64 {
   38809 			break
   38810 		}
   38811 		_ = v_0.Args[1]
   38812 		tuple := v_0.Args[1]
   38813 		v.reset(OpSelect1)
   38814 		v.AddArg(tuple)
   38815 		return true
   38816 	}
   38817 	return false
   38818 }
   38819 func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool {
   38820 	// match: (SignExt16to32 x)
   38821 	// cond:
   38822 	// result: (MOVHreg x)
   38823 	for {
   38824 		x := v.Args[0]
   38825 		v.reset(OpS390XMOVHreg)
   38826 		v.AddArg(x)
   38827 		return true
   38828 	}
   38829 }
   38830 func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool {
   38831 	// match: (SignExt16to64 x)
   38832 	// cond:
   38833 	// result: (MOVHreg x)
   38834 	for {
   38835 		x := v.Args[0]
   38836 		v.reset(OpS390XMOVHreg)
   38837 		v.AddArg(x)
   38838 		return true
   38839 	}
   38840 }
   38841 func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool {
   38842 	// match: (SignExt32to64 x)
   38843 	// cond:
   38844 	// result: (MOVWreg x)
   38845 	for {
   38846 		x := v.Args[0]
   38847 		v.reset(OpS390XMOVWreg)
   38848 		v.AddArg(x)
   38849 		return true
   38850 	}
   38851 }
   38852 func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool {
   38853 	// match: (SignExt8to16 x)
   38854 	// cond:
   38855 	// result: (MOVBreg x)
   38856 	for {
   38857 		x := v.Args[0]
   38858 		v.reset(OpS390XMOVBreg)
   38859 		v.AddArg(x)
   38860 		return true
   38861 	}
   38862 }
   38863 func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool {
   38864 	// match: (SignExt8to32 x)
   38865 	// cond:
   38866 	// result: (MOVBreg x)
   38867 	for {
   38868 		x := v.Args[0]
   38869 		v.reset(OpS390XMOVBreg)
   38870 		v.AddArg(x)
   38871 		return true
   38872 	}
   38873 }
   38874 func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool {
   38875 	// match: (SignExt8to64 x)
   38876 	// cond:
   38877 	// result: (MOVBreg x)
   38878 	for {
   38879 		x := v.Args[0]
   38880 		v.reset(OpS390XMOVBreg)
   38881 		v.AddArg(x)
   38882 		return true
   38883 	}
   38884 }
   38885 func rewriteValueS390X_OpSlicemask_0(v *Value) bool {
   38886 	b := v.Block
   38887 	_ = b
   38888 	// match: (Slicemask <t> x)
   38889 	// cond:
   38890 	// result: (SRADconst (NEG <t> x) [63])
   38891 	for {
   38892 		t := v.Type
   38893 		x := v.Args[0]
   38894 		v.reset(OpS390XSRADconst)
   38895 		v.AuxInt = 63
   38896 		v0 := b.NewValue0(v.Pos, OpS390XNEG, t)
   38897 		v0.AddArg(x)
   38898 		v.AddArg(v0)
   38899 		return true
   38900 	}
   38901 }
   38902 func rewriteValueS390X_OpSqrt_0(v *Value) bool {
   38903 	// match: (Sqrt x)
   38904 	// cond:
   38905 	// result: (FSQRT x)
   38906 	for {
   38907 		x := v.Args[0]
   38908 		v.reset(OpS390XFSQRT)
   38909 		v.AddArg(x)
   38910 		return true
   38911 	}
   38912 }
   38913 func rewriteValueS390X_OpStaticCall_0(v *Value) bool {
   38914 	// match: (StaticCall [argwid] {target} mem)
   38915 	// cond:
   38916 	// result: (CALLstatic [argwid] {target} mem)
   38917 	for {
   38918 		argwid := v.AuxInt
   38919 		target := v.Aux
   38920 		mem := v.Args[0]
   38921 		v.reset(OpS390XCALLstatic)
   38922 		v.AuxInt = argwid
   38923 		v.Aux = target
   38924 		v.AddArg(mem)
   38925 		return true
   38926 	}
   38927 }
   38928 func rewriteValueS390X_OpStore_0(v *Value) bool {
   38929 	// match: (Store {t} ptr val mem)
   38930 	// cond: t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)
   38931 	// result: (FMOVDstore ptr val mem)
   38932 	for {
   38933 		t := v.Aux
   38934 		_ = v.Args[2]
   38935 		ptr := v.Args[0]
   38936 		val := v.Args[1]
   38937 		mem := v.Args[2]
   38938 		if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) {
   38939 			break
   38940 		}
   38941 		v.reset(OpS390XFMOVDstore)
   38942 		v.AddArg(ptr)
   38943 		v.AddArg(val)
   38944 		v.AddArg(mem)
   38945 		return true
   38946 	}
   38947 	// match: (Store {t} ptr val mem)
   38948 	// cond: t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)
   38949 	// result: (FMOVSstore ptr val mem)
   38950 	for {
   38951 		t := v.Aux
   38952 		_ = v.Args[2]
   38953 		ptr := v.Args[0]
   38954 		val := v.Args[1]
   38955 		mem := v.Args[2]
   38956 		if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) {
   38957 			break
   38958 		}
   38959 		v.reset(OpS390XFMOVSstore)
   38960 		v.AddArg(ptr)
   38961 		v.AddArg(val)
   38962 		v.AddArg(mem)
   38963 		return true
   38964 	}
   38965 	// match: (Store {t} ptr val mem)
   38966 	// cond: t.(*types.Type).Size() == 8
   38967 	// result: (MOVDstore ptr val mem)
   38968 	for {
   38969 		t := v.Aux
   38970 		_ = v.Args[2]
   38971 		ptr := v.Args[0]
   38972 		val := v.Args[1]
   38973 		mem := v.Args[2]
   38974 		if !(t.(*types.Type).Size() == 8) {
   38975 			break
   38976 		}
   38977 		v.reset(OpS390XMOVDstore)
   38978 		v.AddArg(ptr)
   38979 		v.AddArg(val)
   38980 		v.AddArg(mem)
   38981 		return true
   38982 	}
   38983 	// match: (Store {t} ptr val mem)
   38984 	// cond: t.(*types.Type).Size() == 4
   38985 	// result: (MOVWstore ptr val mem)
   38986 	for {
   38987 		t := v.Aux
   38988 		_ = v.Args[2]
   38989 		ptr := v.Args[0]
   38990 		val := v.Args[1]
   38991 		mem := v.Args[2]
   38992 		if !(t.(*types.Type).Size() == 4) {
   38993 			break
   38994 		}
   38995 		v.reset(OpS390XMOVWstore)
   38996 		v.AddArg(ptr)
   38997 		v.AddArg(val)
   38998 		v.AddArg(mem)
   38999 		return true
   39000 	}
   39001 	// match: (Store {t} ptr val mem)
   39002 	// cond: t.(*types.Type).Size() == 2
   39003 	// result: (MOVHstore ptr val mem)
   39004 	for {
   39005 		t := v.Aux
   39006 		_ = v.Args[2]
   39007 		ptr := v.Args[0]
   39008 		val := v.Args[1]
   39009 		mem := v.Args[2]
   39010 		if !(t.(*types.Type).Size() == 2) {
   39011 			break
   39012 		}
   39013 		v.reset(OpS390XMOVHstore)
   39014 		v.AddArg(ptr)
   39015 		v.AddArg(val)
   39016 		v.AddArg(mem)
   39017 		return true
   39018 	}
   39019 	// match: (Store {t} ptr val mem)
   39020 	// cond: t.(*types.Type).Size() == 1
   39021 	// result: (MOVBstore ptr val mem)
   39022 	for {
   39023 		t := v.Aux
   39024 		_ = v.Args[2]
   39025 		ptr := v.Args[0]
   39026 		val := v.Args[1]
   39027 		mem := v.Args[2]
   39028 		if !(t.(*types.Type).Size() == 1) {
   39029 			break
   39030 		}
   39031 		v.reset(OpS390XMOVBstore)
   39032 		v.AddArg(ptr)
   39033 		v.AddArg(val)
   39034 		v.AddArg(mem)
   39035 		return true
   39036 	}
   39037 	return false
   39038 }
   39039 func rewriteValueS390X_OpSub16_0(v *Value) bool {
   39040 	// match: (Sub16 x y)
   39041 	// cond:
   39042 	// result: (SUBW  x y)
   39043 	for {
   39044 		_ = v.Args[1]
   39045 		x := v.Args[0]
   39046 		y := v.Args[1]
   39047 		v.reset(OpS390XSUBW)
   39048 		v.AddArg(x)
   39049 		v.AddArg(y)
   39050 		return true
   39051 	}
   39052 }
   39053 func rewriteValueS390X_OpSub32_0(v *Value) bool {
   39054 	// match: (Sub32 x y)
   39055 	// cond:
   39056 	// result: (SUBW  x y)
   39057 	for {
   39058 		_ = v.Args[1]
   39059 		x := v.Args[0]
   39060 		y := v.Args[1]
   39061 		v.reset(OpS390XSUBW)
   39062 		v.AddArg(x)
   39063 		v.AddArg(y)
   39064 		return true
   39065 	}
   39066 }
   39067 func rewriteValueS390X_OpSub32F_0(v *Value) bool {
   39068 	// match: (Sub32F x y)
   39069 	// cond:
   39070 	// result: (FSUBS x y)
   39071 	for {
   39072 		_ = v.Args[1]
   39073 		x := v.Args[0]
   39074 		y := v.Args[1]
   39075 		v.reset(OpS390XFSUBS)
   39076 		v.AddArg(x)
   39077 		v.AddArg(y)
   39078 		return true
   39079 	}
   39080 }
   39081 func rewriteValueS390X_OpSub64_0(v *Value) bool {
   39082 	// match: (Sub64 x y)
   39083 	// cond:
   39084 	// result: (SUB  x y)
   39085 	for {
   39086 		_ = v.Args[1]
   39087 		x := v.Args[0]
   39088 		y := v.Args[1]
   39089 		v.reset(OpS390XSUB)
   39090 		v.AddArg(x)
   39091 		v.AddArg(y)
   39092 		return true
   39093 	}
   39094 }
   39095 func rewriteValueS390X_OpSub64F_0(v *Value) bool {
   39096 	// match: (Sub64F x y)
   39097 	// cond:
   39098 	// result: (FSUB x y)
   39099 	for {
   39100 		_ = v.Args[1]
   39101 		x := v.Args[0]
   39102 		y := v.Args[1]
   39103 		v.reset(OpS390XFSUB)
   39104 		v.AddArg(x)
   39105 		v.AddArg(y)
   39106 		return true
   39107 	}
   39108 }
   39109 func rewriteValueS390X_OpSub8_0(v *Value) bool {
   39110 	// match: (Sub8 x y)
   39111 	// cond:
   39112 	// result: (SUBW  x y)
   39113 	for {
   39114 		_ = v.Args[1]
   39115 		x := v.Args[0]
   39116 		y := v.Args[1]
   39117 		v.reset(OpS390XSUBW)
   39118 		v.AddArg(x)
   39119 		v.AddArg(y)
   39120 		return true
   39121 	}
   39122 }
   39123 func rewriteValueS390X_OpSubPtr_0(v *Value) bool {
   39124 	// match: (SubPtr x y)
   39125 	// cond:
   39126 	// result: (SUB  x y)
   39127 	for {
   39128 		_ = v.Args[1]
   39129 		x := v.Args[0]
   39130 		y := v.Args[1]
   39131 		v.reset(OpS390XSUB)
   39132 		v.AddArg(x)
   39133 		v.AddArg(y)
   39134 		return true
   39135 	}
   39136 }
   39137 func rewriteValueS390X_OpTrunc_0(v *Value) bool {
   39138 	// match: (Trunc x)
   39139 	// cond:
   39140 	// result: (FIDBR [5] x)
   39141 	for {
   39142 		x := v.Args[0]
   39143 		v.reset(OpS390XFIDBR)
   39144 		v.AuxInt = 5
   39145 		v.AddArg(x)
   39146 		return true
   39147 	}
   39148 }
   39149 func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool {
   39150 	// match: (Trunc16to8 x)
   39151 	// cond:
   39152 	// result: x
   39153 	for {
   39154 		x := v.Args[0]
   39155 		v.reset(OpCopy)
   39156 		v.Type = x.Type
   39157 		v.AddArg(x)
   39158 		return true
   39159 	}
   39160 }
   39161 func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool {
   39162 	// match: (Trunc32to16 x)
   39163 	// cond:
   39164 	// result: x
   39165 	for {
   39166 		x := v.Args[0]
   39167 		v.reset(OpCopy)
   39168 		v.Type = x.Type
   39169 		v.AddArg(x)
   39170 		return true
   39171 	}
   39172 }
   39173 func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool {
   39174 	// match: (Trunc32to8 x)
   39175 	// cond:
   39176 	// result: x
   39177 	for {
   39178 		x := v.Args[0]
   39179 		v.reset(OpCopy)
   39180 		v.Type = x.Type
   39181 		v.AddArg(x)
   39182 		return true
   39183 	}
   39184 }
   39185 func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool {
   39186 	// match: (Trunc64to16 x)
   39187 	// cond:
   39188 	// result: x
   39189 	for {
   39190 		x := v.Args[0]
   39191 		v.reset(OpCopy)
   39192 		v.Type = x.Type
   39193 		v.AddArg(x)
   39194 		return true
   39195 	}
   39196 }
   39197 func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool {
   39198 	// match: (Trunc64to32 x)
   39199 	// cond:
   39200 	// result: x
   39201 	for {
   39202 		x := v.Args[0]
   39203 		v.reset(OpCopy)
   39204 		v.Type = x.Type
   39205 		v.AddArg(x)
   39206 		return true
   39207 	}
   39208 }
   39209 func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool {
   39210 	// match: (Trunc64to8 x)
   39211 	// cond:
   39212 	// result: x
   39213 	for {
   39214 		x := v.Args[0]
   39215 		v.reset(OpCopy)
   39216 		v.Type = x.Type
   39217 		v.AddArg(x)
   39218 		return true
   39219 	}
   39220 }
   39221 func rewriteValueS390X_OpXor16_0(v *Value) bool {
   39222 	// match: (Xor16 x y)
   39223 	// cond:
   39224 	// result: (XORW x y)
   39225 	for {
   39226 		_ = v.Args[1]
   39227 		x := v.Args[0]
   39228 		y := v.Args[1]
   39229 		v.reset(OpS390XXORW)
   39230 		v.AddArg(x)
   39231 		v.AddArg(y)
   39232 		return true
   39233 	}
   39234 }
   39235 func rewriteValueS390X_OpXor32_0(v *Value) bool {
   39236 	// match: (Xor32 x y)
   39237 	// cond:
   39238 	// result: (XORW x y)
   39239 	for {
   39240 		_ = v.Args[1]
   39241 		x := v.Args[0]
   39242 		y := v.Args[1]
   39243 		v.reset(OpS390XXORW)
   39244 		v.AddArg(x)
   39245 		v.AddArg(y)
   39246 		return true
   39247 	}
   39248 }
   39249 func rewriteValueS390X_OpXor64_0(v *Value) bool {
   39250 	// match: (Xor64 x y)
   39251 	// cond:
   39252 	// result: (XOR x y)
   39253 	for {
   39254 		_ = v.Args[1]
   39255 		x := v.Args[0]
   39256 		y := v.Args[1]
   39257 		v.reset(OpS390XXOR)
   39258 		v.AddArg(x)
   39259 		v.AddArg(y)
   39260 		return true
   39261 	}
   39262 }
   39263 func rewriteValueS390X_OpXor8_0(v *Value) bool {
   39264 	// match: (Xor8 x y)
   39265 	// cond:
   39266 	// result: (XORW x y)
   39267 	for {
   39268 		_ = v.Args[1]
   39269 		x := v.Args[0]
   39270 		y := v.Args[1]
   39271 		v.reset(OpS390XXORW)
   39272 		v.AddArg(x)
   39273 		v.AddArg(y)
   39274 		return true
   39275 	}
   39276 }
   39277 func rewriteValueS390X_OpZero_0(v *Value) bool {
   39278 	b := v.Block
   39279 	_ = b
   39280 	// match: (Zero [0] _ mem)
   39281 	// cond:
   39282 	// result: mem
   39283 	for {
   39284 		if v.AuxInt != 0 {
   39285 			break
   39286 		}
   39287 		_ = v.Args[1]
   39288 		mem := v.Args[1]
   39289 		v.reset(OpCopy)
   39290 		v.Type = mem.Type
   39291 		v.AddArg(mem)
   39292 		return true
   39293 	}
   39294 	// match: (Zero [1] destptr mem)
   39295 	// cond:
   39296 	// result: (MOVBstoreconst [0] destptr mem)
   39297 	for {
   39298 		if v.AuxInt != 1 {
   39299 			break
   39300 		}
   39301 		_ = v.Args[1]
   39302 		destptr := v.Args[0]
   39303 		mem := v.Args[1]
   39304 		v.reset(OpS390XMOVBstoreconst)
   39305 		v.AuxInt = 0
   39306 		v.AddArg(destptr)
   39307 		v.AddArg(mem)
   39308 		return true
   39309 	}
   39310 	// match: (Zero [2] destptr mem)
   39311 	// cond:
   39312 	// result: (MOVHstoreconst [0] destptr mem)
   39313 	for {
   39314 		if v.AuxInt != 2 {
   39315 			break
   39316 		}
   39317 		_ = v.Args[1]
   39318 		destptr := v.Args[0]
   39319 		mem := v.Args[1]
   39320 		v.reset(OpS390XMOVHstoreconst)
   39321 		v.AuxInt = 0
   39322 		v.AddArg(destptr)
   39323 		v.AddArg(mem)
   39324 		return true
   39325 	}
   39326 	// match: (Zero [4] destptr mem)
   39327 	// cond:
   39328 	// result: (MOVWstoreconst [0] destptr mem)
   39329 	for {
   39330 		if v.AuxInt != 4 {
   39331 			break
   39332 		}
   39333 		_ = v.Args[1]
   39334 		destptr := v.Args[0]
   39335 		mem := v.Args[1]
   39336 		v.reset(OpS390XMOVWstoreconst)
   39337 		v.AuxInt = 0
   39338 		v.AddArg(destptr)
   39339 		v.AddArg(mem)
   39340 		return true
   39341 	}
   39342 	// match: (Zero [8] destptr mem)
   39343 	// cond:
   39344 	// result: (MOVDstoreconst [0] destptr mem)
   39345 	for {
   39346 		if v.AuxInt != 8 {
   39347 			break
   39348 		}
   39349 		_ = v.Args[1]
   39350 		destptr := v.Args[0]
   39351 		mem := v.Args[1]
   39352 		v.reset(OpS390XMOVDstoreconst)
   39353 		v.AuxInt = 0
   39354 		v.AddArg(destptr)
   39355 		v.AddArg(mem)
   39356 		return true
   39357 	}
   39358 	// match: (Zero [3] destptr mem)
   39359 	// cond:
   39360 	// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr 		(MOVHstoreconst [0] destptr mem))
   39361 	for {
   39362 		if v.AuxInt != 3 {
   39363 			break
   39364 		}
   39365 		_ = v.Args[1]
   39366 		destptr := v.Args[0]
   39367 		mem := v.Args[1]
   39368 		v.reset(OpS390XMOVBstoreconst)
   39369 		v.AuxInt = makeValAndOff(0, 2)
   39370 		v.AddArg(destptr)
   39371 		v0 := b.NewValue0(v.Pos, OpS390XMOVHstoreconst, types.TypeMem)
   39372 		v0.AuxInt = 0
   39373 		v0.AddArg(destptr)
   39374 		v0.AddArg(mem)
   39375 		v.AddArg(v0)
   39376 		return true
   39377 	}
   39378 	// match: (Zero [5] destptr mem)
   39379 	// cond:
   39380 	// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr 		(MOVWstoreconst [0] destptr mem))
   39381 	for {
   39382 		if v.AuxInt != 5 {
   39383 			break
   39384 		}
   39385 		_ = v.Args[1]
   39386 		destptr := v.Args[0]
   39387 		mem := v.Args[1]
   39388 		v.reset(OpS390XMOVBstoreconst)
   39389 		v.AuxInt = makeValAndOff(0, 4)
   39390 		v.AddArg(destptr)
   39391 		v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
   39392 		v0.AuxInt = 0
   39393 		v0.AddArg(destptr)
   39394 		v0.AddArg(mem)
   39395 		v.AddArg(v0)
   39396 		return true
   39397 	}
   39398 	// match: (Zero [6] destptr mem)
   39399 	// cond:
   39400 	// result: (MOVHstoreconst [makeValAndOff(0,4)] destptr 		(MOVWstoreconst [0] destptr mem))
   39401 	for {
   39402 		if v.AuxInt != 6 {
   39403 			break
   39404 		}
   39405 		_ = v.Args[1]
   39406 		destptr := v.Args[0]
   39407 		mem := v.Args[1]
   39408 		v.reset(OpS390XMOVHstoreconst)
   39409 		v.AuxInt = makeValAndOff(0, 4)
   39410 		v.AddArg(destptr)
   39411 		v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
   39412 		v0.AuxInt = 0
   39413 		v0.AddArg(destptr)
   39414 		v0.AddArg(mem)
   39415 		v.AddArg(v0)
   39416 		return true
   39417 	}
   39418 	// match: (Zero [7] destptr mem)
   39419 	// cond:
   39420 	// result: (MOVWstoreconst [makeValAndOff(0,3)] destptr 		(MOVWstoreconst [0] destptr mem))
   39421 	for {
   39422 		if v.AuxInt != 7 {
   39423 			break
   39424 		}
   39425 		_ = v.Args[1]
   39426 		destptr := v.Args[0]
   39427 		mem := v.Args[1]
   39428 		v.reset(OpS390XMOVWstoreconst)
   39429 		v.AuxInt = makeValAndOff(0, 3)
   39430 		v.AddArg(destptr)
   39431 		v0 := b.NewValue0(v.Pos, OpS390XMOVWstoreconst, types.TypeMem)
   39432 		v0.AuxInt = 0
   39433 		v0.AddArg(destptr)
   39434 		v0.AddArg(mem)
   39435 		v.AddArg(v0)
   39436 		return true
   39437 	}
   39438 	// match: (Zero [s] destptr mem)
   39439 	// cond: s > 0 && s <= 1024
   39440 	// result: (CLEAR [makeValAndOff(s, 0)] destptr mem)
   39441 	for {
   39442 		s := v.AuxInt
   39443 		_ = v.Args[1]
   39444 		destptr := v.Args[0]
   39445 		mem := v.Args[1]
   39446 		if !(s > 0 && s <= 1024) {
   39447 			break
   39448 		}
   39449 		v.reset(OpS390XCLEAR)
   39450 		v.AuxInt = makeValAndOff(s, 0)
   39451 		v.AddArg(destptr)
   39452 		v.AddArg(mem)
   39453 		return true
   39454 	}
   39455 	return false
   39456 }
   39457 func rewriteValueS390X_OpZero_10(v *Value) bool {
   39458 	b := v.Block
   39459 	_ = b
   39460 	// match: (Zero [s] destptr mem)
   39461 	// cond: s > 1024
   39462 	// result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
   39463 	for {
   39464 		s := v.AuxInt
   39465 		_ = v.Args[1]
   39466 		destptr := v.Args[0]
   39467 		mem := v.Args[1]
   39468 		if !(s > 1024) {
   39469 			break
   39470 		}
   39471 		v.reset(OpS390XLoweredZero)
   39472 		v.AuxInt = s % 256
   39473 		v.AddArg(destptr)
   39474 		v0 := b.NewValue0(v.Pos, OpS390XADDconst, destptr.Type)
   39475 		v0.AuxInt = (s / 256) * 256
   39476 		v0.AddArg(destptr)
   39477 		v.AddArg(v0)
   39478 		v.AddArg(mem)
   39479 		return true
   39480 	}
   39481 	return false
   39482 }
   39483 func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool {
   39484 	// match: (ZeroExt16to32 x)
   39485 	// cond:
   39486 	// result: (MOVHZreg x)
   39487 	for {
   39488 		x := v.Args[0]
   39489 		v.reset(OpS390XMOVHZreg)
   39490 		v.AddArg(x)
   39491 		return true
   39492 	}
   39493 }
   39494 func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool {
   39495 	// match: (ZeroExt16to64 x)
   39496 	// cond:
   39497 	// result: (MOVHZreg x)
   39498 	for {
   39499 		x := v.Args[0]
   39500 		v.reset(OpS390XMOVHZreg)
   39501 		v.AddArg(x)
   39502 		return true
   39503 	}
   39504 }
   39505 func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool {
   39506 	// match: (ZeroExt32to64 x)
   39507 	// cond:
   39508 	// result: (MOVWZreg x)
   39509 	for {
   39510 		x := v.Args[0]
   39511 		v.reset(OpS390XMOVWZreg)
   39512 		v.AddArg(x)
   39513 		return true
   39514 	}
   39515 }
   39516 func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool {
   39517 	// match: (ZeroExt8to16 x)
   39518 	// cond:
   39519 	// result: (MOVBZreg x)
   39520 	for {
   39521 		x := v.Args[0]
   39522 		v.reset(OpS390XMOVBZreg)
   39523 		v.AddArg(x)
   39524 		return true
   39525 	}
   39526 }
   39527 func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool {
   39528 	// match: (ZeroExt8to32 x)
   39529 	// cond:
   39530 	// result: (MOVBZreg x)
   39531 	for {
   39532 		x := v.Args[0]
   39533 		v.reset(OpS390XMOVBZreg)
   39534 		v.AddArg(x)
   39535 		return true
   39536 	}
   39537 }
   39538 func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool {
   39539 	// match: (ZeroExt8to64 x)
   39540 	// cond:
   39541 	// result: (MOVBZreg x)
   39542 	for {
   39543 		x := v.Args[0]
   39544 		v.reset(OpS390XMOVBZreg)
   39545 		v.AddArg(x)
   39546 		return true
   39547 	}
   39548 }
   39549 func rewriteBlockS390X(b *Block) bool {
   39550 	config := b.Func.Config
   39551 	_ = config
   39552 	fe := b.Func.fe
   39553 	_ = fe
   39554 	typ := &config.Types
   39555 	_ = typ
   39556 	switch b.Kind {
   39557 	case BlockS390XEQ:
   39558 		// match: (EQ (InvertFlags cmp) yes no)
   39559 		// cond:
   39560 		// result: (EQ cmp yes no)
   39561 		for {
   39562 			v := b.Control
   39563 			if v.Op != OpS390XInvertFlags {
   39564 				break
   39565 			}
   39566 			cmp := v.Args[0]
   39567 			b.Kind = BlockS390XEQ
   39568 			b.SetControl(cmp)
   39569 			b.Aux = nil
   39570 			return true
   39571 		}
   39572 		// match: (EQ (FlagEQ) yes no)
   39573 		// cond:
   39574 		// result: (First nil yes no)
   39575 		for {
   39576 			v := b.Control
   39577 			if v.Op != OpS390XFlagEQ {
   39578 				break
   39579 			}
   39580 			b.Kind = BlockFirst
   39581 			b.SetControl(nil)
   39582 			b.Aux = nil
   39583 			return true
   39584 		}
   39585 		// match: (EQ (FlagLT) yes no)
   39586 		// cond:
   39587 		// result: (First nil no yes)
   39588 		for {
   39589 			v := b.Control
   39590 			if v.Op != OpS390XFlagLT {
   39591 				break
   39592 			}
   39593 			b.Kind = BlockFirst
   39594 			b.SetControl(nil)
   39595 			b.Aux = nil
   39596 			b.swapSuccessors()
   39597 			return true
   39598 		}
   39599 		// match: (EQ (FlagGT) yes no)
   39600 		// cond:
   39601 		// result: (First nil no yes)
   39602 		for {
   39603 			v := b.Control
   39604 			if v.Op != OpS390XFlagGT {
   39605 				break
   39606 			}
   39607 			b.Kind = BlockFirst
   39608 			b.SetControl(nil)
   39609 			b.Aux = nil
   39610 			b.swapSuccessors()
   39611 			return true
   39612 		}
   39613 	case BlockS390XGE:
   39614 		// match: (GE (InvertFlags cmp) yes no)
   39615 		// cond:
   39616 		// result: (LE cmp yes no)
   39617 		for {
   39618 			v := b.Control
   39619 			if v.Op != OpS390XInvertFlags {
   39620 				break
   39621 			}
   39622 			cmp := v.Args[0]
   39623 			b.Kind = BlockS390XLE
   39624 			b.SetControl(cmp)
   39625 			b.Aux = nil
   39626 			return true
   39627 		}
   39628 		// match: (GE (FlagEQ) yes no)
   39629 		// cond:
   39630 		// result: (First nil yes no)
   39631 		for {
   39632 			v := b.Control
   39633 			if v.Op != OpS390XFlagEQ {
   39634 				break
   39635 			}
   39636 			b.Kind = BlockFirst
   39637 			b.SetControl(nil)
   39638 			b.Aux = nil
   39639 			return true
   39640 		}
   39641 		// match: (GE (FlagLT) yes no)
   39642 		// cond:
   39643 		// result: (First nil no yes)
   39644 		for {
   39645 			v := b.Control
   39646 			if v.Op != OpS390XFlagLT {
   39647 				break
   39648 			}
   39649 			b.Kind = BlockFirst
   39650 			b.SetControl(nil)
   39651 			b.Aux = nil
   39652 			b.swapSuccessors()
   39653 			return true
   39654 		}
   39655 		// match: (GE (FlagGT) yes no)
   39656 		// cond:
   39657 		// result: (First nil yes no)
   39658 		for {
   39659 			v := b.Control
   39660 			if v.Op != OpS390XFlagGT {
   39661 				break
   39662 			}
   39663 			b.Kind = BlockFirst
   39664 			b.SetControl(nil)
   39665 			b.Aux = nil
   39666 			return true
   39667 		}
   39668 	case BlockS390XGT:
   39669 		// match: (GT (InvertFlags cmp) yes no)
   39670 		// cond:
   39671 		// result: (LT cmp yes no)
   39672 		for {
   39673 			v := b.Control
   39674 			if v.Op != OpS390XInvertFlags {
   39675 				break
   39676 			}
   39677 			cmp := v.Args[0]
   39678 			b.Kind = BlockS390XLT
   39679 			b.SetControl(cmp)
   39680 			b.Aux = nil
   39681 			return true
   39682 		}
   39683 		// match: (GT (FlagEQ) yes no)
   39684 		// cond:
   39685 		// result: (First nil no yes)
   39686 		for {
   39687 			v := b.Control
   39688 			if v.Op != OpS390XFlagEQ {
   39689 				break
   39690 			}
   39691 			b.Kind = BlockFirst
   39692 			b.SetControl(nil)
   39693 			b.Aux = nil
   39694 			b.swapSuccessors()
   39695 			return true
   39696 		}
   39697 		// match: (GT (FlagLT) yes no)
   39698 		// cond:
   39699 		// result: (First nil no yes)
   39700 		for {
   39701 			v := b.Control
   39702 			if v.Op != OpS390XFlagLT {
   39703 				break
   39704 			}
   39705 			b.Kind = BlockFirst
   39706 			b.SetControl(nil)
   39707 			b.Aux = nil
   39708 			b.swapSuccessors()
   39709 			return true
   39710 		}
   39711 		// match: (GT (FlagGT) yes no)
   39712 		// cond:
   39713 		// result: (First nil yes no)
   39714 		for {
   39715 			v := b.Control
   39716 			if v.Op != OpS390XFlagGT {
   39717 				break
   39718 			}
   39719 			b.Kind = BlockFirst
   39720 			b.SetControl(nil)
   39721 			b.Aux = nil
   39722 			return true
   39723 		}
   39724 	case BlockIf:
   39725 		// match: (If (MOVDLT (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39726 		// cond:
   39727 		// result: (LT cmp yes no)
   39728 		for {
   39729 			v := b.Control
   39730 			if v.Op != OpS390XMOVDLT {
   39731 				break
   39732 			}
   39733 			_ = v.Args[2]
   39734 			v_0 := v.Args[0]
   39735 			if v_0.Op != OpS390XMOVDconst {
   39736 				break
   39737 			}
   39738 			if v_0.AuxInt != 0 {
   39739 				break
   39740 			}
   39741 			v_1 := v.Args[1]
   39742 			if v_1.Op != OpS390XMOVDconst {
   39743 				break
   39744 			}
   39745 			if v_1.AuxInt != 1 {
   39746 				break
   39747 			}
   39748 			cmp := v.Args[2]
   39749 			b.Kind = BlockS390XLT
   39750 			b.SetControl(cmp)
   39751 			b.Aux = nil
   39752 			return true
   39753 		}
   39754 		// match: (If (MOVDLE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39755 		// cond:
   39756 		// result: (LE cmp yes no)
   39757 		for {
   39758 			v := b.Control
   39759 			if v.Op != OpS390XMOVDLE {
   39760 				break
   39761 			}
   39762 			_ = v.Args[2]
   39763 			v_0 := v.Args[0]
   39764 			if v_0.Op != OpS390XMOVDconst {
   39765 				break
   39766 			}
   39767 			if v_0.AuxInt != 0 {
   39768 				break
   39769 			}
   39770 			v_1 := v.Args[1]
   39771 			if v_1.Op != OpS390XMOVDconst {
   39772 				break
   39773 			}
   39774 			if v_1.AuxInt != 1 {
   39775 				break
   39776 			}
   39777 			cmp := v.Args[2]
   39778 			b.Kind = BlockS390XLE
   39779 			b.SetControl(cmp)
   39780 			b.Aux = nil
   39781 			return true
   39782 		}
   39783 		// match: (If (MOVDGT (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39784 		// cond:
   39785 		// result: (GT cmp yes no)
   39786 		for {
   39787 			v := b.Control
   39788 			if v.Op != OpS390XMOVDGT {
   39789 				break
   39790 			}
   39791 			_ = v.Args[2]
   39792 			v_0 := v.Args[0]
   39793 			if v_0.Op != OpS390XMOVDconst {
   39794 				break
   39795 			}
   39796 			if v_0.AuxInt != 0 {
   39797 				break
   39798 			}
   39799 			v_1 := v.Args[1]
   39800 			if v_1.Op != OpS390XMOVDconst {
   39801 				break
   39802 			}
   39803 			if v_1.AuxInt != 1 {
   39804 				break
   39805 			}
   39806 			cmp := v.Args[2]
   39807 			b.Kind = BlockS390XGT
   39808 			b.SetControl(cmp)
   39809 			b.Aux = nil
   39810 			return true
   39811 		}
   39812 		// match: (If (MOVDGE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39813 		// cond:
   39814 		// result: (GE cmp yes no)
   39815 		for {
   39816 			v := b.Control
   39817 			if v.Op != OpS390XMOVDGE {
   39818 				break
   39819 			}
   39820 			_ = v.Args[2]
   39821 			v_0 := v.Args[0]
   39822 			if v_0.Op != OpS390XMOVDconst {
   39823 				break
   39824 			}
   39825 			if v_0.AuxInt != 0 {
   39826 				break
   39827 			}
   39828 			v_1 := v.Args[1]
   39829 			if v_1.Op != OpS390XMOVDconst {
   39830 				break
   39831 			}
   39832 			if v_1.AuxInt != 1 {
   39833 				break
   39834 			}
   39835 			cmp := v.Args[2]
   39836 			b.Kind = BlockS390XGE
   39837 			b.SetControl(cmp)
   39838 			b.Aux = nil
   39839 			return true
   39840 		}
   39841 		// match: (If (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39842 		// cond:
   39843 		// result: (EQ cmp yes no)
   39844 		for {
   39845 			v := b.Control
   39846 			if v.Op != OpS390XMOVDEQ {
   39847 				break
   39848 			}
   39849 			_ = v.Args[2]
   39850 			v_0 := v.Args[0]
   39851 			if v_0.Op != OpS390XMOVDconst {
   39852 				break
   39853 			}
   39854 			if v_0.AuxInt != 0 {
   39855 				break
   39856 			}
   39857 			v_1 := v.Args[1]
   39858 			if v_1.Op != OpS390XMOVDconst {
   39859 				break
   39860 			}
   39861 			if v_1.AuxInt != 1 {
   39862 				break
   39863 			}
   39864 			cmp := v.Args[2]
   39865 			b.Kind = BlockS390XEQ
   39866 			b.SetControl(cmp)
   39867 			b.Aux = nil
   39868 			return true
   39869 		}
   39870 		// match: (If (MOVDNE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39871 		// cond:
   39872 		// result: (NE cmp yes no)
   39873 		for {
   39874 			v := b.Control
   39875 			if v.Op != OpS390XMOVDNE {
   39876 				break
   39877 			}
   39878 			_ = v.Args[2]
   39879 			v_0 := v.Args[0]
   39880 			if v_0.Op != OpS390XMOVDconst {
   39881 				break
   39882 			}
   39883 			if v_0.AuxInt != 0 {
   39884 				break
   39885 			}
   39886 			v_1 := v.Args[1]
   39887 			if v_1.Op != OpS390XMOVDconst {
   39888 				break
   39889 			}
   39890 			if v_1.AuxInt != 1 {
   39891 				break
   39892 			}
   39893 			cmp := v.Args[2]
   39894 			b.Kind = BlockS390XNE
   39895 			b.SetControl(cmp)
   39896 			b.Aux = nil
   39897 			return true
   39898 		}
   39899 		// match: (If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39900 		// cond:
   39901 		// result: (GTF cmp yes no)
   39902 		for {
   39903 			v := b.Control
   39904 			if v.Op != OpS390XMOVDGTnoinv {
   39905 				break
   39906 			}
   39907 			_ = v.Args[2]
   39908 			v_0 := v.Args[0]
   39909 			if v_0.Op != OpS390XMOVDconst {
   39910 				break
   39911 			}
   39912 			if v_0.AuxInt != 0 {
   39913 				break
   39914 			}
   39915 			v_1 := v.Args[1]
   39916 			if v_1.Op != OpS390XMOVDconst {
   39917 				break
   39918 			}
   39919 			if v_1.AuxInt != 1 {
   39920 				break
   39921 			}
   39922 			cmp := v.Args[2]
   39923 			b.Kind = BlockS390XGTF
   39924 			b.SetControl(cmp)
   39925 			b.Aux = nil
   39926 			return true
   39927 		}
   39928 		// match: (If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
   39929 		// cond:
   39930 		// result: (GEF cmp yes no)
   39931 		for {
   39932 			v := b.Control
   39933 			if v.Op != OpS390XMOVDGEnoinv {
   39934 				break
   39935 			}
   39936 			_ = v.Args[2]
   39937 			v_0 := v.Args[0]
   39938 			if v_0.Op != OpS390XMOVDconst {
   39939 				break
   39940 			}
   39941 			if v_0.AuxInt != 0 {
   39942 				break
   39943 			}
   39944 			v_1 := v.Args[1]
   39945 			if v_1.Op != OpS390XMOVDconst {
   39946 				break
   39947 			}
   39948 			if v_1.AuxInt != 1 {
   39949 				break
   39950 			}
   39951 			cmp := v.Args[2]
   39952 			b.Kind = BlockS390XGEF
   39953 			b.SetControl(cmp)
   39954 			b.Aux = nil
   39955 			return true
   39956 		}
   39957 		// match: (If cond yes no)
   39958 		// cond:
   39959 		// result: (NE (CMPWconst [0] (MOVBZreg <typ.Bool> cond)) yes no)
   39960 		for {
   39961 			v := b.Control
   39962 			_ = v
   39963 			cond := b.Control
   39964 			b.Kind = BlockS390XNE
   39965 			v0 := b.NewValue0(v.Pos, OpS390XCMPWconst, types.TypeFlags)
   39966 			v0.AuxInt = 0
   39967 			v1 := b.NewValue0(v.Pos, OpS390XMOVBZreg, typ.Bool)
   39968 			v1.AddArg(cond)
   39969 			v0.AddArg(v1)
   39970 			b.SetControl(v0)
   39971 			b.Aux = nil
   39972 			return true
   39973 		}
   39974 	case BlockS390XLE:
   39975 		// match: (LE (InvertFlags cmp) yes no)
   39976 		// cond:
   39977 		// result: (GE cmp yes no)
   39978 		for {
   39979 			v := b.Control
   39980 			if v.Op != OpS390XInvertFlags {
   39981 				break
   39982 			}
   39983 			cmp := v.Args[0]
   39984 			b.Kind = BlockS390XGE
   39985 			b.SetControl(cmp)
   39986 			b.Aux = nil
   39987 			return true
   39988 		}
   39989 		// match: (LE (FlagEQ) yes no)
   39990 		// cond:
   39991 		// result: (First nil yes no)
   39992 		for {
   39993 			v := b.Control
   39994 			if v.Op != OpS390XFlagEQ {
   39995 				break
   39996 			}
   39997 			b.Kind = BlockFirst
   39998 			b.SetControl(nil)
   39999 			b.Aux = nil
   40000 			return true
   40001 		}
   40002 		// match: (LE (FlagLT) yes no)
   40003 		// cond:
   40004 		// result: (First nil yes no)
   40005 		for {
   40006 			v := b.Control
   40007 			if v.Op != OpS390XFlagLT {
   40008 				break
   40009 			}
   40010 			b.Kind = BlockFirst
   40011 			b.SetControl(nil)
   40012 			b.Aux = nil
   40013 			return true
   40014 		}
   40015 		// match: (LE (FlagGT) yes no)
   40016 		// cond:
   40017 		// result: (First nil no yes)
   40018 		for {
   40019 			v := b.Control
   40020 			if v.Op != OpS390XFlagGT {
   40021 				break
   40022 			}
   40023 			b.Kind = BlockFirst
   40024 			b.SetControl(nil)
   40025 			b.Aux = nil
   40026 			b.swapSuccessors()
   40027 			return true
   40028 		}
   40029 	case BlockS390XLT:
   40030 		// match: (LT (InvertFlags cmp) yes no)
   40031 		// cond:
   40032 		// result: (GT cmp yes no)
   40033 		for {
   40034 			v := b.Control
   40035 			if v.Op != OpS390XInvertFlags {
   40036 				break
   40037 			}
   40038 			cmp := v.Args[0]
   40039 			b.Kind = BlockS390XGT
   40040 			b.SetControl(cmp)
   40041 			b.Aux = nil
   40042 			return true
   40043 		}
   40044 		// match: (LT (FlagEQ) yes no)
   40045 		// cond:
   40046 		// result: (First nil no yes)
   40047 		for {
   40048 			v := b.Control
   40049 			if v.Op != OpS390XFlagEQ {
   40050 				break
   40051 			}
   40052 			b.Kind = BlockFirst
   40053 			b.SetControl(nil)
   40054 			b.Aux = nil
   40055 			b.swapSuccessors()
   40056 			return true
   40057 		}
   40058 		// match: (LT (FlagLT) yes no)
   40059 		// cond:
   40060 		// result: (First nil yes no)
   40061 		for {
   40062 			v := b.Control
   40063 			if v.Op != OpS390XFlagLT {
   40064 				break
   40065 			}
   40066 			b.Kind = BlockFirst
   40067 			b.SetControl(nil)
   40068 			b.Aux = nil
   40069 			return true
   40070 		}
   40071 		// match: (LT (FlagGT) yes no)
   40072 		// cond:
   40073 		// result: (First nil no yes)
   40074 		for {
   40075 			v := b.Control
   40076 			if v.Op != OpS390XFlagGT {
   40077 				break
   40078 			}
   40079 			b.Kind = BlockFirst
   40080 			b.SetControl(nil)
   40081 			b.Aux = nil
   40082 			b.swapSuccessors()
   40083 			return true
   40084 		}
   40085 	case BlockS390XNE:
   40086 		// match: (NE (CMPWconst [0] (MOVDLT (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40087 		// cond:
   40088 		// result: (LT cmp yes no)
   40089 		for {
   40090 			v := b.Control
   40091 			if v.Op != OpS390XCMPWconst {
   40092 				break
   40093 			}
   40094 			if v.AuxInt != 0 {
   40095 				break
   40096 			}
   40097 			v_0 := v.Args[0]
   40098 			if v_0.Op != OpS390XMOVDLT {
   40099 				break
   40100 			}
   40101 			_ = v_0.Args[2]
   40102 			v_0_0 := v_0.Args[0]
   40103 			if v_0_0.Op != OpS390XMOVDconst {
   40104 				break
   40105 			}
   40106 			if v_0_0.AuxInt != 0 {
   40107 				break
   40108 			}
   40109 			v_0_1 := v_0.Args[1]
   40110 			if v_0_1.Op != OpS390XMOVDconst {
   40111 				break
   40112 			}
   40113 			if v_0_1.AuxInt != 1 {
   40114 				break
   40115 			}
   40116 			cmp := v_0.Args[2]
   40117 			b.Kind = BlockS390XLT
   40118 			b.SetControl(cmp)
   40119 			b.Aux = nil
   40120 			return true
   40121 		}
   40122 		// match: (NE (CMPWconst [0] (MOVDLE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40123 		// cond:
   40124 		// result: (LE cmp yes no)
   40125 		for {
   40126 			v := b.Control
   40127 			if v.Op != OpS390XCMPWconst {
   40128 				break
   40129 			}
   40130 			if v.AuxInt != 0 {
   40131 				break
   40132 			}
   40133 			v_0 := v.Args[0]
   40134 			if v_0.Op != OpS390XMOVDLE {
   40135 				break
   40136 			}
   40137 			_ = v_0.Args[2]
   40138 			v_0_0 := v_0.Args[0]
   40139 			if v_0_0.Op != OpS390XMOVDconst {
   40140 				break
   40141 			}
   40142 			if v_0_0.AuxInt != 0 {
   40143 				break
   40144 			}
   40145 			v_0_1 := v_0.Args[1]
   40146 			if v_0_1.Op != OpS390XMOVDconst {
   40147 				break
   40148 			}
   40149 			if v_0_1.AuxInt != 1 {
   40150 				break
   40151 			}
   40152 			cmp := v_0.Args[2]
   40153 			b.Kind = BlockS390XLE
   40154 			b.SetControl(cmp)
   40155 			b.Aux = nil
   40156 			return true
   40157 		}
   40158 		// match: (NE (CMPWconst [0] (MOVDGT (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40159 		// cond:
   40160 		// result: (GT cmp yes no)
   40161 		for {
   40162 			v := b.Control
   40163 			if v.Op != OpS390XCMPWconst {
   40164 				break
   40165 			}
   40166 			if v.AuxInt != 0 {
   40167 				break
   40168 			}
   40169 			v_0 := v.Args[0]
   40170 			if v_0.Op != OpS390XMOVDGT {
   40171 				break
   40172 			}
   40173 			_ = v_0.Args[2]
   40174 			v_0_0 := v_0.Args[0]
   40175 			if v_0_0.Op != OpS390XMOVDconst {
   40176 				break
   40177 			}
   40178 			if v_0_0.AuxInt != 0 {
   40179 				break
   40180 			}
   40181 			v_0_1 := v_0.Args[1]
   40182 			if v_0_1.Op != OpS390XMOVDconst {
   40183 				break
   40184 			}
   40185 			if v_0_1.AuxInt != 1 {
   40186 				break
   40187 			}
   40188 			cmp := v_0.Args[2]
   40189 			b.Kind = BlockS390XGT
   40190 			b.SetControl(cmp)
   40191 			b.Aux = nil
   40192 			return true
   40193 		}
   40194 		// match: (NE (CMPWconst [0] (MOVDGE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40195 		// cond:
   40196 		// result: (GE cmp yes no)
   40197 		for {
   40198 			v := b.Control
   40199 			if v.Op != OpS390XCMPWconst {
   40200 				break
   40201 			}
   40202 			if v.AuxInt != 0 {
   40203 				break
   40204 			}
   40205 			v_0 := v.Args[0]
   40206 			if v_0.Op != OpS390XMOVDGE {
   40207 				break
   40208 			}
   40209 			_ = v_0.Args[2]
   40210 			v_0_0 := v_0.Args[0]
   40211 			if v_0_0.Op != OpS390XMOVDconst {
   40212 				break
   40213 			}
   40214 			if v_0_0.AuxInt != 0 {
   40215 				break
   40216 			}
   40217 			v_0_1 := v_0.Args[1]
   40218 			if v_0_1.Op != OpS390XMOVDconst {
   40219 				break
   40220 			}
   40221 			if v_0_1.AuxInt != 1 {
   40222 				break
   40223 			}
   40224 			cmp := v_0.Args[2]
   40225 			b.Kind = BlockS390XGE
   40226 			b.SetControl(cmp)
   40227 			b.Aux = nil
   40228 			return true
   40229 		}
   40230 		// match: (NE (CMPWconst [0] (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40231 		// cond:
   40232 		// result: (EQ cmp yes no)
   40233 		for {
   40234 			v := b.Control
   40235 			if v.Op != OpS390XCMPWconst {
   40236 				break
   40237 			}
   40238 			if v.AuxInt != 0 {
   40239 				break
   40240 			}
   40241 			v_0 := v.Args[0]
   40242 			if v_0.Op != OpS390XMOVDEQ {
   40243 				break
   40244 			}
   40245 			_ = v_0.Args[2]
   40246 			v_0_0 := v_0.Args[0]
   40247 			if v_0_0.Op != OpS390XMOVDconst {
   40248 				break
   40249 			}
   40250 			if v_0_0.AuxInt != 0 {
   40251 				break
   40252 			}
   40253 			v_0_1 := v_0.Args[1]
   40254 			if v_0_1.Op != OpS390XMOVDconst {
   40255 				break
   40256 			}
   40257 			if v_0_1.AuxInt != 1 {
   40258 				break
   40259 			}
   40260 			cmp := v_0.Args[2]
   40261 			b.Kind = BlockS390XEQ
   40262 			b.SetControl(cmp)
   40263 			b.Aux = nil
   40264 			return true
   40265 		}
   40266 		// match: (NE (CMPWconst [0] (MOVDNE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40267 		// cond:
   40268 		// result: (NE cmp yes no)
   40269 		for {
   40270 			v := b.Control
   40271 			if v.Op != OpS390XCMPWconst {
   40272 				break
   40273 			}
   40274 			if v.AuxInt != 0 {
   40275 				break
   40276 			}
   40277 			v_0 := v.Args[0]
   40278 			if v_0.Op != OpS390XMOVDNE {
   40279 				break
   40280 			}
   40281 			_ = v_0.Args[2]
   40282 			v_0_0 := v_0.Args[0]
   40283 			if v_0_0.Op != OpS390XMOVDconst {
   40284 				break
   40285 			}
   40286 			if v_0_0.AuxInt != 0 {
   40287 				break
   40288 			}
   40289 			v_0_1 := v_0.Args[1]
   40290 			if v_0_1.Op != OpS390XMOVDconst {
   40291 				break
   40292 			}
   40293 			if v_0_1.AuxInt != 1 {
   40294 				break
   40295 			}
   40296 			cmp := v_0.Args[2]
   40297 			b.Kind = BlockS390XNE
   40298 			b.SetControl(cmp)
   40299 			b.Aux = nil
   40300 			return true
   40301 		}
   40302 		// match: (NE (CMPWconst [0] (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40303 		// cond:
   40304 		// result: (GTF cmp yes no)
   40305 		for {
   40306 			v := b.Control
   40307 			if v.Op != OpS390XCMPWconst {
   40308 				break
   40309 			}
   40310 			if v.AuxInt != 0 {
   40311 				break
   40312 			}
   40313 			v_0 := v.Args[0]
   40314 			if v_0.Op != OpS390XMOVDGTnoinv {
   40315 				break
   40316 			}
   40317 			_ = v_0.Args[2]
   40318 			v_0_0 := v_0.Args[0]
   40319 			if v_0_0.Op != OpS390XMOVDconst {
   40320 				break
   40321 			}
   40322 			if v_0_0.AuxInt != 0 {
   40323 				break
   40324 			}
   40325 			v_0_1 := v_0.Args[1]
   40326 			if v_0_1.Op != OpS390XMOVDconst {
   40327 				break
   40328 			}
   40329 			if v_0_1.AuxInt != 1 {
   40330 				break
   40331 			}
   40332 			cmp := v_0.Args[2]
   40333 			b.Kind = BlockS390XGTF
   40334 			b.SetControl(cmp)
   40335 			b.Aux = nil
   40336 			return true
   40337 		}
   40338 		// match: (NE (CMPWconst [0] (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
   40339 		// cond:
   40340 		// result: (GEF cmp yes no)
   40341 		for {
   40342 			v := b.Control
   40343 			if v.Op != OpS390XCMPWconst {
   40344 				break
   40345 			}
   40346 			if v.AuxInt != 0 {
   40347 				break
   40348 			}
   40349 			v_0 := v.Args[0]
   40350 			if v_0.Op != OpS390XMOVDGEnoinv {
   40351 				break
   40352 			}
   40353 			_ = v_0.Args[2]
   40354 			v_0_0 := v_0.Args[0]
   40355 			if v_0_0.Op != OpS390XMOVDconst {
   40356 				break
   40357 			}
   40358 			if v_0_0.AuxInt != 0 {
   40359 				break
   40360 			}
   40361 			v_0_1 := v_0.Args[1]
   40362 			if v_0_1.Op != OpS390XMOVDconst {
   40363 				break
   40364 			}
   40365 			if v_0_1.AuxInt != 1 {
   40366 				break
   40367 			}
   40368 			cmp := v_0.Args[2]
   40369 			b.Kind = BlockS390XGEF
   40370 			b.SetControl(cmp)
   40371 			b.Aux = nil
   40372 			return true
   40373 		}
   40374 		// match: (NE (InvertFlags cmp) yes no)
   40375 		// cond:
   40376 		// result: (NE cmp yes no)
   40377 		for {
   40378 			v := b.Control
   40379 			if v.Op != OpS390XInvertFlags {
   40380 				break
   40381 			}
   40382 			cmp := v.Args[0]
   40383 			b.Kind = BlockS390XNE
   40384 			b.SetControl(cmp)
   40385 			b.Aux = nil
   40386 			return true
   40387 		}
   40388 		// match: (NE (FlagEQ) yes no)
   40389 		// cond:
   40390 		// result: (First nil no yes)
   40391 		for {
   40392 			v := b.Control
   40393 			if v.Op != OpS390XFlagEQ {
   40394 				break
   40395 			}
   40396 			b.Kind = BlockFirst
   40397 			b.SetControl(nil)
   40398 			b.Aux = nil
   40399 			b.swapSuccessors()
   40400 			return true
   40401 		}
   40402 		// match: (NE (FlagLT) yes no)
   40403 		// cond:
   40404 		// result: (First nil yes no)
   40405 		for {
   40406 			v := b.Control
   40407 			if v.Op != OpS390XFlagLT {
   40408 				break
   40409 			}
   40410 			b.Kind = BlockFirst
   40411 			b.SetControl(nil)
   40412 			b.Aux = nil
   40413 			return true
   40414 		}
   40415 		// match: (NE (FlagGT) yes no)
   40416 		// cond:
   40417 		// result: (First nil yes no)
   40418 		for {
   40419 			v := b.Control
   40420 			if v.Op != OpS390XFlagGT {
   40421 				break
   40422 			}
   40423 			b.Kind = BlockFirst
   40424 			b.SetControl(nil)
   40425 			b.Aux = nil
   40426 			return true
   40427 		}
   40428 	}
   40429 	return false
   40430 }
   40431