Home | History | Annotate | Download | only in ssa 
      1 // Code generated from gen/386.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 rewriteValue386(v *Value) bool {
     17 	switch v.Op {
     18 	case Op386ADCL:
     19 		return rewriteValue386_Op386ADCL_0(v)
     20 	case Op386ADDL:
     21 		return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v)
     22 	case Op386ADDLcarry:
     23 		return rewriteValue386_Op386ADDLcarry_0(v)
     24 	case Op386ADDLconst:
     25 		return rewriteValue386_Op386ADDLconst_0(v)
     26 	case Op386ANDL:
     27 		return rewriteValue386_Op386ANDL_0(v)
     28 	case Op386ANDLconst:
     29 		return rewriteValue386_Op386ANDLconst_0(v)
     30 	case Op386CMPB:
     31 		return rewriteValue386_Op386CMPB_0(v)
     32 	case Op386CMPBconst:
     33 		return rewriteValue386_Op386CMPBconst_0(v)
     34 	case Op386CMPL:
     35 		return rewriteValue386_Op386CMPL_0(v)
     36 	case Op386CMPLconst:
     37 		return rewriteValue386_Op386CMPLconst_0(v)
     38 	case Op386CMPW:
     39 		return rewriteValue386_Op386CMPW_0(v)
     40 	case Op386CMPWconst:
     41 		return rewriteValue386_Op386CMPWconst_0(v)
     42 	case Op386LEAL:
     43 		return rewriteValue386_Op386LEAL_0(v)
     44 	case Op386LEAL1:
     45 		return rewriteValue386_Op386LEAL1_0(v)
     46 	case Op386LEAL2:
     47 		return rewriteValue386_Op386LEAL2_0(v)
     48 	case Op386LEAL4:
     49 		return rewriteValue386_Op386LEAL4_0(v)
     50 	case Op386LEAL8:
     51 		return rewriteValue386_Op386LEAL8_0(v)
     52 	case Op386MOVBLSX:
     53 		return rewriteValue386_Op386MOVBLSX_0(v)
     54 	case Op386MOVBLSXload:
     55 		return rewriteValue386_Op386MOVBLSXload_0(v)
     56 	case Op386MOVBLZX:
     57 		return rewriteValue386_Op386MOVBLZX_0(v)
     58 	case Op386MOVBload:
     59 		return rewriteValue386_Op386MOVBload_0(v)
     60 	case Op386MOVBloadidx1:
     61 		return rewriteValue386_Op386MOVBloadidx1_0(v)
     62 	case Op386MOVBstore:
     63 		return rewriteValue386_Op386MOVBstore_0(v)
     64 	case Op386MOVBstoreconst:
     65 		return rewriteValue386_Op386MOVBstoreconst_0(v)
     66 	case Op386MOVBstoreconstidx1:
     67 		return rewriteValue386_Op386MOVBstoreconstidx1_0(v)
     68 	case Op386MOVBstoreidx1:
     69 		return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v)
     70 	case Op386MOVLload:
     71 		return rewriteValue386_Op386MOVLload_0(v)
     72 	case Op386MOVLloadidx1:
     73 		return rewriteValue386_Op386MOVLloadidx1_0(v)
     74 	case Op386MOVLloadidx4:
     75 		return rewriteValue386_Op386MOVLloadidx4_0(v)
     76 	case Op386MOVLstore:
     77 		return rewriteValue386_Op386MOVLstore_0(v)
     78 	case Op386MOVLstoreconst:
     79 		return rewriteValue386_Op386MOVLstoreconst_0(v)
     80 	case Op386MOVLstoreconstidx1:
     81 		return rewriteValue386_Op386MOVLstoreconstidx1_0(v)
     82 	case Op386MOVLstoreconstidx4:
     83 		return rewriteValue386_Op386MOVLstoreconstidx4_0(v)
     84 	case Op386MOVLstoreidx1:
     85 		return rewriteValue386_Op386MOVLstoreidx1_0(v)
     86 	case Op386MOVLstoreidx4:
     87 		return rewriteValue386_Op386MOVLstoreidx4_0(v)
     88 	case Op386MOVSDconst:
     89 		return rewriteValue386_Op386MOVSDconst_0(v)
     90 	case Op386MOVSDload:
     91 		return rewriteValue386_Op386MOVSDload_0(v)
     92 	case Op386MOVSDloadidx1:
     93 		return rewriteValue386_Op386MOVSDloadidx1_0(v)
     94 	case Op386MOVSDloadidx8:
     95 		return rewriteValue386_Op386MOVSDloadidx8_0(v)
     96 	case Op386MOVSDstore:
     97 		return rewriteValue386_Op386MOVSDstore_0(v)
     98 	case Op386MOVSDstoreidx1:
     99 		return rewriteValue386_Op386MOVSDstoreidx1_0(v)
    100 	case Op386MOVSDstoreidx8:
    101 		return rewriteValue386_Op386MOVSDstoreidx8_0(v)
    102 	case Op386MOVSSconst:
    103 		return rewriteValue386_Op386MOVSSconst_0(v)
    104 	case Op386MOVSSload:
    105 		return rewriteValue386_Op386MOVSSload_0(v)
    106 	case Op386MOVSSloadidx1:
    107 		return rewriteValue386_Op386MOVSSloadidx1_0(v)
    108 	case Op386MOVSSloadidx4:
    109 		return rewriteValue386_Op386MOVSSloadidx4_0(v)
    110 	case Op386MOVSSstore:
    111 		return rewriteValue386_Op386MOVSSstore_0(v)
    112 	case Op386MOVSSstoreidx1:
    113 		return rewriteValue386_Op386MOVSSstoreidx1_0(v)
    114 	case Op386MOVSSstoreidx4:
    115 		return rewriteValue386_Op386MOVSSstoreidx4_0(v)
    116 	case Op386MOVWLSX:
    117 		return rewriteValue386_Op386MOVWLSX_0(v)
    118 	case Op386MOVWLSXload:
    119 		return rewriteValue386_Op386MOVWLSXload_0(v)
    120 	case Op386MOVWLZX:
    121 		return rewriteValue386_Op386MOVWLZX_0(v)
    122 	case Op386MOVWload:
    123 		return rewriteValue386_Op386MOVWload_0(v)
    124 	case Op386MOVWloadidx1:
    125 		return rewriteValue386_Op386MOVWloadidx1_0(v)
    126 	case Op386MOVWloadidx2:
    127 		return rewriteValue386_Op386MOVWloadidx2_0(v)
    128 	case Op386MOVWstore:
    129 		return rewriteValue386_Op386MOVWstore_0(v)
    130 	case Op386MOVWstoreconst:
    131 		return rewriteValue386_Op386MOVWstoreconst_0(v)
    132 	case Op386MOVWstoreconstidx1:
    133 		return rewriteValue386_Op386MOVWstoreconstidx1_0(v)
    134 	case Op386MOVWstoreconstidx2:
    135 		return rewriteValue386_Op386MOVWstoreconstidx2_0(v)
    136 	case Op386MOVWstoreidx1:
    137 		return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v)
    138 	case Op386MOVWstoreidx2:
    139 		return rewriteValue386_Op386MOVWstoreidx2_0(v)
    140 	case Op386MULL:
    141 		return rewriteValue386_Op386MULL_0(v)
    142 	case Op386MULLconst:
    143 		return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v)
    144 	case Op386NEGL:
    145 		return rewriteValue386_Op386NEGL_0(v)
    146 	case Op386NOTL:
    147 		return rewriteValue386_Op386NOTL_0(v)
    148 	case Op386ORL:
    149 		return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v)
    150 	case Op386ORLconst:
    151 		return rewriteValue386_Op386ORLconst_0(v)
    152 	case Op386ROLBconst:
    153 		return rewriteValue386_Op386ROLBconst_0(v)
    154 	case Op386ROLLconst:
    155 		return rewriteValue386_Op386ROLLconst_0(v)
    156 	case Op386ROLWconst:
    157 		return rewriteValue386_Op386ROLWconst_0(v)
    158 	case Op386SARB:
    159 		return rewriteValue386_Op386SARB_0(v)
    160 	case Op386SARBconst:
    161 		return rewriteValue386_Op386SARBconst_0(v)
    162 	case Op386SARL:
    163 		return rewriteValue386_Op386SARL_0(v)
    164 	case Op386SARLconst:
    165 		return rewriteValue386_Op386SARLconst_0(v)
    166 	case Op386SARW:
    167 		return rewriteValue386_Op386SARW_0(v)
    168 	case Op386SARWconst:
    169 		return rewriteValue386_Op386SARWconst_0(v)
    170 	case Op386SBBL:
    171 		return rewriteValue386_Op386SBBL_0(v)
    172 	case Op386SBBLcarrymask:
    173 		return rewriteValue386_Op386SBBLcarrymask_0(v)
    174 	case Op386SETA:
    175 		return rewriteValue386_Op386SETA_0(v)
    176 	case Op386SETAE:
    177 		return rewriteValue386_Op386SETAE_0(v)
    178 	case Op386SETB:
    179 		return rewriteValue386_Op386SETB_0(v)
    180 	case Op386SETBE:
    181 		return rewriteValue386_Op386SETBE_0(v)
    182 	case Op386SETEQ:
    183 		return rewriteValue386_Op386SETEQ_0(v)
    184 	case Op386SETG:
    185 		return rewriteValue386_Op386SETG_0(v)
    186 	case Op386SETGE:
    187 		return rewriteValue386_Op386SETGE_0(v)
    188 	case Op386SETL:
    189 		return rewriteValue386_Op386SETL_0(v)
    190 	case Op386SETLE:
    191 		return rewriteValue386_Op386SETLE_0(v)
    192 	case Op386SETNE:
    193 		return rewriteValue386_Op386SETNE_0(v)
    194 	case Op386SHLL:
    195 		return rewriteValue386_Op386SHLL_0(v)
    196 	case Op386SHLLconst:
    197 		return rewriteValue386_Op386SHLLconst_0(v)
    198 	case Op386SHRB:
    199 		return rewriteValue386_Op386SHRB_0(v)
    200 	case Op386SHRBconst:
    201 		return rewriteValue386_Op386SHRBconst_0(v)
    202 	case Op386SHRL:
    203 		return rewriteValue386_Op386SHRL_0(v)
    204 	case Op386SHRLconst:
    205 		return rewriteValue386_Op386SHRLconst_0(v)
    206 	case Op386SHRW:
    207 		return rewriteValue386_Op386SHRW_0(v)
    208 	case Op386SHRWconst:
    209 		return rewriteValue386_Op386SHRWconst_0(v)
    210 	case Op386SUBL:
    211 		return rewriteValue386_Op386SUBL_0(v)
    212 	case Op386SUBLcarry:
    213 		return rewriteValue386_Op386SUBLcarry_0(v)
    214 	case Op386SUBLconst:
    215 		return rewriteValue386_Op386SUBLconst_0(v)
    216 	case Op386XORL:
    217 		return rewriteValue386_Op386XORL_0(v)
    218 	case Op386XORLconst:
    219 		return rewriteValue386_Op386XORLconst_0(v)
    220 	case OpAdd16:
    221 		return rewriteValue386_OpAdd16_0(v)
    222 	case OpAdd32:
    223 		return rewriteValue386_OpAdd32_0(v)
    224 	case OpAdd32F:
    225 		return rewriteValue386_OpAdd32F_0(v)
    226 	case OpAdd32carry:
    227 		return rewriteValue386_OpAdd32carry_0(v)
    228 	case OpAdd32withcarry:
    229 		return rewriteValue386_OpAdd32withcarry_0(v)
    230 	case OpAdd64F:
    231 		return rewriteValue386_OpAdd64F_0(v)
    232 	case OpAdd8:
    233 		return rewriteValue386_OpAdd8_0(v)
    234 	case OpAddPtr:
    235 		return rewriteValue386_OpAddPtr_0(v)
    236 	case OpAddr:
    237 		return rewriteValue386_OpAddr_0(v)
    238 	case OpAnd16:
    239 		return rewriteValue386_OpAnd16_0(v)
    240 	case OpAnd32:
    241 		return rewriteValue386_OpAnd32_0(v)
    242 	case OpAnd8:
    243 		return rewriteValue386_OpAnd8_0(v)
    244 	case OpAndB:
    245 		return rewriteValue386_OpAndB_0(v)
    246 	case OpAvg32u:
    247 		return rewriteValue386_OpAvg32u_0(v)
    248 	case OpBswap32:
    249 		return rewriteValue386_OpBswap32_0(v)
    250 	case OpClosureCall:
    251 		return rewriteValue386_OpClosureCall_0(v)
    252 	case OpCom16:
    253 		return rewriteValue386_OpCom16_0(v)
    254 	case OpCom32:
    255 		return rewriteValue386_OpCom32_0(v)
    256 	case OpCom8:
    257 		return rewriteValue386_OpCom8_0(v)
    258 	case OpConst16:
    259 		return rewriteValue386_OpConst16_0(v)
    260 	case OpConst32:
    261 		return rewriteValue386_OpConst32_0(v)
    262 	case OpConst32F:
    263 		return rewriteValue386_OpConst32F_0(v)
    264 	case OpConst64F:
    265 		return rewriteValue386_OpConst64F_0(v)
    266 	case OpConst8:
    267 		return rewriteValue386_OpConst8_0(v)
    268 	case OpConstBool:
    269 		return rewriteValue386_OpConstBool_0(v)
    270 	case OpConstNil:
    271 		return rewriteValue386_OpConstNil_0(v)
    272 	case OpConvert:
    273 		return rewriteValue386_OpConvert_0(v)
    274 	case OpCvt32Fto32:
    275 		return rewriteValue386_OpCvt32Fto32_0(v)
    276 	case OpCvt32Fto64F:
    277 		return rewriteValue386_OpCvt32Fto64F_0(v)
    278 	case OpCvt32to32F:
    279 		return rewriteValue386_OpCvt32to32F_0(v)
    280 	case OpCvt32to64F:
    281 		return rewriteValue386_OpCvt32to64F_0(v)
    282 	case OpCvt64Fto32:
    283 		return rewriteValue386_OpCvt64Fto32_0(v)
    284 	case OpCvt64Fto32F:
    285 		return rewriteValue386_OpCvt64Fto32F_0(v)
    286 	case OpDiv16:
    287 		return rewriteValue386_OpDiv16_0(v)
    288 	case OpDiv16u:
    289 		return rewriteValue386_OpDiv16u_0(v)
    290 	case OpDiv32:
    291 		return rewriteValue386_OpDiv32_0(v)
    292 	case OpDiv32F:
    293 		return rewriteValue386_OpDiv32F_0(v)
    294 	case OpDiv32u:
    295 		return rewriteValue386_OpDiv32u_0(v)
    296 	case OpDiv64F:
    297 		return rewriteValue386_OpDiv64F_0(v)
    298 	case OpDiv8:
    299 		return rewriteValue386_OpDiv8_0(v)
    300 	case OpDiv8u:
    301 		return rewriteValue386_OpDiv8u_0(v)
    302 	case OpEq16:
    303 		return rewriteValue386_OpEq16_0(v)
    304 	case OpEq32:
    305 		return rewriteValue386_OpEq32_0(v)
    306 	case OpEq32F:
    307 		return rewriteValue386_OpEq32F_0(v)
    308 	case OpEq64F:
    309 		return rewriteValue386_OpEq64F_0(v)
    310 	case OpEq8:
    311 		return rewriteValue386_OpEq8_0(v)
    312 	case OpEqB:
    313 		return rewriteValue386_OpEqB_0(v)
    314 	case OpEqPtr:
    315 		return rewriteValue386_OpEqPtr_0(v)
    316 	case OpGeq16:
    317 		return rewriteValue386_OpGeq16_0(v)
    318 	case OpGeq16U:
    319 		return rewriteValue386_OpGeq16U_0(v)
    320 	case OpGeq32:
    321 		return rewriteValue386_OpGeq32_0(v)
    322 	case OpGeq32F:
    323 		return rewriteValue386_OpGeq32F_0(v)
    324 	case OpGeq32U:
    325 		return rewriteValue386_OpGeq32U_0(v)
    326 	case OpGeq64F:
    327 		return rewriteValue386_OpGeq64F_0(v)
    328 	case OpGeq8:
    329 		return rewriteValue386_OpGeq8_0(v)
    330 	case OpGeq8U:
    331 		return rewriteValue386_OpGeq8U_0(v)
    332 	case OpGetCallerPC:
    333 		return rewriteValue386_OpGetCallerPC_0(v)
    334 	case OpGetCallerSP:
    335 		return rewriteValue386_OpGetCallerSP_0(v)
    336 	case OpGetClosurePtr:
    337 		return rewriteValue386_OpGetClosurePtr_0(v)
    338 	case OpGetG:
    339 		return rewriteValue386_OpGetG_0(v)
    340 	case OpGreater16:
    341 		return rewriteValue386_OpGreater16_0(v)
    342 	case OpGreater16U:
    343 		return rewriteValue386_OpGreater16U_0(v)
    344 	case OpGreater32:
    345 		return rewriteValue386_OpGreater32_0(v)
    346 	case OpGreater32F:
    347 		return rewriteValue386_OpGreater32F_0(v)
    348 	case OpGreater32U:
    349 		return rewriteValue386_OpGreater32U_0(v)
    350 	case OpGreater64F:
    351 		return rewriteValue386_OpGreater64F_0(v)
    352 	case OpGreater8:
    353 		return rewriteValue386_OpGreater8_0(v)
    354 	case OpGreater8U:
    355 		return rewriteValue386_OpGreater8U_0(v)
    356 	case OpHmul32:
    357 		return rewriteValue386_OpHmul32_0(v)
    358 	case OpHmul32u:
    359 		return rewriteValue386_OpHmul32u_0(v)
    360 	case OpInterCall:
    361 		return rewriteValue386_OpInterCall_0(v)
    362 	case OpIsInBounds:
    363 		return rewriteValue386_OpIsInBounds_0(v)
    364 	case OpIsNonNil:
    365 		return rewriteValue386_OpIsNonNil_0(v)
    366 	case OpIsSliceInBounds:
    367 		return rewriteValue386_OpIsSliceInBounds_0(v)
    368 	case OpLeq16:
    369 		return rewriteValue386_OpLeq16_0(v)
    370 	case OpLeq16U:
    371 		return rewriteValue386_OpLeq16U_0(v)
    372 	case OpLeq32:
    373 		return rewriteValue386_OpLeq32_0(v)
    374 	case OpLeq32F:
    375 		return rewriteValue386_OpLeq32F_0(v)
    376 	case OpLeq32U:
    377 		return rewriteValue386_OpLeq32U_0(v)
    378 	case OpLeq64F:
    379 		return rewriteValue386_OpLeq64F_0(v)
    380 	case OpLeq8:
    381 		return rewriteValue386_OpLeq8_0(v)
    382 	case OpLeq8U:
    383 		return rewriteValue386_OpLeq8U_0(v)
    384 	case OpLess16:
    385 		return rewriteValue386_OpLess16_0(v)
    386 	case OpLess16U:
    387 		return rewriteValue386_OpLess16U_0(v)
    388 	case OpLess32:
    389 		return rewriteValue386_OpLess32_0(v)
    390 	case OpLess32F:
    391 		return rewriteValue386_OpLess32F_0(v)
    392 	case OpLess32U:
    393 		return rewriteValue386_OpLess32U_0(v)
    394 	case OpLess64F:
    395 		return rewriteValue386_OpLess64F_0(v)
    396 	case OpLess8:
    397 		return rewriteValue386_OpLess8_0(v)
    398 	case OpLess8U:
    399 		return rewriteValue386_OpLess8U_0(v)
    400 	case OpLoad:
    401 		return rewriteValue386_OpLoad_0(v)
    402 	case OpLsh16x16:
    403 		return rewriteValue386_OpLsh16x16_0(v)
    404 	case OpLsh16x32:
    405 		return rewriteValue386_OpLsh16x32_0(v)
    406 	case OpLsh16x64:
    407 		return rewriteValue386_OpLsh16x64_0(v)
    408 	case OpLsh16x8:
    409 		return rewriteValue386_OpLsh16x8_0(v)
    410 	case OpLsh32x16:
    411 		return rewriteValue386_OpLsh32x16_0(v)
    412 	case OpLsh32x32:
    413 		return rewriteValue386_OpLsh32x32_0(v)
    414 	case OpLsh32x64:
    415 		return rewriteValue386_OpLsh32x64_0(v)
    416 	case OpLsh32x8:
    417 		return rewriteValue386_OpLsh32x8_0(v)
    418 	case OpLsh8x16:
    419 		return rewriteValue386_OpLsh8x16_0(v)
    420 	case OpLsh8x32:
    421 		return rewriteValue386_OpLsh8x32_0(v)
    422 	case OpLsh8x64:
    423 		return rewriteValue386_OpLsh8x64_0(v)
    424 	case OpLsh8x8:
    425 		return rewriteValue386_OpLsh8x8_0(v)
    426 	case OpMod16:
    427 		return rewriteValue386_OpMod16_0(v)
    428 	case OpMod16u:
    429 		return rewriteValue386_OpMod16u_0(v)
    430 	case OpMod32:
    431 		return rewriteValue386_OpMod32_0(v)
    432 	case OpMod32u:
    433 		return rewriteValue386_OpMod32u_0(v)
    434 	case OpMod8:
    435 		return rewriteValue386_OpMod8_0(v)
    436 	case OpMod8u:
    437 		return rewriteValue386_OpMod8u_0(v)
    438 	case OpMove:
    439 		return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v)
    440 	case OpMul16:
    441 		return rewriteValue386_OpMul16_0(v)
    442 	case OpMul32:
    443 		return rewriteValue386_OpMul32_0(v)
    444 	case OpMul32F:
    445 		return rewriteValue386_OpMul32F_0(v)
    446 	case OpMul32uhilo:
    447 		return rewriteValue386_OpMul32uhilo_0(v)
    448 	case OpMul64F:
    449 		return rewriteValue386_OpMul64F_0(v)
    450 	case OpMul8:
    451 		return rewriteValue386_OpMul8_0(v)
    452 	case OpNeg16:
    453 		return rewriteValue386_OpNeg16_0(v)
    454 	case OpNeg32:
    455 		return rewriteValue386_OpNeg32_0(v)
    456 	case OpNeg32F:
    457 		return rewriteValue386_OpNeg32F_0(v)
    458 	case OpNeg64F:
    459 		return rewriteValue386_OpNeg64F_0(v)
    460 	case OpNeg8:
    461 		return rewriteValue386_OpNeg8_0(v)
    462 	case OpNeq16:
    463 		return rewriteValue386_OpNeq16_0(v)
    464 	case OpNeq32:
    465 		return rewriteValue386_OpNeq32_0(v)
    466 	case OpNeq32F:
    467 		return rewriteValue386_OpNeq32F_0(v)
    468 	case OpNeq64F:
    469 		return rewriteValue386_OpNeq64F_0(v)
    470 	case OpNeq8:
    471 		return rewriteValue386_OpNeq8_0(v)
    472 	case OpNeqB:
    473 		return rewriteValue386_OpNeqB_0(v)
    474 	case OpNeqPtr:
    475 		return rewriteValue386_OpNeqPtr_0(v)
    476 	case OpNilCheck:
    477 		return rewriteValue386_OpNilCheck_0(v)
    478 	case OpNot:
    479 		return rewriteValue386_OpNot_0(v)
    480 	case OpOffPtr:
    481 		return rewriteValue386_OpOffPtr_0(v)
    482 	case OpOr16:
    483 		return rewriteValue386_OpOr16_0(v)
    484 	case OpOr32:
    485 		return rewriteValue386_OpOr32_0(v)
    486 	case OpOr8:
    487 		return rewriteValue386_OpOr8_0(v)
    488 	case OpOrB:
    489 		return rewriteValue386_OpOrB_0(v)
    490 	case OpRound32F:
    491 		return rewriteValue386_OpRound32F_0(v)
    492 	case OpRound64F:
    493 		return rewriteValue386_OpRound64F_0(v)
    494 	case OpRsh16Ux16:
    495 		return rewriteValue386_OpRsh16Ux16_0(v)
    496 	case OpRsh16Ux32:
    497 		return rewriteValue386_OpRsh16Ux32_0(v)
    498 	case OpRsh16Ux64:
    499 		return rewriteValue386_OpRsh16Ux64_0(v)
    500 	case OpRsh16Ux8:
    501 		return rewriteValue386_OpRsh16Ux8_0(v)
    502 	case OpRsh16x16:
    503 		return rewriteValue386_OpRsh16x16_0(v)
    504 	case OpRsh16x32:
    505 		return rewriteValue386_OpRsh16x32_0(v)
    506 	case OpRsh16x64:
    507 		return rewriteValue386_OpRsh16x64_0(v)
    508 	case OpRsh16x8:
    509 		return rewriteValue386_OpRsh16x8_0(v)
    510 	case OpRsh32Ux16:
    511 		return rewriteValue386_OpRsh32Ux16_0(v)
    512 	case OpRsh32Ux32:
    513 		return rewriteValue386_OpRsh32Ux32_0(v)
    514 	case OpRsh32Ux64:
    515 		return rewriteValue386_OpRsh32Ux64_0(v)
    516 	case OpRsh32Ux8:
    517 		return rewriteValue386_OpRsh32Ux8_0(v)
    518 	case OpRsh32x16:
    519 		return rewriteValue386_OpRsh32x16_0(v)
    520 	case OpRsh32x32:
    521 		return rewriteValue386_OpRsh32x32_0(v)
    522 	case OpRsh32x64:
    523 		return rewriteValue386_OpRsh32x64_0(v)
    524 	case OpRsh32x8:
    525 		return rewriteValue386_OpRsh32x8_0(v)
    526 	case OpRsh8Ux16:
    527 		return rewriteValue386_OpRsh8Ux16_0(v)
    528 	case OpRsh8Ux32:
    529 		return rewriteValue386_OpRsh8Ux32_0(v)
    530 	case OpRsh8Ux64:
    531 		return rewriteValue386_OpRsh8Ux64_0(v)
    532 	case OpRsh8Ux8:
    533 		return rewriteValue386_OpRsh8Ux8_0(v)
    534 	case OpRsh8x16:
    535 		return rewriteValue386_OpRsh8x16_0(v)
    536 	case OpRsh8x32:
    537 		return rewriteValue386_OpRsh8x32_0(v)
    538 	case OpRsh8x64:
    539 		return rewriteValue386_OpRsh8x64_0(v)
    540 	case OpRsh8x8:
    541 		return rewriteValue386_OpRsh8x8_0(v)
    542 	case OpSignExt16to32:
    543 		return rewriteValue386_OpSignExt16to32_0(v)
    544 	case OpSignExt8to16:
    545 		return rewriteValue386_OpSignExt8to16_0(v)
    546 	case OpSignExt8to32:
    547 		return rewriteValue386_OpSignExt8to32_0(v)
    548 	case OpSignmask:
    549 		return rewriteValue386_OpSignmask_0(v)
    550 	case OpSlicemask:
    551 		return rewriteValue386_OpSlicemask_0(v)
    552 	case OpSqrt:
    553 		return rewriteValue386_OpSqrt_0(v)
    554 	case OpStaticCall:
    555 		return rewriteValue386_OpStaticCall_0(v)
    556 	case OpStore:
    557 		return rewriteValue386_OpStore_0(v)
    558 	case OpSub16:
    559 		return rewriteValue386_OpSub16_0(v)
    560 	case OpSub32:
    561 		return rewriteValue386_OpSub32_0(v)
    562 	case OpSub32F:
    563 		return rewriteValue386_OpSub32F_0(v)
    564 	case OpSub32carry:
    565 		return rewriteValue386_OpSub32carry_0(v)
    566 	case OpSub32withcarry:
    567 		return rewriteValue386_OpSub32withcarry_0(v)
    568 	case OpSub64F:
    569 		return rewriteValue386_OpSub64F_0(v)
    570 	case OpSub8:
    571 		return rewriteValue386_OpSub8_0(v)
    572 	case OpSubPtr:
    573 		return rewriteValue386_OpSubPtr_0(v)
    574 	case OpTrunc16to8:
    575 		return rewriteValue386_OpTrunc16to8_0(v)
    576 	case OpTrunc32to16:
    577 		return rewriteValue386_OpTrunc32to16_0(v)
    578 	case OpTrunc32to8:
    579 		return rewriteValue386_OpTrunc32to8_0(v)
    580 	case OpXor16:
    581 		return rewriteValue386_OpXor16_0(v)
    582 	case OpXor32:
    583 		return rewriteValue386_OpXor32_0(v)
    584 	case OpXor8:
    585 		return rewriteValue386_OpXor8_0(v)
    586 	case OpZero:
    587 		return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v)
    588 	case OpZeroExt16to32:
    589 		return rewriteValue386_OpZeroExt16to32_0(v)
    590 	case OpZeroExt8to16:
    591 		return rewriteValue386_OpZeroExt8to16_0(v)
    592 	case OpZeroExt8to32:
    593 		return rewriteValue386_OpZeroExt8to32_0(v)
    594 	case OpZeromask:
    595 		return rewriteValue386_OpZeromask_0(v)
    596 	}
    597 	return false
    598 }
    599 func rewriteValue386_Op386ADCL_0(v *Value) bool {
    600 	// match: (ADCL x (MOVLconst [c]) f)
    601 	// cond:
    602 	// result: (ADCLconst [c] x f)
    603 	for {
    604 		_ = v.Args[2]
    605 		x := v.Args[0]
    606 		v_1 := v.Args[1]
    607 		if v_1.Op != Op386MOVLconst {
    608 			break
    609 		}
    610 		c := v_1.AuxInt
    611 		f := v.Args[2]
    612 		v.reset(Op386ADCLconst)
    613 		v.AuxInt = c
    614 		v.AddArg(x)
    615 		v.AddArg(f)
    616 		return true
    617 	}
    618 	// match: (ADCL (MOVLconst [c]) x f)
    619 	// cond:
    620 	// result: (ADCLconst [c] x f)
    621 	for {
    622 		_ = v.Args[2]
    623 		v_0 := v.Args[0]
    624 		if v_0.Op != Op386MOVLconst {
    625 			break
    626 		}
    627 		c := v_0.AuxInt
    628 		x := v.Args[1]
    629 		f := v.Args[2]
    630 		v.reset(Op386ADCLconst)
    631 		v.AuxInt = c
    632 		v.AddArg(x)
    633 		v.AddArg(f)
    634 		return true
    635 	}
    636 	// match: (ADCL (MOVLconst [c]) x f)
    637 	// cond:
    638 	// result: (ADCLconst [c] x f)
    639 	for {
    640 		_ = v.Args[2]
    641 		v_0 := v.Args[0]
    642 		if v_0.Op != Op386MOVLconst {
    643 			break
    644 		}
    645 		c := v_0.AuxInt
    646 		x := v.Args[1]
    647 		f := v.Args[2]
    648 		v.reset(Op386ADCLconst)
    649 		v.AuxInt = c
    650 		v.AddArg(x)
    651 		v.AddArg(f)
    652 		return true
    653 	}
    654 	// match: (ADCL x (MOVLconst [c]) f)
    655 	// cond:
    656 	// result: (ADCLconst [c] x f)
    657 	for {
    658 		_ = v.Args[2]
    659 		x := v.Args[0]
    660 		v_1 := v.Args[1]
    661 		if v_1.Op != Op386MOVLconst {
    662 			break
    663 		}
    664 		c := v_1.AuxInt
    665 		f := v.Args[2]
    666 		v.reset(Op386ADCLconst)
    667 		v.AuxInt = c
    668 		v.AddArg(x)
    669 		v.AddArg(f)
    670 		return true
    671 	}
    672 	return false
    673 }
    674 func rewriteValue386_Op386ADDL_0(v *Value) bool {
    675 	// match: (ADDL x (MOVLconst [c]))
    676 	// cond:
    677 	// result: (ADDLconst [c] x)
    678 	for {
    679 		_ = v.Args[1]
    680 		x := v.Args[0]
    681 		v_1 := v.Args[1]
    682 		if v_1.Op != Op386MOVLconst {
    683 			break
    684 		}
    685 		c := v_1.AuxInt
    686 		v.reset(Op386ADDLconst)
    687 		v.AuxInt = c
    688 		v.AddArg(x)
    689 		return true
    690 	}
    691 	// match: (ADDL (MOVLconst [c]) x)
    692 	// cond:
    693 	// result: (ADDLconst [c] x)
    694 	for {
    695 		_ = v.Args[1]
    696 		v_0 := v.Args[0]
    697 		if v_0.Op != Op386MOVLconst {
    698 			break
    699 		}
    700 		c := v_0.AuxInt
    701 		x := v.Args[1]
    702 		v.reset(Op386ADDLconst)
    703 		v.AuxInt = c
    704 		v.AddArg(x)
    705 		return true
    706 	}
    707 	// match: (ADDL (SHLLconst [c] x) (SHRLconst [d] x))
    708 	// cond: d == 32-c
    709 	// result: (ROLLconst [c] x)
    710 	for {
    711 		_ = v.Args[1]
    712 		v_0 := v.Args[0]
    713 		if v_0.Op != Op386SHLLconst {
    714 			break
    715 		}
    716 		c := v_0.AuxInt
    717 		x := v_0.Args[0]
    718 		v_1 := v.Args[1]
    719 		if v_1.Op != Op386SHRLconst {
    720 			break
    721 		}
    722 		d := v_1.AuxInt
    723 		if x != v_1.Args[0] {
    724 			break
    725 		}
    726 		if !(d == 32-c) {
    727 			break
    728 		}
    729 		v.reset(Op386ROLLconst)
    730 		v.AuxInt = c
    731 		v.AddArg(x)
    732 		return true
    733 	}
    734 	// match: (ADDL (SHRLconst [d] x) (SHLLconst [c] x))
    735 	// cond: d == 32-c
    736 	// result: (ROLLconst [c] x)
    737 	for {
    738 		_ = v.Args[1]
    739 		v_0 := v.Args[0]
    740 		if v_0.Op != Op386SHRLconst {
    741 			break
    742 		}
    743 		d := v_0.AuxInt
    744 		x := v_0.Args[0]
    745 		v_1 := v.Args[1]
    746 		if v_1.Op != Op386SHLLconst {
    747 			break
    748 		}
    749 		c := v_1.AuxInt
    750 		if x != v_1.Args[0] {
    751 			break
    752 		}
    753 		if !(d == 32-c) {
    754 			break
    755 		}
    756 		v.reset(Op386ROLLconst)
    757 		v.AuxInt = c
    758 		v.AddArg(x)
    759 		return true
    760 	}
    761 	// match: (ADDL <t> (SHLLconst x [c]) (SHRWconst x [d]))
    762 	// cond: c < 16 && d == 16-c && t.Size() == 2
    763 	// result: (ROLWconst x [c])
    764 	for {
    765 		t := v.Type
    766 		_ = v.Args[1]
    767 		v_0 := v.Args[0]
    768 		if v_0.Op != Op386SHLLconst {
    769 			break
    770 		}
    771 		c := v_0.AuxInt
    772 		x := v_0.Args[0]
    773 		v_1 := v.Args[1]
    774 		if v_1.Op != Op386SHRWconst {
    775 			break
    776 		}
    777 		d := v_1.AuxInt
    778 		if x != v_1.Args[0] {
    779 			break
    780 		}
    781 		if !(c < 16 && d == 16-c && t.Size() == 2) {
    782 			break
    783 		}
    784 		v.reset(Op386ROLWconst)
    785 		v.AuxInt = c
    786 		v.AddArg(x)
    787 		return true
    788 	}
    789 	// match: (ADDL <t> (SHRWconst x [d]) (SHLLconst x [c]))
    790 	// cond: c < 16 && d == 16-c && t.Size() == 2
    791 	// result: (ROLWconst x [c])
    792 	for {
    793 		t := v.Type
    794 		_ = v.Args[1]
    795 		v_0 := v.Args[0]
    796 		if v_0.Op != Op386SHRWconst {
    797 			break
    798 		}
    799 		d := v_0.AuxInt
    800 		x := v_0.Args[0]
    801 		v_1 := v.Args[1]
    802 		if v_1.Op != Op386SHLLconst {
    803 			break
    804 		}
    805 		c := v_1.AuxInt
    806 		if x != v_1.Args[0] {
    807 			break
    808 		}
    809 		if !(c < 16 && d == 16-c && t.Size() == 2) {
    810 			break
    811 		}
    812 		v.reset(Op386ROLWconst)
    813 		v.AuxInt = c
    814 		v.AddArg(x)
    815 		return true
    816 	}
    817 	// match: (ADDL <t> (SHLLconst x [c]) (SHRBconst x [d]))
    818 	// cond: c < 8 && d == 8-c && t.Size() == 1
    819 	// result: (ROLBconst x [c])
    820 	for {
    821 		t := v.Type
    822 		_ = v.Args[1]
    823 		v_0 := v.Args[0]
    824 		if v_0.Op != Op386SHLLconst {
    825 			break
    826 		}
    827 		c := v_0.AuxInt
    828 		x := v_0.Args[0]
    829 		v_1 := v.Args[1]
    830 		if v_1.Op != Op386SHRBconst {
    831 			break
    832 		}
    833 		d := v_1.AuxInt
    834 		if x != v_1.Args[0] {
    835 			break
    836 		}
    837 		if !(c < 8 && d == 8-c && t.Size() == 1) {
    838 			break
    839 		}
    840 		v.reset(Op386ROLBconst)
    841 		v.AuxInt = c
    842 		v.AddArg(x)
    843 		return true
    844 	}
    845 	// match: (ADDL <t> (SHRBconst x [d]) (SHLLconst x [c]))
    846 	// cond: c < 8 && d == 8-c && t.Size() == 1
    847 	// result: (ROLBconst x [c])
    848 	for {
    849 		t := v.Type
    850 		_ = v.Args[1]
    851 		v_0 := v.Args[0]
    852 		if v_0.Op != Op386SHRBconst {
    853 			break
    854 		}
    855 		d := v_0.AuxInt
    856 		x := v_0.Args[0]
    857 		v_1 := v.Args[1]
    858 		if v_1.Op != Op386SHLLconst {
    859 			break
    860 		}
    861 		c := v_1.AuxInt
    862 		if x != v_1.Args[0] {
    863 			break
    864 		}
    865 		if !(c < 8 && d == 8-c && t.Size() == 1) {
    866 			break
    867 		}
    868 		v.reset(Op386ROLBconst)
    869 		v.AuxInt = c
    870 		v.AddArg(x)
    871 		return true
    872 	}
    873 	// match: (ADDL x (SHLLconst [3] y))
    874 	// cond:
    875 	// result: (LEAL8 x y)
    876 	for {
    877 		_ = v.Args[1]
    878 		x := v.Args[0]
    879 		v_1 := v.Args[1]
    880 		if v_1.Op != Op386SHLLconst {
    881 			break
    882 		}
    883 		if v_1.AuxInt != 3 {
    884 			break
    885 		}
    886 		y := v_1.Args[0]
    887 		v.reset(Op386LEAL8)
    888 		v.AddArg(x)
    889 		v.AddArg(y)
    890 		return true
    891 	}
    892 	// match: (ADDL (SHLLconst [3] y) x)
    893 	// cond:
    894 	// result: (LEAL8 x y)
    895 	for {
    896 		_ = v.Args[1]
    897 		v_0 := v.Args[0]
    898 		if v_0.Op != Op386SHLLconst {
    899 			break
    900 		}
    901 		if v_0.AuxInt != 3 {
    902 			break
    903 		}
    904 		y := v_0.Args[0]
    905 		x := v.Args[1]
    906 		v.reset(Op386LEAL8)
    907 		v.AddArg(x)
    908 		v.AddArg(y)
    909 		return true
    910 	}
    911 	return false
    912 }
    913 func rewriteValue386_Op386ADDL_10(v *Value) bool {
    914 	// match: (ADDL x (SHLLconst [2] y))
    915 	// cond:
    916 	// result: (LEAL4 x y)
    917 	for {
    918 		_ = v.Args[1]
    919 		x := v.Args[0]
    920 		v_1 := v.Args[1]
    921 		if v_1.Op != Op386SHLLconst {
    922 			break
    923 		}
    924 		if v_1.AuxInt != 2 {
    925 			break
    926 		}
    927 		y := v_1.Args[0]
    928 		v.reset(Op386LEAL4)
    929 		v.AddArg(x)
    930 		v.AddArg(y)
    931 		return true
    932 	}
    933 	// match: (ADDL (SHLLconst [2] y) x)
    934 	// cond:
    935 	// result: (LEAL4 x y)
    936 	for {
    937 		_ = v.Args[1]
    938 		v_0 := v.Args[0]
    939 		if v_0.Op != Op386SHLLconst {
    940 			break
    941 		}
    942 		if v_0.AuxInt != 2 {
    943 			break
    944 		}
    945 		y := v_0.Args[0]
    946 		x := v.Args[1]
    947 		v.reset(Op386LEAL4)
    948 		v.AddArg(x)
    949 		v.AddArg(y)
    950 		return true
    951 	}
    952 	// match: (ADDL x (SHLLconst [1] y))
    953 	// cond:
    954 	// result: (LEAL2 x y)
    955 	for {
    956 		_ = v.Args[1]
    957 		x := v.Args[0]
    958 		v_1 := v.Args[1]
    959 		if v_1.Op != Op386SHLLconst {
    960 			break
    961 		}
    962 		if v_1.AuxInt != 1 {
    963 			break
    964 		}
    965 		y := v_1.Args[0]
    966 		v.reset(Op386LEAL2)
    967 		v.AddArg(x)
    968 		v.AddArg(y)
    969 		return true
    970 	}
    971 	// match: (ADDL (SHLLconst [1] y) x)
    972 	// cond:
    973 	// result: (LEAL2 x y)
    974 	for {
    975 		_ = v.Args[1]
    976 		v_0 := v.Args[0]
    977 		if v_0.Op != Op386SHLLconst {
    978 			break
    979 		}
    980 		if v_0.AuxInt != 1 {
    981 			break
    982 		}
    983 		y := v_0.Args[0]
    984 		x := v.Args[1]
    985 		v.reset(Op386LEAL2)
    986 		v.AddArg(x)
    987 		v.AddArg(y)
    988 		return true
    989 	}
    990 	// match: (ADDL x (ADDL y y))
    991 	// cond:
    992 	// result: (LEAL2 x y)
    993 	for {
    994 		_ = v.Args[1]
    995 		x := v.Args[0]
    996 		v_1 := v.Args[1]
    997 		if v_1.Op != Op386ADDL {
    998 			break
    999 		}
   1000 		_ = v_1.Args[1]
   1001 		y := v_1.Args[0]
   1002 		if y != v_1.Args[1] {
   1003 			break
   1004 		}
   1005 		v.reset(Op386LEAL2)
   1006 		v.AddArg(x)
   1007 		v.AddArg(y)
   1008 		return true
   1009 	}
   1010 	// match: (ADDL (ADDL y y) x)
   1011 	// cond:
   1012 	// result: (LEAL2 x y)
   1013 	for {
   1014 		_ = v.Args[1]
   1015 		v_0 := v.Args[0]
   1016 		if v_0.Op != Op386ADDL {
   1017 			break
   1018 		}
   1019 		_ = v_0.Args[1]
   1020 		y := v_0.Args[0]
   1021 		if y != v_0.Args[1] {
   1022 			break
   1023 		}
   1024 		x := v.Args[1]
   1025 		v.reset(Op386LEAL2)
   1026 		v.AddArg(x)
   1027 		v.AddArg(y)
   1028 		return true
   1029 	}
   1030 	// match: (ADDL x (ADDL x y))
   1031 	// cond:
   1032 	// result: (LEAL2 y x)
   1033 	for {
   1034 		_ = v.Args[1]
   1035 		x := v.Args[0]
   1036 		v_1 := v.Args[1]
   1037 		if v_1.Op != Op386ADDL {
   1038 			break
   1039 		}
   1040 		_ = v_1.Args[1]
   1041 		if x != v_1.Args[0] {
   1042 			break
   1043 		}
   1044 		y := v_1.Args[1]
   1045 		v.reset(Op386LEAL2)
   1046 		v.AddArg(y)
   1047 		v.AddArg(x)
   1048 		return true
   1049 	}
   1050 	// match: (ADDL x (ADDL y x))
   1051 	// cond:
   1052 	// result: (LEAL2 y x)
   1053 	for {
   1054 		_ = v.Args[1]
   1055 		x := v.Args[0]
   1056 		v_1 := v.Args[1]
   1057 		if v_1.Op != Op386ADDL {
   1058 			break
   1059 		}
   1060 		_ = v_1.Args[1]
   1061 		y := v_1.Args[0]
   1062 		if x != v_1.Args[1] {
   1063 			break
   1064 		}
   1065 		v.reset(Op386LEAL2)
   1066 		v.AddArg(y)
   1067 		v.AddArg(x)
   1068 		return true
   1069 	}
   1070 	// match: (ADDL (ADDL x y) x)
   1071 	// cond:
   1072 	// result: (LEAL2 y x)
   1073 	for {
   1074 		_ = v.Args[1]
   1075 		v_0 := v.Args[0]
   1076 		if v_0.Op != Op386ADDL {
   1077 			break
   1078 		}
   1079 		_ = v_0.Args[1]
   1080 		x := v_0.Args[0]
   1081 		y := v_0.Args[1]
   1082 		if x != v.Args[1] {
   1083 			break
   1084 		}
   1085 		v.reset(Op386LEAL2)
   1086 		v.AddArg(y)
   1087 		v.AddArg(x)
   1088 		return true
   1089 	}
   1090 	// match: (ADDL (ADDL y x) x)
   1091 	// cond:
   1092 	// result: (LEAL2 y x)
   1093 	for {
   1094 		_ = v.Args[1]
   1095 		v_0 := v.Args[0]
   1096 		if v_0.Op != Op386ADDL {
   1097 			break
   1098 		}
   1099 		_ = v_0.Args[1]
   1100 		y := v_0.Args[0]
   1101 		x := v_0.Args[1]
   1102 		if x != v.Args[1] {
   1103 			break
   1104 		}
   1105 		v.reset(Op386LEAL2)
   1106 		v.AddArg(y)
   1107 		v.AddArg(x)
   1108 		return true
   1109 	}
   1110 	return false
   1111 }
   1112 func rewriteValue386_Op386ADDL_20(v *Value) bool {
   1113 	// match: (ADDL (ADDLconst [c] x) y)
   1114 	// cond:
   1115 	// result: (LEAL1 [c] x y)
   1116 	for {
   1117 		_ = v.Args[1]
   1118 		v_0 := v.Args[0]
   1119 		if v_0.Op != Op386ADDLconst {
   1120 			break
   1121 		}
   1122 		c := v_0.AuxInt
   1123 		x := v_0.Args[0]
   1124 		y := v.Args[1]
   1125 		v.reset(Op386LEAL1)
   1126 		v.AuxInt = c
   1127 		v.AddArg(x)
   1128 		v.AddArg(y)
   1129 		return true
   1130 	}
   1131 	// match: (ADDL y (ADDLconst [c] x))
   1132 	// cond:
   1133 	// result: (LEAL1 [c] x y)
   1134 	for {
   1135 		_ = v.Args[1]
   1136 		y := v.Args[0]
   1137 		v_1 := v.Args[1]
   1138 		if v_1.Op != Op386ADDLconst {
   1139 			break
   1140 		}
   1141 		c := v_1.AuxInt
   1142 		x := v_1.Args[0]
   1143 		v.reset(Op386LEAL1)
   1144 		v.AuxInt = c
   1145 		v.AddArg(x)
   1146 		v.AddArg(y)
   1147 		return true
   1148 	}
   1149 	// match: (ADDL x (LEAL [c] {s} y))
   1150 	// cond: x.Op != OpSB && y.Op != OpSB
   1151 	// result: (LEAL1 [c] {s} x y)
   1152 	for {
   1153 		_ = v.Args[1]
   1154 		x := v.Args[0]
   1155 		v_1 := v.Args[1]
   1156 		if v_1.Op != Op386LEAL {
   1157 			break
   1158 		}
   1159 		c := v_1.AuxInt
   1160 		s := v_1.Aux
   1161 		y := v_1.Args[0]
   1162 		if !(x.Op != OpSB && y.Op != OpSB) {
   1163 			break
   1164 		}
   1165 		v.reset(Op386LEAL1)
   1166 		v.AuxInt = c
   1167 		v.Aux = s
   1168 		v.AddArg(x)
   1169 		v.AddArg(y)
   1170 		return true
   1171 	}
   1172 	// match: (ADDL (LEAL [c] {s} y) x)
   1173 	// cond: x.Op != OpSB && y.Op != OpSB
   1174 	// result: (LEAL1 [c] {s} x y)
   1175 	for {
   1176 		_ = v.Args[1]
   1177 		v_0 := v.Args[0]
   1178 		if v_0.Op != Op386LEAL {
   1179 			break
   1180 		}
   1181 		c := v_0.AuxInt
   1182 		s := v_0.Aux
   1183 		y := v_0.Args[0]
   1184 		x := v.Args[1]
   1185 		if !(x.Op != OpSB && y.Op != OpSB) {
   1186 			break
   1187 		}
   1188 		v.reset(Op386LEAL1)
   1189 		v.AuxInt = c
   1190 		v.Aux = s
   1191 		v.AddArg(x)
   1192 		v.AddArg(y)
   1193 		return true
   1194 	}
   1195 	// match: (ADDL x (NEGL y))
   1196 	// cond:
   1197 	// result: (SUBL x y)
   1198 	for {
   1199 		_ = v.Args[1]
   1200 		x := v.Args[0]
   1201 		v_1 := v.Args[1]
   1202 		if v_1.Op != Op386NEGL {
   1203 			break
   1204 		}
   1205 		y := v_1.Args[0]
   1206 		v.reset(Op386SUBL)
   1207 		v.AddArg(x)
   1208 		v.AddArg(y)
   1209 		return true
   1210 	}
   1211 	// match: (ADDL (NEGL y) x)
   1212 	// cond:
   1213 	// result: (SUBL x y)
   1214 	for {
   1215 		_ = v.Args[1]
   1216 		v_0 := v.Args[0]
   1217 		if v_0.Op != Op386NEGL {
   1218 			break
   1219 		}
   1220 		y := v_0.Args[0]
   1221 		x := v.Args[1]
   1222 		v.reset(Op386SUBL)
   1223 		v.AddArg(x)
   1224 		v.AddArg(y)
   1225 		return true
   1226 	}
   1227 	return false
   1228 }
   1229 func rewriteValue386_Op386ADDLcarry_0(v *Value) bool {
   1230 	// match: (ADDLcarry x (MOVLconst [c]))
   1231 	// cond:
   1232 	// result: (ADDLconstcarry [c] x)
   1233 	for {
   1234 		_ = v.Args[1]
   1235 		x := v.Args[0]
   1236 		v_1 := v.Args[1]
   1237 		if v_1.Op != Op386MOVLconst {
   1238 			break
   1239 		}
   1240 		c := v_1.AuxInt
   1241 		v.reset(Op386ADDLconstcarry)
   1242 		v.AuxInt = c
   1243 		v.AddArg(x)
   1244 		return true
   1245 	}
   1246 	// match: (ADDLcarry (MOVLconst [c]) x)
   1247 	// cond:
   1248 	// result: (ADDLconstcarry [c] x)
   1249 	for {
   1250 		_ = v.Args[1]
   1251 		v_0 := v.Args[0]
   1252 		if v_0.Op != Op386MOVLconst {
   1253 			break
   1254 		}
   1255 		c := v_0.AuxInt
   1256 		x := v.Args[1]
   1257 		v.reset(Op386ADDLconstcarry)
   1258 		v.AuxInt = c
   1259 		v.AddArg(x)
   1260 		return true
   1261 	}
   1262 	return false
   1263 }
   1264 func rewriteValue386_Op386ADDLconst_0(v *Value) bool {
   1265 	// match: (ADDLconst [c] (ADDL x y))
   1266 	// cond:
   1267 	// result: (LEAL1 [c] x y)
   1268 	for {
   1269 		c := v.AuxInt
   1270 		v_0 := v.Args[0]
   1271 		if v_0.Op != Op386ADDL {
   1272 			break
   1273 		}
   1274 		_ = v_0.Args[1]
   1275 		x := v_0.Args[0]
   1276 		y := v_0.Args[1]
   1277 		v.reset(Op386LEAL1)
   1278 		v.AuxInt = c
   1279 		v.AddArg(x)
   1280 		v.AddArg(y)
   1281 		return true
   1282 	}
   1283 	// match: (ADDLconst [c] (LEAL [d] {s} x))
   1284 	// cond: is32Bit(c+d)
   1285 	// result: (LEAL [c+d] {s} x)
   1286 	for {
   1287 		c := v.AuxInt
   1288 		v_0 := v.Args[0]
   1289 		if v_0.Op != Op386LEAL {
   1290 			break
   1291 		}
   1292 		d := v_0.AuxInt
   1293 		s := v_0.Aux
   1294 		x := v_0.Args[0]
   1295 		if !(is32Bit(c + d)) {
   1296 			break
   1297 		}
   1298 		v.reset(Op386LEAL)
   1299 		v.AuxInt = c + d
   1300 		v.Aux = s
   1301 		v.AddArg(x)
   1302 		return true
   1303 	}
   1304 	// match: (ADDLconst [c] (LEAL1 [d] {s} x y))
   1305 	// cond: is32Bit(c+d)
   1306 	// result: (LEAL1 [c+d] {s} x y)
   1307 	for {
   1308 		c := v.AuxInt
   1309 		v_0 := v.Args[0]
   1310 		if v_0.Op != Op386LEAL1 {
   1311 			break
   1312 		}
   1313 		d := v_0.AuxInt
   1314 		s := v_0.Aux
   1315 		_ = v_0.Args[1]
   1316 		x := v_0.Args[0]
   1317 		y := v_0.Args[1]
   1318 		if !(is32Bit(c + d)) {
   1319 			break
   1320 		}
   1321 		v.reset(Op386LEAL1)
   1322 		v.AuxInt = c + d
   1323 		v.Aux = s
   1324 		v.AddArg(x)
   1325 		v.AddArg(y)
   1326 		return true
   1327 	}
   1328 	// match: (ADDLconst [c] (LEAL2 [d] {s} x y))
   1329 	// cond: is32Bit(c+d)
   1330 	// result: (LEAL2 [c+d] {s} x y)
   1331 	for {
   1332 		c := v.AuxInt
   1333 		v_0 := v.Args[0]
   1334 		if v_0.Op != Op386LEAL2 {
   1335 			break
   1336 		}
   1337 		d := v_0.AuxInt
   1338 		s := v_0.Aux
   1339 		_ = v_0.Args[1]
   1340 		x := v_0.Args[0]
   1341 		y := v_0.Args[1]
   1342 		if !(is32Bit(c + d)) {
   1343 			break
   1344 		}
   1345 		v.reset(Op386LEAL2)
   1346 		v.AuxInt = c + d
   1347 		v.Aux = s
   1348 		v.AddArg(x)
   1349 		v.AddArg(y)
   1350 		return true
   1351 	}
   1352 	// match: (ADDLconst [c] (LEAL4 [d] {s} x y))
   1353 	// cond: is32Bit(c+d)
   1354 	// result: (LEAL4 [c+d] {s} x y)
   1355 	for {
   1356 		c := v.AuxInt
   1357 		v_0 := v.Args[0]
   1358 		if v_0.Op != Op386LEAL4 {
   1359 			break
   1360 		}
   1361 		d := v_0.AuxInt
   1362 		s := v_0.Aux
   1363 		_ = v_0.Args[1]
   1364 		x := v_0.Args[0]
   1365 		y := v_0.Args[1]
   1366 		if !(is32Bit(c + d)) {
   1367 			break
   1368 		}
   1369 		v.reset(Op386LEAL4)
   1370 		v.AuxInt = c + d
   1371 		v.Aux = s
   1372 		v.AddArg(x)
   1373 		v.AddArg(y)
   1374 		return true
   1375 	}
   1376 	// match: (ADDLconst [c] (LEAL8 [d] {s} x y))
   1377 	// cond: is32Bit(c+d)
   1378 	// result: (LEAL8 [c+d] {s} x y)
   1379 	for {
   1380 		c := v.AuxInt
   1381 		v_0 := v.Args[0]
   1382 		if v_0.Op != Op386LEAL8 {
   1383 			break
   1384 		}
   1385 		d := v_0.AuxInt
   1386 		s := v_0.Aux
   1387 		_ = v_0.Args[1]
   1388 		x := v_0.Args[0]
   1389 		y := v_0.Args[1]
   1390 		if !(is32Bit(c + d)) {
   1391 			break
   1392 		}
   1393 		v.reset(Op386LEAL8)
   1394 		v.AuxInt = c + d
   1395 		v.Aux = s
   1396 		v.AddArg(x)
   1397 		v.AddArg(y)
   1398 		return true
   1399 	}
   1400 	// match: (ADDLconst [c] x)
   1401 	// cond: int32(c)==0
   1402 	// result: x
   1403 	for {
   1404 		c := v.AuxInt
   1405 		x := v.Args[0]
   1406 		if !(int32(c) == 0) {
   1407 			break
   1408 		}
   1409 		v.reset(OpCopy)
   1410 		v.Type = x.Type
   1411 		v.AddArg(x)
   1412 		return true
   1413 	}
   1414 	// match: (ADDLconst [c] (MOVLconst [d]))
   1415 	// cond:
   1416 	// result: (MOVLconst [int64(int32(c+d))])
   1417 	for {
   1418 		c := v.AuxInt
   1419 		v_0 := v.Args[0]
   1420 		if v_0.Op != Op386MOVLconst {
   1421 			break
   1422 		}
   1423 		d := v_0.AuxInt
   1424 		v.reset(Op386MOVLconst)
   1425 		v.AuxInt = int64(int32(c + d))
   1426 		return true
   1427 	}
   1428 	// match: (ADDLconst [c] (ADDLconst [d] x))
   1429 	// cond:
   1430 	// result: (ADDLconst [int64(int32(c+d))] x)
   1431 	for {
   1432 		c := v.AuxInt
   1433 		v_0 := v.Args[0]
   1434 		if v_0.Op != Op386ADDLconst {
   1435 			break
   1436 		}
   1437 		d := v_0.AuxInt
   1438 		x := v_0.Args[0]
   1439 		v.reset(Op386ADDLconst)
   1440 		v.AuxInt = int64(int32(c + d))
   1441 		v.AddArg(x)
   1442 		return true
   1443 	}
   1444 	return false
   1445 }
   1446 func rewriteValue386_Op386ANDL_0(v *Value) bool {
   1447 	// match: (ANDL x (MOVLconst [c]))
   1448 	// cond:
   1449 	// result: (ANDLconst [c] x)
   1450 	for {
   1451 		_ = v.Args[1]
   1452 		x := v.Args[0]
   1453 		v_1 := v.Args[1]
   1454 		if v_1.Op != Op386MOVLconst {
   1455 			break
   1456 		}
   1457 		c := v_1.AuxInt
   1458 		v.reset(Op386ANDLconst)
   1459 		v.AuxInt = c
   1460 		v.AddArg(x)
   1461 		return true
   1462 	}
   1463 	// match: (ANDL (MOVLconst [c]) x)
   1464 	// cond:
   1465 	// result: (ANDLconst [c] x)
   1466 	for {
   1467 		_ = v.Args[1]
   1468 		v_0 := v.Args[0]
   1469 		if v_0.Op != Op386MOVLconst {
   1470 			break
   1471 		}
   1472 		c := v_0.AuxInt
   1473 		x := v.Args[1]
   1474 		v.reset(Op386ANDLconst)
   1475 		v.AuxInt = c
   1476 		v.AddArg(x)
   1477 		return true
   1478 	}
   1479 	// match: (ANDL x x)
   1480 	// cond:
   1481 	// result: x
   1482 	for {
   1483 		_ = v.Args[1]
   1484 		x := v.Args[0]
   1485 		if x != v.Args[1] {
   1486 			break
   1487 		}
   1488 		v.reset(OpCopy)
   1489 		v.Type = x.Type
   1490 		v.AddArg(x)
   1491 		return true
   1492 	}
   1493 	return false
   1494 }
   1495 func rewriteValue386_Op386ANDLconst_0(v *Value) bool {
   1496 	// match: (ANDLconst [c] (ANDLconst [d] x))
   1497 	// cond:
   1498 	// result: (ANDLconst [c & d] x)
   1499 	for {
   1500 		c := v.AuxInt
   1501 		v_0 := v.Args[0]
   1502 		if v_0.Op != Op386ANDLconst {
   1503 			break
   1504 		}
   1505 		d := v_0.AuxInt
   1506 		x := v_0.Args[0]
   1507 		v.reset(Op386ANDLconst)
   1508 		v.AuxInt = c & d
   1509 		v.AddArg(x)
   1510 		return true
   1511 	}
   1512 	// match: (ANDLconst [c] _)
   1513 	// cond: int32(c)==0
   1514 	// result: (MOVLconst [0])
   1515 	for {
   1516 		c := v.AuxInt
   1517 		if !(int32(c) == 0) {
   1518 			break
   1519 		}
   1520 		v.reset(Op386MOVLconst)
   1521 		v.AuxInt = 0
   1522 		return true
   1523 	}
   1524 	// match: (ANDLconst [c] x)
   1525 	// cond: int32(c)==-1
   1526 	// result: x
   1527 	for {
   1528 		c := v.AuxInt
   1529 		x := v.Args[0]
   1530 		if !(int32(c) == -1) {
   1531 			break
   1532 		}
   1533 		v.reset(OpCopy)
   1534 		v.Type = x.Type
   1535 		v.AddArg(x)
   1536 		return true
   1537 	}
   1538 	// match: (ANDLconst [c] (MOVLconst [d]))
   1539 	// cond:
   1540 	// result: (MOVLconst [c&d])
   1541 	for {
   1542 		c := v.AuxInt
   1543 		v_0 := v.Args[0]
   1544 		if v_0.Op != Op386MOVLconst {
   1545 			break
   1546 		}
   1547 		d := v_0.AuxInt
   1548 		v.reset(Op386MOVLconst)
   1549 		v.AuxInt = c & d
   1550 		return true
   1551 	}
   1552 	return false
   1553 }
   1554 func rewriteValue386_Op386CMPB_0(v *Value) bool {
   1555 	b := v.Block
   1556 	_ = b
   1557 	// match: (CMPB x (MOVLconst [c]))
   1558 	// cond:
   1559 	// result: (CMPBconst x [int64(int8(c))])
   1560 	for {
   1561 		_ = v.Args[1]
   1562 		x := v.Args[0]
   1563 		v_1 := v.Args[1]
   1564 		if v_1.Op != Op386MOVLconst {
   1565 			break
   1566 		}
   1567 		c := v_1.AuxInt
   1568 		v.reset(Op386CMPBconst)
   1569 		v.AuxInt = int64(int8(c))
   1570 		v.AddArg(x)
   1571 		return true
   1572 	}
   1573 	// match: (CMPB (MOVLconst [c]) x)
   1574 	// cond:
   1575 	// result: (InvertFlags (CMPBconst x [int64(int8(c))]))
   1576 	for {
   1577 		_ = v.Args[1]
   1578 		v_0 := v.Args[0]
   1579 		if v_0.Op != Op386MOVLconst {
   1580 			break
   1581 		}
   1582 		c := v_0.AuxInt
   1583 		x := v.Args[1]
   1584 		v.reset(Op386InvertFlags)
   1585 		v0 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   1586 		v0.AuxInt = int64(int8(c))
   1587 		v0.AddArg(x)
   1588 		v.AddArg(v0)
   1589 		return true
   1590 	}
   1591 	return false
   1592 }
   1593 func rewriteValue386_Op386CMPBconst_0(v *Value) bool {
   1594 	// match: (CMPBconst (MOVLconst [x]) [y])
   1595 	// cond: int8(x)==int8(y)
   1596 	// result: (FlagEQ)
   1597 	for {
   1598 		y := v.AuxInt
   1599 		v_0 := v.Args[0]
   1600 		if v_0.Op != Op386MOVLconst {
   1601 			break
   1602 		}
   1603 		x := v_0.AuxInt
   1604 		if !(int8(x) == int8(y)) {
   1605 			break
   1606 		}
   1607 		v.reset(Op386FlagEQ)
   1608 		return true
   1609 	}
   1610 	// match: (CMPBconst (MOVLconst [x]) [y])
   1611 	// cond: int8(x)<int8(y) && uint8(x)<uint8(y)
   1612 	// result: (FlagLT_ULT)
   1613 	for {
   1614 		y := v.AuxInt
   1615 		v_0 := v.Args[0]
   1616 		if v_0.Op != Op386MOVLconst {
   1617 			break
   1618 		}
   1619 		x := v_0.AuxInt
   1620 		if !(int8(x) < int8(y) && uint8(x) < uint8(y)) {
   1621 			break
   1622 		}
   1623 		v.reset(Op386FlagLT_ULT)
   1624 		return true
   1625 	}
   1626 	// match: (CMPBconst (MOVLconst [x]) [y])
   1627 	// cond: int8(x)<int8(y) && uint8(x)>uint8(y)
   1628 	// result: (FlagLT_UGT)
   1629 	for {
   1630 		y := v.AuxInt
   1631 		v_0 := v.Args[0]
   1632 		if v_0.Op != Op386MOVLconst {
   1633 			break
   1634 		}
   1635 		x := v_0.AuxInt
   1636 		if !(int8(x) < int8(y) && uint8(x) > uint8(y)) {
   1637 			break
   1638 		}
   1639 		v.reset(Op386FlagLT_UGT)
   1640 		return true
   1641 	}
   1642 	// match: (CMPBconst (MOVLconst [x]) [y])
   1643 	// cond: int8(x)>int8(y) && uint8(x)<uint8(y)
   1644 	// result: (FlagGT_ULT)
   1645 	for {
   1646 		y := v.AuxInt
   1647 		v_0 := v.Args[0]
   1648 		if v_0.Op != Op386MOVLconst {
   1649 			break
   1650 		}
   1651 		x := v_0.AuxInt
   1652 		if !(int8(x) > int8(y) && uint8(x) < uint8(y)) {
   1653 			break
   1654 		}
   1655 		v.reset(Op386FlagGT_ULT)
   1656 		return true
   1657 	}
   1658 	// match: (CMPBconst (MOVLconst [x]) [y])
   1659 	// cond: int8(x)>int8(y) && uint8(x)>uint8(y)
   1660 	// result: (FlagGT_UGT)
   1661 	for {
   1662 		y := v.AuxInt
   1663 		v_0 := v.Args[0]
   1664 		if v_0.Op != Op386MOVLconst {
   1665 			break
   1666 		}
   1667 		x := v_0.AuxInt
   1668 		if !(int8(x) > int8(y) && uint8(x) > uint8(y)) {
   1669 			break
   1670 		}
   1671 		v.reset(Op386FlagGT_UGT)
   1672 		return true
   1673 	}
   1674 	// match: (CMPBconst (ANDLconst _ [m]) [n])
   1675 	// cond: 0 <= int8(m) && int8(m) < int8(n)
   1676 	// result: (FlagLT_ULT)
   1677 	for {
   1678 		n := v.AuxInt
   1679 		v_0 := v.Args[0]
   1680 		if v_0.Op != Op386ANDLconst {
   1681 			break
   1682 		}
   1683 		m := v_0.AuxInt
   1684 		if !(0 <= int8(m) && int8(m) < int8(n)) {
   1685 			break
   1686 		}
   1687 		v.reset(Op386FlagLT_ULT)
   1688 		return true
   1689 	}
   1690 	// match: (CMPBconst (ANDL x y) [0])
   1691 	// cond:
   1692 	// result: (TESTB x y)
   1693 	for {
   1694 		if v.AuxInt != 0 {
   1695 			break
   1696 		}
   1697 		v_0 := v.Args[0]
   1698 		if v_0.Op != Op386ANDL {
   1699 			break
   1700 		}
   1701 		_ = v_0.Args[1]
   1702 		x := v_0.Args[0]
   1703 		y := v_0.Args[1]
   1704 		v.reset(Op386TESTB)
   1705 		v.AddArg(x)
   1706 		v.AddArg(y)
   1707 		return true
   1708 	}
   1709 	// match: (CMPBconst (ANDLconst [c] x) [0])
   1710 	// cond:
   1711 	// result: (TESTBconst [int64(int8(c))] x)
   1712 	for {
   1713 		if v.AuxInt != 0 {
   1714 			break
   1715 		}
   1716 		v_0 := v.Args[0]
   1717 		if v_0.Op != Op386ANDLconst {
   1718 			break
   1719 		}
   1720 		c := v_0.AuxInt
   1721 		x := v_0.Args[0]
   1722 		v.reset(Op386TESTBconst)
   1723 		v.AuxInt = int64(int8(c))
   1724 		v.AddArg(x)
   1725 		return true
   1726 	}
   1727 	// match: (CMPBconst x [0])
   1728 	// cond:
   1729 	// result: (TESTB x x)
   1730 	for {
   1731 		if v.AuxInt != 0 {
   1732 			break
   1733 		}
   1734 		x := v.Args[0]
   1735 		v.reset(Op386TESTB)
   1736 		v.AddArg(x)
   1737 		v.AddArg(x)
   1738 		return true
   1739 	}
   1740 	return false
   1741 }
   1742 func rewriteValue386_Op386CMPL_0(v *Value) bool {
   1743 	b := v.Block
   1744 	_ = b
   1745 	// match: (CMPL x (MOVLconst [c]))
   1746 	// cond:
   1747 	// result: (CMPLconst x [c])
   1748 	for {
   1749 		_ = v.Args[1]
   1750 		x := v.Args[0]
   1751 		v_1 := v.Args[1]
   1752 		if v_1.Op != Op386MOVLconst {
   1753 			break
   1754 		}
   1755 		c := v_1.AuxInt
   1756 		v.reset(Op386CMPLconst)
   1757 		v.AuxInt = c
   1758 		v.AddArg(x)
   1759 		return true
   1760 	}
   1761 	// match: (CMPL (MOVLconst [c]) x)
   1762 	// cond:
   1763 	// result: (InvertFlags (CMPLconst x [c]))
   1764 	for {
   1765 		_ = v.Args[1]
   1766 		v_0 := v.Args[0]
   1767 		if v_0.Op != Op386MOVLconst {
   1768 			break
   1769 		}
   1770 		c := v_0.AuxInt
   1771 		x := v.Args[1]
   1772 		v.reset(Op386InvertFlags)
   1773 		v0 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   1774 		v0.AuxInt = c
   1775 		v0.AddArg(x)
   1776 		v.AddArg(v0)
   1777 		return true
   1778 	}
   1779 	return false
   1780 }
   1781 func rewriteValue386_Op386CMPLconst_0(v *Value) bool {
   1782 	// match: (CMPLconst (MOVLconst [x]) [y])
   1783 	// cond: int32(x)==int32(y)
   1784 	// result: (FlagEQ)
   1785 	for {
   1786 		y := v.AuxInt
   1787 		v_0 := v.Args[0]
   1788 		if v_0.Op != Op386MOVLconst {
   1789 			break
   1790 		}
   1791 		x := v_0.AuxInt
   1792 		if !(int32(x) == int32(y)) {
   1793 			break
   1794 		}
   1795 		v.reset(Op386FlagEQ)
   1796 		return true
   1797 	}
   1798 	// match: (CMPLconst (MOVLconst [x]) [y])
   1799 	// cond: int32(x)<int32(y) && uint32(x)<uint32(y)
   1800 	// result: (FlagLT_ULT)
   1801 	for {
   1802 		y := v.AuxInt
   1803 		v_0 := v.Args[0]
   1804 		if v_0.Op != Op386MOVLconst {
   1805 			break
   1806 		}
   1807 		x := v_0.AuxInt
   1808 		if !(int32(x) < int32(y) && uint32(x) < uint32(y)) {
   1809 			break
   1810 		}
   1811 		v.reset(Op386FlagLT_ULT)
   1812 		return true
   1813 	}
   1814 	// match: (CMPLconst (MOVLconst [x]) [y])
   1815 	// cond: int32(x)<int32(y) && uint32(x)>uint32(y)
   1816 	// result: (FlagLT_UGT)
   1817 	for {
   1818 		y := v.AuxInt
   1819 		v_0 := v.Args[0]
   1820 		if v_0.Op != Op386MOVLconst {
   1821 			break
   1822 		}
   1823 		x := v_0.AuxInt
   1824 		if !(int32(x) < int32(y) && uint32(x) > uint32(y)) {
   1825 			break
   1826 		}
   1827 		v.reset(Op386FlagLT_UGT)
   1828 		return true
   1829 	}
   1830 	// match: (CMPLconst (MOVLconst [x]) [y])
   1831 	// cond: int32(x)>int32(y) && uint32(x)<uint32(y)
   1832 	// result: (FlagGT_ULT)
   1833 	for {
   1834 		y := v.AuxInt
   1835 		v_0 := v.Args[0]
   1836 		if v_0.Op != Op386MOVLconst {
   1837 			break
   1838 		}
   1839 		x := v_0.AuxInt
   1840 		if !(int32(x) > int32(y) && uint32(x) < uint32(y)) {
   1841 			break
   1842 		}
   1843 		v.reset(Op386FlagGT_ULT)
   1844 		return true
   1845 	}
   1846 	// match: (CMPLconst (MOVLconst [x]) [y])
   1847 	// cond: int32(x)>int32(y) && uint32(x)>uint32(y)
   1848 	// result: (FlagGT_UGT)
   1849 	for {
   1850 		y := v.AuxInt
   1851 		v_0 := v.Args[0]
   1852 		if v_0.Op != Op386MOVLconst {
   1853 			break
   1854 		}
   1855 		x := v_0.AuxInt
   1856 		if !(int32(x) > int32(y) && uint32(x) > uint32(y)) {
   1857 			break
   1858 		}
   1859 		v.reset(Op386FlagGT_UGT)
   1860 		return true
   1861 	}
   1862 	// match: (CMPLconst (SHRLconst _ [c]) [n])
   1863 	// cond: 0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n)
   1864 	// result: (FlagLT_ULT)
   1865 	for {
   1866 		n := v.AuxInt
   1867 		v_0 := v.Args[0]
   1868 		if v_0.Op != Op386SHRLconst {
   1869 			break
   1870 		}
   1871 		c := v_0.AuxInt
   1872 		if !(0 <= n && 0 < c && c <= 32 && (1<<uint64(32-c)) <= uint64(n)) {
   1873 			break
   1874 		}
   1875 		v.reset(Op386FlagLT_ULT)
   1876 		return true
   1877 	}
   1878 	// match: (CMPLconst (ANDLconst _ [m]) [n])
   1879 	// cond: 0 <= int32(m) && int32(m) < int32(n)
   1880 	// result: (FlagLT_ULT)
   1881 	for {
   1882 		n := v.AuxInt
   1883 		v_0 := v.Args[0]
   1884 		if v_0.Op != Op386ANDLconst {
   1885 			break
   1886 		}
   1887 		m := v_0.AuxInt
   1888 		if !(0 <= int32(m) && int32(m) < int32(n)) {
   1889 			break
   1890 		}
   1891 		v.reset(Op386FlagLT_ULT)
   1892 		return true
   1893 	}
   1894 	// match: (CMPLconst (ANDL x y) [0])
   1895 	// cond:
   1896 	// result: (TESTL x y)
   1897 	for {
   1898 		if v.AuxInt != 0 {
   1899 			break
   1900 		}
   1901 		v_0 := v.Args[0]
   1902 		if v_0.Op != Op386ANDL {
   1903 			break
   1904 		}
   1905 		_ = v_0.Args[1]
   1906 		x := v_0.Args[0]
   1907 		y := v_0.Args[1]
   1908 		v.reset(Op386TESTL)
   1909 		v.AddArg(x)
   1910 		v.AddArg(y)
   1911 		return true
   1912 	}
   1913 	// match: (CMPLconst (ANDLconst [c] x) [0])
   1914 	// cond:
   1915 	// result: (TESTLconst [c] x)
   1916 	for {
   1917 		if v.AuxInt != 0 {
   1918 			break
   1919 		}
   1920 		v_0 := v.Args[0]
   1921 		if v_0.Op != Op386ANDLconst {
   1922 			break
   1923 		}
   1924 		c := v_0.AuxInt
   1925 		x := v_0.Args[0]
   1926 		v.reset(Op386TESTLconst)
   1927 		v.AuxInt = c
   1928 		v.AddArg(x)
   1929 		return true
   1930 	}
   1931 	// match: (CMPLconst x [0])
   1932 	// cond:
   1933 	// result: (TESTL x x)
   1934 	for {
   1935 		if v.AuxInt != 0 {
   1936 			break
   1937 		}
   1938 		x := v.Args[0]
   1939 		v.reset(Op386TESTL)
   1940 		v.AddArg(x)
   1941 		v.AddArg(x)
   1942 		return true
   1943 	}
   1944 	return false
   1945 }
   1946 func rewriteValue386_Op386CMPW_0(v *Value) bool {
   1947 	b := v.Block
   1948 	_ = b
   1949 	// match: (CMPW x (MOVLconst [c]))
   1950 	// cond:
   1951 	// result: (CMPWconst x [int64(int16(c))])
   1952 	for {
   1953 		_ = v.Args[1]
   1954 		x := v.Args[0]
   1955 		v_1 := v.Args[1]
   1956 		if v_1.Op != Op386MOVLconst {
   1957 			break
   1958 		}
   1959 		c := v_1.AuxInt
   1960 		v.reset(Op386CMPWconst)
   1961 		v.AuxInt = int64(int16(c))
   1962 		v.AddArg(x)
   1963 		return true
   1964 	}
   1965 	// match: (CMPW (MOVLconst [c]) x)
   1966 	// cond:
   1967 	// result: (InvertFlags (CMPWconst x [int64(int16(c))]))
   1968 	for {
   1969 		_ = v.Args[1]
   1970 		v_0 := v.Args[0]
   1971 		if v_0.Op != Op386MOVLconst {
   1972 			break
   1973 		}
   1974 		c := v_0.AuxInt
   1975 		x := v.Args[1]
   1976 		v.reset(Op386InvertFlags)
   1977 		v0 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   1978 		v0.AuxInt = int64(int16(c))
   1979 		v0.AddArg(x)
   1980 		v.AddArg(v0)
   1981 		return true
   1982 	}
   1983 	return false
   1984 }
   1985 func rewriteValue386_Op386CMPWconst_0(v *Value) bool {
   1986 	// match: (CMPWconst (MOVLconst [x]) [y])
   1987 	// cond: int16(x)==int16(y)
   1988 	// result: (FlagEQ)
   1989 	for {
   1990 		y := v.AuxInt
   1991 		v_0 := v.Args[0]
   1992 		if v_0.Op != Op386MOVLconst {
   1993 			break
   1994 		}
   1995 		x := v_0.AuxInt
   1996 		if !(int16(x) == int16(y)) {
   1997 			break
   1998 		}
   1999 		v.reset(Op386FlagEQ)
   2000 		return true
   2001 	}
   2002 	// match: (CMPWconst (MOVLconst [x]) [y])
   2003 	// cond: int16(x)<int16(y) && uint16(x)<uint16(y)
   2004 	// result: (FlagLT_ULT)
   2005 	for {
   2006 		y := v.AuxInt
   2007 		v_0 := v.Args[0]
   2008 		if v_0.Op != Op386MOVLconst {
   2009 			break
   2010 		}
   2011 		x := v_0.AuxInt
   2012 		if !(int16(x) < int16(y) && uint16(x) < uint16(y)) {
   2013 			break
   2014 		}
   2015 		v.reset(Op386FlagLT_ULT)
   2016 		return true
   2017 	}
   2018 	// match: (CMPWconst (MOVLconst [x]) [y])
   2019 	// cond: int16(x)<int16(y) && uint16(x)>uint16(y)
   2020 	// result: (FlagLT_UGT)
   2021 	for {
   2022 		y := v.AuxInt
   2023 		v_0 := v.Args[0]
   2024 		if v_0.Op != Op386MOVLconst {
   2025 			break
   2026 		}
   2027 		x := v_0.AuxInt
   2028 		if !(int16(x) < int16(y) && uint16(x) > uint16(y)) {
   2029 			break
   2030 		}
   2031 		v.reset(Op386FlagLT_UGT)
   2032 		return true
   2033 	}
   2034 	// match: (CMPWconst (MOVLconst [x]) [y])
   2035 	// cond: int16(x)>int16(y) && uint16(x)<uint16(y)
   2036 	// result: (FlagGT_ULT)
   2037 	for {
   2038 		y := v.AuxInt
   2039 		v_0 := v.Args[0]
   2040 		if v_0.Op != Op386MOVLconst {
   2041 			break
   2042 		}
   2043 		x := v_0.AuxInt
   2044 		if !(int16(x) > int16(y) && uint16(x) < uint16(y)) {
   2045 			break
   2046 		}
   2047 		v.reset(Op386FlagGT_ULT)
   2048 		return true
   2049 	}
   2050 	// match: (CMPWconst (MOVLconst [x]) [y])
   2051 	// cond: int16(x)>int16(y) && uint16(x)>uint16(y)
   2052 	// result: (FlagGT_UGT)
   2053 	for {
   2054 		y := v.AuxInt
   2055 		v_0 := v.Args[0]
   2056 		if v_0.Op != Op386MOVLconst {
   2057 			break
   2058 		}
   2059 		x := v_0.AuxInt
   2060 		if !(int16(x) > int16(y) && uint16(x) > uint16(y)) {
   2061 			break
   2062 		}
   2063 		v.reset(Op386FlagGT_UGT)
   2064 		return true
   2065 	}
   2066 	// match: (CMPWconst (ANDLconst _ [m]) [n])
   2067 	// cond: 0 <= int16(m) && int16(m) < int16(n)
   2068 	// result: (FlagLT_ULT)
   2069 	for {
   2070 		n := v.AuxInt
   2071 		v_0 := v.Args[0]
   2072 		if v_0.Op != Op386ANDLconst {
   2073 			break
   2074 		}
   2075 		m := v_0.AuxInt
   2076 		if !(0 <= int16(m) && int16(m) < int16(n)) {
   2077 			break
   2078 		}
   2079 		v.reset(Op386FlagLT_ULT)
   2080 		return true
   2081 	}
   2082 	// match: (CMPWconst (ANDL x y) [0])
   2083 	// cond:
   2084 	// result: (TESTW x y)
   2085 	for {
   2086 		if v.AuxInt != 0 {
   2087 			break
   2088 		}
   2089 		v_0 := v.Args[0]
   2090 		if v_0.Op != Op386ANDL {
   2091 			break
   2092 		}
   2093 		_ = v_0.Args[1]
   2094 		x := v_0.Args[0]
   2095 		y := v_0.Args[1]
   2096 		v.reset(Op386TESTW)
   2097 		v.AddArg(x)
   2098 		v.AddArg(y)
   2099 		return true
   2100 	}
   2101 	// match: (CMPWconst (ANDLconst [c] x) [0])
   2102 	// cond:
   2103 	// result: (TESTWconst [int64(int16(c))] x)
   2104 	for {
   2105 		if v.AuxInt != 0 {
   2106 			break
   2107 		}
   2108 		v_0 := v.Args[0]
   2109 		if v_0.Op != Op386ANDLconst {
   2110 			break
   2111 		}
   2112 		c := v_0.AuxInt
   2113 		x := v_0.Args[0]
   2114 		v.reset(Op386TESTWconst)
   2115 		v.AuxInt = int64(int16(c))
   2116 		v.AddArg(x)
   2117 		return true
   2118 	}
   2119 	// match: (CMPWconst x [0])
   2120 	// cond:
   2121 	// result: (TESTW x x)
   2122 	for {
   2123 		if v.AuxInt != 0 {
   2124 			break
   2125 		}
   2126 		x := v.Args[0]
   2127 		v.reset(Op386TESTW)
   2128 		v.AddArg(x)
   2129 		v.AddArg(x)
   2130 		return true
   2131 	}
   2132 	return false
   2133 }
   2134 func rewriteValue386_Op386LEAL_0(v *Value) bool {
   2135 	// match: (LEAL [c] {s} (ADDLconst [d] x))
   2136 	// cond: is32Bit(c+d)
   2137 	// result: (LEAL [c+d] {s} x)
   2138 	for {
   2139 		c := v.AuxInt
   2140 		s := v.Aux
   2141 		v_0 := v.Args[0]
   2142 		if v_0.Op != Op386ADDLconst {
   2143 			break
   2144 		}
   2145 		d := v_0.AuxInt
   2146 		x := v_0.Args[0]
   2147 		if !(is32Bit(c + d)) {
   2148 			break
   2149 		}
   2150 		v.reset(Op386LEAL)
   2151 		v.AuxInt = c + d
   2152 		v.Aux = s
   2153 		v.AddArg(x)
   2154 		return true
   2155 	}
   2156 	// match: (LEAL [c] {s} (ADDL x y))
   2157 	// cond: x.Op != OpSB && y.Op != OpSB
   2158 	// result: (LEAL1 [c] {s} x y)
   2159 	for {
   2160 		c := v.AuxInt
   2161 		s := v.Aux
   2162 		v_0 := v.Args[0]
   2163 		if v_0.Op != Op386ADDL {
   2164 			break
   2165 		}
   2166 		_ = v_0.Args[1]
   2167 		x := v_0.Args[0]
   2168 		y := v_0.Args[1]
   2169 		if !(x.Op != OpSB && y.Op != OpSB) {
   2170 			break
   2171 		}
   2172 		v.reset(Op386LEAL1)
   2173 		v.AuxInt = c
   2174 		v.Aux = s
   2175 		v.AddArg(x)
   2176 		v.AddArg(y)
   2177 		return true
   2178 	}
   2179 	// match: (LEAL [off1] {sym1} (LEAL [off2] {sym2} x))
   2180 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   2181 	// result: (LEAL [off1+off2] {mergeSym(sym1,sym2)} x)
   2182 	for {
   2183 		off1 := v.AuxInt
   2184 		sym1 := v.Aux
   2185 		v_0 := v.Args[0]
   2186 		if v_0.Op != Op386LEAL {
   2187 			break
   2188 		}
   2189 		off2 := v_0.AuxInt
   2190 		sym2 := v_0.Aux
   2191 		x := v_0.Args[0]
   2192 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   2193 			break
   2194 		}
   2195 		v.reset(Op386LEAL)
   2196 		v.AuxInt = off1 + off2
   2197 		v.Aux = mergeSym(sym1, sym2)
   2198 		v.AddArg(x)
   2199 		return true
   2200 	}
   2201 	// match: (LEAL [off1] {sym1} (LEAL1 [off2] {sym2} x y))
   2202 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   2203 	// result: (LEAL1 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2204 	for {
   2205 		off1 := v.AuxInt
   2206 		sym1 := v.Aux
   2207 		v_0 := v.Args[0]
   2208 		if v_0.Op != Op386LEAL1 {
   2209 			break
   2210 		}
   2211 		off2 := v_0.AuxInt
   2212 		sym2 := v_0.Aux
   2213 		_ = v_0.Args[1]
   2214 		x := v_0.Args[0]
   2215 		y := v_0.Args[1]
   2216 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   2217 			break
   2218 		}
   2219 		v.reset(Op386LEAL1)
   2220 		v.AuxInt = off1 + off2
   2221 		v.Aux = mergeSym(sym1, sym2)
   2222 		v.AddArg(x)
   2223 		v.AddArg(y)
   2224 		return true
   2225 	}
   2226 	// match: (LEAL [off1] {sym1} (LEAL2 [off2] {sym2} x y))
   2227 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   2228 	// result: (LEAL2 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2229 	for {
   2230 		off1 := v.AuxInt
   2231 		sym1 := v.Aux
   2232 		v_0 := v.Args[0]
   2233 		if v_0.Op != Op386LEAL2 {
   2234 			break
   2235 		}
   2236 		off2 := v_0.AuxInt
   2237 		sym2 := v_0.Aux
   2238 		_ = v_0.Args[1]
   2239 		x := v_0.Args[0]
   2240 		y := v_0.Args[1]
   2241 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   2242 			break
   2243 		}
   2244 		v.reset(Op386LEAL2)
   2245 		v.AuxInt = off1 + off2
   2246 		v.Aux = mergeSym(sym1, sym2)
   2247 		v.AddArg(x)
   2248 		v.AddArg(y)
   2249 		return true
   2250 	}
   2251 	// match: (LEAL [off1] {sym1} (LEAL4 [off2] {sym2} x y))
   2252 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   2253 	// result: (LEAL4 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2254 	for {
   2255 		off1 := v.AuxInt
   2256 		sym1 := v.Aux
   2257 		v_0 := v.Args[0]
   2258 		if v_0.Op != Op386LEAL4 {
   2259 			break
   2260 		}
   2261 		off2 := v_0.AuxInt
   2262 		sym2 := v_0.Aux
   2263 		_ = v_0.Args[1]
   2264 		x := v_0.Args[0]
   2265 		y := v_0.Args[1]
   2266 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   2267 			break
   2268 		}
   2269 		v.reset(Op386LEAL4)
   2270 		v.AuxInt = off1 + off2
   2271 		v.Aux = mergeSym(sym1, sym2)
   2272 		v.AddArg(x)
   2273 		v.AddArg(y)
   2274 		return true
   2275 	}
   2276 	// match: (LEAL [off1] {sym1} (LEAL8 [off2] {sym2} x y))
   2277 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   2278 	// result: (LEAL8 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2279 	for {
   2280 		off1 := v.AuxInt
   2281 		sym1 := v.Aux
   2282 		v_0 := v.Args[0]
   2283 		if v_0.Op != Op386LEAL8 {
   2284 			break
   2285 		}
   2286 		off2 := v_0.AuxInt
   2287 		sym2 := v_0.Aux
   2288 		_ = v_0.Args[1]
   2289 		x := v_0.Args[0]
   2290 		y := v_0.Args[1]
   2291 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   2292 			break
   2293 		}
   2294 		v.reset(Op386LEAL8)
   2295 		v.AuxInt = off1 + off2
   2296 		v.Aux = mergeSym(sym1, sym2)
   2297 		v.AddArg(x)
   2298 		v.AddArg(y)
   2299 		return true
   2300 	}
   2301 	return false
   2302 }
   2303 func rewriteValue386_Op386LEAL1_0(v *Value) bool {
   2304 	// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
   2305 	// cond: is32Bit(c+d)   && x.Op != OpSB
   2306 	// result: (LEAL1 [c+d] {s} x y)
   2307 	for {
   2308 		c := v.AuxInt
   2309 		s := v.Aux
   2310 		_ = v.Args[1]
   2311 		v_0 := v.Args[0]
   2312 		if v_0.Op != Op386ADDLconst {
   2313 			break
   2314 		}
   2315 		d := v_0.AuxInt
   2316 		x := v_0.Args[0]
   2317 		y := v.Args[1]
   2318 		if !(is32Bit(c+d) && x.Op != OpSB) {
   2319 			break
   2320 		}
   2321 		v.reset(Op386LEAL1)
   2322 		v.AuxInt = c + d
   2323 		v.Aux = s
   2324 		v.AddArg(x)
   2325 		v.AddArg(y)
   2326 		return true
   2327 	}
   2328 	// match: (LEAL1 [c] {s} y (ADDLconst [d] x))
   2329 	// cond: is32Bit(c+d)   && x.Op != OpSB
   2330 	// result: (LEAL1 [c+d] {s} x y)
   2331 	for {
   2332 		c := v.AuxInt
   2333 		s := v.Aux
   2334 		_ = v.Args[1]
   2335 		y := v.Args[0]
   2336 		v_1 := v.Args[1]
   2337 		if v_1.Op != Op386ADDLconst {
   2338 			break
   2339 		}
   2340 		d := v_1.AuxInt
   2341 		x := v_1.Args[0]
   2342 		if !(is32Bit(c+d) && x.Op != OpSB) {
   2343 			break
   2344 		}
   2345 		v.reset(Op386LEAL1)
   2346 		v.AuxInt = c + d
   2347 		v.Aux = s
   2348 		v.AddArg(x)
   2349 		v.AddArg(y)
   2350 		return true
   2351 	}
   2352 	// match: (LEAL1 [c] {s} x (SHLLconst [1] y))
   2353 	// cond:
   2354 	// result: (LEAL2 [c] {s} x y)
   2355 	for {
   2356 		c := v.AuxInt
   2357 		s := v.Aux
   2358 		_ = v.Args[1]
   2359 		x := v.Args[0]
   2360 		v_1 := v.Args[1]
   2361 		if v_1.Op != Op386SHLLconst {
   2362 			break
   2363 		}
   2364 		if v_1.AuxInt != 1 {
   2365 			break
   2366 		}
   2367 		y := v_1.Args[0]
   2368 		v.reset(Op386LEAL2)
   2369 		v.AuxInt = c
   2370 		v.Aux = s
   2371 		v.AddArg(x)
   2372 		v.AddArg(y)
   2373 		return true
   2374 	}
   2375 	// match: (LEAL1 [c] {s} (SHLLconst [1] y) x)
   2376 	// cond:
   2377 	// result: (LEAL2 [c] {s} x y)
   2378 	for {
   2379 		c := v.AuxInt
   2380 		s := v.Aux
   2381 		_ = v.Args[1]
   2382 		v_0 := v.Args[0]
   2383 		if v_0.Op != Op386SHLLconst {
   2384 			break
   2385 		}
   2386 		if v_0.AuxInt != 1 {
   2387 			break
   2388 		}
   2389 		y := v_0.Args[0]
   2390 		x := v.Args[1]
   2391 		v.reset(Op386LEAL2)
   2392 		v.AuxInt = c
   2393 		v.Aux = s
   2394 		v.AddArg(x)
   2395 		v.AddArg(y)
   2396 		return true
   2397 	}
   2398 	// match: (LEAL1 [c] {s} x (SHLLconst [2] y))
   2399 	// cond:
   2400 	// result: (LEAL4 [c] {s} x y)
   2401 	for {
   2402 		c := v.AuxInt
   2403 		s := v.Aux
   2404 		_ = v.Args[1]
   2405 		x := v.Args[0]
   2406 		v_1 := v.Args[1]
   2407 		if v_1.Op != Op386SHLLconst {
   2408 			break
   2409 		}
   2410 		if v_1.AuxInt != 2 {
   2411 			break
   2412 		}
   2413 		y := v_1.Args[0]
   2414 		v.reset(Op386LEAL4)
   2415 		v.AuxInt = c
   2416 		v.Aux = s
   2417 		v.AddArg(x)
   2418 		v.AddArg(y)
   2419 		return true
   2420 	}
   2421 	// match: (LEAL1 [c] {s} (SHLLconst [2] y) x)
   2422 	// cond:
   2423 	// result: (LEAL4 [c] {s} x y)
   2424 	for {
   2425 		c := v.AuxInt
   2426 		s := v.Aux
   2427 		_ = v.Args[1]
   2428 		v_0 := v.Args[0]
   2429 		if v_0.Op != Op386SHLLconst {
   2430 			break
   2431 		}
   2432 		if v_0.AuxInt != 2 {
   2433 			break
   2434 		}
   2435 		y := v_0.Args[0]
   2436 		x := v.Args[1]
   2437 		v.reset(Op386LEAL4)
   2438 		v.AuxInt = c
   2439 		v.Aux = s
   2440 		v.AddArg(x)
   2441 		v.AddArg(y)
   2442 		return true
   2443 	}
   2444 	// match: (LEAL1 [c] {s} x (SHLLconst [3] y))
   2445 	// cond:
   2446 	// result: (LEAL8 [c] {s} x y)
   2447 	for {
   2448 		c := v.AuxInt
   2449 		s := v.Aux
   2450 		_ = v.Args[1]
   2451 		x := v.Args[0]
   2452 		v_1 := v.Args[1]
   2453 		if v_1.Op != Op386SHLLconst {
   2454 			break
   2455 		}
   2456 		if v_1.AuxInt != 3 {
   2457 			break
   2458 		}
   2459 		y := v_1.Args[0]
   2460 		v.reset(Op386LEAL8)
   2461 		v.AuxInt = c
   2462 		v.Aux = s
   2463 		v.AddArg(x)
   2464 		v.AddArg(y)
   2465 		return true
   2466 	}
   2467 	// match: (LEAL1 [c] {s} (SHLLconst [3] y) x)
   2468 	// cond:
   2469 	// result: (LEAL8 [c] {s} x y)
   2470 	for {
   2471 		c := v.AuxInt
   2472 		s := v.Aux
   2473 		_ = v.Args[1]
   2474 		v_0 := v.Args[0]
   2475 		if v_0.Op != Op386SHLLconst {
   2476 			break
   2477 		}
   2478 		if v_0.AuxInt != 3 {
   2479 			break
   2480 		}
   2481 		y := v_0.Args[0]
   2482 		x := v.Args[1]
   2483 		v.reset(Op386LEAL8)
   2484 		v.AuxInt = c
   2485 		v.Aux = s
   2486 		v.AddArg(x)
   2487 		v.AddArg(y)
   2488 		return true
   2489 	}
   2490 	// match: (LEAL1 [off1] {sym1} (LEAL [off2] {sym2} x) y)
   2491 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
   2492 	// result: (LEAL1 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2493 	for {
   2494 		off1 := v.AuxInt
   2495 		sym1 := v.Aux
   2496 		_ = v.Args[1]
   2497 		v_0 := v.Args[0]
   2498 		if v_0.Op != Op386LEAL {
   2499 			break
   2500 		}
   2501 		off2 := v_0.AuxInt
   2502 		sym2 := v_0.Aux
   2503 		x := v_0.Args[0]
   2504 		y := v.Args[1]
   2505 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
   2506 			break
   2507 		}
   2508 		v.reset(Op386LEAL1)
   2509 		v.AuxInt = off1 + off2
   2510 		v.Aux = mergeSym(sym1, sym2)
   2511 		v.AddArg(x)
   2512 		v.AddArg(y)
   2513 		return true
   2514 	}
   2515 	// match: (LEAL1 [off1] {sym1} y (LEAL [off2] {sym2} x))
   2516 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
   2517 	// result: (LEAL1 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2518 	for {
   2519 		off1 := v.AuxInt
   2520 		sym1 := v.Aux
   2521 		_ = v.Args[1]
   2522 		y := v.Args[0]
   2523 		v_1 := v.Args[1]
   2524 		if v_1.Op != Op386LEAL {
   2525 			break
   2526 		}
   2527 		off2 := v_1.AuxInt
   2528 		sym2 := v_1.Aux
   2529 		x := v_1.Args[0]
   2530 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
   2531 			break
   2532 		}
   2533 		v.reset(Op386LEAL1)
   2534 		v.AuxInt = off1 + off2
   2535 		v.Aux = mergeSym(sym1, sym2)
   2536 		v.AddArg(x)
   2537 		v.AddArg(y)
   2538 		return true
   2539 	}
   2540 	return false
   2541 }
   2542 func rewriteValue386_Op386LEAL2_0(v *Value) bool {
   2543 	// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
   2544 	// cond: is32Bit(c+d)   && x.Op != OpSB
   2545 	// result: (LEAL2 [c+d] {s} x y)
   2546 	for {
   2547 		c := v.AuxInt
   2548 		s := v.Aux
   2549 		_ = v.Args[1]
   2550 		v_0 := v.Args[0]
   2551 		if v_0.Op != Op386ADDLconst {
   2552 			break
   2553 		}
   2554 		d := v_0.AuxInt
   2555 		x := v_0.Args[0]
   2556 		y := v.Args[1]
   2557 		if !(is32Bit(c+d) && x.Op != OpSB) {
   2558 			break
   2559 		}
   2560 		v.reset(Op386LEAL2)
   2561 		v.AuxInt = c + d
   2562 		v.Aux = s
   2563 		v.AddArg(x)
   2564 		v.AddArg(y)
   2565 		return true
   2566 	}
   2567 	// match: (LEAL2 [c] {s} x (ADDLconst [d] y))
   2568 	// cond: is32Bit(c+2*d) && y.Op != OpSB
   2569 	// result: (LEAL2 [c+2*d] {s} x y)
   2570 	for {
   2571 		c := v.AuxInt
   2572 		s := v.Aux
   2573 		_ = v.Args[1]
   2574 		x := v.Args[0]
   2575 		v_1 := v.Args[1]
   2576 		if v_1.Op != Op386ADDLconst {
   2577 			break
   2578 		}
   2579 		d := v_1.AuxInt
   2580 		y := v_1.Args[0]
   2581 		if !(is32Bit(c+2*d) && y.Op != OpSB) {
   2582 			break
   2583 		}
   2584 		v.reset(Op386LEAL2)
   2585 		v.AuxInt = c + 2*d
   2586 		v.Aux = s
   2587 		v.AddArg(x)
   2588 		v.AddArg(y)
   2589 		return true
   2590 	}
   2591 	// match: (LEAL2 [c] {s} x (SHLLconst [1] y))
   2592 	// cond:
   2593 	// result: (LEAL4 [c] {s} x y)
   2594 	for {
   2595 		c := v.AuxInt
   2596 		s := v.Aux
   2597 		_ = v.Args[1]
   2598 		x := v.Args[0]
   2599 		v_1 := v.Args[1]
   2600 		if v_1.Op != Op386SHLLconst {
   2601 			break
   2602 		}
   2603 		if v_1.AuxInt != 1 {
   2604 			break
   2605 		}
   2606 		y := v_1.Args[0]
   2607 		v.reset(Op386LEAL4)
   2608 		v.AuxInt = c
   2609 		v.Aux = s
   2610 		v.AddArg(x)
   2611 		v.AddArg(y)
   2612 		return true
   2613 	}
   2614 	// match: (LEAL2 [c] {s} x (SHLLconst [2] y))
   2615 	// cond:
   2616 	// result: (LEAL8 [c] {s} x y)
   2617 	for {
   2618 		c := v.AuxInt
   2619 		s := v.Aux
   2620 		_ = v.Args[1]
   2621 		x := v.Args[0]
   2622 		v_1 := v.Args[1]
   2623 		if v_1.Op != Op386SHLLconst {
   2624 			break
   2625 		}
   2626 		if v_1.AuxInt != 2 {
   2627 			break
   2628 		}
   2629 		y := v_1.Args[0]
   2630 		v.reset(Op386LEAL8)
   2631 		v.AuxInt = c
   2632 		v.Aux = s
   2633 		v.AddArg(x)
   2634 		v.AddArg(y)
   2635 		return true
   2636 	}
   2637 	// match: (LEAL2 [off1] {sym1} (LEAL [off2] {sym2} x) y)
   2638 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
   2639 	// result: (LEAL2 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2640 	for {
   2641 		off1 := v.AuxInt
   2642 		sym1 := v.Aux
   2643 		_ = v.Args[1]
   2644 		v_0 := v.Args[0]
   2645 		if v_0.Op != Op386LEAL {
   2646 			break
   2647 		}
   2648 		off2 := v_0.AuxInt
   2649 		sym2 := v_0.Aux
   2650 		x := v_0.Args[0]
   2651 		y := v.Args[1]
   2652 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
   2653 			break
   2654 		}
   2655 		v.reset(Op386LEAL2)
   2656 		v.AuxInt = off1 + off2
   2657 		v.Aux = mergeSym(sym1, sym2)
   2658 		v.AddArg(x)
   2659 		v.AddArg(y)
   2660 		return true
   2661 	}
   2662 	return false
   2663 }
   2664 func rewriteValue386_Op386LEAL4_0(v *Value) bool {
   2665 	// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
   2666 	// cond: is32Bit(c+d)   && x.Op != OpSB
   2667 	// result: (LEAL4 [c+d] {s} x y)
   2668 	for {
   2669 		c := v.AuxInt
   2670 		s := v.Aux
   2671 		_ = v.Args[1]
   2672 		v_0 := v.Args[0]
   2673 		if v_0.Op != Op386ADDLconst {
   2674 			break
   2675 		}
   2676 		d := v_0.AuxInt
   2677 		x := v_0.Args[0]
   2678 		y := v.Args[1]
   2679 		if !(is32Bit(c+d) && x.Op != OpSB) {
   2680 			break
   2681 		}
   2682 		v.reset(Op386LEAL4)
   2683 		v.AuxInt = c + d
   2684 		v.Aux = s
   2685 		v.AddArg(x)
   2686 		v.AddArg(y)
   2687 		return true
   2688 	}
   2689 	// match: (LEAL4 [c] {s} x (ADDLconst [d] y))
   2690 	// cond: is32Bit(c+4*d) && y.Op != OpSB
   2691 	// result: (LEAL4 [c+4*d] {s} x y)
   2692 	for {
   2693 		c := v.AuxInt
   2694 		s := v.Aux
   2695 		_ = v.Args[1]
   2696 		x := v.Args[0]
   2697 		v_1 := v.Args[1]
   2698 		if v_1.Op != Op386ADDLconst {
   2699 			break
   2700 		}
   2701 		d := v_1.AuxInt
   2702 		y := v_1.Args[0]
   2703 		if !(is32Bit(c+4*d) && y.Op != OpSB) {
   2704 			break
   2705 		}
   2706 		v.reset(Op386LEAL4)
   2707 		v.AuxInt = c + 4*d
   2708 		v.Aux = s
   2709 		v.AddArg(x)
   2710 		v.AddArg(y)
   2711 		return true
   2712 	}
   2713 	// match: (LEAL4 [c] {s} x (SHLLconst [1] y))
   2714 	// cond:
   2715 	// result: (LEAL8 [c] {s} x y)
   2716 	for {
   2717 		c := v.AuxInt
   2718 		s := v.Aux
   2719 		_ = v.Args[1]
   2720 		x := v.Args[0]
   2721 		v_1 := v.Args[1]
   2722 		if v_1.Op != Op386SHLLconst {
   2723 			break
   2724 		}
   2725 		if v_1.AuxInt != 1 {
   2726 			break
   2727 		}
   2728 		y := v_1.Args[0]
   2729 		v.reset(Op386LEAL8)
   2730 		v.AuxInt = c
   2731 		v.Aux = s
   2732 		v.AddArg(x)
   2733 		v.AddArg(y)
   2734 		return true
   2735 	}
   2736 	// match: (LEAL4 [off1] {sym1} (LEAL [off2] {sym2} x) y)
   2737 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
   2738 	// result: (LEAL4 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2739 	for {
   2740 		off1 := v.AuxInt
   2741 		sym1 := v.Aux
   2742 		_ = v.Args[1]
   2743 		v_0 := v.Args[0]
   2744 		if v_0.Op != Op386LEAL {
   2745 			break
   2746 		}
   2747 		off2 := v_0.AuxInt
   2748 		sym2 := v_0.Aux
   2749 		x := v_0.Args[0]
   2750 		y := v.Args[1]
   2751 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
   2752 			break
   2753 		}
   2754 		v.reset(Op386LEAL4)
   2755 		v.AuxInt = off1 + off2
   2756 		v.Aux = mergeSym(sym1, sym2)
   2757 		v.AddArg(x)
   2758 		v.AddArg(y)
   2759 		return true
   2760 	}
   2761 	return false
   2762 }
   2763 func rewriteValue386_Op386LEAL8_0(v *Value) bool {
   2764 	// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
   2765 	// cond: is32Bit(c+d)   && x.Op != OpSB
   2766 	// result: (LEAL8 [c+d] {s} x y)
   2767 	for {
   2768 		c := v.AuxInt
   2769 		s := v.Aux
   2770 		_ = v.Args[1]
   2771 		v_0 := v.Args[0]
   2772 		if v_0.Op != Op386ADDLconst {
   2773 			break
   2774 		}
   2775 		d := v_0.AuxInt
   2776 		x := v_0.Args[0]
   2777 		y := v.Args[1]
   2778 		if !(is32Bit(c+d) && x.Op != OpSB) {
   2779 			break
   2780 		}
   2781 		v.reset(Op386LEAL8)
   2782 		v.AuxInt = c + d
   2783 		v.Aux = s
   2784 		v.AddArg(x)
   2785 		v.AddArg(y)
   2786 		return true
   2787 	}
   2788 	// match: (LEAL8 [c] {s} x (ADDLconst [d] y))
   2789 	// cond: is32Bit(c+8*d) && y.Op != OpSB
   2790 	// result: (LEAL8 [c+8*d] {s} x y)
   2791 	for {
   2792 		c := v.AuxInt
   2793 		s := v.Aux
   2794 		_ = v.Args[1]
   2795 		x := v.Args[0]
   2796 		v_1 := v.Args[1]
   2797 		if v_1.Op != Op386ADDLconst {
   2798 			break
   2799 		}
   2800 		d := v_1.AuxInt
   2801 		y := v_1.Args[0]
   2802 		if !(is32Bit(c+8*d) && y.Op != OpSB) {
   2803 			break
   2804 		}
   2805 		v.reset(Op386LEAL8)
   2806 		v.AuxInt = c + 8*d
   2807 		v.Aux = s
   2808 		v.AddArg(x)
   2809 		v.AddArg(y)
   2810 		return true
   2811 	}
   2812 	// match: (LEAL8 [off1] {sym1} (LEAL [off2] {sym2} x) y)
   2813 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB
   2814 	// result: (LEAL8 [off1+off2] {mergeSym(sym1,sym2)} x y)
   2815 	for {
   2816 		off1 := v.AuxInt
   2817 		sym1 := v.Aux
   2818 		_ = v.Args[1]
   2819 		v_0 := v.Args[0]
   2820 		if v_0.Op != Op386LEAL {
   2821 			break
   2822 		}
   2823 		off2 := v_0.AuxInt
   2824 		sym2 := v_0.Aux
   2825 		x := v_0.Args[0]
   2826 		y := v.Args[1]
   2827 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && x.Op != OpSB) {
   2828 			break
   2829 		}
   2830 		v.reset(Op386LEAL8)
   2831 		v.AuxInt = off1 + off2
   2832 		v.Aux = mergeSym(sym1, sym2)
   2833 		v.AddArg(x)
   2834 		v.AddArg(y)
   2835 		return true
   2836 	}
   2837 	return false
   2838 }
   2839 func rewriteValue386_Op386MOVBLSX_0(v *Value) bool {
   2840 	b := v.Block
   2841 	_ = b
   2842 	// match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem))
   2843 	// cond: x.Uses == 1 && clobber(x)
   2844 	// result: @x.Block (MOVBLSXload <v.Type> [off] {sym} ptr mem)
   2845 	for {
   2846 		x := v.Args[0]
   2847 		if x.Op != Op386MOVBload {
   2848 			break
   2849 		}
   2850 		off := x.AuxInt
   2851 		sym := x.Aux
   2852 		_ = x.Args[1]
   2853 		ptr := x.Args[0]
   2854 		mem := x.Args[1]
   2855 		if !(x.Uses == 1 && clobber(x)) {
   2856 			break
   2857 		}
   2858 		b = x.Block
   2859 		v0 := b.NewValue0(v.Pos, Op386MOVBLSXload, v.Type)
   2860 		v.reset(OpCopy)
   2861 		v.AddArg(v0)
   2862 		v0.AuxInt = off
   2863 		v0.Aux = sym
   2864 		v0.AddArg(ptr)
   2865 		v0.AddArg(mem)
   2866 		return true
   2867 	}
   2868 	// match: (MOVBLSX (ANDLconst [c] x))
   2869 	// cond: c & 0x80 == 0
   2870 	// result: (ANDLconst [c & 0x7f] x)
   2871 	for {
   2872 		v_0 := v.Args[0]
   2873 		if v_0.Op != Op386ANDLconst {
   2874 			break
   2875 		}
   2876 		c := v_0.AuxInt
   2877 		x := v_0.Args[0]
   2878 		if !(c&0x80 == 0) {
   2879 			break
   2880 		}
   2881 		v.reset(Op386ANDLconst)
   2882 		v.AuxInt = c & 0x7f
   2883 		v.AddArg(x)
   2884 		return true
   2885 	}
   2886 	return false
   2887 }
   2888 func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool {
   2889 	b := v.Block
   2890 	_ = b
   2891 	config := b.Func.Config
   2892 	_ = config
   2893 	// match: (MOVBLSXload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
   2894 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
   2895 	// result: (MOVBLSX x)
   2896 	for {
   2897 		off := v.AuxInt
   2898 		sym := v.Aux
   2899 		_ = v.Args[1]
   2900 		ptr := v.Args[0]
   2901 		v_1 := v.Args[1]
   2902 		if v_1.Op != Op386MOVBstore {
   2903 			break
   2904 		}
   2905 		off2 := v_1.AuxInt
   2906 		sym2 := v_1.Aux
   2907 		_ = v_1.Args[2]
   2908 		ptr2 := v_1.Args[0]
   2909 		x := v_1.Args[1]
   2910 		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
   2911 			break
   2912 		}
   2913 		v.reset(Op386MOVBLSX)
   2914 		v.AddArg(x)
   2915 		return true
   2916 	}
   2917 	// match: (MOVBLSXload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   2918 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   2919 	// result: (MOVBLSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   2920 	for {
   2921 		off1 := v.AuxInt
   2922 		sym1 := v.Aux
   2923 		_ = v.Args[1]
   2924 		v_0 := v.Args[0]
   2925 		if v_0.Op != Op386LEAL {
   2926 			break
   2927 		}
   2928 		off2 := v_0.AuxInt
   2929 		sym2 := v_0.Aux
   2930 		base := v_0.Args[0]
   2931 		mem := v.Args[1]
   2932 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   2933 			break
   2934 		}
   2935 		v.reset(Op386MOVBLSXload)
   2936 		v.AuxInt = off1 + off2
   2937 		v.Aux = mergeSym(sym1, sym2)
   2938 		v.AddArg(base)
   2939 		v.AddArg(mem)
   2940 		return true
   2941 	}
   2942 	return false
   2943 }
   2944 func rewriteValue386_Op386MOVBLZX_0(v *Value) bool {
   2945 	b := v.Block
   2946 	_ = b
   2947 	// match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem))
   2948 	// cond: x.Uses == 1 && clobber(x)
   2949 	// result: @x.Block (MOVBload <v.Type> [off] {sym} ptr mem)
   2950 	for {
   2951 		x := v.Args[0]
   2952 		if x.Op != Op386MOVBload {
   2953 			break
   2954 		}
   2955 		off := x.AuxInt
   2956 		sym := x.Aux
   2957 		_ = x.Args[1]
   2958 		ptr := x.Args[0]
   2959 		mem := x.Args[1]
   2960 		if !(x.Uses == 1 && clobber(x)) {
   2961 			break
   2962 		}
   2963 		b = x.Block
   2964 		v0 := b.NewValue0(v.Pos, Op386MOVBload, v.Type)
   2965 		v.reset(OpCopy)
   2966 		v.AddArg(v0)
   2967 		v0.AuxInt = off
   2968 		v0.Aux = sym
   2969 		v0.AddArg(ptr)
   2970 		v0.AddArg(mem)
   2971 		return true
   2972 	}
   2973 	// match: (MOVBLZX x:(MOVBloadidx1 [off] {sym} ptr idx mem))
   2974 	// cond: x.Uses == 1 && clobber(x)
   2975 	// result: @x.Block (MOVBloadidx1 <v.Type> [off] {sym} ptr idx mem)
   2976 	for {
   2977 		x := v.Args[0]
   2978 		if x.Op != Op386MOVBloadidx1 {
   2979 			break
   2980 		}
   2981 		off := x.AuxInt
   2982 		sym := x.Aux
   2983 		_ = x.Args[2]
   2984 		ptr := x.Args[0]
   2985 		idx := x.Args[1]
   2986 		mem := x.Args[2]
   2987 		if !(x.Uses == 1 && clobber(x)) {
   2988 			break
   2989 		}
   2990 		b = x.Block
   2991 		v0 := b.NewValue0(v.Pos, Op386MOVBloadidx1, v.Type)
   2992 		v.reset(OpCopy)
   2993 		v.AddArg(v0)
   2994 		v0.AuxInt = off
   2995 		v0.Aux = sym
   2996 		v0.AddArg(ptr)
   2997 		v0.AddArg(idx)
   2998 		v0.AddArg(mem)
   2999 		return true
   3000 	}
   3001 	// match: (MOVBLZX (ANDLconst [c] x))
   3002 	// cond:
   3003 	// result: (ANDLconst [c & 0xff] x)
   3004 	for {
   3005 		v_0 := v.Args[0]
   3006 		if v_0.Op != Op386ANDLconst {
   3007 			break
   3008 		}
   3009 		c := v_0.AuxInt
   3010 		x := v_0.Args[0]
   3011 		v.reset(Op386ANDLconst)
   3012 		v.AuxInt = c & 0xff
   3013 		v.AddArg(x)
   3014 		return true
   3015 	}
   3016 	return false
   3017 }
   3018 func rewriteValue386_Op386MOVBload_0(v *Value) bool {
   3019 	b := v.Block
   3020 	_ = b
   3021 	config := b.Func.Config
   3022 	_ = config
   3023 	// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
   3024 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
   3025 	// result: (MOVBLZX x)
   3026 	for {
   3027 		off := v.AuxInt
   3028 		sym := v.Aux
   3029 		_ = v.Args[1]
   3030 		ptr := v.Args[0]
   3031 		v_1 := v.Args[1]
   3032 		if v_1.Op != Op386MOVBstore {
   3033 			break
   3034 		}
   3035 		off2 := v_1.AuxInt
   3036 		sym2 := v_1.Aux
   3037 		_ = v_1.Args[2]
   3038 		ptr2 := v_1.Args[0]
   3039 		x := v_1.Args[1]
   3040 		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
   3041 			break
   3042 		}
   3043 		v.reset(Op386MOVBLZX)
   3044 		v.AddArg(x)
   3045 		return true
   3046 	}
   3047 	// match: (MOVBload [off1] {sym} (ADDLconst [off2] ptr) mem)
   3048 	// cond: is32Bit(off1+off2)
   3049 	// result: (MOVBload  [off1+off2] {sym} ptr mem)
   3050 	for {
   3051 		off1 := v.AuxInt
   3052 		sym := v.Aux
   3053 		_ = v.Args[1]
   3054 		v_0 := v.Args[0]
   3055 		if v_0.Op != Op386ADDLconst {
   3056 			break
   3057 		}
   3058 		off2 := v_0.AuxInt
   3059 		ptr := v_0.Args[0]
   3060 		mem := v.Args[1]
   3061 		if !(is32Bit(off1 + off2)) {
   3062 			break
   3063 		}
   3064 		v.reset(Op386MOVBload)
   3065 		v.AuxInt = off1 + off2
   3066 		v.Aux = sym
   3067 		v.AddArg(ptr)
   3068 		v.AddArg(mem)
   3069 		return true
   3070 	}
   3071 	// match: (MOVBload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   3072 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   3073 	// result: (MOVBload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   3074 	for {
   3075 		off1 := v.AuxInt
   3076 		sym1 := v.Aux
   3077 		_ = v.Args[1]
   3078 		v_0 := v.Args[0]
   3079 		if v_0.Op != Op386LEAL {
   3080 			break
   3081 		}
   3082 		off2 := v_0.AuxInt
   3083 		sym2 := v_0.Aux
   3084 		base := v_0.Args[0]
   3085 		mem := v.Args[1]
   3086 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   3087 			break
   3088 		}
   3089 		v.reset(Op386MOVBload)
   3090 		v.AuxInt = off1 + off2
   3091 		v.Aux = mergeSym(sym1, sym2)
   3092 		v.AddArg(base)
   3093 		v.AddArg(mem)
   3094 		return true
   3095 	}
   3096 	// match: (MOVBload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem)
   3097 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   3098 	// result: (MOVBloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   3099 	for {
   3100 		off1 := v.AuxInt
   3101 		sym1 := v.Aux
   3102 		_ = v.Args[1]
   3103 		v_0 := v.Args[0]
   3104 		if v_0.Op != Op386LEAL1 {
   3105 			break
   3106 		}
   3107 		off2 := v_0.AuxInt
   3108 		sym2 := v_0.Aux
   3109 		_ = v_0.Args[1]
   3110 		ptr := v_0.Args[0]
   3111 		idx := v_0.Args[1]
   3112 		mem := v.Args[1]
   3113 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   3114 			break
   3115 		}
   3116 		v.reset(Op386MOVBloadidx1)
   3117 		v.AuxInt = off1 + off2
   3118 		v.Aux = mergeSym(sym1, sym2)
   3119 		v.AddArg(ptr)
   3120 		v.AddArg(idx)
   3121 		v.AddArg(mem)
   3122 		return true
   3123 	}
   3124 	// match: (MOVBload [off] {sym} (ADDL ptr idx) mem)
   3125 	// cond: ptr.Op != OpSB
   3126 	// result: (MOVBloadidx1 [off] {sym} ptr idx mem)
   3127 	for {
   3128 		off := v.AuxInt
   3129 		sym := v.Aux
   3130 		_ = v.Args[1]
   3131 		v_0 := v.Args[0]
   3132 		if v_0.Op != Op386ADDL {
   3133 			break
   3134 		}
   3135 		_ = v_0.Args[1]
   3136 		ptr := v_0.Args[0]
   3137 		idx := v_0.Args[1]
   3138 		mem := v.Args[1]
   3139 		if !(ptr.Op != OpSB) {
   3140 			break
   3141 		}
   3142 		v.reset(Op386MOVBloadidx1)
   3143 		v.AuxInt = off
   3144 		v.Aux = sym
   3145 		v.AddArg(ptr)
   3146 		v.AddArg(idx)
   3147 		v.AddArg(mem)
   3148 		return true
   3149 	}
   3150 	return false
   3151 }
   3152 func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool {
   3153 	// match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
   3154 	// cond:
   3155 	// result: (MOVBloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   3156 	for {
   3157 		c := v.AuxInt
   3158 		sym := v.Aux
   3159 		_ = v.Args[2]
   3160 		v_0 := v.Args[0]
   3161 		if v_0.Op != Op386ADDLconst {
   3162 			break
   3163 		}
   3164 		d := v_0.AuxInt
   3165 		ptr := v_0.Args[0]
   3166 		idx := v.Args[1]
   3167 		mem := v.Args[2]
   3168 		v.reset(Op386MOVBloadidx1)
   3169 		v.AuxInt = int64(int32(c + d))
   3170 		v.Aux = sym
   3171 		v.AddArg(ptr)
   3172 		v.AddArg(idx)
   3173 		v.AddArg(mem)
   3174 		return true
   3175 	}
   3176 	// match: (MOVBloadidx1 [c] {sym} idx (ADDLconst [d] ptr) mem)
   3177 	// cond:
   3178 	// result: (MOVBloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   3179 	for {
   3180 		c := v.AuxInt
   3181 		sym := v.Aux
   3182 		_ = v.Args[2]
   3183 		idx := v.Args[0]
   3184 		v_1 := v.Args[1]
   3185 		if v_1.Op != Op386ADDLconst {
   3186 			break
   3187 		}
   3188 		d := v_1.AuxInt
   3189 		ptr := v_1.Args[0]
   3190 		mem := v.Args[2]
   3191 		v.reset(Op386MOVBloadidx1)
   3192 		v.AuxInt = int64(int32(c + d))
   3193 		v.Aux = sym
   3194 		v.AddArg(ptr)
   3195 		v.AddArg(idx)
   3196 		v.AddArg(mem)
   3197 		return true
   3198 	}
   3199 	// match: (MOVBloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem)
   3200 	// cond:
   3201 	// result: (MOVBloadidx1  [int64(int32(c+d))]   {sym} ptr idx mem)
   3202 	for {
   3203 		c := v.AuxInt
   3204 		sym := v.Aux
   3205 		_ = v.Args[2]
   3206 		ptr := v.Args[0]
   3207 		v_1 := v.Args[1]
   3208 		if v_1.Op != Op386ADDLconst {
   3209 			break
   3210 		}
   3211 		d := v_1.AuxInt
   3212 		idx := v_1.Args[0]
   3213 		mem := v.Args[2]
   3214 		v.reset(Op386MOVBloadidx1)
   3215 		v.AuxInt = int64(int32(c + d))
   3216 		v.Aux = sym
   3217 		v.AddArg(ptr)
   3218 		v.AddArg(idx)
   3219 		v.AddArg(mem)
   3220 		return true
   3221 	}
   3222 	// match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] idx) ptr mem)
   3223 	// cond:
   3224 	// result: (MOVBloadidx1  [int64(int32(c+d))]   {sym} ptr idx mem)
   3225 	for {
   3226 		c := v.AuxInt
   3227 		sym := v.Aux
   3228 		_ = v.Args[2]
   3229 		v_0 := v.Args[0]
   3230 		if v_0.Op != Op386ADDLconst {
   3231 			break
   3232 		}
   3233 		d := v_0.AuxInt
   3234 		idx := v_0.Args[0]
   3235 		ptr := v.Args[1]
   3236 		mem := v.Args[2]
   3237 		v.reset(Op386MOVBloadidx1)
   3238 		v.AuxInt = int64(int32(c + d))
   3239 		v.Aux = sym
   3240 		v.AddArg(ptr)
   3241 		v.AddArg(idx)
   3242 		v.AddArg(mem)
   3243 		return true
   3244 	}
   3245 	return false
   3246 }
   3247 func rewriteValue386_Op386MOVBstore_0(v *Value) bool {
   3248 	b := v.Block
   3249 	_ = b
   3250 	config := b.Func.Config
   3251 	_ = config
   3252 	// match: (MOVBstore [off] {sym} ptr (MOVBLSX x) mem)
   3253 	// cond:
   3254 	// result: (MOVBstore [off] {sym} ptr x mem)
   3255 	for {
   3256 		off := v.AuxInt
   3257 		sym := v.Aux
   3258 		_ = v.Args[2]
   3259 		ptr := v.Args[0]
   3260 		v_1 := v.Args[1]
   3261 		if v_1.Op != Op386MOVBLSX {
   3262 			break
   3263 		}
   3264 		x := v_1.Args[0]
   3265 		mem := v.Args[2]
   3266 		v.reset(Op386MOVBstore)
   3267 		v.AuxInt = off
   3268 		v.Aux = sym
   3269 		v.AddArg(ptr)
   3270 		v.AddArg(x)
   3271 		v.AddArg(mem)
   3272 		return true
   3273 	}
   3274 	// match: (MOVBstore [off] {sym} ptr (MOVBLZX x) mem)
   3275 	// cond:
   3276 	// result: (MOVBstore [off] {sym} ptr x mem)
   3277 	for {
   3278 		off := v.AuxInt
   3279 		sym := v.Aux
   3280 		_ = v.Args[2]
   3281 		ptr := v.Args[0]
   3282 		v_1 := v.Args[1]
   3283 		if v_1.Op != Op386MOVBLZX {
   3284 			break
   3285 		}
   3286 		x := v_1.Args[0]
   3287 		mem := v.Args[2]
   3288 		v.reset(Op386MOVBstore)
   3289 		v.AuxInt = off
   3290 		v.Aux = sym
   3291 		v.AddArg(ptr)
   3292 		v.AddArg(x)
   3293 		v.AddArg(mem)
   3294 		return true
   3295 	}
   3296 	// match: (MOVBstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
   3297 	// cond: is32Bit(off1+off2)
   3298 	// result: (MOVBstore  [off1+off2] {sym} ptr val mem)
   3299 	for {
   3300 		off1 := v.AuxInt
   3301 		sym := v.Aux
   3302 		_ = v.Args[2]
   3303 		v_0 := v.Args[0]
   3304 		if v_0.Op != Op386ADDLconst {
   3305 			break
   3306 		}
   3307 		off2 := v_0.AuxInt
   3308 		ptr := v_0.Args[0]
   3309 		val := v.Args[1]
   3310 		mem := v.Args[2]
   3311 		if !(is32Bit(off1 + off2)) {
   3312 			break
   3313 		}
   3314 		v.reset(Op386MOVBstore)
   3315 		v.AuxInt = off1 + off2
   3316 		v.Aux = sym
   3317 		v.AddArg(ptr)
   3318 		v.AddArg(val)
   3319 		v.AddArg(mem)
   3320 		return true
   3321 	}
   3322 	// match: (MOVBstore [off] {sym} ptr (MOVLconst [c]) mem)
   3323 	// cond: validOff(off)
   3324 	// result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
   3325 	for {
   3326 		off := v.AuxInt
   3327 		sym := v.Aux
   3328 		_ = v.Args[2]
   3329 		ptr := v.Args[0]
   3330 		v_1 := v.Args[1]
   3331 		if v_1.Op != Op386MOVLconst {
   3332 			break
   3333 		}
   3334 		c := v_1.AuxInt
   3335 		mem := v.Args[2]
   3336 		if !(validOff(off)) {
   3337 			break
   3338 		}
   3339 		v.reset(Op386MOVBstoreconst)
   3340 		v.AuxInt = makeValAndOff(int64(int8(c)), off)
   3341 		v.Aux = sym
   3342 		v.AddArg(ptr)
   3343 		v.AddArg(mem)
   3344 		return true
   3345 	}
   3346 	// match: (MOVBstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
   3347 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   3348 	// result: (MOVBstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   3349 	for {
   3350 		off1 := v.AuxInt
   3351 		sym1 := v.Aux
   3352 		_ = v.Args[2]
   3353 		v_0 := v.Args[0]
   3354 		if v_0.Op != Op386LEAL {
   3355 			break
   3356 		}
   3357 		off2 := v_0.AuxInt
   3358 		sym2 := v_0.Aux
   3359 		base := v_0.Args[0]
   3360 		val := v.Args[1]
   3361 		mem := v.Args[2]
   3362 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   3363 			break
   3364 		}
   3365 		v.reset(Op386MOVBstore)
   3366 		v.AuxInt = off1 + off2
   3367 		v.Aux = mergeSym(sym1, sym2)
   3368 		v.AddArg(base)
   3369 		v.AddArg(val)
   3370 		v.AddArg(mem)
   3371 		return true
   3372 	}
   3373 	// match: (MOVBstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem)
   3374 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   3375 	// result: (MOVBstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   3376 	for {
   3377 		off1 := v.AuxInt
   3378 		sym1 := v.Aux
   3379 		_ = v.Args[2]
   3380 		v_0 := v.Args[0]
   3381 		if v_0.Op != Op386LEAL1 {
   3382 			break
   3383 		}
   3384 		off2 := v_0.AuxInt
   3385 		sym2 := v_0.Aux
   3386 		_ = v_0.Args[1]
   3387 		ptr := v_0.Args[0]
   3388 		idx := v_0.Args[1]
   3389 		val := v.Args[1]
   3390 		mem := v.Args[2]
   3391 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   3392 			break
   3393 		}
   3394 		v.reset(Op386MOVBstoreidx1)
   3395 		v.AuxInt = off1 + off2
   3396 		v.Aux = mergeSym(sym1, sym2)
   3397 		v.AddArg(ptr)
   3398 		v.AddArg(idx)
   3399 		v.AddArg(val)
   3400 		v.AddArg(mem)
   3401 		return true
   3402 	}
   3403 	// match: (MOVBstore [off] {sym} (ADDL ptr idx) val mem)
   3404 	// cond: ptr.Op != OpSB
   3405 	// result: (MOVBstoreidx1 [off] {sym} ptr idx val mem)
   3406 	for {
   3407 		off := v.AuxInt
   3408 		sym := v.Aux
   3409 		_ = v.Args[2]
   3410 		v_0 := v.Args[0]
   3411 		if v_0.Op != Op386ADDL {
   3412 			break
   3413 		}
   3414 		_ = v_0.Args[1]
   3415 		ptr := v_0.Args[0]
   3416 		idx := v_0.Args[1]
   3417 		val := v.Args[1]
   3418 		mem := v.Args[2]
   3419 		if !(ptr.Op != OpSB) {
   3420 			break
   3421 		}
   3422 		v.reset(Op386MOVBstoreidx1)
   3423 		v.AuxInt = off
   3424 		v.Aux = sym
   3425 		v.AddArg(ptr)
   3426 		v.AddArg(idx)
   3427 		v.AddArg(val)
   3428 		v.AddArg(mem)
   3429 		return true
   3430 	}
   3431 	// match: (MOVBstore [i] {s} p (SHRLconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
   3432 	// cond: x.Uses == 1   && clobber(x)
   3433 	// result: (MOVWstore [i-1] {s} p w mem)
   3434 	for {
   3435 		i := v.AuxInt
   3436 		s := v.Aux
   3437 		_ = v.Args[2]
   3438 		p := v.Args[0]
   3439 		v_1 := v.Args[1]
   3440 		if v_1.Op != Op386SHRLconst {
   3441 			break
   3442 		}
   3443 		if v_1.AuxInt != 8 {
   3444 			break
   3445 		}
   3446 		w := v_1.Args[0]
   3447 		x := v.Args[2]
   3448 		if x.Op != Op386MOVBstore {
   3449 			break
   3450 		}
   3451 		if x.AuxInt != i-1 {
   3452 			break
   3453 		}
   3454 		if x.Aux != s {
   3455 			break
   3456 		}
   3457 		_ = x.Args[2]
   3458 		if p != x.Args[0] {
   3459 			break
   3460 		}
   3461 		if w != x.Args[1] {
   3462 			break
   3463 		}
   3464 		mem := x.Args[2]
   3465 		if !(x.Uses == 1 && clobber(x)) {
   3466 			break
   3467 		}
   3468 		v.reset(Op386MOVWstore)
   3469 		v.AuxInt = i - 1
   3470 		v.Aux = s
   3471 		v.AddArg(p)
   3472 		v.AddArg(w)
   3473 		v.AddArg(mem)
   3474 		return true
   3475 	}
   3476 	// match: (MOVBstore [i] {s} p (SHRLconst [j] w) x:(MOVBstore [i-1] {s} p w0:(SHRLconst [j-8] w) mem))
   3477 	// cond: x.Uses == 1   && clobber(x)
   3478 	// result: (MOVWstore [i-1] {s} p w0 mem)
   3479 	for {
   3480 		i := v.AuxInt
   3481 		s := v.Aux
   3482 		_ = v.Args[2]
   3483 		p := v.Args[0]
   3484 		v_1 := v.Args[1]
   3485 		if v_1.Op != Op386SHRLconst {
   3486 			break
   3487 		}
   3488 		j := v_1.AuxInt
   3489 		w := v_1.Args[0]
   3490 		x := v.Args[2]
   3491 		if x.Op != Op386MOVBstore {
   3492 			break
   3493 		}
   3494 		if x.AuxInt != i-1 {
   3495 			break
   3496 		}
   3497 		if x.Aux != s {
   3498 			break
   3499 		}
   3500 		_ = x.Args[2]
   3501 		if p != x.Args[0] {
   3502 			break
   3503 		}
   3504 		w0 := x.Args[1]
   3505 		if w0.Op != Op386SHRLconst {
   3506 			break
   3507 		}
   3508 		if w0.AuxInt != j-8 {
   3509 			break
   3510 		}
   3511 		if w != w0.Args[0] {
   3512 			break
   3513 		}
   3514 		mem := x.Args[2]
   3515 		if !(x.Uses == 1 && clobber(x)) {
   3516 			break
   3517 		}
   3518 		v.reset(Op386MOVWstore)
   3519 		v.AuxInt = i - 1
   3520 		v.Aux = s
   3521 		v.AddArg(p)
   3522 		v.AddArg(w0)
   3523 		v.AddArg(mem)
   3524 		return true
   3525 	}
   3526 	return false
   3527 }
   3528 func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool {
   3529 	b := v.Block
   3530 	_ = b
   3531 	config := b.Func.Config
   3532 	_ = config
   3533 	// match: (MOVBstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
   3534 	// cond: ValAndOff(sc).canAdd(off)
   3535 	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   3536 	for {
   3537 		sc := v.AuxInt
   3538 		s := v.Aux
   3539 		_ = v.Args[1]
   3540 		v_0 := v.Args[0]
   3541 		if v_0.Op != Op386ADDLconst {
   3542 			break
   3543 		}
   3544 		off := v_0.AuxInt
   3545 		ptr := v_0.Args[0]
   3546 		mem := v.Args[1]
   3547 		if !(ValAndOff(sc).canAdd(off)) {
   3548 			break
   3549 		}
   3550 		v.reset(Op386MOVBstoreconst)
   3551 		v.AuxInt = ValAndOff(sc).add(off)
   3552 		v.Aux = s
   3553 		v.AddArg(ptr)
   3554 		v.AddArg(mem)
   3555 		return true
   3556 	}
   3557 	// match: (MOVBstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
   3558 	// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)   && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
   3559 	// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   3560 	for {
   3561 		sc := v.AuxInt
   3562 		sym1 := v.Aux
   3563 		_ = v.Args[1]
   3564 		v_0 := v.Args[0]
   3565 		if v_0.Op != Op386LEAL {
   3566 			break
   3567 		}
   3568 		off := v_0.AuxInt
   3569 		sym2 := v_0.Aux
   3570 		ptr := v_0.Args[0]
   3571 		mem := v.Args[1]
   3572 		if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) {
   3573 			break
   3574 		}
   3575 		v.reset(Op386MOVBstoreconst)
   3576 		v.AuxInt = ValAndOff(sc).add(off)
   3577 		v.Aux = mergeSym(sym1, sym2)
   3578 		v.AddArg(ptr)
   3579 		v.AddArg(mem)
   3580 		return true
   3581 	}
   3582 	// match: (MOVBstoreconst [x] {sym1} (LEAL1 [off] {sym2} ptr idx) mem)
   3583 	// cond: canMergeSym(sym1, sym2)
   3584 	// result: (MOVBstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
   3585 	for {
   3586 		x := v.AuxInt
   3587 		sym1 := v.Aux
   3588 		_ = v.Args[1]
   3589 		v_0 := v.Args[0]
   3590 		if v_0.Op != Op386LEAL1 {
   3591 			break
   3592 		}
   3593 		off := v_0.AuxInt
   3594 		sym2 := v_0.Aux
   3595 		_ = v_0.Args[1]
   3596 		ptr := v_0.Args[0]
   3597 		idx := v_0.Args[1]
   3598 		mem := v.Args[1]
   3599 		if !(canMergeSym(sym1, sym2)) {
   3600 			break
   3601 		}
   3602 		v.reset(Op386MOVBstoreconstidx1)
   3603 		v.AuxInt = ValAndOff(x).add(off)
   3604 		v.Aux = mergeSym(sym1, sym2)
   3605 		v.AddArg(ptr)
   3606 		v.AddArg(idx)
   3607 		v.AddArg(mem)
   3608 		return true
   3609 	}
   3610 	// match: (MOVBstoreconst [x] {sym} (ADDL ptr idx) mem)
   3611 	// cond:
   3612 	// result: (MOVBstoreconstidx1 [x] {sym} ptr idx mem)
   3613 	for {
   3614 		x := v.AuxInt
   3615 		sym := v.Aux
   3616 		_ = v.Args[1]
   3617 		v_0 := v.Args[0]
   3618 		if v_0.Op != Op386ADDL {
   3619 			break
   3620 		}
   3621 		_ = v_0.Args[1]
   3622 		ptr := v_0.Args[0]
   3623 		idx := v_0.Args[1]
   3624 		mem := v.Args[1]
   3625 		v.reset(Op386MOVBstoreconstidx1)
   3626 		v.AuxInt = x
   3627 		v.Aux = sym
   3628 		v.AddArg(ptr)
   3629 		v.AddArg(idx)
   3630 		v.AddArg(mem)
   3631 		return true
   3632 	}
   3633 	// match: (MOVBstoreconst [c] {s} p x:(MOVBstoreconst [a] {s} p mem))
   3634 	// cond: x.Uses == 1   && ValAndOff(a).Off() + 1 == ValAndOff(c).Off()   && clobber(x)
   3635 	// result: (MOVWstoreconst [makeValAndOff(ValAndOff(a).Val()&0xff | ValAndOff(c).Val()<<8, ValAndOff(a).Off())] {s} p mem)
   3636 	for {
   3637 		c := v.AuxInt
   3638 		s := v.Aux
   3639 		_ = v.Args[1]
   3640 		p := v.Args[0]
   3641 		x := v.Args[1]
   3642 		if x.Op != Op386MOVBstoreconst {
   3643 			break
   3644 		}
   3645 		a := x.AuxInt
   3646 		if x.Aux != s {
   3647 			break
   3648 		}
   3649 		_ = x.Args[1]
   3650 		if p != x.Args[0] {
   3651 			break
   3652 		}
   3653 		mem := x.Args[1]
   3654 		if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
   3655 			break
   3656 		}
   3657 		v.reset(Op386MOVWstoreconst)
   3658 		v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off())
   3659 		v.Aux = s
   3660 		v.AddArg(p)
   3661 		v.AddArg(mem)
   3662 		return true
   3663 	}
   3664 	return false
   3665 }
   3666 func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool {
   3667 	// match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem)
   3668 	// cond:
   3669 	// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   3670 	for {
   3671 		x := v.AuxInt
   3672 		sym := v.Aux
   3673 		_ = v.Args[2]
   3674 		v_0 := v.Args[0]
   3675 		if v_0.Op != Op386ADDLconst {
   3676 			break
   3677 		}
   3678 		c := v_0.AuxInt
   3679 		ptr := v_0.Args[0]
   3680 		idx := v.Args[1]
   3681 		mem := v.Args[2]
   3682 		v.reset(Op386MOVBstoreconstidx1)
   3683 		v.AuxInt = ValAndOff(x).add(c)
   3684 		v.Aux = sym
   3685 		v.AddArg(ptr)
   3686 		v.AddArg(idx)
   3687 		v.AddArg(mem)
   3688 		return true
   3689 	}
   3690 	// match: (MOVBstoreconstidx1 [x] {sym} ptr (ADDLconst [c] idx) mem)
   3691 	// cond:
   3692 	// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   3693 	for {
   3694 		x := v.AuxInt
   3695 		sym := v.Aux
   3696 		_ = v.Args[2]
   3697 		ptr := v.Args[0]
   3698 		v_1 := v.Args[1]
   3699 		if v_1.Op != Op386ADDLconst {
   3700 			break
   3701 		}
   3702 		c := v_1.AuxInt
   3703 		idx := v_1.Args[0]
   3704 		mem := v.Args[2]
   3705 		v.reset(Op386MOVBstoreconstidx1)
   3706 		v.AuxInt = ValAndOff(x).add(c)
   3707 		v.Aux = sym
   3708 		v.AddArg(ptr)
   3709 		v.AddArg(idx)
   3710 		v.AddArg(mem)
   3711 		return true
   3712 	}
   3713 	// match: (MOVBstoreconstidx1 [c] {s} p i x:(MOVBstoreconstidx1 [a] {s} p i mem))
   3714 	// cond: x.Uses == 1   && ValAndOff(a).Off() + 1 == ValAndOff(c).Off()   && clobber(x)
   3715 	// result: (MOVWstoreconstidx1 [makeValAndOff(ValAndOff(a).Val()&0xff | ValAndOff(c).Val()<<8, ValAndOff(a).Off())] {s} p i mem)
   3716 	for {
   3717 		c := v.AuxInt
   3718 		s := v.Aux
   3719 		_ = v.Args[2]
   3720 		p := v.Args[0]
   3721 		i := v.Args[1]
   3722 		x := v.Args[2]
   3723 		if x.Op != Op386MOVBstoreconstidx1 {
   3724 			break
   3725 		}
   3726 		a := x.AuxInt
   3727 		if x.Aux != s {
   3728 			break
   3729 		}
   3730 		_ = x.Args[2]
   3731 		if p != x.Args[0] {
   3732 			break
   3733 		}
   3734 		if i != x.Args[1] {
   3735 			break
   3736 		}
   3737 		mem := x.Args[2]
   3738 		if !(x.Uses == 1 && ValAndOff(a).Off()+1 == ValAndOff(c).Off() && clobber(x)) {
   3739 			break
   3740 		}
   3741 		v.reset(Op386MOVWstoreconstidx1)
   3742 		v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xff|ValAndOff(c).Val()<<8, ValAndOff(a).Off())
   3743 		v.Aux = s
   3744 		v.AddArg(p)
   3745 		v.AddArg(i)
   3746 		v.AddArg(mem)
   3747 		return true
   3748 	}
   3749 	return false
   3750 }
   3751 func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool {
   3752 	// match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   3753 	// cond:
   3754 	// result: (MOVBstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   3755 	for {
   3756 		c := v.AuxInt
   3757 		sym := v.Aux
   3758 		_ = v.Args[3]
   3759 		v_0 := v.Args[0]
   3760 		if v_0.Op != Op386ADDLconst {
   3761 			break
   3762 		}
   3763 		d := v_0.AuxInt
   3764 		ptr := v_0.Args[0]
   3765 		idx := v.Args[1]
   3766 		val := v.Args[2]
   3767 		mem := v.Args[3]
   3768 		v.reset(Op386MOVBstoreidx1)
   3769 		v.AuxInt = int64(int32(c + d))
   3770 		v.Aux = sym
   3771 		v.AddArg(ptr)
   3772 		v.AddArg(idx)
   3773 		v.AddArg(val)
   3774 		v.AddArg(mem)
   3775 		return true
   3776 	}
   3777 	// match: (MOVBstoreidx1 [c] {sym} idx (ADDLconst [d] ptr) val mem)
   3778 	// cond:
   3779 	// result: (MOVBstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   3780 	for {
   3781 		c := v.AuxInt
   3782 		sym := v.Aux
   3783 		_ = v.Args[3]
   3784 		idx := v.Args[0]
   3785 		v_1 := v.Args[1]
   3786 		if v_1.Op != Op386ADDLconst {
   3787 			break
   3788 		}
   3789 		d := v_1.AuxInt
   3790 		ptr := v_1.Args[0]
   3791 		val := v.Args[2]
   3792 		mem := v.Args[3]
   3793 		v.reset(Op386MOVBstoreidx1)
   3794 		v.AuxInt = int64(int32(c + d))
   3795 		v.Aux = sym
   3796 		v.AddArg(ptr)
   3797 		v.AddArg(idx)
   3798 		v.AddArg(val)
   3799 		v.AddArg(mem)
   3800 		return true
   3801 	}
   3802 	// match: (MOVBstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   3803 	// cond:
   3804 	// result: (MOVBstoreidx1  [int64(int32(c+d))]   {sym} ptr idx val mem)
   3805 	for {
   3806 		c := v.AuxInt
   3807 		sym := v.Aux
   3808 		_ = v.Args[3]
   3809 		ptr := v.Args[0]
   3810 		v_1 := v.Args[1]
   3811 		if v_1.Op != Op386ADDLconst {
   3812 			break
   3813 		}
   3814 		d := v_1.AuxInt
   3815 		idx := v_1.Args[0]
   3816 		val := v.Args[2]
   3817 		mem := v.Args[3]
   3818 		v.reset(Op386MOVBstoreidx1)
   3819 		v.AuxInt = int64(int32(c + d))
   3820 		v.Aux = sym
   3821 		v.AddArg(ptr)
   3822 		v.AddArg(idx)
   3823 		v.AddArg(val)
   3824 		v.AddArg(mem)
   3825 		return true
   3826 	}
   3827 	// match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] idx) ptr val mem)
   3828 	// cond:
   3829 	// result: (MOVBstoreidx1  [int64(int32(c+d))]   {sym} ptr idx val mem)
   3830 	for {
   3831 		c := v.AuxInt
   3832 		sym := v.Aux
   3833 		_ = v.Args[3]
   3834 		v_0 := v.Args[0]
   3835 		if v_0.Op != Op386ADDLconst {
   3836 			break
   3837 		}
   3838 		d := v_0.AuxInt
   3839 		idx := v_0.Args[0]
   3840 		ptr := v.Args[1]
   3841 		val := v.Args[2]
   3842 		mem := v.Args[3]
   3843 		v.reset(Op386MOVBstoreidx1)
   3844 		v.AuxInt = int64(int32(c + d))
   3845 		v.Aux = sym
   3846 		v.AddArg(ptr)
   3847 		v.AddArg(idx)
   3848 		v.AddArg(val)
   3849 		v.AddArg(mem)
   3850 		return true
   3851 	}
   3852 	// match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} p idx w mem))
   3853 	// cond: x.Uses == 1   && clobber(x)
   3854 	// result: (MOVWstoreidx1 [i-1] {s} p idx w mem)
   3855 	for {
   3856 		i := v.AuxInt
   3857 		s := v.Aux
   3858 		_ = v.Args[3]
   3859 		p := v.Args[0]
   3860 		idx := v.Args[1]
   3861 		v_2 := v.Args[2]
   3862 		if v_2.Op != Op386SHRLconst {
   3863 			break
   3864 		}
   3865 		if v_2.AuxInt != 8 {
   3866 			break
   3867 		}
   3868 		w := v_2.Args[0]
   3869 		x := v.Args[3]
   3870 		if x.Op != Op386MOVBstoreidx1 {
   3871 			break
   3872 		}
   3873 		if x.AuxInt != i-1 {
   3874 			break
   3875 		}
   3876 		if x.Aux != s {
   3877 			break
   3878 		}
   3879 		_ = x.Args[3]
   3880 		if p != x.Args[0] {
   3881 			break
   3882 		}
   3883 		if idx != x.Args[1] {
   3884 			break
   3885 		}
   3886 		if w != x.Args[2] {
   3887 			break
   3888 		}
   3889 		mem := x.Args[3]
   3890 		if !(x.Uses == 1 && clobber(x)) {
   3891 			break
   3892 		}
   3893 		v.reset(Op386MOVWstoreidx1)
   3894 		v.AuxInt = i - 1
   3895 		v.Aux = s
   3896 		v.AddArg(p)
   3897 		v.AddArg(idx)
   3898 		v.AddArg(w)
   3899 		v.AddArg(mem)
   3900 		return true
   3901 	}
   3902 	// match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} idx p w mem))
   3903 	// cond: x.Uses == 1   && clobber(x)
   3904 	// result: (MOVWstoreidx1 [i-1] {s} p idx w mem)
   3905 	for {
   3906 		i := v.AuxInt
   3907 		s := v.Aux
   3908 		_ = v.Args[3]
   3909 		p := v.Args[0]
   3910 		idx := v.Args[1]
   3911 		v_2 := v.Args[2]
   3912 		if v_2.Op != Op386SHRLconst {
   3913 			break
   3914 		}
   3915 		if v_2.AuxInt != 8 {
   3916 			break
   3917 		}
   3918 		w := v_2.Args[0]
   3919 		x := v.Args[3]
   3920 		if x.Op != Op386MOVBstoreidx1 {
   3921 			break
   3922 		}
   3923 		if x.AuxInt != i-1 {
   3924 			break
   3925 		}
   3926 		if x.Aux != s {
   3927 			break
   3928 		}
   3929 		_ = x.Args[3]
   3930 		if idx != x.Args[0] {
   3931 			break
   3932 		}
   3933 		if p != x.Args[1] {
   3934 			break
   3935 		}
   3936 		if w != x.Args[2] {
   3937 			break
   3938 		}
   3939 		mem := x.Args[3]
   3940 		if !(x.Uses == 1 && clobber(x)) {
   3941 			break
   3942 		}
   3943 		v.reset(Op386MOVWstoreidx1)
   3944 		v.AuxInt = i - 1
   3945 		v.Aux = s
   3946 		v.AddArg(p)
   3947 		v.AddArg(idx)
   3948 		v.AddArg(w)
   3949 		v.AddArg(mem)
   3950 		return true
   3951 	}
   3952 	// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} p idx w mem))
   3953 	// cond: x.Uses == 1   && clobber(x)
   3954 	// result: (MOVWstoreidx1 [i-1] {s} p idx w mem)
   3955 	for {
   3956 		i := v.AuxInt
   3957 		s := v.Aux
   3958 		_ = v.Args[3]
   3959 		idx := v.Args[0]
   3960 		p := v.Args[1]
   3961 		v_2 := v.Args[2]
   3962 		if v_2.Op != Op386SHRLconst {
   3963 			break
   3964 		}
   3965 		if v_2.AuxInt != 8 {
   3966 			break
   3967 		}
   3968 		w := v_2.Args[0]
   3969 		x := v.Args[3]
   3970 		if x.Op != Op386MOVBstoreidx1 {
   3971 			break
   3972 		}
   3973 		if x.AuxInt != i-1 {
   3974 			break
   3975 		}
   3976 		if x.Aux != s {
   3977 			break
   3978 		}
   3979 		_ = x.Args[3]
   3980 		if p != x.Args[0] {
   3981 			break
   3982 		}
   3983 		if idx != x.Args[1] {
   3984 			break
   3985 		}
   3986 		if w != x.Args[2] {
   3987 			break
   3988 		}
   3989 		mem := x.Args[3]
   3990 		if !(x.Uses == 1 && clobber(x)) {
   3991 			break
   3992 		}
   3993 		v.reset(Op386MOVWstoreidx1)
   3994 		v.AuxInt = i - 1
   3995 		v.Aux = s
   3996 		v.AddArg(p)
   3997 		v.AddArg(idx)
   3998 		v.AddArg(w)
   3999 		v.AddArg(mem)
   4000 		return true
   4001 	}
   4002 	// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [8] w) x:(MOVBstoreidx1 [i-1] {s} idx p w mem))
   4003 	// cond: x.Uses == 1   && clobber(x)
   4004 	// result: (MOVWstoreidx1 [i-1] {s} p idx w mem)
   4005 	for {
   4006 		i := v.AuxInt
   4007 		s := v.Aux
   4008 		_ = v.Args[3]
   4009 		idx := v.Args[0]
   4010 		p := v.Args[1]
   4011 		v_2 := v.Args[2]
   4012 		if v_2.Op != Op386SHRLconst {
   4013 			break
   4014 		}
   4015 		if v_2.AuxInt != 8 {
   4016 			break
   4017 		}
   4018 		w := v_2.Args[0]
   4019 		x := v.Args[3]
   4020 		if x.Op != Op386MOVBstoreidx1 {
   4021 			break
   4022 		}
   4023 		if x.AuxInt != i-1 {
   4024 			break
   4025 		}
   4026 		if x.Aux != s {
   4027 			break
   4028 		}
   4029 		_ = x.Args[3]
   4030 		if idx != x.Args[0] {
   4031 			break
   4032 		}
   4033 		if p != x.Args[1] {
   4034 			break
   4035 		}
   4036 		if w != x.Args[2] {
   4037 			break
   4038 		}
   4039 		mem := x.Args[3]
   4040 		if !(x.Uses == 1 && clobber(x)) {
   4041 			break
   4042 		}
   4043 		v.reset(Op386MOVWstoreidx1)
   4044 		v.AuxInt = i - 1
   4045 		v.Aux = s
   4046 		v.AddArg(p)
   4047 		v.AddArg(idx)
   4048 		v.AddArg(w)
   4049 		v.AddArg(mem)
   4050 		return true
   4051 	}
   4052 	// match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem))
   4053 	// cond: x.Uses == 1   && clobber(x)
   4054 	// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
   4055 	for {
   4056 		i := v.AuxInt
   4057 		s := v.Aux
   4058 		_ = v.Args[3]
   4059 		p := v.Args[0]
   4060 		idx := v.Args[1]
   4061 		v_2 := v.Args[2]
   4062 		if v_2.Op != Op386SHRLconst {
   4063 			break
   4064 		}
   4065 		j := v_2.AuxInt
   4066 		w := v_2.Args[0]
   4067 		x := v.Args[3]
   4068 		if x.Op != Op386MOVBstoreidx1 {
   4069 			break
   4070 		}
   4071 		if x.AuxInt != i-1 {
   4072 			break
   4073 		}
   4074 		if x.Aux != s {
   4075 			break
   4076 		}
   4077 		_ = x.Args[3]
   4078 		if p != x.Args[0] {
   4079 			break
   4080 		}
   4081 		if idx != x.Args[1] {
   4082 			break
   4083 		}
   4084 		w0 := x.Args[2]
   4085 		if w0.Op != Op386SHRLconst {
   4086 			break
   4087 		}
   4088 		if w0.AuxInt != j-8 {
   4089 			break
   4090 		}
   4091 		if w != w0.Args[0] {
   4092 			break
   4093 		}
   4094 		mem := x.Args[3]
   4095 		if !(x.Uses == 1 && clobber(x)) {
   4096 			break
   4097 		}
   4098 		v.reset(Op386MOVWstoreidx1)
   4099 		v.AuxInt = i - 1
   4100 		v.Aux = s
   4101 		v.AddArg(p)
   4102 		v.AddArg(idx)
   4103 		v.AddArg(w0)
   4104 		v.AddArg(mem)
   4105 		return true
   4106 	}
   4107 	// match: (MOVBstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} idx p w0:(SHRLconst [j-8] w) mem))
   4108 	// cond: x.Uses == 1   && clobber(x)
   4109 	// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
   4110 	for {
   4111 		i := v.AuxInt
   4112 		s := v.Aux
   4113 		_ = v.Args[3]
   4114 		p := v.Args[0]
   4115 		idx := v.Args[1]
   4116 		v_2 := v.Args[2]
   4117 		if v_2.Op != Op386SHRLconst {
   4118 			break
   4119 		}
   4120 		j := v_2.AuxInt
   4121 		w := v_2.Args[0]
   4122 		x := v.Args[3]
   4123 		if x.Op != Op386MOVBstoreidx1 {
   4124 			break
   4125 		}
   4126 		if x.AuxInt != i-1 {
   4127 			break
   4128 		}
   4129 		if x.Aux != s {
   4130 			break
   4131 		}
   4132 		_ = x.Args[3]
   4133 		if idx != x.Args[0] {
   4134 			break
   4135 		}
   4136 		if p != x.Args[1] {
   4137 			break
   4138 		}
   4139 		w0 := x.Args[2]
   4140 		if w0.Op != Op386SHRLconst {
   4141 			break
   4142 		}
   4143 		if w0.AuxInt != j-8 {
   4144 			break
   4145 		}
   4146 		if w != w0.Args[0] {
   4147 			break
   4148 		}
   4149 		mem := x.Args[3]
   4150 		if !(x.Uses == 1 && clobber(x)) {
   4151 			break
   4152 		}
   4153 		v.reset(Op386MOVWstoreidx1)
   4154 		v.AuxInt = i - 1
   4155 		v.Aux = s
   4156 		v.AddArg(p)
   4157 		v.AddArg(idx)
   4158 		v.AddArg(w0)
   4159 		v.AddArg(mem)
   4160 		return true
   4161 	}
   4162 	return false
   4163 }
   4164 func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool {
   4165 	// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem))
   4166 	// cond: x.Uses == 1   && clobber(x)
   4167 	// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
   4168 	for {
   4169 		i := v.AuxInt
   4170 		s := v.Aux
   4171 		_ = v.Args[3]
   4172 		idx := v.Args[0]
   4173 		p := v.Args[1]
   4174 		v_2 := v.Args[2]
   4175 		if v_2.Op != Op386SHRLconst {
   4176 			break
   4177 		}
   4178 		j := v_2.AuxInt
   4179 		w := v_2.Args[0]
   4180 		x := v.Args[3]
   4181 		if x.Op != Op386MOVBstoreidx1 {
   4182 			break
   4183 		}
   4184 		if x.AuxInt != i-1 {
   4185 			break
   4186 		}
   4187 		if x.Aux != s {
   4188 			break
   4189 		}
   4190 		_ = x.Args[3]
   4191 		if p != x.Args[0] {
   4192 			break
   4193 		}
   4194 		if idx != x.Args[1] {
   4195 			break
   4196 		}
   4197 		w0 := x.Args[2]
   4198 		if w0.Op != Op386SHRLconst {
   4199 			break
   4200 		}
   4201 		if w0.AuxInt != j-8 {
   4202 			break
   4203 		}
   4204 		if w != w0.Args[0] {
   4205 			break
   4206 		}
   4207 		mem := x.Args[3]
   4208 		if !(x.Uses == 1 && clobber(x)) {
   4209 			break
   4210 		}
   4211 		v.reset(Op386MOVWstoreidx1)
   4212 		v.AuxInt = i - 1
   4213 		v.Aux = s
   4214 		v.AddArg(p)
   4215 		v.AddArg(idx)
   4216 		v.AddArg(w0)
   4217 		v.AddArg(mem)
   4218 		return true
   4219 	}
   4220 	// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} idx p w0:(SHRLconst [j-8] w) mem))
   4221 	// cond: x.Uses == 1   && clobber(x)
   4222 	// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
   4223 	for {
   4224 		i := v.AuxInt
   4225 		s := v.Aux
   4226 		_ = v.Args[3]
   4227 		idx := v.Args[0]
   4228 		p := v.Args[1]
   4229 		v_2 := v.Args[2]
   4230 		if v_2.Op != Op386SHRLconst {
   4231 			break
   4232 		}
   4233 		j := v_2.AuxInt
   4234 		w := v_2.Args[0]
   4235 		x := v.Args[3]
   4236 		if x.Op != Op386MOVBstoreidx1 {
   4237 			break
   4238 		}
   4239 		if x.AuxInt != i-1 {
   4240 			break
   4241 		}
   4242 		if x.Aux != s {
   4243 			break
   4244 		}
   4245 		_ = x.Args[3]
   4246 		if idx != x.Args[0] {
   4247 			break
   4248 		}
   4249 		if p != x.Args[1] {
   4250 			break
   4251 		}
   4252 		w0 := x.Args[2]
   4253 		if w0.Op != Op386SHRLconst {
   4254 			break
   4255 		}
   4256 		if w0.AuxInt != j-8 {
   4257 			break
   4258 		}
   4259 		if w != w0.Args[0] {
   4260 			break
   4261 		}
   4262 		mem := x.Args[3]
   4263 		if !(x.Uses == 1 && clobber(x)) {
   4264 			break
   4265 		}
   4266 		v.reset(Op386MOVWstoreidx1)
   4267 		v.AuxInt = i - 1
   4268 		v.Aux = s
   4269 		v.AddArg(p)
   4270 		v.AddArg(idx)
   4271 		v.AddArg(w0)
   4272 		v.AddArg(mem)
   4273 		return true
   4274 	}
   4275 	return false
   4276 }
   4277 func rewriteValue386_Op386MOVLload_0(v *Value) bool {
   4278 	b := v.Block
   4279 	_ = b
   4280 	config := b.Func.Config
   4281 	_ = config
   4282 	// match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
   4283 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
   4284 	// result: x
   4285 	for {
   4286 		off := v.AuxInt
   4287 		sym := v.Aux
   4288 		_ = v.Args[1]
   4289 		ptr := v.Args[0]
   4290 		v_1 := v.Args[1]
   4291 		if v_1.Op != Op386MOVLstore {
   4292 			break
   4293 		}
   4294 		off2 := v_1.AuxInt
   4295 		sym2 := v_1.Aux
   4296 		_ = v_1.Args[2]
   4297 		ptr2 := v_1.Args[0]
   4298 		x := v_1.Args[1]
   4299 		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
   4300 			break
   4301 		}
   4302 		v.reset(OpCopy)
   4303 		v.Type = x.Type
   4304 		v.AddArg(x)
   4305 		return true
   4306 	}
   4307 	// match: (MOVLload [off1] {sym} (ADDLconst [off2] ptr) mem)
   4308 	// cond: is32Bit(off1+off2)
   4309 	// result: (MOVLload  [off1+off2] {sym} ptr mem)
   4310 	for {
   4311 		off1 := v.AuxInt
   4312 		sym := v.Aux
   4313 		_ = v.Args[1]
   4314 		v_0 := v.Args[0]
   4315 		if v_0.Op != Op386ADDLconst {
   4316 			break
   4317 		}
   4318 		off2 := v_0.AuxInt
   4319 		ptr := v_0.Args[0]
   4320 		mem := v.Args[1]
   4321 		if !(is32Bit(off1 + off2)) {
   4322 			break
   4323 		}
   4324 		v.reset(Op386MOVLload)
   4325 		v.AuxInt = off1 + off2
   4326 		v.Aux = sym
   4327 		v.AddArg(ptr)
   4328 		v.AddArg(mem)
   4329 		return true
   4330 	}
   4331 	// match: (MOVLload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   4332 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   4333 	// result: (MOVLload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   4334 	for {
   4335 		off1 := v.AuxInt
   4336 		sym1 := v.Aux
   4337 		_ = v.Args[1]
   4338 		v_0 := v.Args[0]
   4339 		if v_0.Op != Op386LEAL {
   4340 			break
   4341 		}
   4342 		off2 := v_0.AuxInt
   4343 		sym2 := v_0.Aux
   4344 		base := v_0.Args[0]
   4345 		mem := v.Args[1]
   4346 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   4347 			break
   4348 		}
   4349 		v.reset(Op386MOVLload)
   4350 		v.AuxInt = off1 + off2
   4351 		v.Aux = mergeSym(sym1, sym2)
   4352 		v.AddArg(base)
   4353 		v.AddArg(mem)
   4354 		return true
   4355 	}
   4356 	// match: (MOVLload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem)
   4357 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   4358 	// result: (MOVLloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   4359 	for {
   4360 		off1 := v.AuxInt
   4361 		sym1 := v.Aux
   4362 		_ = v.Args[1]
   4363 		v_0 := v.Args[0]
   4364 		if v_0.Op != Op386LEAL1 {
   4365 			break
   4366 		}
   4367 		off2 := v_0.AuxInt
   4368 		sym2 := v_0.Aux
   4369 		_ = v_0.Args[1]
   4370 		ptr := v_0.Args[0]
   4371 		idx := v_0.Args[1]
   4372 		mem := v.Args[1]
   4373 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   4374 			break
   4375 		}
   4376 		v.reset(Op386MOVLloadidx1)
   4377 		v.AuxInt = off1 + off2
   4378 		v.Aux = mergeSym(sym1, sym2)
   4379 		v.AddArg(ptr)
   4380 		v.AddArg(idx)
   4381 		v.AddArg(mem)
   4382 		return true
   4383 	}
   4384 	// match: (MOVLload [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) mem)
   4385 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   4386 	// result: (MOVLloadidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   4387 	for {
   4388 		off1 := v.AuxInt
   4389 		sym1 := v.Aux
   4390 		_ = v.Args[1]
   4391 		v_0 := v.Args[0]
   4392 		if v_0.Op != Op386LEAL4 {
   4393 			break
   4394 		}
   4395 		off2 := v_0.AuxInt
   4396 		sym2 := v_0.Aux
   4397 		_ = v_0.Args[1]
   4398 		ptr := v_0.Args[0]
   4399 		idx := v_0.Args[1]
   4400 		mem := v.Args[1]
   4401 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   4402 			break
   4403 		}
   4404 		v.reset(Op386MOVLloadidx4)
   4405 		v.AuxInt = off1 + off2
   4406 		v.Aux = mergeSym(sym1, sym2)
   4407 		v.AddArg(ptr)
   4408 		v.AddArg(idx)
   4409 		v.AddArg(mem)
   4410 		return true
   4411 	}
   4412 	// match: (MOVLload [off] {sym} (ADDL ptr idx) mem)
   4413 	// cond: ptr.Op != OpSB
   4414 	// result: (MOVLloadidx1 [off] {sym} ptr idx mem)
   4415 	for {
   4416 		off := v.AuxInt
   4417 		sym := v.Aux
   4418 		_ = v.Args[1]
   4419 		v_0 := v.Args[0]
   4420 		if v_0.Op != Op386ADDL {
   4421 			break
   4422 		}
   4423 		_ = v_0.Args[1]
   4424 		ptr := v_0.Args[0]
   4425 		idx := v_0.Args[1]
   4426 		mem := v.Args[1]
   4427 		if !(ptr.Op != OpSB) {
   4428 			break
   4429 		}
   4430 		v.reset(Op386MOVLloadidx1)
   4431 		v.AuxInt = off
   4432 		v.Aux = sym
   4433 		v.AddArg(ptr)
   4434 		v.AddArg(idx)
   4435 		v.AddArg(mem)
   4436 		return true
   4437 	}
   4438 	return false
   4439 }
   4440 func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool {
   4441 	// match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
   4442 	// cond:
   4443 	// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
   4444 	for {
   4445 		c := v.AuxInt
   4446 		sym := v.Aux
   4447 		_ = v.Args[2]
   4448 		ptr := v.Args[0]
   4449 		v_1 := v.Args[1]
   4450 		if v_1.Op != Op386SHLLconst {
   4451 			break
   4452 		}
   4453 		if v_1.AuxInt != 2 {
   4454 			break
   4455 		}
   4456 		idx := v_1.Args[0]
   4457 		mem := v.Args[2]
   4458 		v.reset(Op386MOVLloadidx4)
   4459 		v.AuxInt = c
   4460 		v.Aux = sym
   4461 		v.AddArg(ptr)
   4462 		v.AddArg(idx)
   4463 		v.AddArg(mem)
   4464 		return true
   4465 	}
   4466 	// match: (MOVLloadidx1 [c] {sym} (SHLLconst [2] idx) ptr mem)
   4467 	// cond:
   4468 	// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
   4469 	for {
   4470 		c := v.AuxInt
   4471 		sym := v.Aux
   4472 		_ = v.Args[2]
   4473 		v_0 := v.Args[0]
   4474 		if v_0.Op != Op386SHLLconst {
   4475 			break
   4476 		}
   4477 		if v_0.AuxInt != 2 {
   4478 			break
   4479 		}
   4480 		idx := v_0.Args[0]
   4481 		ptr := v.Args[1]
   4482 		mem := v.Args[2]
   4483 		v.reset(Op386MOVLloadidx4)
   4484 		v.AuxInt = c
   4485 		v.Aux = sym
   4486 		v.AddArg(ptr)
   4487 		v.AddArg(idx)
   4488 		v.AddArg(mem)
   4489 		return true
   4490 	}
   4491 	// match: (MOVLloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
   4492 	// cond:
   4493 	// result: (MOVLloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   4494 	for {
   4495 		c := v.AuxInt
   4496 		sym := v.Aux
   4497 		_ = v.Args[2]
   4498 		v_0 := v.Args[0]
   4499 		if v_0.Op != Op386ADDLconst {
   4500 			break
   4501 		}
   4502 		d := v_0.AuxInt
   4503 		ptr := v_0.Args[0]
   4504 		idx := v.Args[1]
   4505 		mem := v.Args[2]
   4506 		v.reset(Op386MOVLloadidx1)
   4507 		v.AuxInt = int64(int32(c + d))
   4508 		v.Aux = sym
   4509 		v.AddArg(ptr)
   4510 		v.AddArg(idx)
   4511 		v.AddArg(mem)
   4512 		return true
   4513 	}
   4514 	// match: (MOVLloadidx1 [c] {sym} idx (ADDLconst [d] ptr) mem)
   4515 	// cond:
   4516 	// result: (MOVLloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   4517 	for {
   4518 		c := v.AuxInt
   4519 		sym := v.Aux
   4520 		_ = v.Args[2]
   4521 		idx := v.Args[0]
   4522 		v_1 := v.Args[1]
   4523 		if v_1.Op != Op386ADDLconst {
   4524 			break
   4525 		}
   4526 		d := v_1.AuxInt
   4527 		ptr := v_1.Args[0]
   4528 		mem := v.Args[2]
   4529 		v.reset(Op386MOVLloadidx1)
   4530 		v.AuxInt = int64(int32(c + d))
   4531 		v.Aux = sym
   4532 		v.AddArg(ptr)
   4533 		v.AddArg(idx)
   4534 		v.AddArg(mem)
   4535 		return true
   4536 	}
   4537 	// match: (MOVLloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem)
   4538 	// cond:
   4539 	// result: (MOVLloadidx1  [int64(int32(c+d))]   {sym} ptr idx mem)
   4540 	for {
   4541 		c := v.AuxInt
   4542 		sym := v.Aux
   4543 		_ = v.Args[2]
   4544 		ptr := v.Args[0]
   4545 		v_1 := v.Args[1]
   4546 		if v_1.Op != Op386ADDLconst {
   4547 			break
   4548 		}
   4549 		d := v_1.AuxInt
   4550 		idx := v_1.Args[0]
   4551 		mem := v.Args[2]
   4552 		v.reset(Op386MOVLloadidx1)
   4553 		v.AuxInt = int64(int32(c + d))
   4554 		v.Aux = sym
   4555 		v.AddArg(ptr)
   4556 		v.AddArg(idx)
   4557 		v.AddArg(mem)
   4558 		return true
   4559 	}
   4560 	// match: (MOVLloadidx1 [c] {sym} (ADDLconst [d] idx) ptr mem)
   4561 	// cond:
   4562 	// result: (MOVLloadidx1  [int64(int32(c+d))]   {sym} ptr idx mem)
   4563 	for {
   4564 		c := v.AuxInt
   4565 		sym := v.Aux
   4566 		_ = v.Args[2]
   4567 		v_0 := v.Args[0]
   4568 		if v_0.Op != Op386ADDLconst {
   4569 			break
   4570 		}
   4571 		d := v_0.AuxInt
   4572 		idx := v_0.Args[0]
   4573 		ptr := v.Args[1]
   4574 		mem := v.Args[2]
   4575 		v.reset(Op386MOVLloadidx1)
   4576 		v.AuxInt = int64(int32(c + d))
   4577 		v.Aux = sym
   4578 		v.AddArg(ptr)
   4579 		v.AddArg(idx)
   4580 		v.AddArg(mem)
   4581 		return true
   4582 	}
   4583 	return false
   4584 }
   4585 func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool {
   4586 	// match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
   4587 	// cond:
   4588 	// result: (MOVLloadidx4 [int64(int32(c+d))] {sym} ptr idx mem)
   4589 	for {
   4590 		c := v.AuxInt
   4591 		sym := v.Aux
   4592 		_ = v.Args[2]
   4593 		v_0 := v.Args[0]
   4594 		if v_0.Op != Op386ADDLconst {
   4595 			break
   4596 		}
   4597 		d := v_0.AuxInt
   4598 		ptr := v_0.Args[0]
   4599 		idx := v.Args[1]
   4600 		mem := v.Args[2]
   4601 		v.reset(Op386MOVLloadidx4)
   4602 		v.AuxInt = int64(int32(c + d))
   4603 		v.Aux = sym
   4604 		v.AddArg(ptr)
   4605 		v.AddArg(idx)
   4606 		v.AddArg(mem)
   4607 		return true
   4608 	}
   4609 	// match: (MOVLloadidx4 [c] {sym} ptr (ADDLconst [d] idx) mem)
   4610 	// cond:
   4611 	// result: (MOVLloadidx4  [int64(int32(c+4*d))] {sym} ptr idx mem)
   4612 	for {
   4613 		c := v.AuxInt
   4614 		sym := v.Aux
   4615 		_ = v.Args[2]
   4616 		ptr := v.Args[0]
   4617 		v_1 := v.Args[1]
   4618 		if v_1.Op != Op386ADDLconst {
   4619 			break
   4620 		}
   4621 		d := v_1.AuxInt
   4622 		idx := v_1.Args[0]
   4623 		mem := v.Args[2]
   4624 		v.reset(Op386MOVLloadidx4)
   4625 		v.AuxInt = int64(int32(c + 4*d))
   4626 		v.Aux = sym
   4627 		v.AddArg(ptr)
   4628 		v.AddArg(idx)
   4629 		v.AddArg(mem)
   4630 		return true
   4631 	}
   4632 	return false
   4633 }
   4634 func rewriteValue386_Op386MOVLstore_0(v *Value) bool {
   4635 	b := v.Block
   4636 	_ = b
   4637 	config := b.Func.Config
   4638 	_ = config
   4639 	// match: (MOVLstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
   4640 	// cond: is32Bit(off1+off2)
   4641 	// result: (MOVLstore  [off1+off2] {sym} ptr val mem)
   4642 	for {
   4643 		off1 := v.AuxInt
   4644 		sym := v.Aux
   4645 		_ = v.Args[2]
   4646 		v_0 := v.Args[0]
   4647 		if v_0.Op != Op386ADDLconst {
   4648 			break
   4649 		}
   4650 		off2 := v_0.AuxInt
   4651 		ptr := v_0.Args[0]
   4652 		val := v.Args[1]
   4653 		mem := v.Args[2]
   4654 		if !(is32Bit(off1 + off2)) {
   4655 			break
   4656 		}
   4657 		v.reset(Op386MOVLstore)
   4658 		v.AuxInt = off1 + off2
   4659 		v.Aux = sym
   4660 		v.AddArg(ptr)
   4661 		v.AddArg(val)
   4662 		v.AddArg(mem)
   4663 		return true
   4664 	}
   4665 	// match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem)
   4666 	// cond: validOff(off)
   4667 	// result: (MOVLstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem)
   4668 	for {
   4669 		off := v.AuxInt
   4670 		sym := v.Aux
   4671 		_ = v.Args[2]
   4672 		ptr := v.Args[0]
   4673 		v_1 := v.Args[1]
   4674 		if v_1.Op != Op386MOVLconst {
   4675 			break
   4676 		}
   4677 		c := v_1.AuxInt
   4678 		mem := v.Args[2]
   4679 		if !(validOff(off)) {
   4680 			break
   4681 		}
   4682 		v.reset(Op386MOVLstoreconst)
   4683 		v.AuxInt = makeValAndOff(int64(int32(c)), off)
   4684 		v.Aux = sym
   4685 		v.AddArg(ptr)
   4686 		v.AddArg(mem)
   4687 		return true
   4688 	}
   4689 	// match: (MOVLstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
   4690 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   4691 	// result: (MOVLstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   4692 	for {
   4693 		off1 := v.AuxInt
   4694 		sym1 := v.Aux
   4695 		_ = v.Args[2]
   4696 		v_0 := v.Args[0]
   4697 		if v_0.Op != Op386LEAL {
   4698 			break
   4699 		}
   4700 		off2 := v_0.AuxInt
   4701 		sym2 := v_0.Aux
   4702 		base := v_0.Args[0]
   4703 		val := v.Args[1]
   4704 		mem := v.Args[2]
   4705 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   4706 			break
   4707 		}
   4708 		v.reset(Op386MOVLstore)
   4709 		v.AuxInt = off1 + off2
   4710 		v.Aux = mergeSym(sym1, sym2)
   4711 		v.AddArg(base)
   4712 		v.AddArg(val)
   4713 		v.AddArg(mem)
   4714 		return true
   4715 	}
   4716 	// match: (MOVLstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem)
   4717 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   4718 	// result: (MOVLstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   4719 	for {
   4720 		off1 := v.AuxInt
   4721 		sym1 := v.Aux
   4722 		_ = v.Args[2]
   4723 		v_0 := v.Args[0]
   4724 		if v_0.Op != Op386LEAL1 {
   4725 			break
   4726 		}
   4727 		off2 := v_0.AuxInt
   4728 		sym2 := v_0.Aux
   4729 		_ = v_0.Args[1]
   4730 		ptr := v_0.Args[0]
   4731 		idx := v_0.Args[1]
   4732 		val := v.Args[1]
   4733 		mem := v.Args[2]
   4734 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   4735 			break
   4736 		}
   4737 		v.reset(Op386MOVLstoreidx1)
   4738 		v.AuxInt = off1 + off2
   4739 		v.Aux = mergeSym(sym1, sym2)
   4740 		v.AddArg(ptr)
   4741 		v.AddArg(idx)
   4742 		v.AddArg(val)
   4743 		v.AddArg(mem)
   4744 		return true
   4745 	}
   4746 	// match: (MOVLstore [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) val mem)
   4747 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   4748 	// result: (MOVLstoreidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   4749 	for {
   4750 		off1 := v.AuxInt
   4751 		sym1 := v.Aux
   4752 		_ = v.Args[2]
   4753 		v_0 := v.Args[0]
   4754 		if v_0.Op != Op386LEAL4 {
   4755 			break
   4756 		}
   4757 		off2 := v_0.AuxInt
   4758 		sym2 := v_0.Aux
   4759 		_ = v_0.Args[1]
   4760 		ptr := v_0.Args[0]
   4761 		idx := v_0.Args[1]
   4762 		val := v.Args[1]
   4763 		mem := v.Args[2]
   4764 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   4765 			break
   4766 		}
   4767 		v.reset(Op386MOVLstoreidx4)
   4768 		v.AuxInt = off1 + off2
   4769 		v.Aux = mergeSym(sym1, sym2)
   4770 		v.AddArg(ptr)
   4771 		v.AddArg(idx)
   4772 		v.AddArg(val)
   4773 		v.AddArg(mem)
   4774 		return true
   4775 	}
   4776 	// match: (MOVLstore [off] {sym} (ADDL ptr idx) val mem)
   4777 	// cond: ptr.Op != OpSB
   4778 	// result: (MOVLstoreidx1 [off] {sym} ptr idx val mem)
   4779 	for {
   4780 		off := v.AuxInt
   4781 		sym := v.Aux
   4782 		_ = v.Args[2]
   4783 		v_0 := v.Args[0]
   4784 		if v_0.Op != Op386ADDL {
   4785 			break
   4786 		}
   4787 		_ = v_0.Args[1]
   4788 		ptr := v_0.Args[0]
   4789 		idx := v_0.Args[1]
   4790 		val := v.Args[1]
   4791 		mem := v.Args[2]
   4792 		if !(ptr.Op != OpSB) {
   4793 			break
   4794 		}
   4795 		v.reset(Op386MOVLstoreidx1)
   4796 		v.AuxInt = off
   4797 		v.Aux = sym
   4798 		v.AddArg(ptr)
   4799 		v.AddArg(idx)
   4800 		v.AddArg(val)
   4801 		v.AddArg(mem)
   4802 		return true
   4803 	}
   4804 	return false
   4805 }
   4806 func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool {
   4807 	b := v.Block
   4808 	_ = b
   4809 	config := b.Func.Config
   4810 	_ = config
   4811 	// match: (MOVLstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
   4812 	// cond: ValAndOff(sc).canAdd(off)
   4813 	// result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   4814 	for {
   4815 		sc := v.AuxInt
   4816 		s := v.Aux
   4817 		_ = v.Args[1]
   4818 		v_0 := v.Args[0]
   4819 		if v_0.Op != Op386ADDLconst {
   4820 			break
   4821 		}
   4822 		off := v_0.AuxInt
   4823 		ptr := v_0.Args[0]
   4824 		mem := v.Args[1]
   4825 		if !(ValAndOff(sc).canAdd(off)) {
   4826 			break
   4827 		}
   4828 		v.reset(Op386MOVLstoreconst)
   4829 		v.AuxInt = ValAndOff(sc).add(off)
   4830 		v.Aux = s
   4831 		v.AddArg(ptr)
   4832 		v.AddArg(mem)
   4833 		return true
   4834 	}
   4835 	// match: (MOVLstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
   4836 	// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)   && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
   4837 	// result: (MOVLstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   4838 	for {
   4839 		sc := v.AuxInt
   4840 		sym1 := v.Aux
   4841 		_ = v.Args[1]
   4842 		v_0 := v.Args[0]
   4843 		if v_0.Op != Op386LEAL {
   4844 			break
   4845 		}
   4846 		off := v_0.AuxInt
   4847 		sym2 := v_0.Aux
   4848 		ptr := v_0.Args[0]
   4849 		mem := v.Args[1]
   4850 		if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) {
   4851 			break
   4852 		}
   4853 		v.reset(Op386MOVLstoreconst)
   4854 		v.AuxInt = ValAndOff(sc).add(off)
   4855 		v.Aux = mergeSym(sym1, sym2)
   4856 		v.AddArg(ptr)
   4857 		v.AddArg(mem)
   4858 		return true
   4859 	}
   4860 	// match: (MOVLstoreconst [x] {sym1} (LEAL1 [off] {sym2} ptr idx) mem)
   4861 	// cond: canMergeSym(sym1, sym2)
   4862 	// result: (MOVLstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
   4863 	for {
   4864 		x := v.AuxInt
   4865 		sym1 := v.Aux
   4866 		_ = v.Args[1]
   4867 		v_0 := v.Args[0]
   4868 		if v_0.Op != Op386LEAL1 {
   4869 			break
   4870 		}
   4871 		off := v_0.AuxInt
   4872 		sym2 := v_0.Aux
   4873 		_ = v_0.Args[1]
   4874 		ptr := v_0.Args[0]
   4875 		idx := v_0.Args[1]
   4876 		mem := v.Args[1]
   4877 		if !(canMergeSym(sym1, sym2)) {
   4878 			break
   4879 		}
   4880 		v.reset(Op386MOVLstoreconstidx1)
   4881 		v.AuxInt = ValAndOff(x).add(off)
   4882 		v.Aux = mergeSym(sym1, sym2)
   4883 		v.AddArg(ptr)
   4884 		v.AddArg(idx)
   4885 		v.AddArg(mem)
   4886 		return true
   4887 	}
   4888 	// match: (MOVLstoreconst [x] {sym1} (LEAL4 [off] {sym2} ptr idx) mem)
   4889 	// cond: canMergeSym(sym1, sym2)
   4890 	// result: (MOVLstoreconstidx4 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
   4891 	for {
   4892 		x := v.AuxInt
   4893 		sym1 := v.Aux
   4894 		_ = v.Args[1]
   4895 		v_0 := v.Args[0]
   4896 		if v_0.Op != Op386LEAL4 {
   4897 			break
   4898 		}
   4899 		off := v_0.AuxInt
   4900 		sym2 := v_0.Aux
   4901 		_ = v_0.Args[1]
   4902 		ptr := v_0.Args[0]
   4903 		idx := v_0.Args[1]
   4904 		mem := v.Args[1]
   4905 		if !(canMergeSym(sym1, sym2)) {
   4906 			break
   4907 		}
   4908 		v.reset(Op386MOVLstoreconstidx4)
   4909 		v.AuxInt = ValAndOff(x).add(off)
   4910 		v.Aux = mergeSym(sym1, sym2)
   4911 		v.AddArg(ptr)
   4912 		v.AddArg(idx)
   4913 		v.AddArg(mem)
   4914 		return true
   4915 	}
   4916 	// match: (MOVLstoreconst [x] {sym} (ADDL ptr idx) mem)
   4917 	// cond:
   4918 	// result: (MOVLstoreconstidx1 [x] {sym} ptr idx mem)
   4919 	for {
   4920 		x := v.AuxInt
   4921 		sym := v.Aux
   4922 		_ = v.Args[1]
   4923 		v_0 := v.Args[0]
   4924 		if v_0.Op != Op386ADDL {
   4925 			break
   4926 		}
   4927 		_ = v_0.Args[1]
   4928 		ptr := v_0.Args[0]
   4929 		idx := v_0.Args[1]
   4930 		mem := v.Args[1]
   4931 		v.reset(Op386MOVLstoreconstidx1)
   4932 		v.AuxInt = x
   4933 		v.Aux = sym
   4934 		v.AddArg(ptr)
   4935 		v.AddArg(idx)
   4936 		v.AddArg(mem)
   4937 		return true
   4938 	}
   4939 	return false
   4940 }
   4941 func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool {
   4942 	// match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
   4943 	// cond:
   4944 	// result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem)
   4945 	for {
   4946 		c := v.AuxInt
   4947 		sym := v.Aux
   4948 		_ = v.Args[2]
   4949 		ptr := v.Args[0]
   4950 		v_1 := v.Args[1]
   4951 		if v_1.Op != Op386SHLLconst {
   4952 			break
   4953 		}
   4954 		if v_1.AuxInt != 2 {
   4955 			break
   4956 		}
   4957 		idx := v_1.Args[0]
   4958 		mem := v.Args[2]
   4959 		v.reset(Op386MOVLstoreconstidx4)
   4960 		v.AuxInt = c
   4961 		v.Aux = sym
   4962 		v.AddArg(ptr)
   4963 		v.AddArg(idx)
   4964 		v.AddArg(mem)
   4965 		return true
   4966 	}
   4967 	// match: (MOVLstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem)
   4968 	// cond:
   4969 	// result: (MOVLstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   4970 	for {
   4971 		x := v.AuxInt
   4972 		sym := v.Aux
   4973 		_ = v.Args[2]
   4974 		v_0 := v.Args[0]
   4975 		if v_0.Op != Op386ADDLconst {
   4976 			break
   4977 		}
   4978 		c := v_0.AuxInt
   4979 		ptr := v_0.Args[0]
   4980 		idx := v.Args[1]
   4981 		mem := v.Args[2]
   4982 		v.reset(Op386MOVLstoreconstidx1)
   4983 		v.AuxInt = ValAndOff(x).add(c)
   4984 		v.Aux = sym
   4985 		v.AddArg(ptr)
   4986 		v.AddArg(idx)
   4987 		v.AddArg(mem)
   4988 		return true
   4989 	}
   4990 	// match: (MOVLstoreconstidx1 [x] {sym} ptr (ADDLconst [c] idx) mem)
   4991 	// cond:
   4992 	// result: (MOVLstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   4993 	for {
   4994 		x := v.AuxInt
   4995 		sym := v.Aux
   4996 		_ = v.Args[2]
   4997 		ptr := v.Args[0]
   4998 		v_1 := v.Args[1]
   4999 		if v_1.Op != Op386ADDLconst {
   5000 			break
   5001 		}
   5002 		c := v_1.AuxInt
   5003 		idx := v_1.Args[0]
   5004 		mem := v.Args[2]
   5005 		v.reset(Op386MOVLstoreconstidx1)
   5006 		v.AuxInt = ValAndOff(x).add(c)
   5007 		v.Aux = sym
   5008 		v.AddArg(ptr)
   5009 		v.AddArg(idx)
   5010 		v.AddArg(mem)
   5011 		return true
   5012 	}
   5013 	return false
   5014 }
   5015 func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool {
   5016 	// match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem)
   5017 	// cond:
   5018 	// result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   5019 	for {
   5020 		x := v.AuxInt
   5021 		sym := v.Aux
   5022 		_ = v.Args[2]
   5023 		v_0 := v.Args[0]
   5024 		if v_0.Op != Op386ADDLconst {
   5025 			break
   5026 		}
   5027 		c := v_0.AuxInt
   5028 		ptr := v_0.Args[0]
   5029 		idx := v.Args[1]
   5030 		mem := v.Args[2]
   5031 		v.reset(Op386MOVLstoreconstidx4)
   5032 		v.AuxInt = ValAndOff(x).add(c)
   5033 		v.Aux = sym
   5034 		v.AddArg(ptr)
   5035 		v.AddArg(idx)
   5036 		v.AddArg(mem)
   5037 		return true
   5038 	}
   5039 	// match: (MOVLstoreconstidx4 [x] {sym} ptr (ADDLconst [c] idx) mem)
   5040 	// cond:
   5041 	// result: (MOVLstoreconstidx4 [ValAndOff(x).add(4*c)] {sym} ptr idx mem)
   5042 	for {
   5043 		x := v.AuxInt
   5044 		sym := v.Aux
   5045 		_ = v.Args[2]
   5046 		ptr := v.Args[0]
   5047 		v_1 := v.Args[1]
   5048 		if v_1.Op != Op386ADDLconst {
   5049 			break
   5050 		}
   5051 		c := v_1.AuxInt
   5052 		idx := v_1.Args[0]
   5053 		mem := v.Args[2]
   5054 		v.reset(Op386MOVLstoreconstidx4)
   5055 		v.AuxInt = ValAndOff(x).add(4 * c)
   5056 		v.Aux = sym
   5057 		v.AddArg(ptr)
   5058 		v.AddArg(idx)
   5059 		v.AddArg(mem)
   5060 		return true
   5061 	}
   5062 	return false
   5063 }
   5064 func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool {
   5065 	// match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem)
   5066 	// cond:
   5067 	// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
   5068 	for {
   5069 		c := v.AuxInt
   5070 		sym := v.Aux
   5071 		_ = v.Args[3]
   5072 		ptr := v.Args[0]
   5073 		v_1 := v.Args[1]
   5074 		if v_1.Op != Op386SHLLconst {
   5075 			break
   5076 		}
   5077 		if v_1.AuxInt != 2 {
   5078 			break
   5079 		}
   5080 		idx := v_1.Args[0]
   5081 		val := v.Args[2]
   5082 		mem := v.Args[3]
   5083 		v.reset(Op386MOVLstoreidx4)
   5084 		v.AuxInt = c
   5085 		v.Aux = sym
   5086 		v.AddArg(ptr)
   5087 		v.AddArg(idx)
   5088 		v.AddArg(val)
   5089 		v.AddArg(mem)
   5090 		return true
   5091 	}
   5092 	// match: (MOVLstoreidx1 [c] {sym} (SHLLconst [2] idx) ptr val mem)
   5093 	// cond:
   5094 	// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
   5095 	for {
   5096 		c := v.AuxInt
   5097 		sym := v.Aux
   5098 		_ = v.Args[3]
   5099 		v_0 := v.Args[0]
   5100 		if v_0.Op != Op386SHLLconst {
   5101 			break
   5102 		}
   5103 		if v_0.AuxInt != 2 {
   5104 			break
   5105 		}
   5106 		idx := v_0.Args[0]
   5107 		ptr := v.Args[1]
   5108 		val := v.Args[2]
   5109 		mem := v.Args[3]
   5110 		v.reset(Op386MOVLstoreidx4)
   5111 		v.AuxInt = c
   5112 		v.Aux = sym
   5113 		v.AddArg(ptr)
   5114 		v.AddArg(idx)
   5115 		v.AddArg(val)
   5116 		v.AddArg(mem)
   5117 		return true
   5118 	}
   5119 	// match: (MOVLstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   5120 	// cond:
   5121 	// result: (MOVLstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   5122 	for {
   5123 		c := v.AuxInt
   5124 		sym := v.Aux
   5125 		_ = v.Args[3]
   5126 		v_0 := v.Args[0]
   5127 		if v_0.Op != Op386ADDLconst {
   5128 			break
   5129 		}
   5130 		d := v_0.AuxInt
   5131 		ptr := v_0.Args[0]
   5132 		idx := v.Args[1]
   5133 		val := v.Args[2]
   5134 		mem := v.Args[3]
   5135 		v.reset(Op386MOVLstoreidx1)
   5136 		v.AuxInt = int64(int32(c + d))
   5137 		v.Aux = sym
   5138 		v.AddArg(ptr)
   5139 		v.AddArg(idx)
   5140 		v.AddArg(val)
   5141 		v.AddArg(mem)
   5142 		return true
   5143 	}
   5144 	// match: (MOVLstoreidx1 [c] {sym} idx (ADDLconst [d] ptr) val mem)
   5145 	// cond:
   5146 	// result: (MOVLstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   5147 	for {
   5148 		c := v.AuxInt
   5149 		sym := v.Aux
   5150 		_ = v.Args[3]
   5151 		idx := v.Args[0]
   5152 		v_1 := v.Args[1]
   5153 		if v_1.Op != Op386ADDLconst {
   5154 			break
   5155 		}
   5156 		d := v_1.AuxInt
   5157 		ptr := v_1.Args[0]
   5158 		val := v.Args[2]
   5159 		mem := v.Args[3]
   5160 		v.reset(Op386MOVLstoreidx1)
   5161 		v.AuxInt = int64(int32(c + d))
   5162 		v.Aux = sym
   5163 		v.AddArg(ptr)
   5164 		v.AddArg(idx)
   5165 		v.AddArg(val)
   5166 		v.AddArg(mem)
   5167 		return true
   5168 	}
   5169 	// match: (MOVLstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   5170 	// cond:
   5171 	// result: (MOVLstoreidx1  [int64(int32(c+d))]   {sym} ptr idx val mem)
   5172 	for {
   5173 		c := v.AuxInt
   5174 		sym := v.Aux
   5175 		_ = v.Args[3]
   5176 		ptr := v.Args[0]
   5177 		v_1 := v.Args[1]
   5178 		if v_1.Op != Op386ADDLconst {
   5179 			break
   5180 		}
   5181 		d := v_1.AuxInt
   5182 		idx := v_1.Args[0]
   5183 		val := v.Args[2]
   5184 		mem := v.Args[3]
   5185 		v.reset(Op386MOVLstoreidx1)
   5186 		v.AuxInt = int64(int32(c + d))
   5187 		v.Aux = sym
   5188 		v.AddArg(ptr)
   5189 		v.AddArg(idx)
   5190 		v.AddArg(val)
   5191 		v.AddArg(mem)
   5192 		return true
   5193 	}
   5194 	// match: (MOVLstoreidx1 [c] {sym} (ADDLconst [d] idx) ptr val mem)
   5195 	// cond:
   5196 	// result: (MOVLstoreidx1  [int64(int32(c+d))]   {sym} ptr idx val mem)
   5197 	for {
   5198 		c := v.AuxInt
   5199 		sym := v.Aux
   5200 		_ = v.Args[3]
   5201 		v_0 := v.Args[0]
   5202 		if v_0.Op != Op386ADDLconst {
   5203 			break
   5204 		}
   5205 		d := v_0.AuxInt
   5206 		idx := v_0.Args[0]
   5207 		ptr := v.Args[1]
   5208 		val := v.Args[2]
   5209 		mem := v.Args[3]
   5210 		v.reset(Op386MOVLstoreidx1)
   5211 		v.AuxInt = int64(int32(c + d))
   5212 		v.Aux = sym
   5213 		v.AddArg(ptr)
   5214 		v.AddArg(idx)
   5215 		v.AddArg(val)
   5216 		v.AddArg(mem)
   5217 		return true
   5218 	}
   5219 	return false
   5220 }
   5221 func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool {
   5222 	// match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   5223 	// cond:
   5224 	// result: (MOVLstoreidx4 [int64(int32(c+d))] {sym} ptr idx val mem)
   5225 	for {
   5226 		c := v.AuxInt
   5227 		sym := v.Aux
   5228 		_ = v.Args[3]
   5229 		v_0 := v.Args[0]
   5230 		if v_0.Op != Op386ADDLconst {
   5231 			break
   5232 		}
   5233 		d := v_0.AuxInt
   5234 		ptr := v_0.Args[0]
   5235 		idx := v.Args[1]
   5236 		val := v.Args[2]
   5237 		mem := v.Args[3]
   5238 		v.reset(Op386MOVLstoreidx4)
   5239 		v.AuxInt = int64(int32(c + d))
   5240 		v.Aux = sym
   5241 		v.AddArg(ptr)
   5242 		v.AddArg(idx)
   5243 		v.AddArg(val)
   5244 		v.AddArg(mem)
   5245 		return true
   5246 	}
   5247 	// match: (MOVLstoreidx4 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   5248 	// cond:
   5249 	// result: (MOVLstoreidx4  [int64(int32(c+4*d))] {sym} ptr idx val mem)
   5250 	for {
   5251 		c := v.AuxInt
   5252 		sym := v.Aux
   5253 		_ = v.Args[3]
   5254 		ptr := v.Args[0]
   5255 		v_1 := v.Args[1]
   5256 		if v_1.Op != Op386ADDLconst {
   5257 			break
   5258 		}
   5259 		d := v_1.AuxInt
   5260 		idx := v_1.Args[0]
   5261 		val := v.Args[2]
   5262 		mem := v.Args[3]
   5263 		v.reset(Op386MOVLstoreidx4)
   5264 		v.AuxInt = int64(int32(c + 4*d))
   5265 		v.Aux = sym
   5266 		v.AddArg(ptr)
   5267 		v.AddArg(idx)
   5268 		v.AddArg(val)
   5269 		v.AddArg(mem)
   5270 		return true
   5271 	}
   5272 	return false
   5273 }
   5274 func rewriteValue386_Op386MOVSDconst_0(v *Value) bool {
   5275 	b := v.Block
   5276 	_ = b
   5277 	config := b.Func.Config
   5278 	_ = config
   5279 	typ := &b.Func.Config.Types
   5280 	_ = typ
   5281 	// match: (MOVSDconst [c])
   5282 	// cond: config.ctxt.Flag_shared
   5283 	// result: (MOVSDconst2 (MOVSDconst1 [c]))
   5284 	for {
   5285 		c := v.AuxInt
   5286 		if !(config.ctxt.Flag_shared) {
   5287 			break
   5288 		}
   5289 		v.reset(Op386MOVSDconst2)
   5290 		v0 := b.NewValue0(v.Pos, Op386MOVSDconst1, typ.UInt32)
   5291 		v0.AuxInt = c
   5292 		v.AddArg(v0)
   5293 		return true
   5294 	}
   5295 	return false
   5296 }
   5297 func rewriteValue386_Op386MOVSDload_0(v *Value) bool {
   5298 	b := v.Block
   5299 	_ = b
   5300 	config := b.Func.Config
   5301 	_ = config
   5302 	// match: (MOVSDload [off1] {sym} (ADDLconst [off2] ptr) mem)
   5303 	// cond: is32Bit(off1+off2)
   5304 	// result: (MOVSDload [off1+off2] {sym} ptr mem)
   5305 	for {
   5306 		off1 := v.AuxInt
   5307 		sym := v.Aux
   5308 		_ = v.Args[1]
   5309 		v_0 := v.Args[0]
   5310 		if v_0.Op != Op386ADDLconst {
   5311 			break
   5312 		}
   5313 		off2 := v_0.AuxInt
   5314 		ptr := v_0.Args[0]
   5315 		mem := v.Args[1]
   5316 		if !(is32Bit(off1 + off2)) {
   5317 			break
   5318 		}
   5319 		v.reset(Op386MOVSDload)
   5320 		v.AuxInt = off1 + off2
   5321 		v.Aux = sym
   5322 		v.AddArg(ptr)
   5323 		v.AddArg(mem)
   5324 		return true
   5325 	}
   5326 	// match: (MOVSDload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   5327 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   5328 	// result: (MOVSDload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   5329 	for {
   5330 		off1 := v.AuxInt
   5331 		sym1 := v.Aux
   5332 		_ = v.Args[1]
   5333 		v_0 := v.Args[0]
   5334 		if v_0.Op != Op386LEAL {
   5335 			break
   5336 		}
   5337 		off2 := v_0.AuxInt
   5338 		sym2 := v_0.Aux
   5339 		base := v_0.Args[0]
   5340 		mem := v.Args[1]
   5341 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   5342 			break
   5343 		}
   5344 		v.reset(Op386MOVSDload)
   5345 		v.AuxInt = off1 + off2
   5346 		v.Aux = mergeSym(sym1, sym2)
   5347 		v.AddArg(base)
   5348 		v.AddArg(mem)
   5349 		return true
   5350 	}
   5351 	// match: (MOVSDload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem)
   5352 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   5353 	// result: (MOVSDloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   5354 	for {
   5355 		off1 := v.AuxInt
   5356 		sym1 := v.Aux
   5357 		_ = v.Args[1]
   5358 		v_0 := v.Args[0]
   5359 		if v_0.Op != Op386LEAL1 {
   5360 			break
   5361 		}
   5362 		off2 := v_0.AuxInt
   5363 		sym2 := v_0.Aux
   5364 		_ = v_0.Args[1]
   5365 		ptr := v_0.Args[0]
   5366 		idx := v_0.Args[1]
   5367 		mem := v.Args[1]
   5368 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   5369 			break
   5370 		}
   5371 		v.reset(Op386MOVSDloadidx1)
   5372 		v.AuxInt = off1 + off2
   5373 		v.Aux = mergeSym(sym1, sym2)
   5374 		v.AddArg(ptr)
   5375 		v.AddArg(idx)
   5376 		v.AddArg(mem)
   5377 		return true
   5378 	}
   5379 	// match: (MOVSDload [off1] {sym1} (LEAL8 [off2] {sym2} ptr idx) mem)
   5380 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   5381 	// result: (MOVSDloadidx8 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   5382 	for {
   5383 		off1 := v.AuxInt
   5384 		sym1 := v.Aux
   5385 		_ = v.Args[1]
   5386 		v_0 := v.Args[0]
   5387 		if v_0.Op != Op386LEAL8 {
   5388 			break
   5389 		}
   5390 		off2 := v_0.AuxInt
   5391 		sym2 := v_0.Aux
   5392 		_ = v_0.Args[1]
   5393 		ptr := v_0.Args[0]
   5394 		idx := v_0.Args[1]
   5395 		mem := v.Args[1]
   5396 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   5397 			break
   5398 		}
   5399 		v.reset(Op386MOVSDloadidx8)
   5400 		v.AuxInt = off1 + off2
   5401 		v.Aux = mergeSym(sym1, sym2)
   5402 		v.AddArg(ptr)
   5403 		v.AddArg(idx)
   5404 		v.AddArg(mem)
   5405 		return true
   5406 	}
   5407 	// match: (MOVSDload [off] {sym} (ADDL ptr idx) mem)
   5408 	// cond: ptr.Op != OpSB
   5409 	// result: (MOVSDloadidx1 [off] {sym} ptr idx mem)
   5410 	for {
   5411 		off := v.AuxInt
   5412 		sym := v.Aux
   5413 		_ = v.Args[1]
   5414 		v_0 := v.Args[0]
   5415 		if v_0.Op != Op386ADDL {
   5416 			break
   5417 		}
   5418 		_ = v_0.Args[1]
   5419 		ptr := v_0.Args[0]
   5420 		idx := v_0.Args[1]
   5421 		mem := v.Args[1]
   5422 		if !(ptr.Op != OpSB) {
   5423 			break
   5424 		}
   5425 		v.reset(Op386MOVSDloadidx1)
   5426 		v.AuxInt = off
   5427 		v.Aux = sym
   5428 		v.AddArg(ptr)
   5429 		v.AddArg(idx)
   5430 		v.AddArg(mem)
   5431 		return true
   5432 	}
   5433 	return false
   5434 }
   5435 func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool {
   5436 	// match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
   5437 	// cond:
   5438 	// result: (MOVSDloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   5439 	for {
   5440 		c := v.AuxInt
   5441 		sym := v.Aux
   5442 		_ = v.Args[2]
   5443 		v_0 := v.Args[0]
   5444 		if v_0.Op != Op386ADDLconst {
   5445 			break
   5446 		}
   5447 		d := v_0.AuxInt
   5448 		ptr := v_0.Args[0]
   5449 		idx := v.Args[1]
   5450 		mem := v.Args[2]
   5451 		v.reset(Op386MOVSDloadidx1)
   5452 		v.AuxInt = int64(int32(c + d))
   5453 		v.Aux = sym
   5454 		v.AddArg(ptr)
   5455 		v.AddArg(idx)
   5456 		v.AddArg(mem)
   5457 		return true
   5458 	}
   5459 	// match: (MOVSDloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem)
   5460 	// cond:
   5461 	// result: (MOVSDloadidx1 [int64(int32(c+d))]   {sym} ptr idx mem)
   5462 	for {
   5463 		c := v.AuxInt
   5464 		sym := v.Aux
   5465 		_ = v.Args[2]
   5466 		ptr := v.Args[0]
   5467 		v_1 := v.Args[1]
   5468 		if v_1.Op != Op386ADDLconst {
   5469 			break
   5470 		}
   5471 		d := v_1.AuxInt
   5472 		idx := v_1.Args[0]
   5473 		mem := v.Args[2]
   5474 		v.reset(Op386MOVSDloadidx1)
   5475 		v.AuxInt = int64(int32(c + d))
   5476 		v.Aux = sym
   5477 		v.AddArg(ptr)
   5478 		v.AddArg(idx)
   5479 		v.AddArg(mem)
   5480 		return true
   5481 	}
   5482 	return false
   5483 }
   5484 func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool {
   5485 	// match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem)
   5486 	// cond:
   5487 	// result: (MOVSDloadidx8 [int64(int32(c+d))] {sym} ptr idx mem)
   5488 	for {
   5489 		c := v.AuxInt
   5490 		sym := v.Aux
   5491 		_ = v.Args[2]
   5492 		v_0 := v.Args[0]
   5493 		if v_0.Op != Op386ADDLconst {
   5494 			break
   5495 		}
   5496 		d := v_0.AuxInt
   5497 		ptr := v_0.Args[0]
   5498 		idx := v.Args[1]
   5499 		mem := v.Args[2]
   5500 		v.reset(Op386MOVSDloadidx8)
   5501 		v.AuxInt = int64(int32(c + d))
   5502 		v.Aux = sym
   5503 		v.AddArg(ptr)
   5504 		v.AddArg(idx)
   5505 		v.AddArg(mem)
   5506 		return true
   5507 	}
   5508 	// match: (MOVSDloadidx8 [c] {sym} ptr (ADDLconst [d] idx) mem)
   5509 	// cond:
   5510 	// result: (MOVSDloadidx8 [int64(int32(c+8*d))] {sym} ptr idx mem)
   5511 	for {
   5512 		c := v.AuxInt
   5513 		sym := v.Aux
   5514 		_ = v.Args[2]
   5515 		ptr := v.Args[0]
   5516 		v_1 := v.Args[1]
   5517 		if v_1.Op != Op386ADDLconst {
   5518 			break
   5519 		}
   5520 		d := v_1.AuxInt
   5521 		idx := v_1.Args[0]
   5522 		mem := v.Args[2]
   5523 		v.reset(Op386MOVSDloadidx8)
   5524 		v.AuxInt = int64(int32(c + 8*d))
   5525 		v.Aux = sym
   5526 		v.AddArg(ptr)
   5527 		v.AddArg(idx)
   5528 		v.AddArg(mem)
   5529 		return true
   5530 	}
   5531 	return false
   5532 }
   5533 func rewriteValue386_Op386MOVSDstore_0(v *Value) bool {
   5534 	b := v.Block
   5535 	_ = b
   5536 	config := b.Func.Config
   5537 	_ = config
   5538 	// match: (MOVSDstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
   5539 	// cond: is32Bit(off1+off2)
   5540 	// result: (MOVSDstore [off1+off2] {sym} ptr val mem)
   5541 	for {
   5542 		off1 := v.AuxInt
   5543 		sym := v.Aux
   5544 		_ = v.Args[2]
   5545 		v_0 := v.Args[0]
   5546 		if v_0.Op != Op386ADDLconst {
   5547 			break
   5548 		}
   5549 		off2 := v_0.AuxInt
   5550 		ptr := v_0.Args[0]
   5551 		val := v.Args[1]
   5552 		mem := v.Args[2]
   5553 		if !(is32Bit(off1 + off2)) {
   5554 			break
   5555 		}
   5556 		v.reset(Op386MOVSDstore)
   5557 		v.AuxInt = off1 + off2
   5558 		v.Aux = sym
   5559 		v.AddArg(ptr)
   5560 		v.AddArg(val)
   5561 		v.AddArg(mem)
   5562 		return true
   5563 	}
   5564 	// match: (MOVSDstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
   5565 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   5566 	// result: (MOVSDstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   5567 	for {
   5568 		off1 := v.AuxInt
   5569 		sym1 := v.Aux
   5570 		_ = v.Args[2]
   5571 		v_0 := v.Args[0]
   5572 		if v_0.Op != Op386LEAL {
   5573 			break
   5574 		}
   5575 		off2 := v_0.AuxInt
   5576 		sym2 := v_0.Aux
   5577 		base := v_0.Args[0]
   5578 		val := v.Args[1]
   5579 		mem := v.Args[2]
   5580 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   5581 			break
   5582 		}
   5583 		v.reset(Op386MOVSDstore)
   5584 		v.AuxInt = off1 + off2
   5585 		v.Aux = mergeSym(sym1, sym2)
   5586 		v.AddArg(base)
   5587 		v.AddArg(val)
   5588 		v.AddArg(mem)
   5589 		return true
   5590 	}
   5591 	// match: (MOVSDstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem)
   5592 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   5593 	// result: (MOVSDstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   5594 	for {
   5595 		off1 := v.AuxInt
   5596 		sym1 := v.Aux
   5597 		_ = v.Args[2]
   5598 		v_0 := v.Args[0]
   5599 		if v_0.Op != Op386LEAL1 {
   5600 			break
   5601 		}
   5602 		off2 := v_0.AuxInt
   5603 		sym2 := v_0.Aux
   5604 		_ = v_0.Args[1]
   5605 		ptr := v_0.Args[0]
   5606 		idx := v_0.Args[1]
   5607 		val := v.Args[1]
   5608 		mem := v.Args[2]
   5609 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   5610 			break
   5611 		}
   5612 		v.reset(Op386MOVSDstoreidx1)
   5613 		v.AuxInt = off1 + off2
   5614 		v.Aux = mergeSym(sym1, sym2)
   5615 		v.AddArg(ptr)
   5616 		v.AddArg(idx)
   5617 		v.AddArg(val)
   5618 		v.AddArg(mem)
   5619 		return true
   5620 	}
   5621 	// match: (MOVSDstore [off1] {sym1} (LEAL8 [off2] {sym2} ptr idx) val mem)
   5622 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   5623 	// result: (MOVSDstoreidx8 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   5624 	for {
   5625 		off1 := v.AuxInt
   5626 		sym1 := v.Aux
   5627 		_ = v.Args[2]
   5628 		v_0 := v.Args[0]
   5629 		if v_0.Op != Op386LEAL8 {
   5630 			break
   5631 		}
   5632 		off2 := v_0.AuxInt
   5633 		sym2 := v_0.Aux
   5634 		_ = v_0.Args[1]
   5635 		ptr := v_0.Args[0]
   5636 		idx := v_0.Args[1]
   5637 		val := v.Args[1]
   5638 		mem := v.Args[2]
   5639 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   5640 			break
   5641 		}
   5642 		v.reset(Op386MOVSDstoreidx8)
   5643 		v.AuxInt = off1 + off2
   5644 		v.Aux = mergeSym(sym1, sym2)
   5645 		v.AddArg(ptr)
   5646 		v.AddArg(idx)
   5647 		v.AddArg(val)
   5648 		v.AddArg(mem)
   5649 		return true
   5650 	}
   5651 	// match: (MOVSDstore [off] {sym} (ADDL ptr idx) val mem)
   5652 	// cond: ptr.Op != OpSB
   5653 	// result: (MOVSDstoreidx1 [off] {sym} ptr idx val mem)
   5654 	for {
   5655 		off := v.AuxInt
   5656 		sym := v.Aux
   5657 		_ = v.Args[2]
   5658 		v_0 := v.Args[0]
   5659 		if v_0.Op != Op386ADDL {
   5660 			break
   5661 		}
   5662 		_ = v_0.Args[1]
   5663 		ptr := v_0.Args[0]
   5664 		idx := v_0.Args[1]
   5665 		val := v.Args[1]
   5666 		mem := v.Args[2]
   5667 		if !(ptr.Op != OpSB) {
   5668 			break
   5669 		}
   5670 		v.reset(Op386MOVSDstoreidx1)
   5671 		v.AuxInt = off
   5672 		v.Aux = sym
   5673 		v.AddArg(ptr)
   5674 		v.AddArg(idx)
   5675 		v.AddArg(val)
   5676 		v.AddArg(mem)
   5677 		return true
   5678 	}
   5679 	return false
   5680 }
   5681 func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool {
   5682 	// match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   5683 	// cond:
   5684 	// result: (MOVSDstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   5685 	for {
   5686 		c := v.AuxInt
   5687 		sym := v.Aux
   5688 		_ = v.Args[3]
   5689 		v_0 := v.Args[0]
   5690 		if v_0.Op != Op386ADDLconst {
   5691 			break
   5692 		}
   5693 		d := v_0.AuxInt
   5694 		ptr := v_0.Args[0]
   5695 		idx := v.Args[1]
   5696 		val := v.Args[2]
   5697 		mem := v.Args[3]
   5698 		v.reset(Op386MOVSDstoreidx1)
   5699 		v.AuxInt = int64(int32(c + d))
   5700 		v.Aux = sym
   5701 		v.AddArg(ptr)
   5702 		v.AddArg(idx)
   5703 		v.AddArg(val)
   5704 		v.AddArg(mem)
   5705 		return true
   5706 	}
   5707 	// match: (MOVSDstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   5708 	// cond:
   5709 	// result: (MOVSDstoreidx1 [int64(int32(c+d))]   {sym} ptr idx val mem)
   5710 	for {
   5711 		c := v.AuxInt
   5712 		sym := v.Aux
   5713 		_ = v.Args[3]
   5714 		ptr := v.Args[0]
   5715 		v_1 := v.Args[1]
   5716 		if v_1.Op != Op386ADDLconst {
   5717 			break
   5718 		}
   5719 		d := v_1.AuxInt
   5720 		idx := v_1.Args[0]
   5721 		val := v.Args[2]
   5722 		mem := v.Args[3]
   5723 		v.reset(Op386MOVSDstoreidx1)
   5724 		v.AuxInt = int64(int32(c + d))
   5725 		v.Aux = sym
   5726 		v.AddArg(ptr)
   5727 		v.AddArg(idx)
   5728 		v.AddArg(val)
   5729 		v.AddArg(mem)
   5730 		return true
   5731 	}
   5732 	return false
   5733 }
   5734 func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool {
   5735 	// match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   5736 	// cond:
   5737 	// result: (MOVSDstoreidx8 [int64(int32(c+d))] {sym} ptr idx val mem)
   5738 	for {
   5739 		c := v.AuxInt
   5740 		sym := v.Aux
   5741 		_ = v.Args[3]
   5742 		v_0 := v.Args[0]
   5743 		if v_0.Op != Op386ADDLconst {
   5744 			break
   5745 		}
   5746 		d := v_0.AuxInt
   5747 		ptr := v_0.Args[0]
   5748 		idx := v.Args[1]
   5749 		val := v.Args[2]
   5750 		mem := v.Args[3]
   5751 		v.reset(Op386MOVSDstoreidx8)
   5752 		v.AuxInt = int64(int32(c + d))
   5753 		v.Aux = sym
   5754 		v.AddArg(ptr)
   5755 		v.AddArg(idx)
   5756 		v.AddArg(val)
   5757 		v.AddArg(mem)
   5758 		return true
   5759 	}
   5760 	// match: (MOVSDstoreidx8 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   5761 	// cond:
   5762 	// result: (MOVSDstoreidx8 [int64(int32(c+8*d))] {sym} ptr idx val mem)
   5763 	for {
   5764 		c := v.AuxInt
   5765 		sym := v.Aux
   5766 		_ = v.Args[3]
   5767 		ptr := v.Args[0]
   5768 		v_1 := v.Args[1]
   5769 		if v_1.Op != Op386ADDLconst {
   5770 			break
   5771 		}
   5772 		d := v_1.AuxInt
   5773 		idx := v_1.Args[0]
   5774 		val := v.Args[2]
   5775 		mem := v.Args[3]
   5776 		v.reset(Op386MOVSDstoreidx8)
   5777 		v.AuxInt = int64(int32(c + 8*d))
   5778 		v.Aux = sym
   5779 		v.AddArg(ptr)
   5780 		v.AddArg(idx)
   5781 		v.AddArg(val)
   5782 		v.AddArg(mem)
   5783 		return true
   5784 	}
   5785 	return false
   5786 }
   5787 func rewriteValue386_Op386MOVSSconst_0(v *Value) bool {
   5788 	b := v.Block
   5789 	_ = b
   5790 	config := b.Func.Config
   5791 	_ = config
   5792 	typ := &b.Func.Config.Types
   5793 	_ = typ
   5794 	// match: (MOVSSconst [c])
   5795 	// cond: config.ctxt.Flag_shared
   5796 	// result: (MOVSSconst2 (MOVSSconst1 [c]))
   5797 	for {
   5798 		c := v.AuxInt
   5799 		if !(config.ctxt.Flag_shared) {
   5800 			break
   5801 		}
   5802 		v.reset(Op386MOVSSconst2)
   5803 		v0 := b.NewValue0(v.Pos, Op386MOVSSconst1, typ.UInt32)
   5804 		v0.AuxInt = c
   5805 		v.AddArg(v0)
   5806 		return true
   5807 	}
   5808 	return false
   5809 }
   5810 func rewriteValue386_Op386MOVSSload_0(v *Value) bool {
   5811 	b := v.Block
   5812 	_ = b
   5813 	config := b.Func.Config
   5814 	_ = config
   5815 	// match: (MOVSSload [off1] {sym} (ADDLconst [off2] ptr) mem)
   5816 	// cond: is32Bit(off1+off2)
   5817 	// result: (MOVSSload [off1+off2] {sym} ptr mem)
   5818 	for {
   5819 		off1 := v.AuxInt
   5820 		sym := v.Aux
   5821 		_ = v.Args[1]
   5822 		v_0 := v.Args[0]
   5823 		if v_0.Op != Op386ADDLconst {
   5824 			break
   5825 		}
   5826 		off2 := v_0.AuxInt
   5827 		ptr := v_0.Args[0]
   5828 		mem := v.Args[1]
   5829 		if !(is32Bit(off1 + off2)) {
   5830 			break
   5831 		}
   5832 		v.reset(Op386MOVSSload)
   5833 		v.AuxInt = off1 + off2
   5834 		v.Aux = sym
   5835 		v.AddArg(ptr)
   5836 		v.AddArg(mem)
   5837 		return true
   5838 	}
   5839 	// match: (MOVSSload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   5840 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   5841 	// result: (MOVSSload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   5842 	for {
   5843 		off1 := v.AuxInt
   5844 		sym1 := v.Aux
   5845 		_ = v.Args[1]
   5846 		v_0 := v.Args[0]
   5847 		if v_0.Op != Op386LEAL {
   5848 			break
   5849 		}
   5850 		off2 := v_0.AuxInt
   5851 		sym2 := v_0.Aux
   5852 		base := v_0.Args[0]
   5853 		mem := v.Args[1]
   5854 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   5855 			break
   5856 		}
   5857 		v.reset(Op386MOVSSload)
   5858 		v.AuxInt = off1 + off2
   5859 		v.Aux = mergeSym(sym1, sym2)
   5860 		v.AddArg(base)
   5861 		v.AddArg(mem)
   5862 		return true
   5863 	}
   5864 	// match: (MOVSSload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem)
   5865 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   5866 	// result: (MOVSSloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   5867 	for {
   5868 		off1 := v.AuxInt
   5869 		sym1 := v.Aux
   5870 		_ = v.Args[1]
   5871 		v_0 := v.Args[0]
   5872 		if v_0.Op != Op386LEAL1 {
   5873 			break
   5874 		}
   5875 		off2 := v_0.AuxInt
   5876 		sym2 := v_0.Aux
   5877 		_ = v_0.Args[1]
   5878 		ptr := v_0.Args[0]
   5879 		idx := v_0.Args[1]
   5880 		mem := v.Args[1]
   5881 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   5882 			break
   5883 		}
   5884 		v.reset(Op386MOVSSloadidx1)
   5885 		v.AuxInt = off1 + off2
   5886 		v.Aux = mergeSym(sym1, sym2)
   5887 		v.AddArg(ptr)
   5888 		v.AddArg(idx)
   5889 		v.AddArg(mem)
   5890 		return true
   5891 	}
   5892 	// match: (MOVSSload [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) mem)
   5893 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   5894 	// result: (MOVSSloadidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   5895 	for {
   5896 		off1 := v.AuxInt
   5897 		sym1 := v.Aux
   5898 		_ = v.Args[1]
   5899 		v_0 := v.Args[0]
   5900 		if v_0.Op != Op386LEAL4 {
   5901 			break
   5902 		}
   5903 		off2 := v_0.AuxInt
   5904 		sym2 := v_0.Aux
   5905 		_ = v_0.Args[1]
   5906 		ptr := v_0.Args[0]
   5907 		idx := v_0.Args[1]
   5908 		mem := v.Args[1]
   5909 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   5910 			break
   5911 		}
   5912 		v.reset(Op386MOVSSloadidx4)
   5913 		v.AuxInt = off1 + off2
   5914 		v.Aux = mergeSym(sym1, sym2)
   5915 		v.AddArg(ptr)
   5916 		v.AddArg(idx)
   5917 		v.AddArg(mem)
   5918 		return true
   5919 	}
   5920 	// match: (MOVSSload [off] {sym} (ADDL ptr idx) mem)
   5921 	// cond: ptr.Op != OpSB
   5922 	// result: (MOVSSloadidx1 [off] {sym} ptr idx mem)
   5923 	for {
   5924 		off := v.AuxInt
   5925 		sym := v.Aux
   5926 		_ = v.Args[1]
   5927 		v_0 := v.Args[0]
   5928 		if v_0.Op != Op386ADDL {
   5929 			break
   5930 		}
   5931 		_ = v_0.Args[1]
   5932 		ptr := v_0.Args[0]
   5933 		idx := v_0.Args[1]
   5934 		mem := v.Args[1]
   5935 		if !(ptr.Op != OpSB) {
   5936 			break
   5937 		}
   5938 		v.reset(Op386MOVSSloadidx1)
   5939 		v.AuxInt = off
   5940 		v.Aux = sym
   5941 		v.AddArg(ptr)
   5942 		v.AddArg(idx)
   5943 		v.AddArg(mem)
   5944 		return true
   5945 	}
   5946 	return false
   5947 }
   5948 func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool {
   5949 	// match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
   5950 	// cond:
   5951 	// result: (MOVSSloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   5952 	for {
   5953 		c := v.AuxInt
   5954 		sym := v.Aux
   5955 		_ = v.Args[2]
   5956 		v_0 := v.Args[0]
   5957 		if v_0.Op != Op386ADDLconst {
   5958 			break
   5959 		}
   5960 		d := v_0.AuxInt
   5961 		ptr := v_0.Args[0]
   5962 		idx := v.Args[1]
   5963 		mem := v.Args[2]
   5964 		v.reset(Op386MOVSSloadidx1)
   5965 		v.AuxInt = int64(int32(c + d))
   5966 		v.Aux = sym
   5967 		v.AddArg(ptr)
   5968 		v.AddArg(idx)
   5969 		v.AddArg(mem)
   5970 		return true
   5971 	}
   5972 	// match: (MOVSSloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem)
   5973 	// cond:
   5974 	// result: (MOVSSloadidx1 [int64(int32(c+d))]   {sym} ptr idx mem)
   5975 	for {
   5976 		c := v.AuxInt
   5977 		sym := v.Aux
   5978 		_ = v.Args[2]
   5979 		ptr := v.Args[0]
   5980 		v_1 := v.Args[1]
   5981 		if v_1.Op != Op386ADDLconst {
   5982 			break
   5983 		}
   5984 		d := v_1.AuxInt
   5985 		idx := v_1.Args[0]
   5986 		mem := v.Args[2]
   5987 		v.reset(Op386MOVSSloadidx1)
   5988 		v.AuxInt = int64(int32(c + d))
   5989 		v.Aux = sym
   5990 		v.AddArg(ptr)
   5991 		v.AddArg(idx)
   5992 		v.AddArg(mem)
   5993 		return true
   5994 	}
   5995 	return false
   5996 }
   5997 func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool {
   5998 	// match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
   5999 	// cond:
   6000 	// result: (MOVSSloadidx4 [int64(int32(c+d))] {sym} ptr idx mem)
   6001 	for {
   6002 		c := v.AuxInt
   6003 		sym := v.Aux
   6004 		_ = v.Args[2]
   6005 		v_0 := v.Args[0]
   6006 		if v_0.Op != Op386ADDLconst {
   6007 			break
   6008 		}
   6009 		d := v_0.AuxInt
   6010 		ptr := v_0.Args[0]
   6011 		idx := v.Args[1]
   6012 		mem := v.Args[2]
   6013 		v.reset(Op386MOVSSloadidx4)
   6014 		v.AuxInt = int64(int32(c + d))
   6015 		v.Aux = sym
   6016 		v.AddArg(ptr)
   6017 		v.AddArg(idx)
   6018 		v.AddArg(mem)
   6019 		return true
   6020 	}
   6021 	// match: (MOVSSloadidx4 [c] {sym} ptr (ADDLconst [d] idx) mem)
   6022 	// cond:
   6023 	// result: (MOVSSloadidx4 [int64(int32(c+4*d))] {sym} ptr idx mem)
   6024 	for {
   6025 		c := v.AuxInt
   6026 		sym := v.Aux
   6027 		_ = v.Args[2]
   6028 		ptr := v.Args[0]
   6029 		v_1 := v.Args[1]
   6030 		if v_1.Op != Op386ADDLconst {
   6031 			break
   6032 		}
   6033 		d := v_1.AuxInt
   6034 		idx := v_1.Args[0]
   6035 		mem := v.Args[2]
   6036 		v.reset(Op386MOVSSloadidx4)
   6037 		v.AuxInt = int64(int32(c + 4*d))
   6038 		v.Aux = sym
   6039 		v.AddArg(ptr)
   6040 		v.AddArg(idx)
   6041 		v.AddArg(mem)
   6042 		return true
   6043 	}
   6044 	return false
   6045 }
   6046 func rewriteValue386_Op386MOVSSstore_0(v *Value) bool {
   6047 	b := v.Block
   6048 	_ = b
   6049 	config := b.Func.Config
   6050 	_ = config
   6051 	// match: (MOVSSstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
   6052 	// cond: is32Bit(off1+off2)
   6053 	// result: (MOVSSstore [off1+off2] {sym} ptr val mem)
   6054 	for {
   6055 		off1 := v.AuxInt
   6056 		sym := v.Aux
   6057 		_ = v.Args[2]
   6058 		v_0 := v.Args[0]
   6059 		if v_0.Op != Op386ADDLconst {
   6060 			break
   6061 		}
   6062 		off2 := v_0.AuxInt
   6063 		ptr := v_0.Args[0]
   6064 		val := v.Args[1]
   6065 		mem := v.Args[2]
   6066 		if !(is32Bit(off1 + off2)) {
   6067 			break
   6068 		}
   6069 		v.reset(Op386MOVSSstore)
   6070 		v.AuxInt = off1 + off2
   6071 		v.Aux = sym
   6072 		v.AddArg(ptr)
   6073 		v.AddArg(val)
   6074 		v.AddArg(mem)
   6075 		return true
   6076 	}
   6077 	// match: (MOVSSstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
   6078 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   6079 	// result: (MOVSSstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   6080 	for {
   6081 		off1 := v.AuxInt
   6082 		sym1 := v.Aux
   6083 		_ = v.Args[2]
   6084 		v_0 := v.Args[0]
   6085 		if v_0.Op != Op386LEAL {
   6086 			break
   6087 		}
   6088 		off2 := v_0.AuxInt
   6089 		sym2 := v_0.Aux
   6090 		base := v_0.Args[0]
   6091 		val := v.Args[1]
   6092 		mem := v.Args[2]
   6093 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   6094 			break
   6095 		}
   6096 		v.reset(Op386MOVSSstore)
   6097 		v.AuxInt = off1 + off2
   6098 		v.Aux = mergeSym(sym1, sym2)
   6099 		v.AddArg(base)
   6100 		v.AddArg(val)
   6101 		v.AddArg(mem)
   6102 		return true
   6103 	}
   6104 	// match: (MOVSSstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem)
   6105 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   6106 	// result: (MOVSSstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   6107 	for {
   6108 		off1 := v.AuxInt
   6109 		sym1 := v.Aux
   6110 		_ = v.Args[2]
   6111 		v_0 := v.Args[0]
   6112 		if v_0.Op != Op386LEAL1 {
   6113 			break
   6114 		}
   6115 		off2 := v_0.AuxInt
   6116 		sym2 := v_0.Aux
   6117 		_ = v_0.Args[1]
   6118 		ptr := v_0.Args[0]
   6119 		idx := v_0.Args[1]
   6120 		val := v.Args[1]
   6121 		mem := v.Args[2]
   6122 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   6123 			break
   6124 		}
   6125 		v.reset(Op386MOVSSstoreidx1)
   6126 		v.AuxInt = off1 + off2
   6127 		v.Aux = mergeSym(sym1, sym2)
   6128 		v.AddArg(ptr)
   6129 		v.AddArg(idx)
   6130 		v.AddArg(val)
   6131 		v.AddArg(mem)
   6132 		return true
   6133 	}
   6134 	// match: (MOVSSstore [off1] {sym1} (LEAL4 [off2] {sym2} ptr idx) val mem)
   6135 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   6136 	// result: (MOVSSstoreidx4 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   6137 	for {
   6138 		off1 := v.AuxInt
   6139 		sym1 := v.Aux
   6140 		_ = v.Args[2]
   6141 		v_0 := v.Args[0]
   6142 		if v_0.Op != Op386LEAL4 {
   6143 			break
   6144 		}
   6145 		off2 := v_0.AuxInt
   6146 		sym2 := v_0.Aux
   6147 		_ = v_0.Args[1]
   6148 		ptr := v_0.Args[0]
   6149 		idx := v_0.Args[1]
   6150 		val := v.Args[1]
   6151 		mem := v.Args[2]
   6152 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   6153 			break
   6154 		}
   6155 		v.reset(Op386MOVSSstoreidx4)
   6156 		v.AuxInt = off1 + off2
   6157 		v.Aux = mergeSym(sym1, sym2)
   6158 		v.AddArg(ptr)
   6159 		v.AddArg(idx)
   6160 		v.AddArg(val)
   6161 		v.AddArg(mem)
   6162 		return true
   6163 	}
   6164 	// match: (MOVSSstore [off] {sym} (ADDL ptr idx) val mem)
   6165 	// cond: ptr.Op != OpSB
   6166 	// result: (MOVSSstoreidx1 [off] {sym} ptr idx val mem)
   6167 	for {
   6168 		off := v.AuxInt
   6169 		sym := v.Aux
   6170 		_ = v.Args[2]
   6171 		v_0 := v.Args[0]
   6172 		if v_0.Op != Op386ADDL {
   6173 			break
   6174 		}
   6175 		_ = v_0.Args[1]
   6176 		ptr := v_0.Args[0]
   6177 		idx := v_0.Args[1]
   6178 		val := v.Args[1]
   6179 		mem := v.Args[2]
   6180 		if !(ptr.Op != OpSB) {
   6181 			break
   6182 		}
   6183 		v.reset(Op386MOVSSstoreidx1)
   6184 		v.AuxInt = off
   6185 		v.Aux = sym
   6186 		v.AddArg(ptr)
   6187 		v.AddArg(idx)
   6188 		v.AddArg(val)
   6189 		v.AddArg(mem)
   6190 		return true
   6191 	}
   6192 	return false
   6193 }
   6194 func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool {
   6195 	// match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   6196 	// cond:
   6197 	// result: (MOVSSstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   6198 	for {
   6199 		c := v.AuxInt
   6200 		sym := v.Aux
   6201 		_ = v.Args[3]
   6202 		v_0 := v.Args[0]
   6203 		if v_0.Op != Op386ADDLconst {
   6204 			break
   6205 		}
   6206 		d := v_0.AuxInt
   6207 		ptr := v_0.Args[0]
   6208 		idx := v.Args[1]
   6209 		val := v.Args[2]
   6210 		mem := v.Args[3]
   6211 		v.reset(Op386MOVSSstoreidx1)
   6212 		v.AuxInt = int64(int32(c + d))
   6213 		v.Aux = sym
   6214 		v.AddArg(ptr)
   6215 		v.AddArg(idx)
   6216 		v.AddArg(val)
   6217 		v.AddArg(mem)
   6218 		return true
   6219 	}
   6220 	// match: (MOVSSstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   6221 	// cond:
   6222 	// result: (MOVSSstoreidx1 [int64(int32(c+d))]   {sym} ptr idx val mem)
   6223 	for {
   6224 		c := v.AuxInt
   6225 		sym := v.Aux
   6226 		_ = v.Args[3]
   6227 		ptr := v.Args[0]
   6228 		v_1 := v.Args[1]
   6229 		if v_1.Op != Op386ADDLconst {
   6230 			break
   6231 		}
   6232 		d := v_1.AuxInt
   6233 		idx := v_1.Args[0]
   6234 		val := v.Args[2]
   6235 		mem := v.Args[3]
   6236 		v.reset(Op386MOVSSstoreidx1)
   6237 		v.AuxInt = int64(int32(c + d))
   6238 		v.Aux = sym
   6239 		v.AddArg(ptr)
   6240 		v.AddArg(idx)
   6241 		v.AddArg(val)
   6242 		v.AddArg(mem)
   6243 		return true
   6244 	}
   6245 	return false
   6246 }
   6247 func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool {
   6248 	// match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   6249 	// cond:
   6250 	// result: (MOVSSstoreidx4 [int64(int32(c+d))] {sym} ptr idx val mem)
   6251 	for {
   6252 		c := v.AuxInt
   6253 		sym := v.Aux
   6254 		_ = v.Args[3]
   6255 		v_0 := v.Args[0]
   6256 		if v_0.Op != Op386ADDLconst {
   6257 			break
   6258 		}
   6259 		d := v_0.AuxInt
   6260 		ptr := v_0.Args[0]
   6261 		idx := v.Args[1]
   6262 		val := v.Args[2]
   6263 		mem := v.Args[3]
   6264 		v.reset(Op386MOVSSstoreidx4)
   6265 		v.AuxInt = int64(int32(c + d))
   6266 		v.Aux = sym
   6267 		v.AddArg(ptr)
   6268 		v.AddArg(idx)
   6269 		v.AddArg(val)
   6270 		v.AddArg(mem)
   6271 		return true
   6272 	}
   6273 	// match: (MOVSSstoreidx4 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   6274 	// cond:
   6275 	// result: (MOVSSstoreidx4 [int64(int32(c+4*d))] {sym} ptr idx val mem)
   6276 	for {
   6277 		c := v.AuxInt
   6278 		sym := v.Aux
   6279 		_ = v.Args[3]
   6280 		ptr := v.Args[0]
   6281 		v_1 := v.Args[1]
   6282 		if v_1.Op != Op386ADDLconst {
   6283 			break
   6284 		}
   6285 		d := v_1.AuxInt
   6286 		idx := v_1.Args[0]
   6287 		val := v.Args[2]
   6288 		mem := v.Args[3]
   6289 		v.reset(Op386MOVSSstoreidx4)
   6290 		v.AuxInt = int64(int32(c + 4*d))
   6291 		v.Aux = sym
   6292 		v.AddArg(ptr)
   6293 		v.AddArg(idx)
   6294 		v.AddArg(val)
   6295 		v.AddArg(mem)
   6296 		return true
   6297 	}
   6298 	return false
   6299 }
   6300 func rewriteValue386_Op386MOVWLSX_0(v *Value) bool {
   6301 	b := v.Block
   6302 	_ = b
   6303 	// match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem))
   6304 	// cond: x.Uses == 1 && clobber(x)
   6305 	// result: @x.Block (MOVWLSXload <v.Type> [off] {sym} ptr mem)
   6306 	for {
   6307 		x := v.Args[0]
   6308 		if x.Op != Op386MOVWload {
   6309 			break
   6310 		}
   6311 		off := x.AuxInt
   6312 		sym := x.Aux
   6313 		_ = x.Args[1]
   6314 		ptr := x.Args[0]
   6315 		mem := x.Args[1]
   6316 		if !(x.Uses == 1 && clobber(x)) {
   6317 			break
   6318 		}
   6319 		b = x.Block
   6320 		v0 := b.NewValue0(v.Pos, Op386MOVWLSXload, v.Type)
   6321 		v.reset(OpCopy)
   6322 		v.AddArg(v0)
   6323 		v0.AuxInt = off
   6324 		v0.Aux = sym
   6325 		v0.AddArg(ptr)
   6326 		v0.AddArg(mem)
   6327 		return true
   6328 	}
   6329 	// match: (MOVWLSX (ANDLconst [c] x))
   6330 	// cond: c & 0x8000 == 0
   6331 	// result: (ANDLconst [c & 0x7fff] x)
   6332 	for {
   6333 		v_0 := v.Args[0]
   6334 		if v_0.Op != Op386ANDLconst {
   6335 			break
   6336 		}
   6337 		c := v_0.AuxInt
   6338 		x := v_0.Args[0]
   6339 		if !(c&0x8000 == 0) {
   6340 			break
   6341 		}
   6342 		v.reset(Op386ANDLconst)
   6343 		v.AuxInt = c & 0x7fff
   6344 		v.AddArg(x)
   6345 		return true
   6346 	}
   6347 	return false
   6348 }
   6349 func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool {
   6350 	b := v.Block
   6351 	_ = b
   6352 	config := b.Func.Config
   6353 	_ = config
   6354 	// match: (MOVWLSXload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
   6355 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
   6356 	// result: (MOVWLSX x)
   6357 	for {
   6358 		off := v.AuxInt
   6359 		sym := v.Aux
   6360 		_ = v.Args[1]
   6361 		ptr := v.Args[0]
   6362 		v_1 := v.Args[1]
   6363 		if v_1.Op != Op386MOVWstore {
   6364 			break
   6365 		}
   6366 		off2 := v_1.AuxInt
   6367 		sym2 := v_1.Aux
   6368 		_ = v_1.Args[2]
   6369 		ptr2 := v_1.Args[0]
   6370 		x := v_1.Args[1]
   6371 		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
   6372 			break
   6373 		}
   6374 		v.reset(Op386MOVWLSX)
   6375 		v.AddArg(x)
   6376 		return true
   6377 	}
   6378 	// match: (MOVWLSXload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   6379 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   6380 	// result: (MOVWLSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
   6381 	for {
   6382 		off1 := v.AuxInt
   6383 		sym1 := v.Aux
   6384 		_ = v.Args[1]
   6385 		v_0 := v.Args[0]
   6386 		if v_0.Op != Op386LEAL {
   6387 			break
   6388 		}
   6389 		off2 := v_0.AuxInt
   6390 		sym2 := v_0.Aux
   6391 		base := v_0.Args[0]
   6392 		mem := v.Args[1]
   6393 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   6394 			break
   6395 		}
   6396 		v.reset(Op386MOVWLSXload)
   6397 		v.AuxInt = off1 + off2
   6398 		v.Aux = mergeSym(sym1, sym2)
   6399 		v.AddArg(base)
   6400 		v.AddArg(mem)
   6401 		return true
   6402 	}
   6403 	return false
   6404 }
   6405 func rewriteValue386_Op386MOVWLZX_0(v *Value) bool {
   6406 	b := v.Block
   6407 	_ = b
   6408 	// match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem))
   6409 	// cond: x.Uses == 1 && clobber(x)
   6410 	// result: @x.Block (MOVWload <v.Type> [off] {sym} ptr mem)
   6411 	for {
   6412 		x := v.Args[0]
   6413 		if x.Op != Op386MOVWload {
   6414 			break
   6415 		}
   6416 		off := x.AuxInt
   6417 		sym := x.Aux
   6418 		_ = x.Args[1]
   6419 		ptr := x.Args[0]
   6420 		mem := x.Args[1]
   6421 		if !(x.Uses == 1 && clobber(x)) {
   6422 			break
   6423 		}
   6424 		b = x.Block
   6425 		v0 := b.NewValue0(v.Pos, Op386MOVWload, v.Type)
   6426 		v.reset(OpCopy)
   6427 		v.AddArg(v0)
   6428 		v0.AuxInt = off
   6429 		v0.Aux = sym
   6430 		v0.AddArg(ptr)
   6431 		v0.AddArg(mem)
   6432 		return true
   6433 	}
   6434 	// match: (MOVWLZX x:(MOVWloadidx1 [off] {sym} ptr idx mem))
   6435 	// cond: x.Uses == 1 && clobber(x)
   6436 	// result: @x.Block (MOVWloadidx1 <v.Type> [off] {sym} ptr idx mem)
   6437 	for {
   6438 		x := v.Args[0]
   6439 		if x.Op != Op386MOVWloadidx1 {
   6440 			break
   6441 		}
   6442 		off := x.AuxInt
   6443 		sym := x.Aux
   6444 		_ = x.Args[2]
   6445 		ptr := x.Args[0]
   6446 		idx := x.Args[1]
   6447 		mem := x.Args[2]
   6448 		if !(x.Uses == 1 && clobber(x)) {
   6449 			break
   6450 		}
   6451 		b = x.Block
   6452 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   6453 		v.reset(OpCopy)
   6454 		v.AddArg(v0)
   6455 		v0.AuxInt = off
   6456 		v0.Aux = sym
   6457 		v0.AddArg(ptr)
   6458 		v0.AddArg(idx)
   6459 		v0.AddArg(mem)
   6460 		return true
   6461 	}
   6462 	// match: (MOVWLZX x:(MOVWloadidx2 [off] {sym} ptr idx mem))
   6463 	// cond: x.Uses == 1 && clobber(x)
   6464 	// result: @x.Block (MOVWloadidx2 <v.Type> [off] {sym} ptr idx mem)
   6465 	for {
   6466 		x := v.Args[0]
   6467 		if x.Op != Op386MOVWloadidx2 {
   6468 			break
   6469 		}
   6470 		off := x.AuxInt
   6471 		sym := x.Aux
   6472 		_ = x.Args[2]
   6473 		ptr := x.Args[0]
   6474 		idx := x.Args[1]
   6475 		mem := x.Args[2]
   6476 		if !(x.Uses == 1 && clobber(x)) {
   6477 			break
   6478 		}
   6479 		b = x.Block
   6480 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx2, v.Type)
   6481 		v.reset(OpCopy)
   6482 		v.AddArg(v0)
   6483 		v0.AuxInt = off
   6484 		v0.Aux = sym
   6485 		v0.AddArg(ptr)
   6486 		v0.AddArg(idx)
   6487 		v0.AddArg(mem)
   6488 		return true
   6489 	}
   6490 	// match: (MOVWLZX (ANDLconst [c] x))
   6491 	// cond:
   6492 	// result: (ANDLconst [c & 0xffff] x)
   6493 	for {
   6494 		v_0 := v.Args[0]
   6495 		if v_0.Op != Op386ANDLconst {
   6496 			break
   6497 		}
   6498 		c := v_0.AuxInt
   6499 		x := v_0.Args[0]
   6500 		v.reset(Op386ANDLconst)
   6501 		v.AuxInt = c & 0xffff
   6502 		v.AddArg(x)
   6503 		return true
   6504 	}
   6505 	return false
   6506 }
   6507 func rewriteValue386_Op386MOVWload_0(v *Value) bool {
   6508 	b := v.Block
   6509 	_ = b
   6510 	config := b.Func.Config
   6511 	_ = config
   6512 	// match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
   6513 	// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
   6514 	// result: (MOVWLZX x)
   6515 	for {
   6516 		off := v.AuxInt
   6517 		sym := v.Aux
   6518 		_ = v.Args[1]
   6519 		ptr := v.Args[0]
   6520 		v_1 := v.Args[1]
   6521 		if v_1.Op != Op386MOVWstore {
   6522 			break
   6523 		}
   6524 		off2 := v_1.AuxInt
   6525 		sym2 := v_1.Aux
   6526 		_ = v_1.Args[2]
   6527 		ptr2 := v_1.Args[0]
   6528 		x := v_1.Args[1]
   6529 		if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
   6530 			break
   6531 		}
   6532 		v.reset(Op386MOVWLZX)
   6533 		v.AddArg(x)
   6534 		return true
   6535 	}
   6536 	// match: (MOVWload [off1] {sym} (ADDLconst [off2] ptr) mem)
   6537 	// cond: is32Bit(off1+off2)
   6538 	// result: (MOVWload  [off1+off2] {sym} ptr mem)
   6539 	for {
   6540 		off1 := v.AuxInt
   6541 		sym := v.Aux
   6542 		_ = v.Args[1]
   6543 		v_0 := v.Args[0]
   6544 		if v_0.Op != Op386ADDLconst {
   6545 			break
   6546 		}
   6547 		off2 := v_0.AuxInt
   6548 		ptr := v_0.Args[0]
   6549 		mem := v.Args[1]
   6550 		if !(is32Bit(off1 + off2)) {
   6551 			break
   6552 		}
   6553 		v.reset(Op386MOVWload)
   6554 		v.AuxInt = off1 + off2
   6555 		v.Aux = sym
   6556 		v.AddArg(ptr)
   6557 		v.AddArg(mem)
   6558 		return true
   6559 	}
   6560 	// match: (MOVWload [off1] {sym1} (LEAL [off2] {sym2} base) mem)
   6561 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   6562 	// result: (MOVWload  [off1+off2] {mergeSym(sym1,sym2)} base mem)
   6563 	for {
   6564 		off1 := v.AuxInt
   6565 		sym1 := v.Aux
   6566 		_ = v.Args[1]
   6567 		v_0 := v.Args[0]
   6568 		if v_0.Op != Op386LEAL {
   6569 			break
   6570 		}
   6571 		off2 := v_0.AuxInt
   6572 		sym2 := v_0.Aux
   6573 		base := v_0.Args[0]
   6574 		mem := v.Args[1]
   6575 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   6576 			break
   6577 		}
   6578 		v.reset(Op386MOVWload)
   6579 		v.AuxInt = off1 + off2
   6580 		v.Aux = mergeSym(sym1, sym2)
   6581 		v.AddArg(base)
   6582 		v.AddArg(mem)
   6583 		return true
   6584 	}
   6585 	// match: (MOVWload [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) mem)
   6586 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   6587 	// result: (MOVWloadidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   6588 	for {
   6589 		off1 := v.AuxInt
   6590 		sym1 := v.Aux
   6591 		_ = v.Args[1]
   6592 		v_0 := v.Args[0]
   6593 		if v_0.Op != Op386LEAL1 {
   6594 			break
   6595 		}
   6596 		off2 := v_0.AuxInt
   6597 		sym2 := v_0.Aux
   6598 		_ = v_0.Args[1]
   6599 		ptr := v_0.Args[0]
   6600 		idx := v_0.Args[1]
   6601 		mem := v.Args[1]
   6602 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   6603 			break
   6604 		}
   6605 		v.reset(Op386MOVWloadidx1)
   6606 		v.AuxInt = off1 + off2
   6607 		v.Aux = mergeSym(sym1, sym2)
   6608 		v.AddArg(ptr)
   6609 		v.AddArg(idx)
   6610 		v.AddArg(mem)
   6611 		return true
   6612 	}
   6613 	// match: (MOVWload [off1] {sym1} (LEAL2 [off2] {sym2} ptr idx) mem)
   6614 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   6615 	// result: (MOVWloadidx2 [off1+off2] {mergeSym(sym1,sym2)} ptr idx mem)
   6616 	for {
   6617 		off1 := v.AuxInt
   6618 		sym1 := v.Aux
   6619 		_ = v.Args[1]
   6620 		v_0 := v.Args[0]
   6621 		if v_0.Op != Op386LEAL2 {
   6622 			break
   6623 		}
   6624 		off2 := v_0.AuxInt
   6625 		sym2 := v_0.Aux
   6626 		_ = v_0.Args[1]
   6627 		ptr := v_0.Args[0]
   6628 		idx := v_0.Args[1]
   6629 		mem := v.Args[1]
   6630 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   6631 			break
   6632 		}
   6633 		v.reset(Op386MOVWloadidx2)
   6634 		v.AuxInt = off1 + off2
   6635 		v.Aux = mergeSym(sym1, sym2)
   6636 		v.AddArg(ptr)
   6637 		v.AddArg(idx)
   6638 		v.AddArg(mem)
   6639 		return true
   6640 	}
   6641 	// match: (MOVWload [off] {sym} (ADDL ptr idx) mem)
   6642 	// cond: ptr.Op != OpSB
   6643 	// result: (MOVWloadidx1 [off] {sym} ptr idx mem)
   6644 	for {
   6645 		off := v.AuxInt
   6646 		sym := v.Aux
   6647 		_ = v.Args[1]
   6648 		v_0 := v.Args[0]
   6649 		if v_0.Op != Op386ADDL {
   6650 			break
   6651 		}
   6652 		_ = v_0.Args[1]
   6653 		ptr := v_0.Args[0]
   6654 		idx := v_0.Args[1]
   6655 		mem := v.Args[1]
   6656 		if !(ptr.Op != OpSB) {
   6657 			break
   6658 		}
   6659 		v.reset(Op386MOVWloadidx1)
   6660 		v.AuxInt = off
   6661 		v.Aux = sym
   6662 		v.AddArg(ptr)
   6663 		v.AddArg(idx)
   6664 		v.AddArg(mem)
   6665 		return true
   6666 	}
   6667 	return false
   6668 }
   6669 func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool {
   6670 	// match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
   6671 	// cond:
   6672 	// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
   6673 	for {
   6674 		c := v.AuxInt
   6675 		sym := v.Aux
   6676 		_ = v.Args[2]
   6677 		ptr := v.Args[0]
   6678 		v_1 := v.Args[1]
   6679 		if v_1.Op != Op386SHLLconst {
   6680 			break
   6681 		}
   6682 		if v_1.AuxInt != 1 {
   6683 			break
   6684 		}
   6685 		idx := v_1.Args[0]
   6686 		mem := v.Args[2]
   6687 		v.reset(Op386MOVWloadidx2)
   6688 		v.AuxInt = c
   6689 		v.Aux = sym
   6690 		v.AddArg(ptr)
   6691 		v.AddArg(idx)
   6692 		v.AddArg(mem)
   6693 		return true
   6694 	}
   6695 	// match: (MOVWloadidx1 [c] {sym} (SHLLconst [1] idx) ptr mem)
   6696 	// cond:
   6697 	// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
   6698 	for {
   6699 		c := v.AuxInt
   6700 		sym := v.Aux
   6701 		_ = v.Args[2]
   6702 		v_0 := v.Args[0]
   6703 		if v_0.Op != Op386SHLLconst {
   6704 			break
   6705 		}
   6706 		if v_0.AuxInt != 1 {
   6707 			break
   6708 		}
   6709 		idx := v_0.Args[0]
   6710 		ptr := v.Args[1]
   6711 		mem := v.Args[2]
   6712 		v.reset(Op386MOVWloadidx2)
   6713 		v.AuxInt = c
   6714 		v.Aux = sym
   6715 		v.AddArg(ptr)
   6716 		v.AddArg(idx)
   6717 		v.AddArg(mem)
   6718 		return true
   6719 	}
   6720 	// match: (MOVWloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
   6721 	// cond:
   6722 	// result: (MOVWloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   6723 	for {
   6724 		c := v.AuxInt
   6725 		sym := v.Aux
   6726 		_ = v.Args[2]
   6727 		v_0 := v.Args[0]
   6728 		if v_0.Op != Op386ADDLconst {
   6729 			break
   6730 		}
   6731 		d := v_0.AuxInt
   6732 		ptr := v_0.Args[0]
   6733 		idx := v.Args[1]
   6734 		mem := v.Args[2]
   6735 		v.reset(Op386MOVWloadidx1)
   6736 		v.AuxInt = int64(int32(c + d))
   6737 		v.Aux = sym
   6738 		v.AddArg(ptr)
   6739 		v.AddArg(idx)
   6740 		v.AddArg(mem)
   6741 		return true
   6742 	}
   6743 	// match: (MOVWloadidx1 [c] {sym} idx (ADDLconst [d] ptr) mem)
   6744 	// cond:
   6745 	// result: (MOVWloadidx1 [int64(int32(c+d))] {sym} ptr idx mem)
   6746 	for {
   6747 		c := v.AuxInt
   6748 		sym := v.Aux
   6749 		_ = v.Args[2]
   6750 		idx := v.Args[0]
   6751 		v_1 := v.Args[1]
   6752 		if v_1.Op != Op386ADDLconst {
   6753 			break
   6754 		}
   6755 		d := v_1.AuxInt
   6756 		ptr := v_1.Args[0]
   6757 		mem := v.Args[2]
   6758 		v.reset(Op386MOVWloadidx1)
   6759 		v.AuxInt = int64(int32(c + d))
   6760 		v.Aux = sym
   6761 		v.AddArg(ptr)
   6762 		v.AddArg(idx)
   6763 		v.AddArg(mem)
   6764 		return true
   6765 	}
   6766 	// match: (MOVWloadidx1 [c] {sym} ptr (ADDLconst [d] idx) mem)
   6767 	// cond:
   6768 	// result: (MOVWloadidx1  [int64(int32(c+d))]   {sym} ptr idx mem)
   6769 	for {
   6770 		c := v.AuxInt
   6771 		sym := v.Aux
   6772 		_ = v.Args[2]
   6773 		ptr := v.Args[0]
   6774 		v_1 := v.Args[1]
   6775 		if v_1.Op != Op386ADDLconst {
   6776 			break
   6777 		}
   6778 		d := v_1.AuxInt
   6779 		idx := v_1.Args[0]
   6780 		mem := v.Args[2]
   6781 		v.reset(Op386MOVWloadidx1)
   6782 		v.AuxInt = int64(int32(c + d))
   6783 		v.Aux = sym
   6784 		v.AddArg(ptr)
   6785 		v.AddArg(idx)
   6786 		v.AddArg(mem)
   6787 		return true
   6788 	}
   6789 	// match: (MOVWloadidx1 [c] {sym} (ADDLconst [d] idx) ptr mem)
   6790 	// cond:
   6791 	// result: (MOVWloadidx1  [int64(int32(c+d))]   {sym} ptr idx mem)
   6792 	for {
   6793 		c := v.AuxInt
   6794 		sym := v.Aux
   6795 		_ = v.Args[2]
   6796 		v_0 := v.Args[0]
   6797 		if v_0.Op != Op386ADDLconst {
   6798 			break
   6799 		}
   6800 		d := v_0.AuxInt
   6801 		idx := v_0.Args[0]
   6802 		ptr := v.Args[1]
   6803 		mem := v.Args[2]
   6804 		v.reset(Op386MOVWloadidx1)
   6805 		v.AuxInt = int64(int32(c + d))
   6806 		v.Aux = sym
   6807 		v.AddArg(ptr)
   6808 		v.AddArg(idx)
   6809 		v.AddArg(mem)
   6810 		return true
   6811 	}
   6812 	return false
   6813 }
   6814 func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool {
   6815 	// match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem)
   6816 	// cond:
   6817 	// result: (MOVWloadidx2 [int64(int32(c+d))] {sym} ptr idx mem)
   6818 	for {
   6819 		c := v.AuxInt
   6820 		sym := v.Aux
   6821 		_ = v.Args[2]
   6822 		v_0 := v.Args[0]
   6823 		if v_0.Op != Op386ADDLconst {
   6824 			break
   6825 		}
   6826 		d := v_0.AuxInt
   6827 		ptr := v_0.Args[0]
   6828 		idx := v.Args[1]
   6829 		mem := v.Args[2]
   6830 		v.reset(Op386MOVWloadidx2)
   6831 		v.AuxInt = int64(int32(c + d))
   6832 		v.Aux = sym
   6833 		v.AddArg(ptr)
   6834 		v.AddArg(idx)
   6835 		v.AddArg(mem)
   6836 		return true
   6837 	}
   6838 	// match: (MOVWloadidx2 [c] {sym} ptr (ADDLconst [d] idx) mem)
   6839 	// cond:
   6840 	// result: (MOVWloadidx2  [int64(int32(c+2*d))] {sym} ptr idx mem)
   6841 	for {
   6842 		c := v.AuxInt
   6843 		sym := v.Aux
   6844 		_ = v.Args[2]
   6845 		ptr := v.Args[0]
   6846 		v_1 := v.Args[1]
   6847 		if v_1.Op != Op386ADDLconst {
   6848 			break
   6849 		}
   6850 		d := v_1.AuxInt
   6851 		idx := v_1.Args[0]
   6852 		mem := v.Args[2]
   6853 		v.reset(Op386MOVWloadidx2)
   6854 		v.AuxInt = int64(int32(c + 2*d))
   6855 		v.Aux = sym
   6856 		v.AddArg(ptr)
   6857 		v.AddArg(idx)
   6858 		v.AddArg(mem)
   6859 		return true
   6860 	}
   6861 	return false
   6862 }
   6863 func rewriteValue386_Op386MOVWstore_0(v *Value) bool {
   6864 	b := v.Block
   6865 	_ = b
   6866 	config := b.Func.Config
   6867 	_ = config
   6868 	// match: (MOVWstore [off] {sym} ptr (MOVWLSX x) mem)
   6869 	// cond:
   6870 	// result: (MOVWstore [off] {sym} ptr x mem)
   6871 	for {
   6872 		off := v.AuxInt
   6873 		sym := v.Aux
   6874 		_ = v.Args[2]
   6875 		ptr := v.Args[0]
   6876 		v_1 := v.Args[1]
   6877 		if v_1.Op != Op386MOVWLSX {
   6878 			break
   6879 		}
   6880 		x := v_1.Args[0]
   6881 		mem := v.Args[2]
   6882 		v.reset(Op386MOVWstore)
   6883 		v.AuxInt = off
   6884 		v.Aux = sym
   6885 		v.AddArg(ptr)
   6886 		v.AddArg(x)
   6887 		v.AddArg(mem)
   6888 		return true
   6889 	}
   6890 	// match: (MOVWstore [off] {sym} ptr (MOVWLZX x) mem)
   6891 	// cond:
   6892 	// result: (MOVWstore [off] {sym} ptr x mem)
   6893 	for {
   6894 		off := v.AuxInt
   6895 		sym := v.Aux
   6896 		_ = v.Args[2]
   6897 		ptr := v.Args[0]
   6898 		v_1 := v.Args[1]
   6899 		if v_1.Op != Op386MOVWLZX {
   6900 			break
   6901 		}
   6902 		x := v_1.Args[0]
   6903 		mem := v.Args[2]
   6904 		v.reset(Op386MOVWstore)
   6905 		v.AuxInt = off
   6906 		v.Aux = sym
   6907 		v.AddArg(ptr)
   6908 		v.AddArg(x)
   6909 		v.AddArg(mem)
   6910 		return true
   6911 	}
   6912 	// match: (MOVWstore [off1] {sym} (ADDLconst [off2] ptr) val mem)
   6913 	// cond: is32Bit(off1+off2)
   6914 	// result: (MOVWstore  [off1+off2] {sym} ptr val mem)
   6915 	for {
   6916 		off1 := v.AuxInt
   6917 		sym := v.Aux
   6918 		_ = v.Args[2]
   6919 		v_0 := v.Args[0]
   6920 		if v_0.Op != Op386ADDLconst {
   6921 			break
   6922 		}
   6923 		off2 := v_0.AuxInt
   6924 		ptr := v_0.Args[0]
   6925 		val := v.Args[1]
   6926 		mem := v.Args[2]
   6927 		if !(is32Bit(off1 + off2)) {
   6928 			break
   6929 		}
   6930 		v.reset(Op386MOVWstore)
   6931 		v.AuxInt = off1 + off2
   6932 		v.Aux = sym
   6933 		v.AddArg(ptr)
   6934 		v.AddArg(val)
   6935 		v.AddArg(mem)
   6936 		return true
   6937 	}
   6938 	// match: (MOVWstore [off] {sym} ptr (MOVLconst [c]) mem)
   6939 	// cond: validOff(off)
   6940 	// result: (MOVWstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem)
   6941 	for {
   6942 		off := v.AuxInt
   6943 		sym := v.Aux
   6944 		_ = v.Args[2]
   6945 		ptr := v.Args[0]
   6946 		v_1 := v.Args[1]
   6947 		if v_1.Op != Op386MOVLconst {
   6948 			break
   6949 		}
   6950 		c := v_1.AuxInt
   6951 		mem := v.Args[2]
   6952 		if !(validOff(off)) {
   6953 			break
   6954 		}
   6955 		v.reset(Op386MOVWstoreconst)
   6956 		v.AuxInt = makeValAndOff(int64(int16(c)), off)
   6957 		v.Aux = sym
   6958 		v.AddArg(ptr)
   6959 		v.AddArg(mem)
   6960 		return true
   6961 	}
   6962 	// match: (MOVWstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
   6963 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)   && (base.Op != OpSB || !config.ctxt.Flag_shared)
   6964 	// result: (MOVWstore  [off1+off2] {mergeSym(sym1,sym2)} base val mem)
   6965 	for {
   6966 		off1 := v.AuxInt
   6967 		sym1 := v.Aux
   6968 		_ = v.Args[2]
   6969 		v_0 := v.Args[0]
   6970 		if v_0.Op != Op386LEAL {
   6971 			break
   6972 		}
   6973 		off2 := v_0.AuxInt
   6974 		sym2 := v_0.Aux
   6975 		base := v_0.Args[0]
   6976 		val := v.Args[1]
   6977 		mem := v.Args[2]
   6978 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2) && (base.Op != OpSB || !config.ctxt.Flag_shared)) {
   6979 			break
   6980 		}
   6981 		v.reset(Op386MOVWstore)
   6982 		v.AuxInt = off1 + off2
   6983 		v.Aux = mergeSym(sym1, sym2)
   6984 		v.AddArg(base)
   6985 		v.AddArg(val)
   6986 		v.AddArg(mem)
   6987 		return true
   6988 	}
   6989 	// match: (MOVWstore [off1] {sym1} (LEAL1 [off2] {sym2} ptr idx) val mem)
   6990 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   6991 	// result: (MOVWstoreidx1 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   6992 	for {
   6993 		off1 := v.AuxInt
   6994 		sym1 := v.Aux
   6995 		_ = v.Args[2]
   6996 		v_0 := v.Args[0]
   6997 		if v_0.Op != Op386LEAL1 {
   6998 			break
   6999 		}
   7000 		off2 := v_0.AuxInt
   7001 		sym2 := v_0.Aux
   7002 		_ = v_0.Args[1]
   7003 		ptr := v_0.Args[0]
   7004 		idx := v_0.Args[1]
   7005 		val := v.Args[1]
   7006 		mem := v.Args[2]
   7007 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   7008 			break
   7009 		}
   7010 		v.reset(Op386MOVWstoreidx1)
   7011 		v.AuxInt = off1 + off2
   7012 		v.Aux = mergeSym(sym1, sym2)
   7013 		v.AddArg(ptr)
   7014 		v.AddArg(idx)
   7015 		v.AddArg(val)
   7016 		v.AddArg(mem)
   7017 		return true
   7018 	}
   7019 	// match: (MOVWstore [off1] {sym1} (LEAL2 [off2] {sym2} ptr idx) val mem)
   7020 	// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
   7021 	// result: (MOVWstoreidx2 [off1+off2] {mergeSym(sym1,sym2)} ptr idx val mem)
   7022 	for {
   7023 		off1 := v.AuxInt
   7024 		sym1 := v.Aux
   7025 		_ = v.Args[2]
   7026 		v_0 := v.Args[0]
   7027 		if v_0.Op != Op386LEAL2 {
   7028 			break
   7029 		}
   7030 		off2 := v_0.AuxInt
   7031 		sym2 := v_0.Aux
   7032 		_ = v_0.Args[1]
   7033 		ptr := v_0.Args[0]
   7034 		idx := v_0.Args[1]
   7035 		val := v.Args[1]
   7036 		mem := v.Args[2]
   7037 		if !(is32Bit(off1+off2) && canMergeSym(sym1, sym2)) {
   7038 			break
   7039 		}
   7040 		v.reset(Op386MOVWstoreidx2)
   7041 		v.AuxInt = off1 + off2
   7042 		v.Aux = mergeSym(sym1, sym2)
   7043 		v.AddArg(ptr)
   7044 		v.AddArg(idx)
   7045 		v.AddArg(val)
   7046 		v.AddArg(mem)
   7047 		return true
   7048 	}
   7049 	// match: (MOVWstore [off] {sym} (ADDL ptr idx) val mem)
   7050 	// cond: ptr.Op != OpSB
   7051 	// result: (MOVWstoreidx1 [off] {sym} ptr idx val mem)
   7052 	for {
   7053 		off := v.AuxInt
   7054 		sym := v.Aux
   7055 		_ = v.Args[2]
   7056 		v_0 := v.Args[0]
   7057 		if v_0.Op != Op386ADDL {
   7058 			break
   7059 		}
   7060 		_ = v_0.Args[1]
   7061 		ptr := v_0.Args[0]
   7062 		idx := v_0.Args[1]
   7063 		val := v.Args[1]
   7064 		mem := v.Args[2]
   7065 		if !(ptr.Op != OpSB) {
   7066 			break
   7067 		}
   7068 		v.reset(Op386MOVWstoreidx1)
   7069 		v.AuxInt = off
   7070 		v.Aux = sym
   7071 		v.AddArg(ptr)
   7072 		v.AddArg(idx)
   7073 		v.AddArg(val)
   7074 		v.AddArg(mem)
   7075 		return true
   7076 	}
   7077 	// match: (MOVWstore [i] {s} p (SHRLconst [16] w) x:(MOVWstore [i-2] {s} p w mem))
   7078 	// cond: x.Uses == 1   && clobber(x)
   7079 	// result: (MOVLstore [i-2] {s} p w mem)
   7080 	for {
   7081 		i := v.AuxInt
   7082 		s := v.Aux
   7083 		_ = v.Args[2]
   7084 		p := v.Args[0]
   7085 		v_1 := v.Args[1]
   7086 		if v_1.Op != Op386SHRLconst {
   7087 			break
   7088 		}
   7089 		if v_1.AuxInt != 16 {
   7090 			break
   7091 		}
   7092 		w := v_1.Args[0]
   7093 		x := v.Args[2]
   7094 		if x.Op != Op386MOVWstore {
   7095 			break
   7096 		}
   7097 		if x.AuxInt != i-2 {
   7098 			break
   7099 		}
   7100 		if x.Aux != s {
   7101 			break
   7102 		}
   7103 		_ = x.Args[2]
   7104 		if p != x.Args[0] {
   7105 			break
   7106 		}
   7107 		if w != x.Args[1] {
   7108 			break
   7109 		}
   7110 		mem := x.Args[2]
   7111 		if !(x.Uses == 1 && clobber(x)) {
   7112 			break
   7113 		}
   7114 		v.reset(Op386MOVLstore)
   7115 		v.AuxInt = i - 2
   7116 		v.Aux = s
   7117 		v.AddArg(p)
   7118 		v.AddArg(w)
   7119 		v.AddArg(mem)
   7120 		return true
   7121 	}
   7122 	// match: (MOVWstore [i] {s} p (SHRLconst [j] w) x:(MOVWstore [i-2] {s} p w0:(SHRLconst [j-16] w) mem))
   7123 	// cond: x.Uses == 1   && clobber(x)
   7124 	// result: (MOVLstore [i-2] {s} p w0 mem)
   7125 	for {
   7126 		i := v.AuxInt
   7127 		s := v.Aux
   7128 		_ = v.Args[2]
   7129 		p := v.Args[0]
   7130 		v_1 := v.Args[1]
   7131 		if v_1.Op != Op386SHRLconst {
   7132 			break
   7133 		}
   7134 		j := v_1.AuxInt
   7135 		w := v_1.Args[0]
   7136 		x := v.Args[2]
   7137 		if x.Op != Op386MOVWstore {
   7138 			break
   7139 		}
   7140 		if x.AuxInt != i-2 {
   7141 			break
   7142 		}
   7143 		if x.Aux != s {
   7144 			break
   7145 		}
   7146 		_ = x.Args[2]
   7147 		if p != x.Args[0] {
   7148 			break
   7149 		}
   7150 		w0 := x.Args[1]
   7151 		if w0.Op != Op386SHRLconst {
   7152 			break
   7153 		}
   7154 		if w0.AuxInt != j-16 {
   7155 			break
   7156 		}
   7157 		if w != w0.Args[0] {
   7158 			break
   7159 		}
   7160 		mem := x.Args[2]
   7161 		if !(x.Uses == 1 && clobber(x)) {
   7162 			break
   7163 		}
   7164 		v.reset(Op386MOVLstore)
   7165 		v.AuxInt = i - 2
   7166 		v.Aux = s
   7167 		v.AddArg(p)
   7168 		v.AddArg(w0)
   7169 		v.AddArg(mem)
   7170 		return true
   7171 	}
   7172 	return false
   7173 }
   7174 func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool {
   7175 	b := v.Block
   7176 	_ = b
   7177 	config := b.Func.Config
   7178 	_ = config
   7179 	// match: (MOVWstoreconst [sc] {s} (ADDLconst [off] ptr) mem)
   7180 	// cond: ValAndOff(sc).canAdd(off)
   7181 	// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
   7182 	for {
   7183 		sc := v.AuxInt
   7184 		s := v.Aux
   7185 		_ = v.Args[1]
   7186 		v_0 := v.Args[0]
   7187 		if v_0.Op != Op386ADDLconst {
   7188 			break
   7189 		}
   7190 		off := v_0.AuxInt
   7191 		ptr := v_0.Args[0]
   7192 		mem := v.Args[1]
   7193 		if !(ValAndOff(sc).canAdd(off)) {
   7194 			break
   7195 		}
   7196 		v.reset(Op386MOVWstoreconst)
   7197 		v.AuxInt = ValAndOff(sc).add(off)
   7198 		v.Aux = s
   7199 		v.AddArg(ptr)
   7200 		v.AddArg(mem)
   7201 		return true
   7202 	}
   7203 	// match: (MOVWstoreconst [sc] {sym1} (LEAL [off] {sym2} ptr) mem)
   7204 	// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)   && (ptr.Op != OpSB || !config.ctxt.Flag_shared)
   7205 	// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
   7206 	for {
   7207 		sc := v.AuxInt
   7208 		sym1 := v.Aux
   7209 		_ = v.Args[1]
   7210 		v_0 := v.Args[0]
   7211 		if v_0.Op != Op386LEAL {
   7212 			break
   7213 		}
   7214 		off := v_0.AuxInt
   7215 		sym2 := v_0.Aux
   7216 		ptr := v_0.Args[0]
   7217 		mem := v.Args[1]
   7218 		if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off) && (ptr.Op != OpSB || !config.ctxt.Flag_shared)) {
   7219 			break
   7220 		}
   7221 		v.reset(Op386MOVWstoreconst)
   7222 		v.AuxInt = ValAndOff(sc).add(off)
   7223 		v.Aux = mergeSym(sym1, sym2)
   7224 		v.AddArg(ptr)
   7225 		v.AddArg(mem)
   7226 		return true
   7227 	}
   7228 	// match: (MOVWstoreconst [x] {sym1} (LEAL1 [off] {sym2} ptr idx) mem)
   7229 	// cond: canMergeSym(sym1, sym2)
   7230 	// result: (MOVWstoreconstidx1 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
   7231 	for {
   7232 		x := v.AuxInt
   7233 		sym1 := v.Aux
   7234 		_ = v.Args[1]
   7235 		v_0 := v.Args[0]
   7236 		if v_0.Op != Op386LEAL1 {
   7237 			break
   7238 		}
   7239 		off := v_0.AuxInt
   7240 		sym2 := v_0.Aux
   7241 		_ = v_0.Args[1]
   7242 		ptr := v_0.Args[0]
   7243 		idx := v_0.Args[1]
   7244 		mem := v.Args[1]
   7245 		if !(canMergeSym(sym1, sym2)) {
   7246 			break
   7247 		}
   7248 		v.reset(Op386MOVWstoreconstidx1)
   7249 		v.AuxInt = ValAndOff(x).add(off)
   7250 		v.Aux = mergeSym(sym1, sym2)
   7251 		v.AddArg(ptr)
   7252 		v.AddArg(idx)
   7253 		v.AddArg(mem)
   7254 		return true
   7255 	}
   7256 	// match: (MOVWstoreconst [x] {sym1} (LEAL2 [off] {sym2} ptr idx) mem)
   7257 	// cond: canMergeSym(sym1, sym2)
   7258 	// result: (MOVWstoreconstidx2 [ValAndOff(x).add(off)] {mergeSym(sym1,sym2)} ptr idx mem)
   7259 	for {
   7260 		x := v.AuxInt
   7261 		sym1 := v.Aux
   7262 		_ = v.Args[1]
   7263 		v_0 := v.Args[0]
   7264 		if v_0.Op != Op386LEAL2 {
   7265 			break
   7266 		}
   7267 		off := v_0.AuxInt
   7268 		sym2 := v_0.Aux
   7269 		_ = v_0.Args[1]
   7270 		ptr := v_0.Args[0]
   7271 		idx := v_0.Args[1]
   7272 		mem := v.Args[1]
   7273 		if !(canMergeSym(sym1, sym2)) {
   7274 			break
   7275 		}
   7276 		v.reset(Op386MOVWstoreconstidx2)
   7277 		v.AuxInt = ValAndOff(x).add(off)
   7278 		v.Aux = mergeSym(sym1, sym2)
   7279 		v.AddArg(ptr)
   7280 		v.AddArg(idx)
   7281 		v.AddArg(mem)
   7282 		return true
   7283 	}
   7284 	// match: (MOVWstoreconst [x] {sym} (ADDL ptr idx) mem)
   7285 	// cond:
   7286 	// result: (MOVWstoreconstidx1 [x] {sym} ptr idx mem)
   7287 	for {
   7288 		x := v.AuxInt
   7289 		sym := v.Aux
   7290 		_ = v.Args[1]
   7291 		v_0 := v.Args[0]
   7292 		if v_0.Op != Op386ADDL {
   7293 			break
   7294 		}
   7295 		_ = v_0.Args[1]
   7296 		ptr := v_0.Args[0]
   7297 		idx := v_0.Args[1]
   7298 		mem := v.Args[1]
   7299 		v.reset(Op386MOVWstoreconstidx1)
   7300 		v.AuxInt = x
   7301 		v.Aux = sym
   7302 		v.AddArg(ptr)
   7303 		v.AddArg(idx)
   7304 		v.AddArg(mem)
   7305 		return true
   7306 	}
   7307 	// match: (MOVWstoreconst [c] {s} p x:(MOVWstoreconst [a] {s} p mem))
   7308 	// cond: x.Uses == 1   && ValAndOff(a).Off() + 2 == ValAndOff(c).Off()   && clobber(x)
   7309 	// result: (MOVLstoreconst [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p mem)
   7310 	for {
   7311 		c := v.AuxInt
   7312 		s := v.Aux
   7313 		_ = v.Args[1]
   7314 		p := v.Args[0]
   7315 		x := v.Args[1]
   7316 		if x.Op != Op386MOVWstoreconst {
   7317 			break
   7318 		}
   7319 		a := x.AuxInt
   7320 		if x.Aux != s {
   7321 			break
   7322 		}
   7323 		_ = x.Args[1]
   7324 		if p != x.Args[0] {
   7325 			break
   7326 		}
   7327 		mem := x.Args[1]
   7328 		if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
   7329 			break
   7330 		}
   7331 		v.reset(Op386MOVLstoreconst)
   7332 		v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
   7333 		v.Aux = s
   7334 		v.AddArg(p)
   7335 		v.AddArg(mem)
   7336 		return true
   7337 	}
   7338 	return false
   7339 }
   7340 func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool {
   7341 	// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
   7342 	// cond:
   7343 	// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
   7344 	for {
   7345 		c := v.AuxInt
   7346 		sym := v.Aux
   7347 		_ = v.Args[2]
   7348 		ptr := v.Args[0]
   7349 		v_1 := v.Args[1]
   7350 		if v_1.Op != Op386SHLLconst {
   7351 			break
   7352 		}
   7353 		if v_1.AuxInt != 1 {
   7354 			break
   7355 		}
   7356 		idx := v_1.Args[0]
   7357 		mem := v.Args[2]
   7358 		v.reset(Op386MOVWstoreconstidx2)
   7359 		v.AuxInt = c
   7360 		v.Aux = sym
   7361 		v.AddArg(ptr)
   7362 		v.AddArg(idx)
   7363 		v.AddArg(mem)
   7364 		return true
   7365 	}
   7366 	// match: (MOVWstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem)
   7367 	// cond:
   7368 	// result: (MOVWstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   7369 	for {
   7370 		x := v.AuxInt
   7371 		sym := v.Aux
   7372 		_ = v.Args[2]
   7373 		v_0 := v.Args[0]
   7374 		if v_0.Op != Op386ADDLconst {
   7375 			break
   7376 		}
   7377 		c := v_0.AuxInt
   7378 		ptr := v_0.Args[0]
   7379 		idx := v.Args[1]
   7380 		mem := v.Args[2]
   7381 		v.reset(Op386MOVWstoreconstidx1)
   7382 		v.AuxInt = ValAndOff(x).add(c)
   7383 		v.Aux = sym
   7384 		v.AddArg(ptr)
   7385 		v.AddArg(idx)
   7386 		v.AddArg(mem)
   7387 		return true
   7388 	}
   7389 	// match: (MOVWstoreconstidx1 [x] {sym} ptr (ADDLconst [c] idx) mem)
   7390 	// cond:
   7391 	// result: (MOVWstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   7392 	for {
   7393 		x := v.AuxInt
   7394 		sym := v.Aux
   7395 		_ = v.Args[2]
   7396 		ptr := v.Args[0]
   7397 		v_1 := v.Args[1]
   7398 		if v_1.Op != Op386ADDLconst {
   7399 			break
   7400 		}
   7401 		c := v_1.AuxInt
   7402 		idx := v_1.Args[0]
   7403 		mem := v.Args[2]
   7404 		v.reset(Op386MOVWstoreconstidx1)
   7405 		v.AuxInt = ValAndOff(x).add(c)
   7406 		v.Aux = sym
   7407 		v.AddArg(ptr)
   7408 		v.AddArg(idx)
   7409 		v.AddArg(mem)
   7410 		return true
   7411 	}
   7412 	// match: (MOVWstoreconstidx1 [c] {s} p i x:(MOVWstoreconstidx1 [a] {s} p i mem))
   7413 	// cond: x.Uses == 1   && ValAndOff(a).Off() + 2 == ValAndOff(c).Off()   && clobber(x)
   7414 	// result: (MOVLstoreconstidx1 [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p i mem)
   7415 	for {
   7416 		c := v.AuxInt
   7417 		s := v.Aux
   7418 		_ = v.Args[2]
   7419 		p := v.Args[0]
   7420 		i := v.Args[1]
   7421 		x := v.Args[2]
   7422 		if x.Op != Op386MOVWstoreconstidx1 {
   7423 			break
   7424 		}
   7425 		a := x.AuxInt
   7426 		if x.Aux != s {
   7427 			break
   7428 		}
   7429 		_ = x.Args[2]
   7430 		if p != x.Args[0] {
   7431 			break
   7432 		}
   7433 		if i != x.Args[1] {
   7434 			break
   7435 		}
   7436 		mem := x.Args[2]
   7437 		if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
   7438 			break
   7439 		}
   7440 		v.reset(Op386MOVLstoreconstidx1)
   7441 		v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
   7442 		v.Aux = s
   7443 		v.AddArg(p)
   7444 		v.AddArg(i)
   7445 		v.AddArg(mem)
   7446 		return true
   7447 	}
   7448 	return false
   7449 }
   7450 func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool {
   7451 	b := v.Block
   7452 	_ = b
   7453 	// match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem)
   7454 	// cond:
   7455 	// result: (MOVWstoreconstidx2 [ValAndOff(x).add(c)] {sym} ptr idx mem)
   7456 	for {
   7457 		x := v.AuxInt
   7458 		sym := v.Aux
   7459 		_ = v.Args[2]
   7460 		v_0 := v.Args[0]
   7461 		if v_0.Op != Op386ADDLconst {
   7462 			break
   7463 		}
   7464 		c := v_0.AuxInt
   7465 		ptr := v_0.Args[0]
   7466 		idx := v.Args[1]
   7467 		mem := v.Args[2]
   7468 		v.reset(Op386MOVWstoreconstidx2)
   7469 		v.AuxInt = ValAndOff(x).add(c)
   7470 		v.Aux = sym
   7471 		v.AddArg(ptr)
   7472 		v.AddArg(idx)
   7473 		v.AddArg(mem)
   7474 		return true
   7475 	}
   7476 	// match: (MOVWstoreconstidx2 [x] {sym} ptr (ADDLconst [c] idx) mem)
   7477 	// cond:
   7478 	// result: (MOVWstoreconstidx2 [ValAndOff(x).add(2*c)] {sym} ptr idx mem)
   7479 	for {
   7480 		x := v.AuxInt
   7481 		sym := v.Aux
   7482 		_ = v.Args[2]
   7483 		ptr := v.Args[0]
   7484 		v_1 := v.Args[1]
   7485 		if v_1.Op != Op386ADDLconst {
   7486 			break
   7487 		}
   7488 		c := v_1.AuxInt
   7489 		idx := v_1.Args[0]
   7490 		mem := v.Args[2]
   7491 		v.reset(Op386MOVWstoreconstidx2)
   7492 		v.AuxInt = ValAndOff(x).add(2 * c)
   7493 		v.Aux = sym
   7494 		v.AddArg(ptr)
   7495 		v.AddArg(idx)
   7496 		v.AddArg(mem)
   7497 		return true
   7498 	}
   7499 	// match: (MOVWstoreconstidx2 [c] {s} p i x:(MOVWstoreconstidx2 [a] {s} p i mem))
   7500 	// cond: x.Uses == 1   && ValAndOff(a).Off() + 2 == ValAndOff(c).Off()   && clobber(x)
   7501 	// result: (MOVLstoreconstidx1 [makeValAndOff(ValAndOff(a).Val()&0xffff | ValAndOff(c).Val()<<16, ValAndOff(a).Off())] {s} p (SHLLconst <i.Type> [1] i) mem)
   7502 	for {
   7503 		c := v.AuxInt
   7504 		s := v.Aux
   7505 		_ = v.Args[2]
   7506 		p := v.Args[0]
   7507 		i := v.Args[1]
   7508 		x := v.Args[2]
   7509 		if x.Op != Op386MOVWstoreconstidx2 {
   7510 			break
   7511 		}
   7512 		a := x.AuxInt
   7513 		if x.Aux != s {
   7514 			break
   7515 		}
   7516 		_ = x.Args[2]
   7517 		if p != x.Args[0] {
   7518 			break
   7519 		}
   7520 		if i != x.Args[1] {
   7521 			break
   7522 		}
   7523 		mem := x.Args[2]
   7524 		if !(x.Uses == 1 && ValAndOff(a).Off()+2 == ValAndOff(c).Off() && clobber(x)) {
   7525 			break
   7526 		}
   7527 		v.reset(Op386MOVLstoreconstidx1)
   7528 		v.AuxInt = makeValAndOff(ValAndOff(a).Val()&0xffff|ValAndOff(c).Val()<<16, ValAndOff(a).Off())
   7529 		v.Aux = s
   7530 		v.AddArg(p)
   7531 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, i.Type)
   7532 		v0.AuxInt = 1
   7533 		v0.AddArg(i)
   7534 		v.AddArg(v0)
   7535 		v.AddArg(mem)
   7536 		return true
   7537 	}
   7538 	return false
   7539 }
   7540 func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool {
   7541 	// match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem)
   7542 	// cond:
   7543 	// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
   7544 	for {
   7545 		c := v.AuxInt
   7546 		sym := v.Aux
   7547 		_ = v.Args[3]
   7548 		ptr := v.Args[0]
   7549 		v_1 := v.Args[1]
   7550 		if v_1.Op != Op386SHLLconst {
   7551 			break
   7552 		}
   7553 		if v_1.AuxInt != 1 {
   7554 			break
   7555 		}
   7556 		idx := v_1.Args[0]
   7557 		val := v.Args[2]
   7558 		mem := v.Args[3]
   7559 		v.reset(Op386MOVWstoreidx2)
   7560 		v.AuxInt = c
   7561 		v.Aux = sym
   7562 		v.AddArg(ptr)
   7563 		v.AddArg(idx)
   7564 		v.AddArg(val)
   7565 		v.AddArg(mem)
   7566 		return true
   7567 	}
   7568 	// match: (MOVWstoreidx1 [c] {sym} (SHLLconst [1] idx) ptr val mem)
   7569 	// cond:
   7570 	// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
   7571 	for {
   7572 		c := v.AuxInt
   7573 		sym := v.Aux
   7574 		_ = v.Args[3]
   7575 		v_0 := v.Args[0]
   7576 		if v_0.Op != Op386SHLLconst {
   7577 			break
   7578 		}
   7579 		if v_0.AuxInt != 1 {
   7580 			break
   7581 		}
   7582 		idx := v_0.Args[0]
   7583 		ptr := v.Args[1]
   7584 		val := v.Args[2]
   7585 		mem := v.Args[3]
   7586 		v.reset(Op386MOVWstoreidx2)
   7587 		v.AuxInt = c
   7588 		v.Aux = sym
   7589 		v.AddArg(ptr)
   7590 		v.AddArg(idx)
   7591 		v.AddArg(val)
   7592 		v.AddArg(mem)
   7593 		return true
   7594 	}
   7595 	// match: (MOVWstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   7596 	// cond:
   7597 	// result: (MOVWstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   7598 	for {
   7599 		c := v.AuxInt
   7600 		sym := v.Aux
   7601 		_ = v.Args[3]
   7602 		v_0 := v.Args[0]
   7603 		if v_0.Op != Op386ADDLconst {
   7604 			break
   7605 		}
   7606 		d := v_0.AuxInt
   7607 		ptr := v_0.Args[0]
   7608 		idx := v.Args[1]
   7609 		val := v.Args[2]
   7610 		mem := v.Args[3]
   7611 		v.reset(Op386MOVWstoreidx1)
   7612 		v.AuxInt = int64(int32(c + d))
   7613 		v.Aux = sym
   7614 		v.AddArg(ptr)
   7615 		v.AddArg(idx)
   7616 		v.AddArg(val)
   7617 		v.AddArg(mem)
   7618 		return true
   7619 	}
   7620 	// match: (MOVWstoreidx1 [c] {sym} idx (ADDLconst [d] ptr) val mem)
   7621 	// cond:
   7622 	// result: (MOVWstoreidx1 [int64(int32(c+d))] {sym} ptr idx val mem)
   7623 	for {
   7624 		c := v.AuxInt
   7625 		sym := v.Aux
   7626 		_ = v.Args[3]
   7627 		idx := v.Args[0]
   7628 		v_1 := v.Args[1]
   7629 		if v_1.Op != Op386ADDLconst {
   7630 			break
   7631 		}
   7632 		d := v_1.AuxInt
   7633 		ptr := v_1.Args[0]
   7634 		val := v.Args[2]
   7635 		mem := v.Args[3]
   7636 		v.reset(Op386MOVWstoreidx1)
   7637 		v.AuxInt = int64(int32(c + d))
   7638 		v.Aux = sym
   7639 		v.AddArg(ptr)
   7640 		v.AddArg(idx)
   7641 		v.AddArg(val)
   7642 		v.AddArg(mem)
   7643 		return true
   7644 	}
   7645 	// match: (MOVWstoreidx1 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   7646 	// cond:
   7647 	// result: (MOVWstoreidx1  [int64(int32(c+d))]   {sym} ptr idx val mem)
   7648 	for {
   7649 		c := v.AuxInt
   7650 		sym := v.Aux
   7651 		_ = v.Args[3]
   7652 		ptr := v.Args[0]
   7653 		v_1 := v.Args[1]
   7654 		if v_1.Op != Op386ADDLconst {
   7655 			break
   7656 		}
   7657 		d := v_1.AuxInt
   7658 		idx := v_1.Args[0]
   7659 		val := v.Args[2]
   7660 		mem := v.Args[3]
   7661 		v.reset(Op386MOVWstoreidx1)
   7662 		v.AuxInt = int64(int32(c + d))
   7663 		v.Aux = sym
   7664 		v.AddArg(ptr)
   7665 		v.AddArg(idx)
   7666 		v.AddArg(val)
   7667 		v.AddArg(mem)
   7668 		return true
   7669 	}
   7670 	// match: (MOVWstoreidx1 [c] {sym} (ADDLconst [d] idx) ptr val mem)
   7671 	// cond:
   7672 	// result: (MOVWstoreidx1  [int64(int32(c+d))]   {sym} ptr idx val mem)
   7673 	for {
   7674 		c := v.AuxInt
   7675 		sym := v.Aux
   7676 		_ = v.Args[3]
   7677 		v_0 := v.Args[0]
   7678 		if v_0.Op != Op386ADDLconst {
   7679 			break
   7680 		}
   7681 		d := v_0.AuxInt
   7682 		idx := v_0.Args[0]
   7683 		ptr := v.Args[1]
   7684 		val := v.Args[2]
   7685 		mem := v.Args[3]
   7686 		v.reset(Op386MOVWstoreidx1)
   7687 		v.AuxInt = int64(int32(c + d))
   7688 		v.Aux = sym
   7689 		v.AddArg(ptr)
   7690 		v.AddArg(idx)
   7691 		v.AddArg(val)
   7692 		v.AddArg(mem)
   7693 		return true
   7694 	}
   7695 	// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} p idx w mem))
   7696 	// cond: x.Uses == 1   && clobber(x)
   7697 	// result: (MOVLstoreidx1 [i-2] {s} p idx w mem)
   7698 	for {
   7699 		i := v.AuxInt
   7700 		s := v.Aux
   7701 		_ = v.Args[3]
   7702 		p := v.Args[0]
   7703 		idx := v.Args[1]
   7704 		v_2 := v.Args[2]
   7705 		if v_2.Op != Op386SHRLconst {
   7706 			break
   7707 		}
   7708 		if v_2.AuxInt != 16 {
   7709 			break
   7710 		}
   7711 		w := v_2.Args[0]
   7712 		x := v.Args[3]
   7713 		if x.Op != Op386MOVWstoreidx1 {
   7714 			break
   7715 		}
   7716 		if x.AuxInt != i-2 {
   7717 			break
   7718 		}
   7719 		if x.Aux != s {
   7720 			break
   7721 		}
   7722 		_ = x.Args[3]
   7723 		if p != x.Args[0] {
   7724 			break
   7725 		}
   7726 		if idx != x.Args[1] {
   7727 			break
   7728 		}
   7729 		if w != x.Args[2] {
   7730 			break
   7731 		}
   7732 		mem := x.Args[3]
   7733 		if !(x.Uses == 1 && clobber(x)) {
   7734 			break
   7735 		}
   7736 		v.reset(Op386MOVLstoreidx1)
   7737 		v.AuxInt = i - 2
   7738 		v.Aux = s
   7739 		v.AddArg(p)
   7740 		v.AddArg(idx)
   7741 		v.AddArg(w)
   7742 		v.AddArg(mem)
   7743 		return true
   7744 	}
   7745 	// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} idx p w mem))
   7746 	// cond: x.Uses == 1   && clobber(x)
   7747 	// result: (MOVLstoreidx1 [i-2] {s} p idx w mem)
   7748 	for {
   7749 		i := v.AuxInt
   7750 		s := v.Aux
   7751 		_ = v.Args[3]
   7752 		p := v.Args[0]
   7753 		idx := v.Args[1]
   7754 		v_2 := v.Args[2]
   7755 		if v_2.Op != Op386SHRLconst {
   7756 			break
   7757 		}
   7758 		if v_2.AuxInt != 16 {
   7759 			break
   7760 		}
   7761 		w := v_2.Args[0]
   7762 		x := v.Args[3]
   7763 		if x.Op != Op386MOVWstoreidx1 {
   7764 			break
   7765 		}
   7766 		if x.AuxInt != i-2 {
   7767 			break
   7768 		}
   7769 		if x.Aux != s {
   7770 			break
   7771 		}
   7772 		_ = x.Args[3]
   7773 		if idx != x.Args[0] {
   7774 			break
   7775 		}
   7776 		if p != x.Args[1] {
   7777 			break
   7778 		}
   7779 		if w != x.Args[2] {
   7780 			break
   7781 		}
   7782 		mem := x.Args[3]
   7783 		if !(x.Uses == 1 && clobber(x)) {
   7784 			break
   7785 		}
   7786 		v.reset(Op386MOVLstoreidx1)
   7787 		v.AuxInt = i - 2
   7788 		v.Aux = s
   7789 		v.AddArg(p)
   7790 		v.AddArg(idx)
   7791 		v.AddArg(w)
   7792 		v.AddArg(mem)
   7793 		return true
   7794 	}
   7795 	// match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} p idx w mem))
   7796 	// cond: x.Uses == 1   && clobber(x)
   7797 	// result: (MOVLstoreidx1 [i-2] {s} p idx w mem)
   7798 	for {
   7799 		i := v.AuxInt
   7800 		s := v.Aux
   7801 		_ = v.Args[3]
   7802 		idx := v.Args[0]
   7803 		p := v.Args[1]
   7804 		v_2 := v.Args[2]
   7805 		if v_2.Op != Op386SHRLconst {
   7806 			break
   7807 		}
   7808 		if v_2.AuxInt != 16 {
   7809 			break
   7810 		}
   7811 		w := v_2.Args[0]
   7812 		x := v.Args[3]
   7813 		if x.Op != Op386MOVWstoreidx1 {
   7814 			break
   7815 		}
   7816 		if x.AuxInt != i-2 {
   7817 			break
   7818 		}
   7819 		if x.Aux != s {
   7820 			break
   7821 		}
   7822 		_ = x.Args[3]
   7823 		if p != x.Args[0] {
   7824 			break
   7825 		}
   7826 		if idx != x.Args[1] {
   7827 			break
   7828 		}
   7829 		if w != x.Args[2] {
   7830 			break
   7831 		}
   7832 		mem := x.Args[3]
   7833 		if !(x.Uses == 1 && clobber(x)) {
   7834 			break
   7835 		}
   7836 		v.reset(Op386MOVLstoreidx1)
   7837 		v.AuxInt = i - 2
   7838 		v.Aux = s
   7839 		v.AddArg(p)
   7840 		v.AddArg(idx)
   7841 		v.AddArg(w)
   7842 		v.AddArg(mem)
   7843 		return true
   7844 	}
   7845 	// match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [16] w) x:(MOVWstoreidx1 [i-2] {s} idx p w mem))
   7846 	// cond: x.Uses == 1   && clobber(x)
   7847 	// result: (MOVLstoreidx1 [i-2] {s} p idx w mem)
   7848 	for {
   7849 		i := v.AuxInt
   7850 		s := v.Aux
   7851 		_ = v.Args[3]
   7852 		idx := v.Args[0]
   7853 		p := v.Args[1]
   7854 		v_2 := v.Args[2]
   7855 		if v_2.Op != Op386SHRLconst {
   7856 			break
   7857 		}
   7858 		if v_2.AuxInt != 16 {
   7859 			break
   7860 		}
   7861 		w := v_2.Args[0]
   7862 		x := v.Args[3]
   7863 		if x.Op != Op386MOVWstoreidx1 {
   7864 			break
   7865 		}
   7866 		if x.AuxInt != i-2 {
   7867 			break
   7868 		}
   7869 		if x.Aux != s {
   7870 			break
   7871 		}
   7872 		_ = x.Args[3]
   7873 		if idx != x.Args[0] {
   7874 			break
   7875 		}
   7876 		if p != x.Args[1] {
   7877 			break
   7878 		}
   7879 		if w != x.Args[2] {
   7880 			break
   7881 		}
   7882 		mem := x.Args[3]
   7883 		if !(x.Uses == 1 && clobber(x)) {
   7884 			break
   7885 		}
   7886 		v.reset(Op386MOVLstoreidx1)
   7887 		v.AuxInt = i - 2
   7888 		v.Aux = s
   7889 		v.AddArg(p)
   7890 		v.AddArg(idx)
   7891 		v.AddArg(w)
   7892 		v.AddArg(mem)
   7893 		return true
   7894 	}
   7895 	return false
   7896 }
   7897 func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool {
   7898 	// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem))
   7899 	// cond: x.Uses == 1   && clobber(x)
   7900 	// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
   7901 	for {
   7902 		i := v.AuxInt
   7903 		s := v.Aux
   7904 		_ = v.Args[3]
   7905 		p := v.Args[0]
   7906 		idx := v.Args[1]
   7907 		v_2 := v.Args[2]
   7908 		if v_2.Op != Op386SHRLconst {
   7909 			break
   7910 		}
   7911 		j := v_2.AuxInt
   7912 		w := v_2.Args[0]
   7913 		x := v.Args[3]
   7914 		if x.Op != Op386MOVWstoreidx1 {
   7915 			break
   7916 		}
   7917 		if x.AuxInt != i-2 {
   7918 			break
   7919 		}
   7920 		if x.Aux != s {
   7921 			break
   7922 		}
   7923 		_ = x.Args[3]
   7924 		if p != x.Args[0] {
   7925 			break
   7926 		}
   7927 		if idx != x.Args[1] {
   7928 			break
   7929 		}
   7930 		w0 := x.Args[2]
   7931 		if w0.Op != Op386SHRLconst {
   7932 			break
   7933 		}
   7934 		if w0.AuxInt != j-16 {
   7935 			break
   7936 		}
   7937 		if w != w0.Args[0] {
   7938 			break
   7939 		}
   7940 		mem := x.Args[3]
   7941 		if !(x.Uses == 1 && clobber(x)) {
   7942 			break
   7943 		}
   7944 		v.reset(Op386MOVLstoreidx1)
   7945 		v.AuxInt = i - 2
   7946 		v.Aux = s
   7947 		v.AddArg(p)
   7948 		v.AddArg(idx)
   7949 		v.AddArg(w0)
   7950 		v.AddArg(mem)
   7951 		return true
   7952 	}
   7953 	// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} idx p w0:(SHRLconst [j-16] w) mem))
   7954 	// cond: x.Uses == 1   && clobber(x)
   7955 	// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
   7956 	for {
   7957 		i := v.AuxInt
   7958 		s := v.Aux
   7959 		_ = v.Args[3]
   7960 		p := v.Args[0]
   7961 		idx := v.Args[1]
   7962 		v_2 := v.Args[2]
   7963 		if v_2.Op != Op386SHRLconst {
   7964 			break
   7965 		}
   7966 		j := v_2.AuxInt
   7967 		w := v_2.Args[0]
   7968 		x := v.Args[3]
   7969 		if x.Op != Op386MOVWstoreidx1 {
   7970 			break
   7971 		}
   7972 		if x.AuxInt != i-2 {
   7973 			break
   7974 		}
   7975 		if x.Aux != s {
   7976 			break
   7977 		}
   7978 		_ = x.Args[3]
   7979 		if idx != x.Args[0] {
   7980 			break
   7981 		}
   7982 		if p != x.Args[1] {
   7983 			break
   7984 		}
   7985 		w0 := x.Args[2]
   7986 		if w0.Op != Op386SHRLconst {
   7987 			break
   7988 		}
   7989 		if w0.AuxInt != j-16 {
   7990 			break
   7991 		}
   7992 		if w != w0.Args[0] {
   7993 			break
   7994 		}
   7995 		mem := x.Args[3]
   7996 		if !(x.Uses == 1 && clobber(x)) {
   7997 			break
   7998 		}
   7999 		v.reset(Op386MOVLstoreidx1)
   8000 		v.AuxInt = i - 2
   8001 		v.Aux = s
   8002 		v.AddArg(p)
   8003 		v.AddArg(idx)
   8004 		v.AddArg(w0)
   8005 		v.AddArg(mem)
   8006 		return true
   8007 	}
   8008 	// match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem))
   8009 	// cond: x.Uses == 1   && clobber(x)
   8010 	// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
   8011 	for {
   8012 		i := v.AuxInt
   8013 		s := v.Aux
   8014 		_ = v.Args[3]
   8015 		idx := v.Args[0]
   8016 		p := v.Args[1]
   8017 		v_2 := v.Args[2]
   8018 		if v_2.Op != Op386SHRLconst {
   8019 			break
   8020 		}
   8021 		j := v_2.AuxInt
   8022 		w := v_2.Args[0]
   8023 		x := v.Args[3]
   8024 		if x.Op != Op386MOVWstoreidx1 {
   8025 			break
   8026 		}
   8027 		if x.AuxInt != i-2 {
   8028 			break
   8029 		}
   8030 		if x.Aux != s {
   8031 			break
   8032 		}
   8033 		_ = x.Args[3]
   8034 		if p != x.Args[0] {
   8035 			break
   8036 		}
   8037 		if idx != x.Args[1] {
   8038 			break
   8039 		}
   8040 		w0 := x.Args[2]
   8041 		if w0.Op != Op386SHRLconst {
   8042 			break
   8043 		}
   8044 		if w0.AuxInt != j-16 {
   8045 			break
   8046 		}
   8047 		if w != w0.Args[0] {
   8048 			break
   8049 		}
   8050 		mem := x.Args[3]
   8051 		if !(x.Uses == 1 && clobber(x)) {
   8052 			break
   8053 		}
   8054 		v.reset(Op386MOVLstoreidx1)
   8055 		v.AuxInt = i - 2
   8056 		v.Aux = s
   8057 		v.AddArg(p)
   8058 		v.AddArg(idx)
   8059 		v.AddArg(w0)
   8060 		v.AddArg(mem)
   8061 		return true
   8062 	}
   8063 	// match: (MOVWstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} idx p w0:(SHRLconst [j-16] w) mem))
   8064 	// cond: x.Uses == 1   && clobber(x)
   8065 	// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
   8066 	for {
   8067 		i := v.AuxInt
   8068 		s := v.Aux
   8069 		_ = v.Args[3]
   8070 		idx := v.Args[0]
   8071 		p := v.Args[1]
   8072 		v_2 := v.Args[2]
   8073 		if v_2.Op != Op386SHRLconst {
   8074 			break
   8075 		}
   8076 		j := v_2.AuxInt
   8077 		w := v_2.Args[0]
   8078 		x := v.Args[3]
   8079 		if x.Op != Op386MOVWstoreidx1 {
   8080 			break
   8081 		}
   8082 		if x.AuxInt != i-2 {
   8083 			break
   8084 		}
   8085 		if x.Aux != s {
   8086 			break
   8087 		}
   8088 		_ = x.Args[3]
   8089 		if idx != x.Args[0] {
   8090 			break
   8091 		}
   8092 		if p != x.Args[1] {
   8093 			break
   8094 		}
   8095 		w0 := x.Args[2]
   8096 		if w0.Op != Op386SHRLconst {
   8097 			break
   8098 		}
   8099 		if w0.AuxInt != j-16 {
   8100 			break
   8101 		}
   8102 		if w != w0.Args[0] {
   8103 			break
   8104 		}
   8105 		mem := x.Args[3]
   8106 		if !(x.Uses == 1 && clobber(x)) {
   8107 			break
   8108 		}
   8109 		v.reset(Op386MOVLstoreidx1)
   8110 		v.AuxInt = i - 2
   8111 		v.Aux = s
   8112 		v.AddArg(p)
   8113 		v.AddArg(idx)
   8114 		v.AddArg(w0)
   8115 		v.AddArg(mem)
   8116 		return true
   8117 	}
   8118 	return false
   8119 }
   8120 func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool {
   8121 	b := v.Block
   8122 	_ = b
   8123 	// match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem)
   8124 	// cond:
   8125 	// result: (MOVWstoreidx2 [int64(int32(c+d))] {sym} ptr idx val mem)
   8126 	for {
   8127 		c := v.AuxInt
   8128 		sym := v.Aux
   8129 		_ = v.Args[3]
   8130 		v_0 := v.Args[0]
   8131 		if v_0.Op != Op386ADDLconst {
   8132 			break
   8133 		}
   8134 		d := v_0.AuxInt
   8135 		ptr := v_0.Args[0]
   8136 		idx := v.Args[1]
   8137 		val := v.Args[2]
   8138 		mem := v.Args[3]
   8139 		v.reset(Op386MOVWstoreidx2)
   8140 		v.AuxInt = int64(int32(c + d))
   8141 		v.Aux = sym
   8142 		v.AddArg(ptr)
   8143 		v.AddArg(idx)
   8144 		v.AddArg(val)
   8145 		v.AddArg(mem)
   8146 		return true
   8147 	}
   8148 	// match: (MOVWstoreidx2 [c] {sym} ptr (ADDLconst [d] idx) val mem)
   8149 	// cond:
   8150 	// result: (MOVWstoreidx2  [int64(int32(c+2*d))] {sym} ptr idx val mem)
   8151 	for {
   8152 		c := v.AuxInt
   8153 		sym := v.Aux
   8154 		_ = v.Args[3]
   8155 		ptr := v.Args[0]
   8156 		v_1 := v.Args[1]
   8157 		if v_1.Op != Op386ADDLconst {
   8158 			break
   8159 		}
   8160 		d := v_1.AuxInt
   8161 		idx := v_1.Args[0]
   8162 		val := v.Args[2]
   8163 		mem := v.Args[3]
   8164 		v.reset(Op386MOVWstoreidx2)
   8165 		v.AuxInt = int64(int32(c + 2*d))
   8166 		v.Aux = sym
   8167 		v.AddArg(ptr)
   8168 		v.AddArg(idx)
   8169 		v.AddArg(val)
   8170 		v.AddArg(mem)
   8171 		return true
   8172 	}
   8173 	// match: (MOVWstoreidx2 [i] {s} p idx (SHRLconst [16] w) x:(MOVWstoreidx2 [i-2] {s} p idx w mem))
   8174 	// cond: x.Uses == 1   && clobber(x)
   8175 	// result: (MOVLstoreidx1 [i-2] {s} p (SHLLconst <idx.Type> [1] idx) w mem)
   8176 	for {
   8177 		i := v.AuxInt
   8178 		s := v.Aux
   8179 		_ = v.Args[3]
   8180 		p := v.Args[0]
   8181 		idx := v.Args[1]
   8182 		v_2 := v.Args[2]
   8183 		if v_2.Op != Op386SHRLconst {
   8184 			break
   8185 		}
   8186 		if v_2.AuxInt != 16 {
   8187 			break
   8188 		}
   8189 		w := v_2.Args[0]
   8190 		x := v.Args[3]
   8191 		if x.Op != Op386MOVWstoreidx2 {
   8192 			break
   8193 		}
   8194 		if x.AuxInt != i-2 {
   8195 			break
   8196 		}
   8197 		if x.Aux != s {
   8198 			break
   8199 		}
   8200 		_ = x.Args[3]
   8201 		if p != x.Args[0] {
   8202 			break
   8203 		}
   8204 		if idx != x.Args[1] {
   8205 			break
   8206 		}
   8207 		if w != x.Args[2] {
   8208 			break
   8209 		}
   8210 		mem := x.Args[3]
   8211 		if !(x.Uses == 1 && clobber(x)) {
   8212 			break
   8213 		}
   8214 		v.reset(Op386MOVLstoreidx1)
   8215 		v.AuxInt = i - 2
   8216 		v.Aux = s
   8217 		v.AddArg(p)
   8218 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, idx.Type)
   8219 		v0.AuxInt = 1
   8220 		v0.AddArg(idx)
   8221 		v.AddArg(v0)
   8222 		v.AddArg(w)
   8223 		v.AddArg(mem)
   8224 		return true
   8225 	}
   8226 	// match: (MOVWstoreidx2 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx2 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem))
   8227 	// cond: x.Uses == 1   && clobber(x)
   8228 	// result: (MOVLstoreidx1 [i-2] {s} p (SHLLconst <idx.Type> [1] idx) w0 mem)
   8229 	for {
   8230 		i := v.AuxInt
   8231 		s := v.Aux
   8232 		_ = v.Args[3]
   8233 		p := v.Args[0]
   8234 		idx := v.Args[1]
   8235 		v_2 := v.Args[2]
   8236 		if v_2.Op != Op386SHRLconst {
   8237 			break
   8238 		}
   8239 		j := v_2.AuxInt
   8240 		w := v_2.Args[0]
   8241 		x := v.Args[3]
   8242 		if x.Op != Op386MOVWstoreidx2 {
   8243 			break
   8244 		}
   8245 		if x.AuxInt != i-2 {
   8246 			break
   8247 		}
   8248 		if x.Aux != s {
   8249 			break
   8250 		}
   8251 		_ = x.Args[3]
   8252 		if p != x.Args[0] {
   8253 			break
   8254 		}
   8255 		if idx != x.Args[1] {
   8256 			break
   8257 		}
   8258 		w0 := x.Args[2]
   8259 		if w0.Op != Op386SHRLconst {
   8260 			break
   8261 		}
   8262 		if w0.AuxInt != j-16 {
   8263 			break
   8264 		}
   8265 		if w != w0.Args[0] {
   8266 			break
   8267 		}
   8268 		mem := x.Args[3]
   8269 		if !(x.Uses == 1 && clobber(x)) {
   8270 			break
   8271 		}
   8272 		v.reset(Op386MOVLstoreidx1)
   8273 		v.AuxInt = i - 2
   8274 		v.Aux = s
   8275 		v.AddArg(p)
   8276 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, idx.Type)
   8277 		v0.AuxInt = 1
   8278 		v0.AddArg(idx)
   8279 		v.AddArg(v0)
   8280 		v.AddArg(w0)
   8281 		v.AddArg(mem)
   8282 		return true
   8283 	}
   8284 	return false
   8285 }
   8286 func rewriteValue386_Op386MULL_0(v *Value) bool {
   8287 	// match: (MULL x (MOVLconst [c]))
   8288 	// cond:
   8289 	// result: (MULLconst [c] x)
   8290 	for {
   8291 		_ = v.Args[1]
   8292 		x := v.Args[0]
   8293 		v_1 := v.Args[1]
   8294 		if v_1.Op != Op386MOVLconst {
   8295 			break
   8296 		}
   8297 		c := v_1.AuxInt
   8298 		v.reset(Op386MULLconst)
   8299 		v.AuxInt = c
   8300 		v.AddArg(x)
   8301 		return true
   8302 	}
   8303 	// match: (MULL (MOVLconst [c]) x)
   8304 	// cond:
   8305 	// result: (MULLconst [c] x)
   8306 	for {
   8307 		_ = v.Args[1]
   8308 		v_0 := v.Args[0]
   8309 		if v_0.Op != Op386MOVLconst {
   8310 			break
   8311 		}
   8312 		c := v_0.AuxInt
   8313 		x := v.Args[1]
   8314 		v.reset(Op386MULLconst)
   8315 		v.AuxInt = c
   8316 		v.AddArg(x)
   8317 		return true
   8318 	}
   8319 	return false
   8320 }
   8321 func rewriteValue386_Op386MULLconst_0(v *Value) bool {
   8322 	b := v.Block
   8323 	_ = b
   8324 	// match: (MULLconst [c] (MULLconst [d] x))
   8325 	// cond:
   8326 	// result: (MULLconst [int64(int32(c * d))] x)
   8327 	for {
   8328 		c := v.AuxInt
   8329 		v_0 := v.Args[0]
   8330 		if v_0.Op != Op386MULLconst {
   8331 			break
   8332 		}
   8333 		d := v_0.AuxInt
   8334 		x := v_0.Args[0]
   8335 		v.reset(Op386MULLconst)
   8336 		v.AuxInt = int64(int32(c * d))
   8337 		v.AddArg(x)
   8338 		return true
   8339 	}
   8340 	// match: (MULLconst [-1] x)
   8341 	// cond:
   8342 	// result: (NEGL x)
   8343 	for {
   8344 		if v.AuxInt != -1 {
   8345 			break
   8346 		}
   8347 		x := v.Args[0]
   8348 		v.reset(Op386NEGL)
   8349 		v.AddArg(x)
   8350 		return true
   8351 	}
   8352 	// match: (MULLconst [0] _)
   8353 	// cond:
   8354 	// result: (MOVLconst [0])
   8355 	for {
   8356 		if v.AuxInt != 0 {
   8357 			break
   8358 		}
   8359 		v.reset(Op386MOVLconst)
   8360 		v.AuxInt = 0
   8361 		return true
   8362 	}
   8363 	// match: (MULLconst [1] x)
   8364 	// cond:
   8365 	// result: x
   8366 	for {
   8367 		if v.AuxInt != 1 {
   8368 			break
   8369 		}
   8370 		x := v.Args[0]
   8371 		v.reset(OpCopy)
   8372 		v.Type = x.Type
   8373 		v.AddArg(x)
   8374 		return true
   8375 	}
   8376 	// match: (MULLconst [3] x)
   8377 	// cond:
   8378 	// result: (LEAL2 x x)
   8379 	for {
   8380 		if v.AuxInt != 3 {
   8381 			break
   8382 		}
   8383 		x := v.Args[0]
   8384 		v.reset(Op386LEAL2)
   8385 		v.AddArg(x)
   8386 		v.AddArg(x)
   8387 		return true
   8388 	}
   8389 	// match: (MULLconst [5] x)
   8390 	// cond:
   8391 	// result: (LEAL4 x x)
   8392 	for {
   8393 		if v.AuxInt != 5 {
   8394 			break
   8395 		}
   8396 		x := v.Args[0]
   8397 		v.reset(Op386LEAL4)
   8398 		v.AddArg(x)
   8399 		v.AddArg(x)
   8400 		return true
   8401 	}
   8402 	// match: (MULLconst [7] x)
   8403 	// cond:
   8404 	// result: (LEAL8 (NEGL <v.Type> x) x)
   8405 	for {
   8406 		if v.AuxInt != 7 {
   8407 			break
   8408 		}
   8409 		x := v.Args[0]
   8410 		v.reset(Op386LEAL8)
   8411 		v0 := b.NewValue0(v.Pos, Op386NEGL, v.Type)
   8412 		v0.AddArg(x)
   8413 		v.AddArg(v0)
   8414 		v.AddArg(x)
   8415 		return true
   8416 	}
   8417 	// match: (MULLconst [9] x)
   8418 	// cond:
   8419 	// result: (LEAL8 x x)
   8420 	for {
   8421 		if v.AuxInt != 9 {
   8422 			break
   8423 		}
   8424 		x := v.Args[0]
   8425 		v.reset(Op386LEAL8)
   8426 		v.AddArg(x)
   8427 		v.AddArg(x)
   8428 		return true
   8429 	}
   8430 	// match: (MULLconst [11] x)
   8431 	// cond:
   8432 	// result: (LEAL2 x (LEAL4 <v.Type> x x))
   8433 	for {
   8434 		if v.AuxInt != 11 {
   8435 			break
   8436 		}
   8437 		x := v.Args[0]
   8438 		v.reset(Op386LEAL2)
   8439 		v.AddArg(x)
   8440 		v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
   8441 		v0.AddArg(x)
   8442 		v0.AddArg(x)
   8443 		v.AddArg(v0)
   8444 		return true
   8445 	}
   8446 	// match: (MULLconst [13] x)
   8447 	// cond:
   8448 	// result: (LEAL4 x (LEAL2 <v.Type> x x))
   8449 	for {
   8450 		if v.AuxInt != 13 {
   8451 			break
   8452 		}
   8453 		x := v.Args[0]
   8454 		v.reset(Op386LEAL4)
   8455 		v.AddArg(x)
   8456 		v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
   8457 		v0.AddArg(x)
   8458 		v0.AddArg(x)
   8459 		v.AddArg(v0)
   8460 		return true
   8461 	}
   8462 	return false
   8463 }
   8464 func rewriteValue386_Op386MULLconst_10(v *Value) bool {
   8465 	b := v.Block
   8466 	_ = b
   8467 	// match: (MULLconst [21] x)
   8468 	// cond:
   8469 	// result: (LEAL4 x (LEAL4 <v.Type> x x))
   8470 	for {
   8471 		if v.AuxInt != 21 {
   8472 			break
   8473 		}
   8474 		x := v.Args[0]
   8475 		v.reset(Op386LEAL4)
   8476 		v.AddArg(x)
   8477 		v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
   8478 		v0.AddArg(x)
   8479 		v0.AddArg(x)
   8480 		v.AddArg(v0)
   8481 		return true
   8482 	}
   8483 	// match: (MULLconst [25] x)
   8484 	// cond:
   8485 	// result: (LEAL8 x (LEAL2 <v.Type> x x))
   8486 	for {
   8487 		if v.AuxInt != 25 {
   8488 			break
   8489 		}
   8490 		x := v.Args[0]
   8491 		v.reset(Op386LEAL8)
   8492 		v.AddArg(x)
   8493 		v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
   8494 		v0.AddArg(x)
   8495 		v0.AddArg(x)
   8496 		v.AddArg(v0)
   8497 		return true
   8498 	}
   8499 	// match: (MULLconst [37] x)
   8500 	// cond:
   8501 	// result: (LEAL4 x (LEAL8 <v.Type> x x))
   8502 	for {
   8503 		if v.AuxInt != 37 {
   8504 			break
   8505 		}
   8506 		x := v.Args[0]
   8507 		v.reset(Op386LEAL4)
   8508 		v.AddArg(x)
   8509 		v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
   8510 		v0.AddArg(x)
   8511 		v0.AddArg(x)
   8512 		v.AddArg(v0)
   8513 		return true
   8514 	}
   8515 	// match: (MULLconst [41] x)
   8516 	// cond:
   8517 	// result: (LEAL8 x (LEAL4 <v.Type> x x))
   8518 	for {
   8519 		if v.AuxInt != 41 {
   8520 			break
   8521 		}
   8522 		x := v.Args[0]
   8523 		v.reset(Op386LEAL8)
   8524 		v.AddArg(x)
   8525 		v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
   8526 		v0.AddArg(x)
   8527 		v0.AddArg(x)
   8528 		v.AddArg(v0)
   8529 		return true
   8530 	}
   8531 	// match: (MULLconst [73] x)
   8532 	// cond:
   8533 	// result: (LEAL8 x (LEAL8 <v.Type> x x))
   8534 	for {
   8535 		if v.AuxInt != 73 {
   8536 			break
   8537 		}
   8538 		x := v.Args[0]
   8539 		v.reset(Op386LEAL8)
   8540 		v.AddArg(x)
   8541 		v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
   8542 		v0.AddArg(x)
   8543 		v0.AddArg(x)
   8544 		v.AddArg(v0)
   8545 		return true
   8546 	}
   8547 	// match: (MULLconst [c] x)
   8548 	// cond: isPowerOfTwo(c+1) && c >= 15
   8549 	// result: (SUBL (SHLLconst <v.Type> [log2(c+1)] x) x)
   8550 	for {
   8551 		c := v.AuxInt
   8552 		x := v.Args[0]
   8553 		if !(isPowerOfTwo(c+1) && c >= 15) {
   8554 			break
   8555 		}
   8556 		v.reset(Op386SUBL)
   8557 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
   8558 		v0.AuxInt = log2(c + 1)
   8559 		v0.AddArg(x)
   8560 		v.AddArg(v0)
   8561 		v.AddArg(x)
   8562 		return true
   8563 	}
   8564 	// match: (MULLconst [c] x)
   8565 	// cond: isPowerOfTwo(c-1) && c >= 17
   8566 	// result: (LEAL1 (SHLLconst <v.Type> [log2(c-1)] x) x)
   8567 	for {
   8568 		c := v.AuxInt
   8569 		x := v.Args[0]
   8570 		if !(isPowerOfTwo(c-1) && c >= 17) {
   8571 			break
   8572 		}
   8573 		v.reset(Op386LEAL1)
   8574 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
   8575 		v0.AuxInt = log2(c - 1)
   8576 		v0.AddArg(x)
   8577 		v.AddArg(v0)
   8578 		v.AddArg(x)
   8579 		return true
   8580 	}
   8581 	// match: (MULLconst [c] x)
   8582 	// cond: isPowerOfTwo(c-2) && c >= 34
   8583 	// result: (LEAL2 (SHLLconst <v.Type> [log2(c-2)] x) x)
   8584 	for {
   8585 		c := v.AuxInt
   8586 		x := v.Args[0]
   8587 		if !(isPowerOfTwo(c-2) && c >= 34) {
   8588 			break
   8589 		}
   8590 		v.reset(Op386LEAL2)
   8591 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
   8592 		v0.AuxInt = log2(c - 2)
   8593 		v0.AddArg(x)
   8594 		v.AddArg(v0)
   8595 		v.AddArg(x)
   8596 		return true
   8597 	}
   8598 	// match: (MULLconst [c] x)
   8599 	// cond: isPowerOfTwo(c-4) && c >= 68
   8600 	// result: (LEAL4 (SHLLconst <v.Type> [log2(c-4)] x) x)
   8601 	for {
   8602 		c := v.AuxInt
   8603 		x := v.Args[0]
   8604 		if !(isPowerOfTwo(c-4) && c >= 68) {
   8605 			break
   8606 		}
   8607 		v.reset(Op386LEAL4)
   8608 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
   8609 		v0.AuxInt = log2(c - 4)
   8610 		v0.AddArg(x)
   8611 		v.AddArg(v0)
   8612 		v.AddArg(x)
   8613 		return true
   8614 	}
   8615 	// match: (MULLconst [c] x)
   8616 	// cond: isPowerOfTwo(c-8) && c >= 136
   8617 	// result: (LEAL8 (SHLLconst <v.Type> [log2(c-8)] x) x)
   8618 	for {
   8619 		c := v.AuxInt
   8620 		x := v.Args[0]
   8621 		if !(isPowerOfTwo(c-8) && c >= 136) {
   8622 			break
   8623 		}
   8624 		v.reset(Op386LEAL8)
   8625 		v0 := b.NewValue0(v.Pos, Op386SHLLconst, v.Type)
   8626 		v0.AuxInt = log2(c - 8)
   8627 		v0.AddArg(x)
   8628 		v.AddArg(v0)
   8629 		v.AddArg(x)
   8630 		return true
   8631 	}
   8632 	return false
   8633 }
   8634 func rewriteValue386_Op386MULLconst_20(v *Value) bool {
   8635 	b := v.Block
   8636 	_ = b
   8637 	// match: (MULLconst [c] x)
   8638 	// cond: c%3 == 0 && isPowerOfTwo(c/3)
   8639 	// result: (SHLLconst [log2(c/3)] (LEAL2 <v.Type> x x))
   8640 	for {
   8641 		c := v.AuxInt
   8642 		x := v.Args[0]
   8643 		if !(c%3 == 0 && isPowerOfTwo(c/3)) {
   8644 			break
   8645 		}
   8646 		v.reset(Op386SHLLconst)
   8647 		v.AuxInt = log2(c / 3)
   8648 		v0 := b.NewValue0(v.Pos, Op386LEAL2, v.Type)
   8649 		v0.AddArg(x)
   8650 		v0.AddArg(x)
   8651 		v.AddArg(v0)
   8652 		return true
   8653 	}
   8654 	// match: (MULLconst [c] x)
   8655 	// cond: c%5 == 0 && isPowerOfTwo(c/5)
   8656 	// result: (SHLLconst [log2(c/5)] (LEAL4 <v.Type> x x))
   8657 	for {
   8658 		c := v.AuxInt
   8659 		x := v.Args[0]
   8660 		if !(c%5 == 0 && isPowerOfTwo(c/5)) {
   8661 			break
   8662 		}
   8663 		v.reset(Op386SHLLconst)
   8664 		v.AuxInt = log2(c / 5)
   8665 		v0 := b.NewValue0(v.Pos, Op386LEAL4, v.Type)
   8666 		v0.AddArg(x)
   8667 		v0.AddArg(x)
   8668 		v.AddArg(v0)
   8669 		return true
   8670 	}
   8671 	// match: (MULLconst [c] x)
   8672 	// cond: c%9 == 0 && isPowerOfTwo(c/9)
   8673 	// result: (SHLLconst [log2(c/9)] (LEAL8 <v.Type> x x))
   8674 	for {
   8675 		c := v.AuxInt
   8676 		x := v.Args[0]
   8677 		if !(c%9 == 0 && isPowerOfTwo(c/9)) {
   8678 			break
   8679 		}
   8680 		v.reset(Op386SHLLconst)
   8681 		v.AuxInt = log2(c / 9)
   8682 		v0 := b.NewValue0(v.Pos, Op386LEAL8, v.Type)
   8683 		v0.AddArg(x)
   8684 		v0.AddArg(x)
   8685 		v.AddArg(v0)
   8686 		return true
   8687 	}
   8688 	// match: (MULLconst [c] (MOVLconst [d]))
   8689 	// cond:
   8690 	// result: (MOVLconst [int64(int32(c*d))])
   8691 	for {
   8692 		c := v.AuxInt
   8693 		v_0 := v.Args[0]
   8694 		if v_0.Op != Op386MOVLconst {
   8695 			break
   8696 		}
   8697 		d := v_0.AuxInt
   8698 		v.reset(Op386MOVLconst)
   8699 		v.AuxInt = int64(int32(c * d))
   8700 		return true
   8701 	}
   8702 	return false
   8703 }
   8704 func rewriteValue386_Op386NEGL_0(v *Value) bool {
   8705 	// match: (NEGL (MOVLconst [c]))
   8706 	// cond:
   8707 	// result: (MOVLconst [int64(int32(-c))])
   8708 	for {
   8709 		v_0 := v.Args[0]
   8710 		if v_0.Op != Op386MOVLconst {
   8711 			break
   8712 		}
   8713 		c := v_0.AuxInt
   8714 		v.reset(Op386MOVLconst)
   8715 		v.AuxInt = int64(int32(-c))
   8716 		return true
   8717 	}
   8718 	return false
   8719 }
   8720 func rewriteValue386_Op386NOTL_0(v *Value) bool {
   8721 	// match: (NOTL (MOVLconst [c]))
   8722 	// cond:
   8723 	// result: (MOVLconst [^c])
   8724 	for {
   8725 		v_0 := v.Args[0]
   8726 		if v_0.Op != Op386MOVLconst {
   8727 			break
   8728 		}
   8729 		c := v_0.AuxInt
   8730 		v.reset(Op386MOVLconst)
   8731 		v.AuxInt = ^c
   8732 		return true
   8733 	}
   8734 	return false
   8735 }
   8736 func rewriteValue386_Op386ORL_0(v *Value) bool {
   8737 	b := v.Block
   8738 	_ = b
   8739 	typ := &b.Func.Config.Types
   8740 	_ = typ
   8741 	// match: (ORL x (MOVLconst [c]))
   8742 	// cond:
   8743 	// result: (ORLconst [c] x)
   8744 	for {
   8745 		_ = v.Args[1]
   8746 		x := v.Args[0]
   8747 		v_1 := v.Args[1]
   8748 		if v_1.Op != Op386MOVLconst {
   8749 			break
   8750 		}
   8751 		c := v_1.AuxInt
   8752 		v.reset(Op386ORLconst)
   8753 		v.AuxInt = c
   8754 		v.AddArg(x)
   8755 		return true
   8756 	}
   8757 	// match: (ORL (MOVLconst [c]) x)
   8758 	// cond:
   8759 	// result: (ORLconst [c] x)
   8760 	for {
   8761 		_ = v.Args[1]
   8762 		v_0 := v.Args[0]
   8763 		if v_0.Op != Op386MOVLconst {
   8764 			break
   8765 		}
   8766 		c := v_0.AuxInt
   8767 		x := v.Args[1]
   8768 		v.reset(Op386ORLconst)
   8769 		v.AuxInt = c
   8770 		v.AddArg(x)
   8771 		return true
   8772 	}
   8773 	// match: (ORL (SHLLconst [c] x) (SHRLconst [d] x))
   8774 	// cond: d == 32-c
   8775 	// result: (ROLLconst [c] x)
   8776 	for {
   8777 		_ = v.Args[1]
   8778 		v_0 := v.Args[0]
   8779 		if v_0.Op != Op386SHLLconst {
   8780 			break
   8781 		}
   8782 		c := v_0.AuxInt
   8783 		x := v_0.Args[0]
   8784 		v_1 := v.Args[1]
   8785 		if v_1.Op != Op386SHRLconst {
   8786 			break
   8787 		}
   8788 		d := v_1.AuxInt
   8789 		if x != v_1.Args[0] {
   8790 			break
   8791 		}
   8792 		if !(d == 32-c) {
   8793 			break
   8794 		}
   8795 		v.reset(Op386ROLLconst)
   8796 		v.AuxInt = c
   8797 		v.AddArg(x)
   8798 		return true
   8799 	}
   8800 	// match: (ORL (SHRLconst [d] x) (SHLLconst [c] x))
   8801 	// cond: d == 32-c
   8802 	// result: (ROLLconst [c] x)
   8803 	for {
   8804 		_ = v.Args[1]
   8805 		v_0 := v.Args[0]
   8806 		if v_0.Op != Op386SHRLconst {
   8807 			break
   8808 		}
   8809 		d := v_0.AuxInt
   8810 		x := v_0.Args[0]
   8811 		v_1 := v.Args[1]
   8812 		if v_1.Op != Op386SHLLconst {
   8813 			break
   8814 		}
   8815 		c := v_1.AuxInt
   8816 		if x != v_1.Args[0] {
   8817 			break
   8818 		}
   8819 		if !(d == 32-c) {
   8820 			break
   8821 		}
   8822 		v.reset(Op386ROLLconst)
   8823 		v.AuxInt = c
   8824 		v.AddArg(x)
   8825 		return true
   8826 	}
   8827 	// match: (ORL <t> (SHLLconst x [c]) (SHRWconst x [d]))
   8828 	// cond: c < 16 && d == 16-c && t.Size() == 2
   8829 	// result: (ROLWconst x [c])
   8830 	for {
   8831 		t := v.Type
   8832 		_ = v.Args[1]
   8833 		v_0 := v.Args[0]
   8834 		if v_0.Op != Op386SHLLconst {
   8835 			break
   8836 		}
   8837 		c := v_0.AuxInt
   8838 		x := v_0.Args[0]
   8839 		v_1 := v.Args[1]
   8840 		if v_1.Op != Op386SHRWconst {
   8841 			break
   8842 		}
   8843 		d := v_1.AuxInt
   8844 		if x != v_1.Args[0] {
   8845 			break
   8846 		}
   8847 		if !(c < 16 && d == 16-c && t.Size() == 2) {
   8848 			break
   8849 		}
   8850 		v.reset(Op386ROLWconst)
   8851 		v.AuxInt = c
   8852 		v.AddArg(x)
   8853 		return true
   8854 	}
   8855 	// match: (ORL <t> (SHRWconst x [d]) (SHLLconst x [c]))
   8856 	// cond: c < 16 && d == 16-c && t.Size() == 2
   8857 	// result: (ROLWconst x [c])
   8858 	for {
   8859 		t := v.Type
   8860 		_ = v.Args[1]
   8861 		v_0 := v.Args[0]
   8862 		if v_0.Op != Op386SHRWconst {
   8863 			break
   8864 		}
   8865 		d := v_0.AuxInt
   8866 		x := v_0.Args[0]
   8867 		v_1 := v.Args[1]
   8868 		if v_1.Op != Op386SHLLconst {
   8869 			break
   8870 		}
   8871 		c := v_1.AuxInt
   8872 		if x != v_1.Args[0] {
   8873 			break
   8874 		}
   8875 		if !(c < 16 && d == 16-c && t.Size() == 2) {
   8876 			break
   8877 		}
   8878 		v.reset(Op386ROLWconst)
   8879 		v.AuxInt = c
   8880 		v.AddArg(x)
   8881 		return true
   8882 	}
   8883 	// match: (ORL <t> (SHLLconst x [c]) (SHRBconst x [d]))
   8884 	// cond: c < 8 && d == 8-c && t.Size() == 1
   8885 	// result: (ROLBconst x [c])
   8886 	for {
   8887 		t := v.Type
   8888 		_ = v.Args[1]
   8889 		v_0 := v.Args[0]
   8890 		if v_0.Op != Op386SHLLconst {
   8891 			break
   8892 		}
   8893 		c := v_0.AuxInt
   8894 		x := v_0.Args[0]
   8895 		v_1 := v.Args[1]
   8896 		if v_1.Op != Op386SHRBconst {
   8897 			break
   8898 		}
   8899 		d := v_1.AuxInt
   8900 		if x != v_1.Args[0] {
   8901 			break
   8902 		}
   8903 		if !(c < 8 && d == 8-c && t.Size() == 1) {
   8904 			break
   8905 		}
   8906 		v.reset(Op386ROLBconst)
   8907 		v.AuxInt = c
   8908 		v.AddArg(x)
   8909 		return true
   8910 	}
   8911 	// match: (ORL <t> (SHRBconst x [d]) (SHLLconst x [c]))
   8912 	// cond: c < 8 && d == 8-c && t.Size() == 1
   8913 	// result: (ROLBconst x [c])
   8914 	for {
   8915 		t := v.Type
   8916 		_ = v.Args[1]
   8917 		v_0 := v.Args[0]
   8918 		if v_0.Op != Op386SHRBconst {
   8919 			break
   8920 		}
   8921 		d := v_0.AuxInt
   8922 		x := v_0.Args[0]
   8923 		v_1 := v.Args[1]
   8924 		if v_1.Op != Op386SHLLconst {
   8925 			break
   8926 		}
   8927 		c := v_1.AuxInt
   8928 		if x != v_1.Args[0] {
   8929 			break
   8930 		}
   8931 		if !(c < 8 && d == 8-c && t.Size() == 1) {
   8932 			break
   8933 		}
   8934 		v.reset(Op386ROLBconst)
   8935 		v.AuxInt = c
   8936 		v.AddArg(x)
   8937 		return true
   8938 	}
   8939 	// match: (ORL x x)
   8940 	// cond:
   8941 	// result: x
   8942 	for {
   8943 		_ = v.Args[1]
   8944 		x := v.Args[0]
   8945 		if x != v.Args[1] {
   8946 			break
   8947 		}
   8948 		v.reset(OpCopy)
   8949 		v.Type = x.Type
   8950 		v.AddArg(x)
   8951 		return true
   8952 	}
   8953 	// match: (ORL x0:(MOVBload [i0] {s} p mem) s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)))
   8954 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   8955 	// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
   8956 	for {
   8957 		_ = v.Args[1]
   8958 		x0 := v.Args[0]
   8959 		if x0.Op != Op386MOVBload {
   8960 			break
   8961 		}
   8962 		i0 := x0.AuxInt
   8963 		s := x0.Aux
   8964 		_ = x0.Args[1]
   8965 		p := x0.Args[0]
   8966 		mem := x0.Args[1]
   8967 		s0 := v.Args[1]
   8968 		if s0.Op != Op386SHLLconst {
   8969 			break
   8970 		}
   8971 		if s0.AuxInt != 8 {
   8972 			break
   8973 		}
   8974 		x1 := s0.Args[0]
   8975 		if x1.Op != Op386MOVBload {
   8976 			break
   8977 		}
   8978 		i1 := x1.AuxInt
   8979 		if x1.Aux != s {
   8980 			break
   8981 		}
   8982 		_ = x1.Args[1]
   8983 		if p != x1.Args[0] {
   8984 			break
   8985 		}
   8986 		if mem != x1.Args[1] {
   8987 			break
   8988 		}
   8989 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   8990 			break
   8991 		}
   8992 		b = mergePoint(b, x0, x1)
   8993 		v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   8994 		v.reset(OpCopy)
   8995 		v.AddArg(v0)
   8996 		v0.AuxInt = i0
   8997 		v0.Aux = s
   8998 		v0.AddArg(p)
   8999 		v0.AddArg(mem)
   9000 		return true
   9001 	}
   9002 	return false
   9003 }
   9004 func rewriteValue386_Op386ORL_10(v *Value) bool {
   9005 	b := v.Block
   9006 	_ = b
   9007 	typ := &b.Func.Config.Types
   9008 	_ = typ
   9009 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
   9010 	// cond: i1 == i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9011 	// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
   9012 	for {
   9013 		_ = v.Args[1]
   9014 		s0 := v.Args[0]
   9015 		if s0.Op != Op386SHLLconst {
   9016 			break
   9017 		}
   9018 		if s0.AuxInt != 8 {
   9019 			break
   9020 		}
   9021 		x1 := s0.Args[0]
   9022 		if x1.Op != Op386MOVBload {
   9023 			break
   9024 		}
   9025 		i1 := x1.AuxInt
   9026 		s := x1.Aux
   9027 		_ = x1.Args[1]
   9028 		p := x1.Args[0]
   9029 		mem := x1.Args[1]
   9030 		x0 := v.Args[1]
   9031 		if x0.Op != Op386MOVBload {
   9032 			break
   9033 		}
   9034 		i0 := x0.AuxInt
   9035 		if x0.Aux != s {
   9036 			break
   9037 		}
   9038 		_ = x0.Args[1]
   9039 		if p != x0.Args[0] {
   9040 			break
   9041 		}
   9042 		if mem != x0.Args[1] {
   9043 			break
   9044 		}
   9045 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9046 			break
   9047 		}
   9048 		b = mergePoint(b, x0, x1)
   9049 		v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   9050 		v.reset(OpCopy)
   9051 		v.AddArg(v0)
   9052 		v0.AuxInt = i0
   9053 		v0.Aux = s
   9054 		v0.AddArg(p)
   9055 		v0.AddArg(mem)
   9056 		return true
   9057 	}
   9058 	// match: (ORL o0:(ORL x0:(MOVWload [i0] {s} p mem) s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem))) s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem)))
   9059 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9060 	// result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem)
   9061 	for {
   9062 		_ = v.Args[1]
   9063 		o0 := v.Args[0]
   9064 		if o0.Op != Op386ORL {
   9065 			break
   9066 		}
   9067 		_ = o0.Args[1]
   9068 		x0 := o0.Args[0]
   9069 		if x0.Op != Op386MOVWload {
   9070 			break
   9071 		}
   9072 		i0 := x0.AuxInt
   9073 		s := x0.Aux
   9074 		_ = x0.Args[1]
   9075 		p := x0.Args[0]
   9076 		mem := x0.Args[1]
   9077 		s0 := o0.Args[1]
   9078 		if s0.Op != Op386SHLLconst {
   9079 			break
   9080 		}
   9081 		if s0.AuxInt != 16 {
   9082 			break
   9083 		}
   9084 		x1 := s0.Args[0]
   9085 		if x1.Op != Op386MOVBload {
   9086 			break
   9087 		}
   9088 		i2 := x1.AuxInt
   9089 		if x1.Aux != s {
   9090 			break
   9091 		}
   9092 		_ = x1.Args[1]
   9093 		if p != x1.Args[0] {
   9094 			break
   9095 		}
   9096 		if mem != x1.Args[1] {
   9097 			break
   9098 		}
   9099 		s1 := v.Args[1]
   9100 		if s1.Op != Op386SHLLconst {
   9101 			break
   9102 		}
   9103 		if s1.AuxInt != 24 {
   9104 			break
   9105 		}
   9106 		x2 := s1.Args[0]
   9107 		if x2.Op != Op386MOVBload {
   9108 			break
   9109 		}
   9110 		i3 := x2.AuxInt
   9111 		if x2.Aux != s {
   9112 			break
   9113 		}
   9114 		_ = x2.Args[1]
   9115 		if p != x2.Args[0] {
   9116 			break
   9117 		}
   9118 		if mem != x2.Args[1] {
   9119 			break
   9120 		}
   9121 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   9122 			break
   9123 		}
   9124 		b = mergePoint(b, x0, x1, x2)
   9125 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   9126 		v.reset(OpCopy)
   9127 		v.AddArg(v0)
   9128 		v0.AuxInt = i0
   9129 		v0.Aux = s
   9130 		v0.AddArg(p)
   9131 		v0.AddArg(mem)
   9132 		return true
   9133 	}
   9134 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem)) x0:(MOVWload [i0] {s} p mem)) s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem)))
   9135 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9136 	// result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem)
   9137 	for {
   9138 		_ = v.Args[1]
   9139 		o0 := v.Args[0]
   9140 		if o0.Op != Op386ORL {
   9141 			break
   9142 		}
   9143 		_ = o0.Args[1]
   9144 		s0 := o0.Args[0]
   9145 		if s0.Op != Op386SHLLconst {
   9146 			break
   9147 		}
   9148 		if s0.AuxInt != 16 {
   9149 			break
   9150 		}
   9151 		x1 := s0.Args[0]
   9152 		if x1.Op != Op386MOVBload {
   9153 			break
   9154 		}
   9155 		i2 := x1.AuxInt
   9156 		s := x1.Aux
   9157 		_ = x1.Args[1]
   9158 		p := x1.Args[0]
   9159 		mem := x1.Args[1]
   9160 		x0 := o0.Args[1]
   9161 		if x0.Op != Op386MOVWload {
   9162 			break
   9163 		}
   9164 		i0 := x0.AuxInt
   9165 		if x0.Aux != s {
   9166 			break
   9167 		}
   9168 		_ = x0.Args[1]
   9169 		if p != x0.Args[0] {
   9170 			break
   9171 		}
   9172 		if mem != x0.Args[1] {
   9173 			break
   9174 		}
   9175 		s1 := v.Args[1]
   9176 		if s1.Op != Op386SHLLconst {
   9177 			break
   9178 		}
   9179 		if s1.AuxInt != 24 {
   9180 			break
   9181 		}
   9182 		x2 := s1.Args[0]
   9183 		if x2.Op != Op386MOVBload {
   9184 			break
   9185 		}
   9186 		i3 := x2.AuxInt
   9187 		if x2.Aux != s {
   9188 			break
   9189 		}
   9190 		_ = x2.Args[1]
   9191 		if p != x2.Args[0] {
   9192 			break
   9193 		}
   9194 		if mem != x2.Args[1] {
   9195 			break
   9196 		}
   9197 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   9198 			break
   9199 		}
   9200 		b = mergePoint(b, x0, x1, x2)
   9201 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   9202 		v.reset(OpCopy)
   9203 		v.AddArg(v0)
   9204 		v0.AuxInt = i0
   9205 		v0.Aux = s
   9206 		v0.AddArg(p)
   9207 		v0.AddArg(mem)
   9208 		return true
   9209 	}
   9210 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem)) o0:(ORL x0:(MOVWload [i0] {s} p mem) s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem))))
   9211 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9212 	// result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem)
   9213 	for {
   9214 		_ = v.Args[1]
   9215 		s1 := v.Args[0]
   9216 		if s1.Op != Op386SHLLconst {
   9217 			break
   9218 		}
   9219 		if s1.AuxInt != 24 {
   9220 			break
   9221 		}
   9222 		x2 := s1.Args[0]
   9223 		if x2.Op != Op386MOVBload {
   9224 			break
   9225 		}
   9226 		i3 := x2.AuxInt
   9227 		s := x2.Aux
   9228 		_ = x2.Args[1]
   9229 		p := x2.Args[0]
   9230 		mem := x2.Args[1]
   9231 		o0 := v.Args[1]
   9232 		if o0.Op != Op386ORL {
   9233 			break
   9234 		}
   9235 		_ = o0.Args[1]
   9236 		x0 := o0.Args[0]
   9237 		if x0.Op != Op386MOVWload {
   9238 			break
   9239 		}
   9240 		i0 := x0.AuxInt
   9241 		if x0.Aux != s {
   9242 			break
   9243 		}
   9244 		_ = x0.Args[1]
   9245 		if p != x0.Args[0] {
   9246 			break
   9247 		}
   9248 		if mem != x0.Args[1] {
   9249 			break
   9250 		}
   9251 		s0 := o0.Args[1]
   9252 		if s0.Op != Op386SHLLconst {
   9253 			break
   9254 		}
   9255 		if s0.AuxInt != 16 {
   9256 			break
   9257 		}
   9258 		x1 := s0.Args[0]
   9259 		if x1.Op != Op386MOVBload {
   9260 			break
   9261 		}
   9262 		i2 := x1.AuxInt
   9263 		if x1.Aux != s {
   9264 			break
   9265 		}
   9266 		_ = x1.Args[1]
   9267 		if p != x1.Args[0] {
   9268 			break
   9269 		}
   9270 		if mem != x1.Args[1] {
   9271 			break
   9272 		}
   9273 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   9274 			break
   9275 		}
   9276 		b = mergePoint(b, x0, x1, x2)
   9277 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   9278 		v.reset(OpCopy)
   9279 		v.AddArg(v0)
   9280 		v0.AuxInt = i0
   9281 		v0.Aux = s
   9282 		v0.AddArg(p)
   9283 		v0.AddArg(mem)
   9284 		return true
   9285 	}
   9286 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBload [i3] {s} p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBload [i2] {s} p mem)) x0:(MOVWload [i0] {s} p mem)))
   9287 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9288 	// result: @mergePoint(b,x0,x1,x2) (MOVLload [i0] {s} p mem)
   9289 	for {
   9290 		_ = v.Args[1]
   9291 		s1 := v.Args[0]
   9292 		if s1.Op != Op386SHLLconst {
   9293 			break
   9294 		}
   9295 		if s1.AuxInt != 24 {
   9296 			break
   9297 		}
   9298 		x2 := s1.Args[0]
   9299 		if x2.Op != Op386MOVBload {
   9300 			break
   9301 		}
   9302 		i3 := x2.AuxInt
   9303 		s := x2.Aux
   9304 		_ = x2.Args[1]
   9305 		p := x2.Args[0]
   9306 		mem := x2.Args[1]
   9307 		o0 := v.Args[1]
   9308 		if o0.Op != Op386ORL {
   9309 			break
   9310 		}
   9311 		_ = o0.Args[1]
   9312 		s0 := o0.Args[0]
   9313 		if s0.Op != Op386SHLLconst {
   9314 			break
   9315 		}
   9316 		if s0.AuxInt != 16 {
   9317 			break
   9318 		}
   9319 		x1 := s0.Args[0]
   9320 		if x1.Op != Op386MOVBload {
   9321 			break
   9322 		}
   9323 		i2 := x1.AuxInt
   9324 		if x1.Aux != s {
   9325 			break
   9326 		}
   9327 		_ = x1.Args[1]
   9328 		if p != x1.Args[0] {
   9329 			break
   9330 		}
   9331 		if mem != x1.Args[1] {
   9332 			break
   9333 		}
   9334 		x0 := o0.Args[1]
   9335 		if x0.Op != Op386MOVWload {
   9336 			break
   9337 		}
   9338 		i0 := x0.AuxInt
   9339 		if x0.Aux != s {
   9340 			break
   9341 		}
   9342 		_ = x0.Args[1]
   9343 		if p != x0.Args[0] {
   9344 			break
   9345 		}
   9346 		if mem != x0.Args[1] {
   9347 			break
   9348 		}
   9349 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   9350 			break
   9351 		}
   9352 		b = mergePoint(b, x0, x1, x2)
   9353 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   9354 		v.reset(OpCopy)
   9355 		v.AddArg(v0)
   9356 		v0.AuxInt = i0
   9357 		v0.Aux = s
   9358 		v0.AddArg(p)
   9359 		v0.AddArg(mem)
   9360 		return true
   9361 	}
   9362 	// match: (ORL x0:(MOVBloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem)))
   9363 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9364 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9365 	for {
   9366 		_ = v.Args[1]
   9367 		x0 := v.Args[0]
   9368 		if x0.Op != Op386MOVBloadidx1 {
   9369 			break
   9370 		}
   9371 		i0 := x0.AuxInt
   9372 		s := x0.Aux
   9373 		_ = x0.Args[2]
   9374 		p := x0.Args[0]
   9375 		idx := x0.Args[1]
   9376 		mem := x0.Args[2]
   9377 		s0 := v.Args[1]
   9378 		if s0.Op != Op386SHLLconst {
   9379 			break
   9380 		}
   9381 		if s0.AuxInt != 8 {
   9382 			break
   9383 		}
   9384 		x1 := s0.Args[0]
   9385 		if x1.Op != Op386MOVBloadidx1 {
   9386 			break
   9387 		}
   9388 		i1 := x1.AuxInt
   9389 		if x1.Aux != s {
   9390 			break
   9391 		}
   9392 		_ = x1.Args[2]
   9393 		if p != x1.Args[0] {
   9394 			break
   9395 		}
   9396 		if idx != x1.Args[1] {
   9397 			break
   9398 		}
   9399 		if mem != x1.Args[2] {
   9400 			break
   9401 		}
   9402 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9403 			break
   9404 		}
   9405 		b = mergePoint(b, x0, x1)
   9406 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9407 		v.reset(OpCopy)
   9408 		v.AddArg(v0)
   9409 		v0.AuxInt = i0
   9410 		v0.Aux = s
   9411 		v0.AddArg(p)
   9412 		v0.AddArg(idx)
   9413 		v0.AddArg(mem)
   9414 		return true
   9415 	}
   9416 	// match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem)))
   9417 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9418 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9419 	for {
   9420 		_ = v.Args[1]
   9421 		x0 := v.Args[0]
   9422 		if x0.Op != Op386MOVBloadidx1 {
   9423 			break
   9424 		}
   9425 		i0 := x0.AuxInt
   9426 		s := x0.Aux
   9427 		_ = x0.Args[2]
   9428 		idx := x0.Args[0]
   9429 		p := x0.Args[1]
   9430 		mem := x0.Args[2]
   9431 		s0 := v.Args[1]
   9432 		if s0.Op != Op386SHLLconst {
   9433 			break
   9434 		}
   9435 		if s0.AuxInt != 8 {
   9436 			break
   9437 		}
   9438 		x1 := s0.Args[0]
   9439 		if x1.Op != Op386MOVBloadidx1 {
   9440 			break
   9441 		}
   9442 		i1 := x1.AuxInt
   9443 		if x1.Aux != s {
   9444 			break
   9445 		}
   9446 		_ = x1.Args[2]
   9447 		if p != x1.Args[0] {
   9448 			break
   9449 		}
   9450 		if idx != x1.Args[1] {
   9451 			break
   9452 		}
   9453 		if mem != x1.Args[2] {
   9454 			break
   9455 		}
   9456 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9457 			break
   9458 		}
   9459 		b = mergePoint(b, x0, x1)
   9460 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9461 		v.reset(OpCopy)
   9462 		v.AddArg(v0)
   9463 		v0.AuxInt = i0
   9464 		v0.Aux = s
   9465 		v0.AddArg(p)
   9466 		v0.AddArg(idx)
   9467 		v0.AddArg(mem)
   9468 		return true
   9469 	}
   9470 	// match: (ORL x0:(MOVBloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)))
   9471 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9472 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9473 	for {
   9474 		_ = v.Args[1]
   9475 		x0 := v.Args[0]
   9476 		if x0.Op != Op386MOVBloadidx1 {
   9477 			break
   9478 		}
   9479 		i0 := x0.AuxInt
   9480 		s := x0.Aux
   9481 		_ = x0.Args[2]
   9482 		p := x0.Args[0]
   9483 		idx := x0.Args[1]
   9484 		mem := x0.Args[2]
   9485 		s0 := v.Args[1]
   9486 		if s0.Op != Op386SHLLconst {
   9487 			break
   9488 		}
   9489 		if s0.AuxInt != 8 {
   9490 			break
   9491 		}
   9492 		x1 := s0.Args[0]
   9493 		if x1.Op != Op386MOVBloadidx1 {
   9494 			break
   9495 		}
   9496 		i1 := x1.AuxInt
   9497 		if x1.Aux != s {
   9498 			break
   9499 		}
   9500 		_ = x1.Args[2]
   9501 		if idx != x1.Args[0] {
   9502 			break
   9503 		}
   9504 		if p != x1.Args[1] {
   9505 			break
   9506 		}
   9507 		if mem != x1.Args[2] {
   9508 			break
   9509 		}
   9510 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9511 			break
   9512 		}
   9513 		b = mergePoint(b, x0, x1)
   9514 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9515 		v.reset(OpCopy)
   9516 		v.AddArg(v0)
   9517 		v0.AuxInt = i0
   9518 		v0.Aux = s
   9519 		v0.AddArg(p)
   9520 		v0.AddArg(idx)
   9521 		v0.AddArg(mem)
   9522 		return true
   9523 	}
   9524 	// match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)))
   9525 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9526 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9527 	for {
   9528 		_ = v.Args[1]
   9529 		x0 := v.Args[0]
   9530 		if x0.Op != Op386MOVBloadidx1 {
   9531 			break
   9532 		}
   9533 		i0 := x0.AuxInt
   9534 		s := x0.Aux
   9535 		_ = x0.Args[2]
   9536 		idx := x0.Args[0]
   9537 		p := x0.Args[1]
   9538 		mem := x0.Args[2]
   9539 		s0 := v.Args[1]
   9540 		if s0.Op != Op386SHLLconst {
   9541 			break
   9542 		}
   9543 		if s0.AuxInt != 8 {
   9544 			break
   9545 		}
   9546 		x1 := s0.Args[0]
   9547 		if x1.Op != Op386MOVBloadidx1 {
   9548 			break
   9549 		}
   9550 		i1 := x1.AuxInt
   9551 		if x1.Aux != s {
   9552 			break
   9553 		}
   9554 		_ = x1.Args[2]
   9555 		if idx != x1.Args[0] {
   9556 			break
   9557 		}
   9558 		if p != x1.Args[1] {
   9559 			break
   9560 		}
   9561 		if mem != x1.Args[2] {
   9562 			break
   9563 		}
   9564 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9565 			break
   9566 		}
   9567 		b = mergePoint(b, x0, x1)
   9568 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9569 		v.reset(OpCopy)
   9570 		v.AddArg(v0)
   9571 		v0.AuxInt = i0
   9572 		v0.Aux = s
   9573 		v0.AddArg(p)
   9574 		v0.AddArg(idx)
   9575 		v0.AddArg(mem)
   9576 		return true
   9577 	}
   9578 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
   9579 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9580 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9581 	for {
   9582 		_ = v.Args[1]
   9583 		s0 := v.Args[0]
   9584 		if s0.Op != Op386SHLLconst {
   9585 			break
   9586 		}
   9587 		if s0.AuxInt != 8 {
   9588 			break
   9589 		}
   9590 		x1 := s0.Args[0]
   9591 		if x1.Op != Op386MOVBloadidx1 {
   9592 			break
   9593 		}
   9594 		i1 := x1.AuxInt
   9595 		s := x1.Aux
   9596 		_ = x1.Args[2]
   9597 		p := x1.Args[0]
   9598 		idx := x1.Args[1]
   9599 		mem := x1.Args[2]
   9600 		x0 := v.Args[1]
   9601 		if x0.Op != Op386MOVBloadidx1 {
   9602 			break
   9603 		}
   9604 		i0 := x0.AuxInt
   9605 		if x0.Aux != s {
   9606 			break
   9607 		}
   9608 		_ = x0.Args[2]
   9609 		if p != x0.Args[0] {
   9610 			break
   9611 		}
   9612 		if idx != x0.Args[1] {
   9613 			break
   9614 		}
   9615 		if mem != x0.Args[2] {
   9616 			break
   9617 		}
   9618 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9619 			break
   9620 		}
   9621 		b = mergePoint(b, x0, x1)
   9622 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9623 		v.reset(OpCopy)
   9624 		v.AddArg(v0)
   9625 		v0.AuxInt = i0
   9626 		v0.Aux = s
   9627 		v0.AddArg(p)
   9628 		v0.AddArg(idx)
   9629 		v0.AddArg(mem)
   9630 		return true
   9631 	}
   9632 	return false
   9633 }
   9634 func rewriteValue386_Op386ORL_20(v *Value) bool {
   9635 	b := v.Block
   9636 	_ = b
   9637 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
   9638 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9639 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9640 	for {
   9641 		_ = v.Args[1]
   9642 		s0 := v.Args[0]
   9643 		if s0.Op != Op386SHLLconst {
   9644 			break
   9645 		}
   9646 		if s0.AuxInt != 8 {
   9647 			break
   9648 		}
   9649 		x1 := s0.Args[0]
   9650 		if x1.Op != Op386MOVBloadidx1 {
   9651 			break
   9652 		}
   9653 		i1 := x1.AuxInt
   9654 		s := x1.Aux
   9655 		_ = x1.Args[2]
   9656 		idx := x1.Args[0]
   9657 		p := x1.Args[1]
   9658 		mem := x1.Args[2]
   9659 		x0 := v.Args[1]
   9660 		if x0.Op != Op386MOVBloadidx1 {
   9661 			break
   9662 		}
   9663 		i0 := x0.AuxInt
   9664 		if x0.Aux != s {
   9665 			break
   9666 		}
   9667 		_ = x0.Args[2]
   9668 		if p != x0.Args[0] {
   9669 			break
   9670 		}
   9671 		if idx != x0.Args[1] {
   9672 			break
   9673 		}
   9674 		if mem != x0.Args[2] {
   9675 			break
   9676 		}
   9677 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9678 			break
   9679 		}
   9680 		b = mergePoint(b, x0, x1)
   9681 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9682 		v.reset(OpCopy)
   9683 		v.AddArg(v0)
   9684 		v0.AuxInt = i0
   9685 		v0.Aux = s
   9686 		v0.AddArg(p)
   9687 		v0.AddArg(idx)
   9688 		v0.AddArg(mem)
   9689 		return true
   9690 	}
   9691 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} p idx mem)) x0:(MOVBloadidx1 [i0] {s} idx p mem))
   9692 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9693 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9694 	for {
   9695 		_ = v.Args[1]
   9696 		s0 := v.Args[0]
   9697 		if s0.Op != Op386SHLLconst {
   9698 			break
   9699 		}
   9700 		if s0.AuxInt != 8 {
   9701 			break
   9702 		}
   9703 		x1 := s0.Args[0]
   9704 		if x1.Op != Op386MOVBloadidx1 {
   9705 			break
   9706 		}
   9707 		i1 := x1.AuxInt
   9708 		s := x1.Aux
   9709 		_ = x1.Args[2]
   9710 		p := x1.Args[0]
   9711 		idx := x1.Args[1]
   9712 		mem := x1.Args[2]
   9713 		x0 := v.Args[1]
   9714 		if x0.Op != Op386MOVBloadidx1 {
   9715 			break
   9716 		}
   9717 		i0 := x0.AuxInt
   9718 		if x0.Aux != s {
   9719 			break
   9720 		}
   9721 		_ = x0.Args[2]
   9722 		if idx != x0.Args[0] {
   9723 			break
   9724 		}
   9725 		if p != x0.Args[1] {
   9726 			break
   9727 		}
   9728 		if mem != x0.Args[2] {
   9729 			break
   9730 		}
   9731 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9732 			break
   9733 		}
   9734 		b = mergePoint(b, x0, x1)
   9735 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9736 		v.reset(OpCopy)
   9737 		v.AddArg(v0)
   9738 		v0.AuxInt = i0
   9739 		v0.Aux = s
   9740 		v0.AddArg(p)
   9741 		v0.AddArg(idx)
   9742 		v0.AddArg(mem)
   9743 		return true
   9744 	}
   9745 	// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} idx p mem))
   9746 	// cond: i1==i0+1   && x0.Uses == 1   && x1.Uses == 1   && s0.Uses == 1   && mergePoint(b,x0,x1) != nil   && clobber(x0)   && clobber(x1)   && clobber(s0)
   9747 	// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
   9748 	for {
   9749 		_ = v.Args[1]
   9750 		s0 := v.Args[0]
   9751 		if s0.Op != Op386SHLLconst {
   9752 			break
   9753 		}
   9754 		if s0.AuxInt != 8 {
   9755 			break
   9756 		}
   9757 		x1 := s0.Args[0]
   9758 		if x1.Op != Op386MOVBloadidx1 {
   9759 			break
   9760 		}
   9761 		i1 := x1.AuxInt
   9762 		s := x1.Aux
   9763 		_ = x1.Args[2]
   9764 		idx := x1.Args[0]
   9765 		p := x1.Args[1]
   9766 		mem := x1.Args[2]
   9767 		x0 := v.Args[1]
   9768 		if x0.Op != Op386MOVBloadidx1 {
   9769 			break
   9770 		}
   9771 		i0 := x0.AuxInt
   9772 		if x0.Aux != s {
   9773 			break
   9774 		}
   9775 		_ = x0.Args[2]
   9776 		if idx != x0.Args[0] {
   9777 			break
   9778 		}
   9779 		if p != x0.Args[1] {
   9780 			break
   9781 		}
   9782 		if mem != x0.Args[2] {
   9783 			break
   9784 		}
   9785 		if !(i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)) {
   9786 			break
   9787 		}
   9788 		b = mergePoint(b, x0, x1)
   9789 		v0 := b.NewValue0(v.Pos, Op386MOVWloadidx1, v.Type)
   9790 		v.reset(OpCopy)
   9791 		v.AddArg(v0)
   9792 		v0.AuxInt = i0
   9793 		v0.Aux = s
   9794 		v0.AddArg(p)
   9795 		v0.AddArg(idx)
   9796 		v0.AddArg(mem)
   9797 		return true
   9798 	}
   9799 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   9800 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9801 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   9802 	for {
   9803 		_ = v.Args[1]
   9804 		o0 := v.Args[0]
   9805 		if o0.Op != Op386ORL {
   9806 			break
   9807 		}
   9808 		_ = o0.Args[1]
   9809 		x0 := o0.Args[0]
   9810 		if x0.Op != Op386MOVWloadidx1 {
   9811 			break
   9812 		}
   9813 		i0 := x0.AuxInt
   9814 		s := x0.Aux
   9815 		_ = x0.Args[2]
   9816 		p := x0.Args[0]
   9817 		idx := x0.Args[1]
   9818 		mem := x0.Args[2]
   9819 		s0 := o0.Args[1]
   9820 		if s0.Op != Op386SHLLconst {
   9821 			break
   9822 		}
   9823 		if s0.AuxInt != 16 {
   9824 			break
   9825 		}
   9826 		x1 := s0.Args[0]
   9827 		if x1.Op != Op386MOVBloadidx1 {
   9828 			break
   9829 		}
   9830 		i2 := x1.AuxInt
   9831 		if x1.Aux != s {
   9832 			break
   9833 		}
   9834 		_ = x1.Args[2]
   9835 		if p != x1.Args[0] {
   9836 			break
   9837 		}
   9838 		if idx != x1.Args[1] {
   9839 			break
   9840 		}
   9841 		if mem != x1.Args[2] {
   9842 			break
   9843 		}
   9844 		s1 := v.Args[1]
   9845 		if s1.Op != Op386SHLLconst {
   9846 			break
   9847 		}
   9848 		if s1.AuxInt != 24 {
   9849 			break
   9850 		}
   9851 		x2 := s1.Args[0]
   9852 		if x2.Op != Op386MOVBloadidx1 {
   9853 			break
   9854 		}
   9855 		i3 := x2.AuxInt
   9856 		if x2.Aux != s {
   9857 			break
   9858 		}
   9859 		_ = x2.Args[2]
   9860 		if p != x2.Args[0] {
   9861 			break
   9862 		}
   9863 		if idx != x2.Args[1] {
   9864 			break
   9865 		}
   9866 		if mem != x2.Args[2] {
   9867 			break
   9868 		}
   9869 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   9870 			break
   9871 		}
   9872 		b = mergePoint(b, x0, x1, x2)
   9873 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   9874 		v.reset(OpCopy)
   9875 		v.AddArg(v0)
   9876 		v0.AuxInt = i0
   9877 		v0.Aux = s
   9878 		v0.AddArg(p)
   9879 		v0.AddArg(idx)
   9880 		v0.AddArg(mem)
   9881 		return true
   9882 	}
   9883 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   9884 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9885 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   9886 	for {
   9887 		_ = v.Args[1]
   9888 		o0 := v.Args[0]
   9889 		if o0.Op != Op386ORL {
   9890 			break
   9891 		}
   9892 		_ = o0.Args[1]
   9893 		x0 := o0.Args[0]
   9894 		if x0.Op != Op386MOVWloadidx1 {
   9895 			break
   9896 		}
   9897 		i0 := x0.AuxInt
   9898 		s := x0.Aux
   9899 		_ = x0.Args[2]
   9900 		idx := x0.Args[0]
   9901 		p := x0.Args[1]
   9902 		mem := x0.Args[2]
   9903 		s0 := o0.Args[1]
   9904 		if s0.Op != Op386SHLLconst {
   9905 			break
   9906 		}
   9907 		if s0.AuxInt != 16 {
   9908 			break
   9909 		}
   9910 		x1 := s0.Args[0]
   9911 		if x1.Op != Op386MOVBloadidx1 {
   9912 			break
   9913 		}
   9914 		i2 := x1.AuxInt
   9915 		if x1.Aux != s {
   9916 			break
   9917 		}
   9918 		_ = x1.Args[2]
   9919 		if p != x1.Args[0] {
   9920 			break
   9921 		}
   9922 		if idx != x1.Args[1] {
   9923 			break
   9924 		}
   9925 		if mem != x1.Args[2] {
   9926 			break
   9927 		}
   9928 		s1 := v.Args[1]
   9929 		if s1.Op != Op386SHLLconst {
   9930 			break
   9931 		}
   9932 		if s1.AuxInt != 24 {
   9933 			break
   9934 		}
   9935 		x2 := s1.Args[0]
   9936 		if x2.Op != Op386MOVBloadidx1 {
   9937 			break
   9938 		}
   9939 		i3 := x2.AuxInt
   9940 		if x2.Aux != s {
   9941 			break
   9942 		}
   9943 		_ = x2.Args[2]
   9944 		if p != x2.Args[0] {
   9945 			break
   9946 		}
   9947 		if idx != x2.Args[1] {
   9948 			break
   9949 		}
   9950 		if mem != x2.Args[2] {
   9951 			break
   9952 		}
   9953 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   9954 			break
   9955 		}
   9956 		b = mergePoint(b, x0, x1, x2)
   9957 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   9958 		v.reset(OpCopy)
   9959 		v.AddArg(v0)
   9960 		v0.AuxInt = i0
   9961 		v0.Aux = s
   9962 		v0.AddArg(p)
   9963 		v0.AddArg(idx)
   9964 		v0.AddArg(mem)
   9965 		return true
   9966 	}
   9967 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   9968 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   9969 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   9970 	for {
   9971 		_ = v.Args[1]
   9972 		o0 := v.Args[0]
   9973 		if o0.Op != Op386ORL {
   9974 			break
   9975 		}
   9976 		_ = o0.Args[1]
   9977 		x0 := o0.Args[0]
   9978 		if x0.Op != Op386MOVWloadidx1 {
   9979 			break
   9980 		}
   9981 		i0 := x0.AuxInt
   9982 		s := x0.Aux
   9983 		_ = x0.Args[2]
   9984 		p := x0.Args[0]
   9985 		idx := x0.Args[1]
   9986 		mem := x0.Args[2]
   9987 		s0 := o0.Args[1]
   9988 		if s0.Op != Op386SHLLconst {
   9989 			break
   9990 		}
   9991 		if s0.AuxInt != 16 {
   9992 			break
   9993 		}
   9994 		x1 := s0.Args[0]
   9995 		if x1.Op != Op386MOVBloadidx1 {
   9996 			break
   9997 		}
   9998 		i2 := x1.AuxInt
   9999 		if x1.Aux != s {
   10000 			break
   10001 		}
   10002 		_ = x1.Args[2]
   10003 		if idx != x1.Args[0] {
   10004 			break
   10005 		}
   10006 		if p != x1.Args[1] {
   10007 			break
   10008 		}
   10009 		if mem != x1.Args[2] {
   10010 			break
   10011 		}
   10012 		s1 := v.Args[1]
   10013 		if s1.Op != Op386SHLLconst {
   10014 			break
   10015 		}
   10016 		if s1.AuxInt != 24 {
   10017 			break
   10018 		}
   10019 		x2 := s1.Args[0]
   10020 		if x2.Op != Op386MOVBloadidx1 {
   10021 			break
   10022 		}
   10023 		i3 := x2.AuxInt
   10024 		if x2.Aux != s {
   10025 			break
   10026 		}
   10027 		_ = x2.Args[2]
   10028 		if p != x2.Args[0] {
   10029 			break
   10030 		}
   10031 		if idx != x2.Args[1] {
   10032 			break
   10033 		}
   10034 		if mem != x2.Args[2] {
   10035 			break
   10036 		}
   10037 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10038 			break
   10039 		}
   10040 		b = mergePoint(b, x0, x1, x2)
   10041 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10042 		v.reset(OpCopy)
   10043 		v.AddArg(v0)
   10044 		v0.AuxInt = i0
   10045 		v0.Aux = s
   10046 		v0.AddArg(p)
   10047 		v0.AddArg(idx)
   10048 		v0.AddArg(mem)
   10049 		return true
   10050 	}
   10051 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   10052 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10053 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10054 	for {
   10055 		_ = v.Args[1]
   10056 		o0 := v.Args[0]
   10057 		if o0.Op != Op386ORL {
   10058 			break
   10059 		}
   10060 		_ = o0.Args[1]
   10061 		x0 := o0.Args[0]
   10062 		if x0.Op != Op386MOVWloadidx1 {
   10063 			break
   10064 		}
   10065 		i0 := x0.AuxInt
   10066 		s := x0.Aux
   10067 		_ = x0.Args[2]
   10068 		idx := x0.Args[0]
   10069 		p := x0.Args[1]
   10070 		mem := x0.Args[2]
   10071 		s0 := o0.Args[1]
   10072 		if s0.Op != Op386SHLLconst {
   10073 			break
   10074 		}
   10075 		if s0.AuxInt != 16 {
   10076 			break
   10077 		}
   10078 		x1 := s0.Args[0]
   10079 		if x1.Op != Op386MOVBloadidx1 {
   10080 			break
   10081 		}
   10082 		i2 := x1.AuxInt
   10083 		if x1.Aux != s {
   10084 			break
   10085 		}
   10086 		_ = x1.Args[2]
   10087 		if idx != x1.Args[0] {
   10088 			break
   10089 		}
   10090 		if p != x1.Args[1] {
   10091 			break
   10092 		}
   10093 		if mem != x1.Args[2] {
   10094 			break
   10095 		}
   10096 		s1 := v.Args[1]
   10097 		if s1.Op != Op386SHLLconst {
   10098 			break
   10099 		}
   10100 		if s1.AuxInt != 24 {
   10101 			break
   10102 		}
   10103 		x2 := s1.Args[0]
   10104 		if x2.Op != Op386MOVBloadidx1 {
   10105 			break
   10106 		}
   10107 		i3 := x2.AuxInt
   10108 		if x2.Aux != s {
   10109 			break
   10110 		}
   10111 		_ = x2.Args[2]
   10112 		if p != x2.Args[0] {
   10113 			break
   10114 		}
   10115 		if idx != x2.Args[1] {
   10116 			break
   10117 		}
   10118 		if mem != x2.Args[2] {
   10119 			break
   10120 		}
   10121 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10122 			break
   10123 		}
   10124 		b = mergePoint(b, x0, x1, x2)
   10125 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10126 		v.reset(OpCopy)
   10127 		v.AddArg(v0)
   10128 		v0.AuxInt = i0
   10129 		v0.Aux = s
   10130 		v0.AddArg(p)
   10131 		v0.AddArg(idx)
   10132 		v0.AddArg(mem)
   10133 		return true
   10134 	}
   10135 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   10136 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10137 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10138 	for {
   10139 		_ = v.Args[1]
   10140 		o0 := v.Args[0]
   10141 		if o0.Op != Op386ORL {
   10142 			break
   10143 		}
   10144 		_ = o0.Args[1]
   10145 		s0 := o0.Args[0]
   10146 		if s0.Op != Op386SHLLconst {
   10147 			break
   10148 		}
   10149 		if s0.AuxInt != 16 {
   10150 			break
   10151 		}
   10152 		x1 := s0.Args[0]
   10153 		if x1.Op != Op386MOVBloadidx1 {
   10154 			break
   10155 		}
   10156 		i2 := x1.AuxInt
   10157 		s := x1.Aux
   10158 		_ = x1.Args[2]
   10159 		p := x1.Args[0]
   10160 		idx := x1.Args[1]
   10161 		mem := x1.Args[2]
   10162 		x0 := o0.Args[1]
   10163 		if x0.Op != Op386MOVWloadidx1 {
   10164 			break
   10165 		}
   10166 		i0 := x0.AuxInt
   10167 		if x0.Aux != s {
   10168 			break
   10169 		}
   10170 		_ = x0.Args[2]
   10171 		if p != x0.Args[0] {
   10172 			break
   10173 		}
   10174 		if idx != x0.Args[1] {
   10175 			break
   10176 		}
   10177 		if mem != x0.Args[2] {
   10178 			break
   10179 		}
   10180 		s1 := v.Args[1]
   10181 		if s1.Op != Op386SHLLconst {
   10182 			break
   10183 		}
   10184 		if s1.AuxInt != 24 {
   10185 			break
   10186 		}
   10187 		x2 := s1.Args[0]
   10188 		if x2.Op != Op386MOVBloadidx1 {
   10189 			break
   10190 		}
   10191 		i3 := x2.AuxInt
   10192 		if x2.Aux != s {
   10193 			break
   10194 		}
   10195 		_ = x2.Args[2]
   10196 		if p != x2.Args[0] {
   10197 			break
   10198 		}
   10199 		if idx != x2.Args[1] {
   10200 			break
   10201 		}
   10202 		if mem != x2.Args[2] {
   10203 			break
   10204 		}
   10205 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10206 			break
   10207 		}
   10208 		b = mergePoint(b, x0, x1, x2)
   10209 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10210 		v.reset(OpCopy)
   10211 		v.AddArg(v0)
   10212 		v0.AuxInt = i0
   10213 		v0.Aux = s
   10214 		v0.AddArg(p)
   10215 		v0.AddArg(idx)
   10216 		v0.AddArg(mem)
   10217 		return true
   10218 	}
   10219 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   10220 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10221 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10222 	for {
   10223 		_ = v.Args[1]
   10224 		o0 := v.Args[0]
   10225 		if o0.Op != Op386ORL {
   10226 			break
   10227 		}
   10228 		_ = o0.Args[1]
   10229 		s0 := o0.Args[0]
   10230 		if s0.Op != Op386SHLLconst {
   10231 			break
   10232 		}
   10233 		if s0.AuxInt != 16 {
   10234 			break
   10235 		}
   10236 		x1 := s0.Args[0]
   10237 		if x1.Op != Op386MOVBloadidx1 {
   10238 			break
   10239 		}
   10240 		i2 := x1.AuxInt
   10241 		s := x1.Aux
   10242 		_ = x1.Args[2]
   10243 		idx := x1.Args[0]
   10244 		p := x1.Args[1]
   10245 		mem := x1.Args[2]
   10246 		x0 := o0.Args[1]
   10247 		if x0.Op != Op386MOVWloadidx1 {
   10248 			break
   10249 		}
   10250 		i0 := x0.AuxInt
   10251 		if x0.Aux != s {
   10252 			break
   10253 		}
   10254 		_ = x0.Args[2]
   10255 		if p != x0.Args[0] {
   10256 			break
   10257 		}
   10258 		if idx != x0.Args[1] {
   10259 			break
   10260 		}
   10261 		if mem != x0.Args[2] {
   10262 			break
   10263 		}
   10264 		s1 := v.Args[1]
   10265 		if s1.Op != Op386SHLLconst {
   10266 			break
   10267 		}
   10268 		if s1.AuxInt != 24 {
   10269 			break
   10270 		}
   10271 		x2 := s1.Args[0]
   10272 		if x2.Op != Op386MOVBloadidx1 {
   10273 			break
   10274 		}
   10275 		i3 := x2.AuxInt
   10276 		if x2.Aux != s {
   10277 			break
   10278 		}
   10279 		_ = x2.Args[2]
   10280 		if p != x2.Args[0] {
   10281 			break
   10282 		}
   10283 		if idx != x2.Args[1] {
   10284 			break
   10285 		}
   10286 		if mem != x2.Args[2] {
   10287 			break
   10288 		}
   10289 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10290 			break
   10291 		}
   10292 		b = mergePoint(b, x0, x1, x2)
   10293 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10294 		v.reset(OpCopy)
   10295 		v.AddArg(v0)
   10296 		v0.AuxInt = i0
   10297 		v0.Aux = s
   10298 		v0.AddArg(p)
   10299 		v0.AddArg(idx)
   10300 		v0.AddArg(mem)
   10301 		return true
   10302 	}
   10303 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   10304 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10305 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10306 	for {
   10307 		_ = v.Args[1]
   10308 		o0 := v.Args[0]
   10309 		if o0.Op != Op386ORL {
   10310 			break
   10311 		}
   10312 		_ = o0.Args[1]
   10313 		s0 := o0.Args[0]
   10314 		if s0.Op != Op386SHLLconst {
   10315 			break
   10316 		}
   10317 		if s0.AuxInt != 16 {
   10318 			break
   10319 		}
   10320 		x1 := s0.Args[0]
   10321 		if x1.Op != Op386MOVBloadidx1 {
   10322 			break
   10323 		}
   10324 		i2 := x1.AuxInt
   10325 		s := x1.Aux
   10326 		_ = x1.Args[2]
   10327 		p := x1.Args[0]
   10328 		idx := x1.Args[1]
   10329 		mem := x1.Args[2]
   10330 		x0 := o0.Args[1]
   10331 		if x0.Op != Op386MOVWloadidx1 {
   10332 			break
   10333 		}
   10334 		i0 := x0.AuxInt
   10335 		if x0.Aux != s {
   10336 			break
   10337 		}
   10338 		_ = x0.Args[2]
   10339 		if idx != x0.Args[0] {
   10340 			break
   10341 		}
   10342 		if p != x0.Args[1] {
   10343 			break
   10344 		}
   10345 		if mem != x0.Args[2] {
   10346 			break
   10347 		}
   10348 		s1 := v.Args[1]
   10349 		if s1.Op != Op386SHLLconst {
   10350 			break
   10351 		}
   10352 		if s1.AuxInt != 24 {
   10353 			break
   10354 		}
   10355 		x2 := s1.Args[0]
   10356 		if x2.Op != Op386MOVBloadidx1 {
   10357 			break
   10358 		}
   10359 		i3 := x2.AuxInt
   10360 		if x2.Aux != s {
   10361 			break
   10362 		}
   10363 		_ = x2.Args[2]
   10364 		if p != x2.Args[0] {
   10365 			break
   10366 		}
   10367 		if idx != x2.Args[1] {
   10368 			break
   10369 		}
   10370 		if mem != x2.Args[2] {
   10371 			break
   10372 		}
   10373 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10374 			break
   10375 		}
   10376 		b = mergePoint(b, x0, x1, x2)
   10377 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10378 		v.reset(OpCopy)
   10379 		v.AddArg(v0)
   10380 		v0.AuxInt = i0
   10381 		v0.Aux = s
   10382 		v0.AddArg(p)
   10383 		v0.AddArg(idx)
   10384 		v0.AddArg(mem)
   10385 		return true
   10386 	}
   10387 	return false
   10388 }
   10389 func rewriteValue386_Op386ORL_30(v *Value) bool {
   10390 	b := v.Block
   10391 	_ = b
   10392 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
   10393 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10394 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10395 	for {
   10396 		_ = v.Args[1]
   10397 		o0 := v.Args[0]
   10398 		if o0.Op != Op386ORL {
   10399 			break
   10400 		}
   10401 		_ = o0.Args[1]
   10402 		s0 := o0.Args[0]
   10403 		if s0.Op != Op386SHLLconst {
   10404 			break
   10405 		}
   10406 		if s0.AuxInt != 16 {
   10407 			break
   10408 		}
   10409 		x1 := s0.Args[0]
   10410 		if x1.Op != Op386MOVBloadidx1 {
   10411 			break
   10412 		}
   10413 		i2 := x1.AuxInt
   10414 		s := x1.Aux
   10415 		_ = x1.Args[2]
   10416 		idx := x1.Args[0]
   10417 		p := x1.Args[1]
   10418 		mem := x1.Args[2]
   10419 		x0 := o0.Args[1]
   10420 		if x0.Op != Op386MOVWloadidx1 {
   10421 			break
   10422 		}
   10423 		i0 := x0.AuxInt
   10424 		if x0.Aux != s {
   10425 			break
   10426 		}
   10427 		_ = x0.Args[2]
   10428 		if idx != x0.Args[0] {
   10429 			break
   10430 		}
   10431 		if p != x0.Args[1] {
   10432 			break
   10433 		}
   10434 		if mem != x0.Args[2] {
   10435 			break
   10436 		}
   10437 		s1 := v.Args[1]
   10438 		if s1.Op != Op386SHLLconst {
   10439 			break
   10440 		}
   10441 		if s1.AuxInt != 24 {
   10442 			break
   10443 		}
   10444 		x2 := s1.Args[0]
   10445 		if x2.Op != Op386MOVBloadidx1 {
   10446 			break
   10447 		}
   10448 		i3 := x2.AuxInt
   10449 		if x2.Aux != s {
   10450 			break
   10451 		}
   10452 		_ = x2.Args[2]
   10453 		if p != x2.Args[0] {
   10454 			break
   10455 		}
   10456 		if idx != x2.Args[1] {
   10457 			break
   10458 		}
   10459 		if mem != x2.Args[2] {
   10460 			break
   10461 		}
   10462 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10463 			break
   10464 		}
   10465 		b = mergePoint(b, x0, x1, x2)
   10466 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10467 		v.reset(OpCopy)
   10468 		v.AddArg(v0)
   10469 		v0.AuxInt = i0
   10470 		v0.Aux = s
   10471 		v0.AddArg(p)
   10472 		v0.AddArg(idx)
   10473 		v0.AddArg(mem)
   10474 		return true
   10475 	}
   10476 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10477 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10478 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10479 	for {
   10480 		_ = v.Args[1]
   10481 		o0 := v.Args[0]
   10482 		if o0.Op != Op386ORL {
   10483 			break
   10484 		}
   10485 		_ = o0.Args[1]
   10486 		x0 := o0.Args[0]
   10487 		if x0.Op != Op386MOVWloadidx1 {
   10488 			break
   10489 		}
   10490 		i0 := x0.AuxInt
   10491 		s := x0.Aux
   10492 		_ = x0.Args[2]
   10493 		p := x0.Args[0]
   10494 		idx := x0.Args[1]
   10495 		mem := x0.Args[2]
   10496 		s0 := o0.Args[1]
   10497 		if s0.Op != Op386SHLLconst {
   10498 			break
   10499 		}
   10500 		if s0.AuxInt != 16 {
   10501 			break
   10502 		}
   10503 		x1 := s0.Args[0]
   10504 		if x1.Op != Op386MOVBloadidx1 {
   10505 			break
   10506 		}
   10507 		i2 := x1.AuxInt
   10508 		if x1.Aux != s {
   10509 			break
   10510 		}
   10511 		_ = x1.Args[2]
   10512 		if p != x1.Args[0] {
   10513 			break
   10514 		}
   10515 		if idx != x1.Args[1] {
   10516 			break
   10517 		}
   10518 		if mem != x1.Args[2] {
   10519 			break
   10520 		}
   10521 		s1 := v.Args[1]
   10522 		if s1.Op != Op386SHLLconst {
   10523 			break
   10524 		}
   10525 		if s1.AuxInt != 24 {
   10526 			break
   10527 		}
   10528 		x2 := s1.Args[0]
   10529 		if x2.Op != Op386MOVBloadidx1 {
   10530 			break
   10531 		}
   10532 		i3 := x2.AuxInt
   10533 		if x2.Aux != s {
   10534 			break
   10535 		}
   10536 		_ = x2.Args[2]
   10537 		if idx != x2.Args[0] {
   10538 			break
   10539 		}
   10540 		if p != x2.Args[1] {
   10541 			break
   10542 		}
   10543 		if mem != x2.Args[2] {
   10544 			break
   10545 		}
   10546 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10547 			break
   10548 		}
   10549 		b = mergePoint(b, x0, x1, x2)
   10550 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10551 		v.reset(OpCopy)
   10552 		v.AddArg(v0)
   10553 		v0.AuxInt = i0
   10554 		v0.Aux = s
   10555 		v0.AddArg(p)
   10556 		v0.AddArg(idx)
   10557 		v0.AddArg(mem)
   10558 		return true
   10559 	}
   10560 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10561 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10562 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10563 	for {
   10564 		_ = v.Args[1]
   10565 		o0 := v.Args[0]
   10566 		if o0.Op != Op386ORL {
   10567 			break
   10568 		}
   10569 		_ = o0.Args[1]
   10570 		x0 := o0.Args[0]
   10571 		if x0.Op != Op386MOVWloadidx1 {
   10572 			break
   10573 		}
   10574 		i0 := x0.AuxInt
   10575 		s := x0.Aux
   10576 		_ = x0.Args[2]
   10577 		idx := x0.Args[0]
   10578 		p := x0.Args[1]
   10579 		mem := x0.Args[2]
   10580 		s0 := o0.Args[1]
   10581 		if s0.Op != Op386SHLLconst {
   10582 			break
   10583 		}
   10584 		if s0.AuxInt != 16 {
   10585 			break
   10586 		}
   10587 		x1 := s0.Args[0]
   10588 		if x1.Op != Op386MOVBloadidx1 {
   10589 			break
   10590 		}
   10591 		i2 := x1.AuxInt
   10592 		if x1.Aux != s {
   10593 			break
   10594 		}
   10595 		_ = x1.Args[2]
   10596 		if p != x1.Args[0] {
   10597 			break
   10598 		}
   10599 		if idx != x1.Args[1] {
   10600 			break
   10601 		}
   10602 		if mem != x1.Args[2] {
   10603 			break
   10604 		}
   10605 		s1 := v.Args[1]
   10606 		if s1.Op != Op386SHLLconst {
   10607 			break
   10608 		}
   10609 		if s1.AuxInt != 24 {
   10610 			break
   10611 		}
   10612 		x2 := s1.Args[0]
   10613 		if x2.Op != Op386MOVBloadidx1 {
   10614 			break
   10615 		}
   10616 		i3 := x2.AuxInt
   10617 		if x2.Aux != s {
   10618 			break
   10619 		}
   10620 		_ = x2.Args[2]
   10621 		if idx != x2.Args[0] {
   10622 			break
   10623 		}
   10624 		if p != x2.Args[1] {
   10625 			break
   10626 		}
   10627 		if mem != x2.Args[2] {
   10628 			break
   10629 		}
   10630 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10631 			break
   10632 		}
   10633 		b = mergePoint(b, x0, x1, x2)
   10634 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10635 		v.reset(OpCopy)
   10636 		v.AddArg(v0)
   10637 		v0.AuxInt = i0
   10638 		v0.Aux = s
   10639 		v0.AddArg(p)
   10640 		v0.AddArg(idx)
   10641 		v0.AddArg(mem)
   10642 		return true
   10643 	}
   10644 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10645 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10646 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10647 	for {
   10648 		_ = v.Args[1]
   10649 		o0 := v.Args[0]
   10650 		if o0.Op != Op386ORL {
   10651 			break
   10652 		}
   10653 		_ = o0.Args[1]
   10654 		x0 := o0.Args[0]
   10655 		if x0.Op != Op386MOVWloadidx1 {
   10656 			break
   10657 		}
   10658 		i0 := x0.AuxInt
   10659 		s := x0.Aux
   10660 		_ = x0.Args[2]
   10661 		p := x0.Args[0]
   10662 		idx := x0.Args[1]
   10663 		mem := x0.Args[2]
   10664 		s0 := o0.Args[1]
   10665 		if s0.Op != Op386SHLLconst {
   10666 			break
   10667 		}
   10668 		if s0.AuxInt != 16 {
   10669 			break
   10670 		}
   10671 		x1 := s0.Args[0]
   10672 		if x1.Op != Op386MOVBloadidx1 {
   10673 			break
   10674 		}
   10675 		i2 := x1.AuxInt
   10676 		if x1.Aux != s {
   10677 			break
   10678 		}
   10679 		_ = x1.Args[2]
   10680 		if idx != x1.Args[0] {
   10681 			break
   10682 		}
   10683 		if p != x1.Args[1] {
   10684 			break
   10685 		}
   10686 		if mem != x1.Args[2] {
   10687 			break
   10688 		}
   10689 		s1 := v.Args[1]
   10690 		if s1.Op != Op386SHLLconst {
   10691 			break
   10692 		}
   10693 		if s1.AuxInt != 24 {
   10694 			break
   10695 		}
   10696 		x2 := s1.Args[0]
   10697 		if x2.Op != Op386MOVBloadidx1 {
   10698 			break
   10699 		}
   10700 		i3 := x2.AuxInt
   10701 		if x2.Aux != s {
   10702 			break
   10703 		}
   10704 		_ = x2.Args[2]
   10705 		if idx != x2.Args[0] {
   10706 			break
   10707 		}
   10708 		if p != x2.Args[1] {
   10709 			break
   10710 		}
   10711 		if mem != x2.Args[2] {
   10712 			break
   10713 		}
   10714 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10715 			break
   10716 		}
   10717 		b = mergePoint(b, x0, x1, x2)
   10718 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10719 		v.reset(OpCopy)
   10720 		v.AddArg(v0)
   10721 		v0.AuxInt = i0
   10722 		v0.Aux = s
   10723 		v0.AddArg(p)
   10724 		v0.AddArg(idx)
   10725 		v0.AddArg(mem)
   10726 		return true
   10727 	}
   10728 	// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10729 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10730 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10731 	for {
   10732 		_ = v.Args[1]
   10733 		o0 := v.Args[0]
   10734 		if o0.Op != Op386ORL {
   10735 			break
   10736 		}
   10737 		_ = o0.Args[1]
   10738 		x0 := o0.Args[0]
   10739 		if x0.Op != Op386MOVWloadidx1 {
   10740 			break
   10741 		}
   10742 		i0 := x0.AuxInt
   10743 		s := x0.Aux
   10744 		_ = x0.Args[2]
   10745 		idx := x0.Args[0]
   10746 		p := x0.Args[1]
   10747 		mem := x0.Args[2]
   10748 		s0 := o0.Args[1]
   10749 		if s0.Op != Op386SHLLconst {
   10750 			break
   10751 		}
   10752 		if s0.AuxInt != 16 {
   10753 			break
   10754 		}
   10755 		x1 := s0.Args[0]
   10756 		if x1.Op != Op386MOVBloadidx1 {
   10757 			break
   10758 		}
   10759 		i2 := x1.AuxInt
   10760 		if x1.Aux != s {
   10761 			break
   10762 		}
   10763 		_ = x1.Args[2]
   10764 		if idx != x1.Args[0] {
   10765 			break
   10766 		}
   10767 		if p != x1.Args[1] {
   10768 			break
   10769 		}
   10770 		if mem != x1.Args[2] {
   10771 			break
   10772 		}
   10773 		s1 := v.Args[1]
   10774 		if s1.Op != Op386SHLLconst {
   10775 			break
   10776 		}
   10777 		if s1.AuxInt != 24 {
   10778 			break
   10779 		}
   10780 		x2 := s1.Args[0]
   10781 		if x2.Op != Op386MOVBloadidx1 {
   10782 			break
   10783 		}
   10784 		i3 := x2.AuxInt
   10785 		if x2.Aux != s {
   10786 			break
   10787 		}
   10788 		_ = x2.Args[2]
   10789 		if idx != x2.Args[0] {
   10790 			break
   10791 		}
   10792 		if p != x2.Args[1] {
   10793 			break
   10794 		}
   10795 		if mem != x2.Args[2] {
   10796 			break
   10797 		}
   10798 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10799 			break
   10800 		}
   10801 		b = mergePoint(b, x0, x1, x2)
   10802 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10803 		v.reset(OpCopy)
   10804 		v.AddArg(v0)
   10805 		v0.AuxInt = i0
   10806 		v0.Aux = s
   10807 		v0.AddArg(p)
   10808 		v0.AddArg(idx)
   10809 		v0.AddArg(mem)
   10810 		return true
   10811 	}
   10812 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10813 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10814 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10815 	for {
   10816 		_ = v.Args[1]
   10817 		o0 := v.Args[0]
   10818 		if o0.Op != Op386ORL {
   10819 			break
   10820 		}
   10821 		_ = o0.Args[1]
   10822 		s0 := o0.Args[0]
   10823 		if s0.Op != Op386SHLLconst {
   10824 			break
   10825 		}
   10826 		if s0.AuxInt != 16 {
   10827 			break
   10828 		}
   10829 		x1 := s0.Args[0]
   10830 		if x1.Op != Op386MOVBloadidx1 {
   10831 			break
   10832 		}
   10833 		i2 := x1.AuxInt
   10834 		s := x1.Aux
   10835 		_ = x1.Args[2]
   10836 		p := x1.Args[0]
   10837 		idx := x1.Args[1]
   10838 		mem := x1.Args[2]
   10839 		x0 := o0.Args[1]
   10840 		if x0.Op != Op386MOVWloadidx1 {
   10841 			break
   10842 		}
   10843 		i0 := x0.AuxInt
   10844 		if x0.Aux != s {
   10845 			break
   10846 		}
   10847 		_ = x0.Args[2]
   10848 		if p != x0.Args[0] {
   10849 			break
   10850 		}
   10851 		if idx != x0.Args[1] {
   10852 			break
   10853 		}
   10854 		if mem != x0.Args[2] {
   10855 			break
   10856 		}
   10857 		s1 := v.Args[1]
   10858 		if s1.Op != Op386SHLLconst {
   10859 			break
   10860 		}
   10861 		if s1.AuxInt != 24 {
   10862 			break
   10863 		}
   10864 		x2 := s1.Args[0]
   10865 		if x2.Op != Op386MOVBloadidx1 {
   10866 			break
   10867 		}
   10868 		i3 := x2.AuxInt
   10869 		if x2.Aux != s {
   10870 			break
   10871 		}
   10872 		_ = x2.Args[2]
   10873 		if idx != x2.Args[0] {
   10874 			break
   10875 		}
   10876 		if p != x2.Args[1] {
   10877 			break
   10878 		}
   10879 		if mem != x2.Args[2] {
   10880 			break
   10881 		}
   10882 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10883 			break
   10884 		}
   10885 		b = mergePoint(b, x0, x1, x2)
   10886 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10887 		v.reset(OpCopy)
   10888 		v.AddArg(v0)
   10889 		v0.AuxInt = i0
   10890 		v0.Aux = s
   10891 		v0.AddArg(p)
   10892 		v0.AddArg(idx)
   10893 		v0.AddArg(mem)
   10894 		return true
   10895 	}
   10896 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10897 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10898 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10899 	for {
   10900 		_ = v.Args[1]
   10901 		o0 := v.Args[0]
   10902 		if o0.Op != Op386ORL {
   10903 			break
   10904 		}
   10905 		_ = o0.Args[1]
   10906 		s0 := o0.Args[0]
   10907 		if s0.Op != Op386SHLLconst {
   10908 			break
   10909 		}
   10910 		if s0.AuxInt != 16 {
   10911 			break
   10912 		}
   10913 		x1 := s0.Args[0]
   10914 		if x1.Op != Op386MOVBloadidx1 {
   10915 			break
   10916 		}
   10917 		i2 := x1.AuxInt
   10918 		s := x1.Aux
   10919 		_ = x1.Args[2]
   10920 		idx := x1.Args[0]
   10921 		p := x1.Args[1]
   10922 		mem := x1.Args[2]
   10923 		x0 := o0.Args[1]
   10924 		if x0.Op != Op386MOVWloadidx1 {
   10925 			break
   10926 		}
   10927 		i0 := x0.AuxInt
   10928 		if x0.Aux != s {
   10929 			break
   10930 		}
   10931 		_ = x0.Args[2]
   10932 		if p != x0.Args[0] {
   10933 			break
   10934 		}
   10935 		if idx != x0.Args[1] {
   10936 			break
   10937 		}
   10938 		if mem != x0.Args[2] {
   10939 			break
   10940 		}
   10941 		s1 := v.Args[1]
   10942 		if s1.Op != Op386SHLLconst {
   10943 			break
   10944 		}
   10945 		if s1.AuxInt != 24 {
   10946 			break
   10947 		}
   10948 		x2 := s1.Args[0]
   10949 		if x2.Op != Op386MOVBloadidx1 {
   10950 			break
   10951 		}
   10952 		i3 := x2.AuxInt
   10953 		if x2.Aux != s {
   10954 			break
   10955 		}
   10956 		_ = x2.Args[2]
   10957 		if idx != x2.Args[0] {
   10958 			break
   10959 		}
   10960 		if p != x2.Args[1] {
   10961 			break
   10962 		}
   10963 		if mem != x2.Args[2] {
   10964 			break
   10965 		}
   10966 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   10967 			break
   10968 		}
   10969 		b = mergePoint(b, x0, x1, x2)
   10970 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   10971 		v.reset(OpCopy)
   10972 		v.AddArg(v0)
   10973 		v0.AuxInt = i0
   10974 		v0.Aux = s
   10975 		v0.AddArg(p)
   10976 		v0.AddArg(idx)
   10977 		v0.AddArg(mem)
   10978 		return true
   10979 	}
   10980 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   10981 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   10982 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   10983 	for {
   10984 		_ = v.Args[1]
   10985 		o0 := v.Args[0]
   10986 		if o0.Op != Op386ORL {
   10987 			break
   10988 		}
   10989 		_ = o0.Args[1]
   10990 		s0 := o0.Args[0]
   10991 		if s0.Op != Op386SHLLconst {
   10992 			break
   10993 		}
   10994 		if s0.AuxInt != 16 {
   10995 			break
   10996 		}
   10997 		x1 := s0.Args[0]
   10998 		if x1.Op != Op386MOVBloadidx1 {
   10999 			break
   11000 		}
   11001 		i2 := x1.AuxInt
   11002 		s := x1.Aux
   11003 		_ = x1.Args[2]
   11004 		p := x1.Args[0]
   11005 		idx := x1.Args[1]
   11006 		mem := x1.Args[2]
   11007 		x0 := o0.Args[1]
   11008 		if x0.Op != Op386MOVWloadidx1 {
   11009 			break
   11010 		}
   11011 		i0 := x0.AuxInt
   11012 		if x0.Aux != s {
   11013 			break
   11014 		}
   11015 		_ = x0.Args[2]
   11016 		if idx != x0.Args[0] {
   11017 			break
   11018 		}
   11019 		if p != x0.Args[1] {
   11020 			break
   11021 		}
   11022 		if mem != x0.Args[2] {
   11023 			break
   11024 		}
   11025 		s1 := v.Args[1]
   11026 		if s1.Op != Op386SHLLconst {
   11027 			break
   11028 		}
   11029 		if s1.AuxInt != 24 {
   11030 			break
   11031 		}
   11032 		x2 := s1.Args[0]
   11033 		if x2.Op != Op386MOVBloadidx1 {
   11034 			break
   11035 		}
   11036 		i3 := x2.AuxInt
   11037 		if x2.Aux != s {
   11038 			break
   11039 		}
   11040 		_ = x2.Args[2]
   11041 		if idx != x2.Args[0] {
   11042 			break
   11043 		}
   11044 		if p != x2.Args[1] {
   11045 			break
   11046 		}
   11047 		if mem != x2.Args[2] {
   11048 			break
   11049 		}
   11050 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11051 			break
   11052 		}
   11053 		b = mergePoint(b, x0, x1, x2)
   11054 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11055 		v.reset(OpCopy)
   11056 		v.AddArg(v0)
   11057 		v0.AuxInt = i0
   11058 		v0.Aux = s
   11059 		v0.AddArg(p)
   11060 		v0.AddArg(idx)
   11061 		v0.AddArg(mem)
   11062 		return true
   11063 	}
   11064 	// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)))
   11065 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11066 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11067 	for {
   11068 		_ = v.Args[1]
   11069 		o0 := v.Args[0]
   11070 		if o0.Op != Op386ORL {
   11071 			break
   11072 		}
   11073 		_ = o0.Args[1]
   11074 		s0 := o0.Args[0]
   11075 		if s0.Op != Op386SHLLconst {
   11076 			break
   11077 		}
   11078 		if s0.AuxInt != 16 {
   11079 			break
   11080 		}
   11081 		x1 := s0.Args[0]
   11082 		if x1.Op != Op386MOVBloadidx1 {
   11083 			break
   11084 		}
   11085 		i2 := x1.AuxInt
   11086 		s := x1.Aux
   11087 		_ = x1.Args[2]
   11088 		idx := x1.Args[0]
   11089 		p := x1.Args[1]
   11090 		mem := x1.Args[2]
   11091 		x0 := o0.Args[1]
   11092 		if x0.Op != Op386MOVWloadidx1 {
   11093 			break
   11094 		}
   11095 		i0 := x0.AuxInt
   11096 		if x0.Aux != s {
   11097 			break
   11098 		}
   11099 		_ = x0.Args[2]
   11100 		if idx != x0.Args[0] {
   11101 			break
   11102 		}
   11103 		if p != x0.Args[1] {
   11104 			break
   11105 		}
   11106 		if mem != x0.Args[2] {
   11107 			break
   11108 		}
   11109 		s1 := v.Args[1]
   11110 		if s1.Op != Op386SHLLconst {
   11111 			break
   11112 		}
   11113 		if s1.AuxInt != 24 {
   11114 			break
   11115 		}
   11116 		x2 := s1.Args[0]
   11117 		if x2.Op != Op386MOVBloadidx1 {
   11118 			break
   11119 		}
   11120 		i3 := x2.AuxInt
   11121 		if x2.Aux != s {
   11122 			break
   11123 		}
   11124 		_ = x2.Args[2]
   11125 		if idx != x2.Args[0] {
   11126 			break
   11127 		}
   11128 		if p != x2.Args[1] {
   11129 			break
   11130 		}
   11131 		if mem != x2.Args[2] {
   11132 			break
   11133 		}
   11134 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11135 			break
   11136 		}
   11137 		b = mergePoint(b, x0, x1, x2)
   11138 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11139 		v.reset(OpCopy)
   11140 		v.AddArg(v0)
   11141 		v0.AuxInt = i0
   11142 		v0.Aux = s
   11143 		v0.AddArg(p)
   11144 		v0.AddArg(idx)
   11145 		v0.AddArg(mem)
   11146 		return true
   11147 	}
   11148 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
   11149 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11150 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11151 	for {
   11152 		_ = v.Args[1]
   11153 		s1 := v.Args[0]
   11154 		if s1.Op != Op386SHLLconst {
   11155 			break
   11156 		}
   11157 		if s1.AuxInt != 24 {
   11158 			break
   11159 		}
   11160 		x2 := s1.Args[0]
   11161 		if x2.Op != Op386MOVBloadidx1 {
   11162 			break
   11163 		}
   11164 		i3 := x2.AuxInt
   11165 		s := x2.Aux
   11166 		_ = x2.Args[2]
   11167 		p := x2.Args[0]
   11168 		idx := x2.Args[1]
   11169 		mem := x2.Args[2]
   11170 		o0 := v.Args[1]
   11171 		if o0.Op != Op386ORL {
   11172 			break
   11173 		}
   11174 		_ = o0.Args[1]
   11175 		x0 := o0.Args[0]
   11176 		if x0.Op != Op386MOVWloadidx1 {
   11177 			break
   11178 		}
   11179 		i0 := x0.AuxInt
   11180 		if x0.Aux != s {
   11181 			break
   11182 		}
   11183 		_ = x0.Args[2]
   11184 		if p != x0.Args[0] {
   11185 			break
   11186 		}
   11187 		if idx != x0.Args[1] {
   11188 			break
   11189 		}
   11190 		if mem != x0.Args[2] {
   11191 			break
   11192 		}
   11193 		s0 := o0.Args[1]
   11194 		if s0.Op != Op386SHLLconst {
   11195 			break
   11196 		}
   11197 		if s0.AuxInt != 16 {
   11198 			break
   11199 		}
   11200 		x1 := s0.Args[0]
   11201 		if x1.Op != Op386MOVBloadidx1 {
   11202 			break
   11203 		}
   11204 		i2 := x1.AuxInt
   11205 		if x1.Aux != s {
   11206 			break
   11207 		}
   11208 		_ = x1.Args[2]
   11209 		if p != x1.Args[0] {
   11210 			break
   11211 		}
   11212 		if idx != x1.Args[1] {
   11213 			break
   11214 		}
   11215 		if mem != x1.Args[2] {
   11216 			break
   11217 		}
   11218 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11219 			break
   11220 		}
   11221 		b = mergePoint(b, x0, x1, x2)
   11222 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11223 		v.reset(OpCopy)
   11224 		v.AddArg(v0)
   11225 		v0.AuxInt = i0
   11226 		v0.Aux = s
   11227 		v0.AddArg(p)
   11228 		v0.AddArg(idx)
   11229 		v0.AddArg(mem)
   11230 		return true
   11231 	}
   11232 	return false
   11233 }
   11234 func rewriteValue386_Op386ORL_40(v *Value) bool {
   11235 	b := v.Block
   11236 	_ = b
   11237 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
   11238 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11239 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11240 	for {
   11241 		_ = v.Args[1]
   11242 		s1 := v.Args[0]
   11243 		if s1.Op != Op386SHLLconst {
   11244 			break
   11245 		}
   11246 		if s1.AuxInt != 24 {
   11247 			break
   11248 		}
   11249 		x2 := s1.Args[0]
   11250 		if x2.Op != Op386MOVBloadidx1 {
   11251 			break
   11252 		}
   11253 		i3 := x2.AuxInt
   11254 		s := x2.Aux
   11255 		_ = x2.Args[2]
   11256 		idx := x2.Args[0]
   11257 		p := x2.Args[1]
   11258 		mem := x2.Args[2]
   11259 		o0 := v.Args[1]
   11260 		if o0.Op != Op386ORL {
   11261 			break
   11262 		}
   11263 		_ = o0.Args[1]
   11264 		x0 := o0.Args[0]
   11265 		if x0.Op != Op386MOVWloadidx1 {
   11266 			break
   11267 		}
   11268 		i0 := x0.AuxInt
   11269 		if x0.Aux != s {
   11270 			break
   11271 		}
   11272 		_ = x0.Args[2]
   11273 		if p != x0.Args[0] {
   11274 			break
   11275 		}
   11276 		if idx != x0.Args[1] {
   11277 			break
   11278 		}
   11279 		if mem != x0.Args[2] {
   11280 			break
   11281 		}
   11282 		s0 := o0.Args[1]
   11283 		if s0.Op != Op386SHLLconst {
   11284 			break
   11285 		}
   11286 		if s0.AuxInt != 16 {
   11287 			break
   11288 		}
   11289 		x1 := s0.Args[0]
   11290 		if x1.Op != Op386MOVBloadidx1 {
   11291 			break
   11292 		}
   11293 		i2 := x1.AuxInt
   11294 		if x1.Aux != s {
   11295 			break
   11296 		}
   11297 		_ = x1.Args[2]
   11298 		if p != x1.Args[0] {
   11299 			break
   11300 		}
   11301 		if idx != x1.Args[1] {
   11302 			break
   11303 		}
   11304 		if mem != x1.Args[2] {
   11305 			break
   11306 		}
   11307 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11308 			break
   11309 		}
   11310 		b = mergePoint(b, x0, x1, x2)
   11311 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11312 		v.reset(OpCopy)
   11313 		v.AddArg(v0)
   11314 		v0.AuxInt = i0
   11315 		v0.Aux = s
   11316 		v0.AddArg(p)
   11317 		v0.AddArg(idx)
   11318 		v0.AddArg(mem)
   11319 		return true
   11320 	}
   11321 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
   11322 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11323 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11324 	for {
   11325 		_ = v.Args[1]
   11326 		s1 := v.Args[0]
   11327 		if s1.Op != Op386SHLLconst {
   11328 			break
   11329 		}
   11330 		if s1.AuxInt != 24 {
   11331 			break
   11332 		}
   11333 		x2 := s1.Args[0]
   11334 		if x2.Op != Op386MOVBloadidx1 {
   11335 			break
   11336 		}
   11337 		i3 := x2.AuxInt
   11338 		s := x2.Aux
   11339 		_ = x2.Args[2]
   11340 		p := x2.Args[0]
   11341 		idx := x2.Args[1]
   11342 		mem := x2.Args[2]
   11343 		o0 := v.Args[1]
   11344 		if o0.Op != Op386ORL {
   11345 			break
   11346 		}
   11347 		_ = o0.Args[1]
   11348 		x0 := o0.Args[0]
   11349 		if x0.Op != Op386MOVWloadidx1 {
   11350 			break
   11351 		}
   11352 		i0 := x0.AuxInt
   11353 		if x0.Aux != s {
   11354 			break
   11355 		}
   11356 		_ = x0.Args[2]
   11357 		if idx != x0.Args[0] {
   11358 			break
   11359 		}
   11360 		if p != x0.Args[1] {
   11361 			break
   11362 		}
   11363 		if mem != x0.Args[2] {
   11364 			break
   11365 		}
   11366 		s0 := o0.Args[1]
   11367 		if s0.Op != Op386SHLLconst {
   11368 			break
   11369 		}
   11370 		if s0.AuxInt != 16 {
   11371 			break
   11372 		}
   11373 		x1 := s0.Args[0]
   11374 		if x1.Op != Op386MOVBloadidx1 {
   11375 			break
   11376 		}
   11377 		i2 := x1.AuxInt
   11378 		if x1.Aux != s {
   11379 			break
   11380 		}
   11381 		_ = x1.Args[2]
   11382 		if p != x1.Args[0] {
   11383 			break
   11384 		}
   11385 		if idx != x1.Args[1] {
   11386 			break
   11387 		}
   11388 		if mem != x1.Args[2] {
   11389 			break
   11390 		}
   11391 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11392 			break
   11393 		}
   11394 		b = mergePoint(b, x0, x1, x2)
   11395 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11396 		v.reset(OpCopy)
   11397 		v.AddArg(v0)
   11398 		v0.AuxInt = i0
   11399 		v0.Aux = s
   11400 		v0.AddArg(p)
   11401 		v0.AddArg(idx)
   11402 		v0.AddArg(mem)
   11403 		return true
   11404 	}
   11405 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
   11406 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11407 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11408 	for {
   11409 		_ = v.Args[1]
   11410 		s1 := v.Args[0]
   11411 		if s1.Op != Op386SHLLconst {
   11412 			break
   11413 		}
   11414 		if s1.AuxInt != 24 {
   11415 			break
   11416 		}
   11417 		x2 := s1.Args[0]
   11418 		if x2.Op != Op386MOVBloadidx1 {
   11419 			break
   11420 		}
   11421 		i3 := x2.AuxInt
   11422 		s := x2.Aux
   11423 		_ = x2.Args[2]
   11424 		idx := x2.Args[0]
   11425 		p := x2.Args[1]
   11426 		mem := x2.Args[2]
   11427 		o0 := v.Args[1]
   11428 		if o0.Op != Op386ORL {
   11429 			break
   11430 		}
   11431 		_ = o0.Args[1]
   11432 		x0 := o0.Args[0]
   11433 		if x0.Op != Op386MOVWloadidx1 {
   11434 			break
   11435 		}
   11436 		i0 := x0.AuxInt
   11437 		if x0.Aux != s {
   11438 			break
   11439 		}
   11440 		_ = x0.Args[2]
   11441 		if idx != x0.Args[0] {
   11442 			break
   11443 		}
   11444 		if p != x0.Args[1] {
   11445 			break
   11446 		}
   11447 		if mem != x0.Args[2] {
   11448 			break
   11449 		}
   11450 		s0 := o0.Args[1]
   11451 		if s0.Op != Op386SHLLconst {
   11452 			break
   11453 		}
   11454 		if s0.AuxInt != 16 {
   11455 			break
   11456 		}
   11457 		x1 := s0.Args[0]
   11458 		if x1.Op != Op386MOVBloadidx1 {
   11459 			break
   11460 		}
   11461 		i2 := x1.AuxInt
   11462 		if x1.Aux != s {
   11463 			break
   11464 		}
   11465 		_ = x1.Args[2]
   11466 		if p != x1.Args[0] {
   11467 			break
   11468 		}
   11469 		if idx != x1.Args[1] {
   11470 			break
   11471 		}
   11472 		if mem != x1.Args[2] {
   11473 			break
   11474 		}
   11475 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11476 			break
   11477 		}
   11478 		b = mergePoint(b, x0, x1, x2)
   11479 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11480 		v.reset(OpCopy)
   11481 		v.AddArg(v0)
   11482 		v0.AuxInt = i0
   11483 		v0.Aux = s
   11484 		v0.AddArg(p)
   11485 		v0.AddArg(idx)
   11486 		v0.AddArg(mem)
   11487 		return true
   11488 	}
   11489 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))))
   11490 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11491 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11492 	for {
   11493 		_ = v.Args[1]
   11494 		s1 := v.Args[0]
   11495 		if s1.Op != Op386SHLLconst {
   11496 			break
   11497 		}
   11498 		if s1.AuxInt != 24 {
   11499 			break
   11500 		}
   11501 		x2 := s1.Args[0]
   11502 		if x2.Op != Op386MOVBloadidx1 {
   11503 			break
   11504 		}
   11505 		i3 := x2.AuxInt
   11506 		s := x2.Aux
   11507 		_ = x2.Args[2]
   11508 		p := x2.Args[0]
   11509 		idx := x2.Args[1]
   11510 		mem := x2.Args[2]
   11511 		o0 := v.Args[1]
   11512 		if o0.Op != Op386ORL {
   11513 			break
   11514 		}
   11515 		_ = o0.Args[1]
   11516 		x0 := o0.Args[0]
   11517 		if x0.Op != Op386MOVWloadidx1 {
   11518 			break
   11519 		}
   11520 		i0 := x0.AuxInt
   11521 		if x0.Aux != s {
   11522 			break
   11523 		}
   11524 		_ = x0.Args[2]
   11525 		if p != x0.Args[0] {
   11526 			break
   11527 		}
   11528 		if idx != x0.Args[1] {
   11529 			break
   11530 		}
   11531 		if mem != x0.Args[2] {
   11532 			break
   11533 		}
   11534 		s0 := o0.Args[1]
   11535 		if s0.Op != Op386SHLLconst {
   11536 			break
   11537 		}
   11538 		if s0.AuxInt != 16 {
   11539 			break
   11540 		}
   11541 		x1 := s0.Args[0]
   11542 		if x1.Op != Op386MOVBloadidx1 {
   11543 			break
   11544 		}
   11545 		i2 := x1.AuxInt
   11546 		if x1.Aux != s {
   11547 			break
   11548 		}
   11549 		_ = x1.Args[2]
   11550 		if idx != x1.Args[0] {
   11551 			break
   11552 		}
   11553 		if p != x1.Args[1] {
   11554 			break
   11555 		}
   11556 		if mem != x1.Args[2] {
   11557 			break
   11558 		}
   11559 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11560 			break
   11561 		}
   11562 		b = mergePoint(b, x0, x1, x2)
   11563 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11564 		v.reset(OpCopy)
   11565 		v.AddArg(v0)
   11566 		v0.AuxInt = i0
   11567 		v0.Aux = s
   11568 		v0.AddArg(p)
   11569 		v0.AddArg(idx)
   11570 		v0.AddArg(mem)
   11571 		return true
   11572 	}
   11573 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))))
   11574 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11575 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11576 	for {
   11577 		_ = v.Args[1]
   11578 		s1 := v.Args[0]
   11579 		if s1.Op != Op386SHLLconst {
   11580 			break
   11581 		}
   11582 		if s1.AuxInt != 24 {
   11583 			break
   11584 		}
   11585 		x2 := s1.Args[0]
   11586 		if x2.Op != Op386MOVBloadidx1 {
   11587 			break
   11588 		}
   11589 		i3 := x2.AuxInt
   11590 		s := x2.Aux
   11591 		_ = x2.Args[2]
   11592 		idx := x2.Args[0]
   11593 		p := x2.Args[1]
   11594 		mem := x2.Args[2]
   11595 		o0 := v.Args[1]
   11596 		if o0.Op != Op386ORL {
   11597 			break
   11598 		}
   11599 		_ = o0.Args[1]
   11600 		x0 := o0.Args[0]
   11601 		if x0.Op != Op386MOVWloadidx1 {
   11602 			break
   11603 		}
   11604 		i0 := x0.AuxInt
   11605 		if x0.Aux != s {
   11606 			break
   11607 		}
   11608 		_ = x0.Args[2]
   11609 		if p != x0.Args[0] {
   11610 			break
   11611 		}
   11612 		if idx != x0.Args[1] {
   11613 			break
   11614 		}
   11615 		if mem != x0.Args[2] {
   11616 			break
   11617 		}
   11618 		s0 := o0.Args[1]
   11619 		if s0.Op != Op386SHLLconst {
   11620 			break
   11621 		}
   11622 		if s0.AuxInt != 16 {
   11623 			break
   11624 		}
   11625 		x1 := s0.Args[0]
   11626 		if x1.Op != Op386MOVBloadidx1 {
   11627 			break
   11628 		}
   11629 		i2 := x1.AuxInt
   11630 		if x1.Aux != s {
   11631 			break
   11632 		}
   11633 		_ = x1.Args[2]
   11634 		if idx != x1.Args[0] {
   11635 			break
   11636 		}
   11637 		if p != x1.Args[1] {
   11638 			break
   11639 		}
   11640 		if mem != x1.Args[2] {
   11641 			break
   11642 		}
   11643 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11644 			break
   11645 		}
   11646 		b = mergePoint(b, x0, x1, x2)
   11647 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11648 		v.reset(OpCopy)
   11649 		v.AddArg(v0)
   11650 		v0.AuxInt = i0
   11651 		v0.Aux = s
   11652 		v0.AddArg(p)
   11653 		v0.AddArg(idx)
   11654 		v0.AddArg(mem)
   11655 		return true
   11656 	}
   11657 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))))
   11658 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11659 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11660 	for {
   11661 		_ = v.Args[1]
   11662 		s1 := v.Args[0]
   11663 		if s1.Op != Op386SHLLconst {
   11664 			break
   11665 		}
   11666 		if s1.AuxInt != 24 {
   11667 			break
   11668 		}
   11669 		x2 := s1.Args[0]
   11670 		if x2.Op != Op386MOVBloadidx1 {
   11671 			break
   11672 		}
   11673 		i3 := x2.AuxInt
   11674 		s := x2.Aux
   11675 		_ = x2.Args[2]
   11676 		p := x2.Args[0]
   11677 		idx := x2.Args[1]
   11678 		mem := x2.Args[2]
   11679 		o0 := v.Args[1]
   11680 		if o0.Op != Op386ORL {
   11681 			break
   11682 		}
   11683 		_ = o0.Args[1]
   11684 		x0 := o0.Args[0]
   11685 		if x0.Op != Op386MOVWloadidx1 {
   11686 			break
   11687 		}
   11688 		i0 := x0.AuxInt
   11689 		if x0.Aux != s {
   11690 			break
   11691 		}
   11692 		_ = x0.Args[2]
   11693 		if idx != x0.Args[0] {
   11694 			break
   11695 		}
   11696 		if p != x0.Args[1] {
   11697 			break
   11698 		}
   11699 		if mem != x0.Args[2] {
   11700 			break
   11701 		}
   11702 		s0 := o0.Args[1]
   11703 		if s0.Op != Op386SHLLconst {
   11704 			break
   11705 		}
   11706 		if s0.AuxInt != 16 {
   11707 			break
   11708 		}
   11709 		x1 := s0.Args[0]
   11710 		if x1.Op != Op386MOVBloadidx1 {
   11711 			break
   11712 		}
   11713 		i2 := x1.AuxInt
   11714 		if x1.Aux != s {
   11715 			break
   11716 		}
   11717 		_ = x1.Args[2]
   11718 		if idx != x1.Args[0] {
   11719 			break
   11720 		}
   11721 		if p != x1.Args[1] {
   11722 			break
   11723 		}
   11724 		if mem != x1.Args[2] {
   11725 			break
   11726 		}
   11727 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11728 			break
   11729 		}
   11730 		b = mergePoint(b, x0, x1, x2)
   11731 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11732 		v.reset(OpCopy)
   11733 		v.AddArg(v0)
   11734 		v0.AuxInt = i0
   11735 		v0.Aux = s
   11736 		v0.AddArg(p)
   11737 		v0.AddArg(idx)
   11738 		v0.AddArg(mem)
   11739 		return true
   11740 	}
   11741 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} idx p mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem))))
   11742 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11743 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11744 	for {
   11745 		_ = v.Args[1]
   11746 		s1 := v.Args[0]
   11747 		if s1.Op != Op386SHLLconst {
   11748 			break
   11749 		}
   11750 		if s1.AuxInt != 24 {
   11751 			break
   11752 		}
   11753 		x2 := s1.Args[0]
   11754 		if x2.Op != Op386MOVBloadidx1 {
   11755 			break
   11756 		}
   11757 		i3 := x2.AuxInt
   11758 		s := x2.Aux
   11759 		_ = x2.Args[2]
   11760 		idx := x2.Args[0]
   11761 		p := x2.Args[1]
   11762 		mem := x2.Args[2]
   11763 		o0 := v.Args[1]
   11764 		if o0.Op != Op386ORL {
   11765 			break
   11766 		}
   11767 		_ = o0.Args[1]
   11768 		x0 := o0.Args[0]
   11769 		if x0.Op != Op386MOVWloadidx1 {
   11770 			break
   11771 		}
   11772 		i0 := x0.AuxInt
   11773 		if x0.Aux != s {
   11774 			break
   11775 		}
   11776 		_ = x0.Args[2]
   11777 		if idx != x0.Args[0] {
   11778 			break
   11779 		}
   11780 		if p != x0.Args[1] {
   11781 			break
   11782 		}
   11783 		if mem != x0.Args[2] {
   11784 			break
   11785 		}
   11786 		s0 := o0.Args[1]
   11787 		if s0.Op != Op386SHLLconst {
   11788 			break
   11789 		}
   11790 		if s0.AuxInt != 16 {
   11791 			break
   11792 		}
   11793 		x1 := s0.Args[0]
   11794 		if x1.Op != Op386MOVBloadidx1 {
   11795 			break
   11796 		}
   11797 		i2 := x1.AuxInt
   11798 		if x1.Aux != s {
   11799 			break
   11800 		}
   11801 		_ = x1.Args[2]
   11802 		if idx != x1.Args[0] {
   11803 			break
   11804 		}
   11805 		if p != x1.Args[1] {
   11806 			break
   11807 		}
   11808 		if mem != x1.Args[2] {
   11809 			break
   11810 		}
   11811 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11812 			break
   11813 		}
   11814 		b = mergePoint(b, x0, x1, x2)
   11815 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11816 		v.reset(OpCopy)
   11817 		v.AddArg(v0)
   11818 		v0.AuxInt = i0
   11819 		v0.Aux = s
   11820 		v0.AddArg(p)
   11821 		v0.AddArg(idx)
   11822 		v0.AddArg(mem)
   11823 		return true
   11824 	}
   11825 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
   11826 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11827 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11828 	for {
   11829 		_ = v.Args[1]
   11830 		s1 := v.Args[0]
   11831 		if s1.Op != Op386SHLLconst {
   11832 			break
   11833 		}
   11834 		if s1.AuxInt != 24 {
   11835 			break
   11836 		}
   11837 		x2 := s1.Args[0]
   11838 		if x2.Op != Op386MOVBloadidx1 {
   11839 			break
   11840 		}
   11841 		i3 := x2.AuxInt
   11842 		s := x2.Aux
   11843 		_ = x2.Args[2]
   11844 		p := x2.Args[0]
   11845 		idx := x2.Args[1]
   11846 		mem := x2.Args[2]
   11847 		o0 := v.Args[1]
   11848 		if o0.Op != Op386ORL {
   11849 			break
   11850 		}
   11851 		_ = o0.Args[1]
   11852 		s0 := o0.Args[0]
   11853 		if s0.Op != Op386SHLLconst {
   11854 			break
   11855 		}
   11856 		if s0.AuxInt != 16 {
   11857 			break
   11858 		}
   11859 		x1 := s0.Args[0]
   11860 		if x1.Op != Op386MOVBloadidx1 {
   11861 			break
   11862 		}
   11863 		i2 := x1.AuxInt
   11864 		if x1.Aux != s {
   11865 			break
   11866 		}
   11867 		_ = x1.Args[2]
   11868 		if p != x1.Args[0] {
   11869 			break
   11870 		}
   11871 		if idx != x1.Args[1] {
   11872 			break
   11873 		}
   11874 		if mem != x1.Args[2] {
   11875 			break
   11876 		}
   11877 		x0 := o0.Args[1]
   11878 		if x0.Op != Op386MOVWloadidx1 {
   11879 			break
   11880 		}
   11881 		i0 := x0.AuxInt
   11882 		if x0.Aux != s {
   11883 			break
   11884 		}
   11885 		_ = x0.Args[2]
   11886 		if p != x0.Args[0] {
   11887 			break
   11888 		}
   11889 		if idx != x0.Args[1] {
   11890 			break
   11891 		}
   11892 		if mem != x0.Args[2] {
   11893 			break
   11894 		}
   11895 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11896 			break
   11897 		}
   11898 		b = mergePoint(b, x0, x1, x2)
   11899 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11900 		v.reset(OpCopy)
   11901 		v.AddArg(v0)
   11902 		v0.AuxInt = i0
   11903 		v0.Aux = s
   11904 		v0.AddArg(p)
   11905 		v0.AddArg(idx)
   11906 		v0.AddArg(mem)
   11907 		return true
   11908 	}
   11909 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
   11910 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11911 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11912 	for {
   11913 		_ = v.Args[1]
   11914 		s1 := v.Args[0]
   11915 		if s1.Op != Op386SHLLconst {
   11916 			break
   11917 		}
   11918 		if s1.AuxInt != 24 {
   11919 			break
   11920 		}
   11921 		x2 := s1.Args[0]
   11922 		if x2.Op != Op386MOVBloadidx1 {
   11923 			break
   11924 		}
   11925 		i3 := x2.AuxInt
   11926 		s := x2.Aux
   11927 		_ = x2.Args[2]
   11928 		idx := x2.Args[0]
   11929 		p := x2.Args[1]
   11930 		mem := x2.Args[2]
   11931 		o0 := v.Args[1]
   11932 		if o0.Op != Op386ORL {
   11933 			break
   11934 		}
   11935 		_ = o0.Args[1]
   11936 		s0 := o0.Args[0]
   11937 		if s0.Op != Op386SHLLconst {
   11938 			break
   11939 		}
   11940 		if s0.AuxInt != 16 {
   11941 			break
   11942 		}
   11943 		x1 := s0.Args[0]
   11944 		if x1.Op != Op386MOVBloadidx1 {
   11945 			break
   11946 		}
   11947 		i2 := x1.AuxInt
   11948 		if x1.Aux != s {
   11949 			break
   11950 		}
   11951 		_ = x1.Args[2]
   11952 		if p != x1.Args[0] {
   11953 			break
   11954 		}
   11955 		if idx != x1.Args[1] {
   11956 			break
   11957 		}
   11958 		if mem != x1.Args[2] {
   11959 			break
   11960 		}
   11961 		x0 := o0.Args[1]
   11962 		if x0.Op != Op386MOVWloadidx1 {
   11963 			break
   11964 		}
   11965 		i0 := x0.AuxInt
   11966 		if x0.Aux != s {
   11967 			break
   11968 		}
   11969 		_ = x0.Args[2]
   11970 		if p != x0.Args[0] {
   11971 			break
   11972 		}
   11973 		if idx != x0.Args[1] {
   11974 			break
   11975 		}
   11976 		if mem != x0.Args[2] {
   11977 			break
   11978 		}
   11979 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   11980 			break
   11981 		}
   11982 		b = mergePoint(b, x0, x1, x2)
   11983 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   11984 		v.reset(OpCopy)
   11985 		v.AddArg(v0)
   11986 		v0.AuxInt = i0
   11987 		v0.Aux = s
   11988 		v0.AddArg(p)
   11989 		v0.AddArg(idx)
   11990 		v0.AddArg(mem)
   11991 		return true
   11992 	}
   11993 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
   11994 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   11995 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   11996 	for {
   11997 		_ = v.Args[1]
   11998 		s1 := v.Args[0]
   11999 		if s1.Op != Op386SHLLconst {
   12000 			break
   12001 		}
   12002 		if s1.AuxInt != 24 {
   12003 			break
   12004 		}
   12005 		x2 := s1.Args[0]
   12006 		if x2.Op != Op386MOVBloadidx1 {
   12007 			break
   12008 		}
   12009 		i3 := x2.AuxInt
   12010 		s := x2.Aux
   12011 		_ = x2.Args[2]
   12012 		p := x2.Args[0]
   12013 		idx := x2.Args[1]
   12014 		mem := x2.Args[2]
   12015 		o0 := v.Args[1]
   12016 		if o0.Op != Op386ORL {
   12017 			break
   12018 		}
   12019 		_ = o0.Args[1]
   12020 		s0 := o0.Args[0]
   12021 		if s0.Op != Op386SHLLconst {
   12022 			break
   12023 		}
   12024 		if s0.AuxInt != 16 {
   12025 			break
   12026 		}
   12027 		x1 := s0.Args[0]
   12028 		if x1.Op != Op386MOVBloadidx1 {
   12029 			break
   12030 		}
   12031 		i2 := x1.AuxInt
   12032 		if x1.Aux != s {
   12033 			break
   12034 		}
   12035 		_ = x1.Args[2]
   12036 		if idx != x1.Args[0] {
   12037 			break
   12038 		}
   12039 		if p != x1.Args[1] {
   12040 			break
   12041 		}
   12042 		if mem != x1.Args[2] {
   12043 			break
   12044 		}
   12045 		x0 := o0.Args[1]
   12046 		if x0.Op != Op386MOVWloadidx1 {
   12047 			break
   12048 		}
   12049 		i0 := x0.AuxInt
   12050 		if x0.Aux != s {
   12051 			break
   12052 		}
   12053 		_ = x0.Args[2]
   12054 		if p != x0.Args[0] {
   12055 			break
   12056 		}
   12057 		if idx != x0.Args[1] {
   12058 			break
   12059 		}
   12060 		if mem != x0.Args[2] {
   12061 			break
   12062 		}
   12063 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   12064 			break
   12065 		}
   12066 		b = mergePoint(b, x0, x1, x2)
   12067 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   12068 		v.reset(OpCopy)
   12069 		v.AddArg(v0)
   12070 		v0.AuxInt = i0
   12071 		v0.Aux = s
   12072 		v0.AddArg(p)
   12073 		v0.AddArg(idx)
   12074 		v0.AddArg(mem)
   12075 		return true
   12076 	}
   12077 	return false
   12078 }
   12079 func rewriteValue386_Op386ORL_50(v *Value) bool {
   12080 	b := v.Block
   12081 	_ = b
   12082 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
   12083 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   12084 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   12085 	for {
   12086 		_ = v.Args[1]
   12087 		s1 := v.Args[0]
   12088 		if s1.Op != Op386SHLLconst {
   12089 			break
   12090 		}
   12091 		if s1.AuxInt != 24 {
   12092 			break
   12093 		}
   12094 		x2 := s1.Args[0]
   12095 		if x2.Op != Op386MOVBloadidx1 {
   12096 			break
   12097 		}
   12098 		i3 := x2.AuxInt
   12099 		s := x2.Aux
   12100 		_ = x2.Args[2]
   12101 		idx := x2.Args[0]
   12102 		p := x2.Args[1]
   12103 		mem := x2.Args[2]
   12104 		o0 := v.Args[1]
   12105 		if o0.Op != Op386ORL {
   12106 			break
   12107 		}
   12108 		_ = o0.Args[1]
   12109 		s0 := o0.Args[0]
   12110 		if s0.Op != Op386SHLLconst {
   12111 			break
   12112 		}
   12113 		if s0.AuxInt != 16 {
   12114 			break
   12115 		}
   12116 		x1 := s0.Args[0]
   12117 		if x1.Op != Op386MOVBloadidx1 {
   12118 			break
   12119 		}
   12120 		i2 := x1.AuxInt
   12121 		if x1.Aux != s {
   12122 			break
   12123 		}
   12124 		_ = x1.Args[2]
   12125 		if idx != x1.Args[0] {
   12126 			break
   12127 		}
   12128 		if p != x1.Args[1] {
   12129 			break
   12130 		}
   12131 		if mem != x1.Args[2] {
   12132 			break
   12133 		}
   12134 		x0 := o0.Args[1]
   12135 		if x0.Op != Op386MOVWloadidx1 {
   12136 			break
   12137 		}
   12138 		i0 := x0.AuxInt
   12139 		if x0.Aux != s {
   12140 			break
   12141 		}
   12142 		_ = x0.Args[2]
   12143 		if p != x0.Args[0] {
   12144 			break
   12145 		}
   12146 		if idx != x0.Args[1] {
   12147 			break
   12148 		}
   12149 		if mem != x0.Args[2] {
   12150 			break
   12151 		}
   12152 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   12153 			break
   12154 		}
   12155 		b = mergePoint(b, x0, x1, x2)
   12156 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   12157 		v.reset(OpCopy)
   12158 		v.AddArg(v0)
   12159 		v0.AuxInt = i0
   12160 		v0.Aux = s
   12161 		v0.AddArg(p)
   12162 		v0.AddArg(idx)
   12163 		v0.AddArg(mem)
   12164 		return true
   12165 	}
   12166 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)))
   12167 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   12168 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   12169 	for {
   12170 		_ = v.Args[1]
   12171 		s1 := v.Args[0]
   12172 		if s1.Op != Op386SHLLconst {
   12173 			break
   12174 		}
   12175 		if s1.AuxInt != 24 {
   12176 			break
   12177 		}
   12178 		x2 := s1.Args[0]
   12179 		if x2.Op != Op386MOVBloadidx1 {
   12180 			break
   12181 		}
   12182 		i3 := x2.AuxInt
   12183 		s := x2.Aux
   12184 		_ = x2.Args[2]
   12185 		p := x2.Args[0]
   12186 		idx := x2.Args[1]
   12187 		mem := x2.Args[2]
   12188 		o0 := v.Args[1]
   12189 		if o0.Op != Op386ORL {
   12190 			break
   12191 		}
   12192 		_ = o0.Args[1]
   12193 		s0 := o0.Args[0]
   12194 		if s0.Op != Op386SHLLconst {
   12195 			break
   12196 		}
   12197 		if s0.AuxInt != 16 {
   12198 			break
   12199 		}
   12200 		x1 := s0.Args[0]
   12201 		if x1.Op != Op386MOVBloadidx1 {
   12202 			break
   12203 		}
   12204 		i2 := x1.AuxInt
   12205 		if x1.Aux != s {
   12206 			break
   12207 		}
   12208 		_ = x1.Args[2]
   12209 		if p != x1.Args[0] {
   12210 			break
   12211 		}
   12212 		if idx != x1.Args[1] {
   12213 			break
   12214 		}
   12215 		if mem != x1.Args[2] {
   12216 			break
   12217 		}
   12218 		x0 := o0.Args[1]
   12219 		if x0.Op != Op386MOVWloadidx1 {
   12220 			break
   12221 		}
   12222 		i0 := x0.AuxInt
   12223 		if x0.Aux != s {
   12224 			break
   12225 		}
   12226 		_ = x0.Args[2]
   12227 		if idx != x0.Args[0] {
   12228 			break
   12229 		}
   12230 		if p != x0.Args[1] {
   12231 			break
   12232 		}
   12233 		if mem != x0.Args[2] {
   12234 			break
   12235 		}
   12236 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   12237 			break
   12238 		}
   12239 		b = mergePoint(b, x0, x1, x2)
   12240 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   12241 		v.reset(OpCopy)
   12242 		v.AddArg(v0)
   12243 		v0.AuxInt = i0
   12244 		v0.Aux = s
   12245 		v0.AddArg(p)
   12246 		v0.AddArg(idx)
   12247 		v0.AddArg(mem)
   12248 		return true
   12249 	}
   12250 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)))
   12251 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   12252 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   12253 	for {
   12254 		_ = v.Args[1]
   12255 		s1 := v.Args[0]
   12256 		if s1.Op != Op386SHLLconst {
   12257 			break
   12258 		}
   12259 		if s1.AuxInt != 24 {
   12260 			break
   12261 		}
   12262 		x2 := s1.Args[0]
   12263 		if x2.Op != Op386MOVBloadidx1 {
   12264 			break
   12265 		}
   12266 		i3 := x2.AuxInt
   12267 		s := x2.Aux
   12268 		_ = x2.Args[2]
   12269 		idx := x2.Args[0]
   12270 		p := x2.Args[1]
   12271 		mem := x2.Args[2]
   12272 		o0 := v.Args[1]
   12273 		if o0.Op != Op386ORL {
   12274 			break
   12275 		}
   12276 		_ = o0.Args[1]
   12277 		s0 := o0.Args[0]
   12278 		if s0.Op != Op386SHLLconst {
   12279 			break
   12280 		}
   12281 		if s0.AuxInt != 16 {
   12282 			break
   12283 		}
   12284 		x1 := s0.Args[0]
   12285 		if x1.Op != Op386MOVBloadidx1 {
   12286 			break
   12287 		}
   12288 		i2 := x1.AuxInt
   12289 		if x1.Aux != s {
   12290 			break
   12291 		}
   12292 		_ = x1.Args[2]
   12293 		if p != x1.Args[0] {
   12294 			break
   12295 		}
   12296 		if idx != x1.Args[1] {
   12297 			break
   12298 		}
   12299 		if mem != x1.Args[2] {
   12300 			break
   12301 		}
   12302 		x0 := o0.Args[1]
   12303 		if x0.Op != Op386MOVWloadidx1 {
   12304 			break
   12305 		}
   12306 		i0 := x0.AuxInt
   12307 		if x0.Aux != s {
   12308 			break
   12309 		}
   12310 		_ = x0.Args[2]
   12311 		if idx != x0.Args[0] {
   12312 			break
   12313 		}
   12314 		if p != x0.Args[1] {
   12315 			break
   12316 		}
   12317 		if mem != x0.Args[2] {
   12318 			break
   12319 		}
   12320 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   12321 			break
   12322 		}
   12323 		b = mergePoint(b, x0, x1, x2)
   12324 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   12325 		v.reset(OpCopy)
   12326 		v.AddArg(v0)
   12327 		v0.AuxInt = i0
   12328 		v0.Aux = s
   12329 		v0.AddArg(p)
   12330 		v0.AddArg(idx)
   12331 		v0.AddArg(mem)
   12332 		return true
   12333 	}
   12334 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)))
   12335 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   12336 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   12337 	for {
   12338 		_ = v.Args[1]
   12339 		s1 := v.Args[0]
   12340 		if s1.Op != Op386SHLLconst {
   12341 			break
   12342 		}
   12343 		if s1.AuxInt != 24 {
   12344 			break
   12345 		}
   12346 		x2 := s1.Args[0]
   12347 		if x2.Op != Op386MOVBloadidx1 {
   12348 			break
   12349 		}
   12350 		i3 := x2.AuxInt
   12351 		s := x2.Aux
   12352 		_ = x2.Args[2]
   12353 		p := x2.Args[0]
   12354 		idx := x2.Args[1]
   12355 		mem := x2.Args[2]
   12356 		o0 := v.Args[1]
   12357 		if o0.Op != Op386ORL {
   12358 			break
   12359 		}
   12360 		_ = o0.Args[1]
   12361 		s0 := o0.Args[0]
   12362 		if s0.Op != Op386SHLLconst {
   12363 			break
   12364 		}
   12365 		if s0.AuxInt != 16 {
   12366 			break
   12367 		}
   12368 		x1 := s0.Args[0]
   12369 		if x1.Op != Op386MOVBloadidx1 {
   12370 			break
   12371 		}
   12372 		i2 := x1.AuxInt
   12373 		if x1.Aux != s {
   12374 			break
   12375 		}
   12376 		_ = x1.Args[2]
   12377 		if idx != x1.Args[0] {
   12378 			break
   12379 		}
   12380 		if p != x1.Args[1] {
   12381 			break
   12382 		}
   12383 		if mem != x1.Args[2] {
   12384 			break
   12385 		}
   12386 		x0 := o0.Args[1]
   12387 		if x0.Op != Op386MOVWloadidx1 {
   12388 			break
   12389 		}
   12390 		i0 := x0.AuxInt
   12391 		if x0.Aux != s {
   12392 			break
   12393 		}
   12394 		_ = x0.Args[2]
   12395 		if idx != x0.Args[0] {
   12396 			break
   12397 		}
   12398 		if p != x0.Args[1] {
   12399 			break
   12400 		}
   12401 		if mem != x0.Args[2] {
   12402 			break
   12403 		}
   12404 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   12405 			break
   12406 		}
   12407 		b = mergePoint(b, x0, x1, x2)
   12408 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   12409 		v.reset(OpCopy)
   12410 		v.AddArg(v0)
   12411 		v0.AuxInt = i0
   12412 		v0.Aux = s
   12413 		v0.AddArg(p)
   12414 		v0.AddArg(idx)
   12415 		v0.AddArg(mem)
   12416 		return true
   12417 	}
   12418 	// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)))
   12419 	// cond: i2 == i0+2   && i3 == i0+3   && x0.Uses == 1   && x1.Uses == 1   && x2.Uses == 1   && s0.Uses == 1   && s1.Uses == 1   && o0.Uses == 1   && mergePoint(b,x0,x1,x2) != nil   && clobber(x0)   && clobber(x1)   && clobber(x2)   && clobber(s0)   && clobber(s1)   && clobber(o0)
   12420 	// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
   12421 	for {
   12422 		_ = v.Args[1]
   12423 		s1 := v.Args[0]
   12424 		if s1.Op != Op386SHLLconst {
   12425 			break
   12426 		}
   12427 		if s1.AuxInt != 24 {
   12428 			break
   12429 		}
   12430 		x2 := s1.Args[0]
   12431 		if x2.Op != Op386MOVBloadidx1 {
   12432 			break
   12433 		}
   12434 		i3 := x2.AuxInt
   12435 		s := x2.Aux
   12436 		_ = x2.Args[2]
   12437 		idx := x2.Args[0]
   12438 		p := x2.Args[1]
   12439 		mem := x2.Args[2]
   12440 		o0 := v.Args[1]
   12441 		if o0.Op != Op386ORL {
   12442 			break
   12443 		}
   12444 		_ = o0.Args[1]
   12445 		s0 := o0.Args[0]
   12446 		if s0.Op != Op386SHLLconst {
   12447 			break
   12448 		}
   12449 		if s0.AuxInt != 16 {
   12450 			break
   12451 		}
   12452 		x1 := s0.Args[0]
   12453 		if x1.Op != Op386MOVBloadidx1 {
   12454 			break
   12455 		}
   12456 		i2 := x1.AuxInt
   12457 		if x1.Aux != s {
   12458 			break
   12459 		}
   12460 		_ = x1.Args[2]
   12461 		if idx != x1.Args[0] {
   12462 			break
   12463 		}
   12464 		if p != x1.Args[1] {
   12465 			break
   12466 		}
   12467 		if mem != x1.Args[2] {
   12468 			break
   12469 		}
   12470 		x0 := o0.Args[1]
   12471 		if x0.Op != Op386MOVWloadidx1 {
   12472 			break
   12473 		}
   12474 		i0 := x0.AuxInt
   12475 		if x0.Aux != s {
   12476 			break
   12477 		}
   12478 		_ = x0.Args[2]
   12479 		if idx != x0.Args[0] {
   12480 			break
   12481 		}
   12482 		if p != x0.Args[1] {
   12483 			break
   12484 		}
   12485 		if mem != x0.Args[2] {
   12486 			break
   12487 		}
   12488 		if !(i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b, x0, x1, x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)) {
   12489 			break
   12490 		}
   12491 		b = mergePoint(b, x0, x1, x2)
   12492 		v0 := b.NewValue0(v.Pos, Op386MOVLloadidx1, v.Type)
   12493 		v.reset(OpCopy)
   12494 		v.AddArg(v0)
   12495 		v0.AuxInt = i0
   12496 		v0.Aux = s
   12497 		v0.AddArg(p)
   12498 		v0.AddArg(idx)
   12499 		v0.AddArg(mem)
   12500 		return true
   12501 	}
   12502 	return false
   12503 }
   12504 func rewriteValue386_Op386ORLconst_0(v *Value) bool {
   12505 	// match: (ORLconst [c] x)
   12506 	// cond: int32(c)==0
   12507 	// result: x
   12508 	for {
   12509 		c := v.AuxInt
   12510 		x := v.Args[0]
   12511 		if !(int32(c) == 0) {
   12512 			break
   12513 		}
   12514 		v.reset(OpCopy)
   12515 		v.Type = x.Type
   12516 		v.AddArg(x)
   12517 		return true
   12518 	}
   12519 	// match: (ORLconst [c] _)
   12520 	// cond: int32(c)==-1
   12521 	// result: (MOVLconst [-1])
   12522 	for {
   12523 		c := v.AuxInt
   12524 		if !(int32(c) == -1) {
   12525 			break
   12526 		}
   12527 		v.reset(Op386MOVLconst)
   12528 		v.AuxInt = -1
   12529 		return true
   12530 	}
   12531 	// match: (ORLconst [c] (MOVLconst [d]))
   12532 	// cond:
   12533 	// result: (MOVLconst [c|d])
   12534 	for {
   12535 		c := v.AuxInt
   12536 		v_0 := v.Args[0]
   12537 		if v_0.Op != Op386MOVLconst {
   12538 			break
   12539 		}
   12540 		d := v_0.AuxInt
   12541 		v.reset(Op386MOVLconst)
   12542 		v.AuxInt = c | d
   12543 		return true
   12544 	}
   12545 	return false
   12546 }
   12547 func rewriteValue386_Op386ROLBconst_0(v *Value) bool {
   12548 	// match: (ROLBconst [c] (ROLBconst [d] x))
   12549 	// cond:
   12550 	// result: (ROLBconst [(c+d)& 7] x)
   12551 	for {
   12552 		c := v.AuxInt
   12553 		v_0 := v.Args[0]
   12554 		if v_0.Op != Op386ROLBconst {
   12555 			break
   12556 		}
   12557 		d := v_0.AuxInt
   12558 		x := v_0.Args[0]
   12559 		v.reset(Op386ROLBconst)
   12560 		v.AuxInt = (c + d) & 7
   12561 		v.AddArg(x)
   12562 		return true
   12563 	}
   12564 	// match: (ROLBconst [0] x)
   12565 	// cond:
   12566 	// result: x
   12567 	for {
   12568 		if v.AuxInt != 0 {
   12569 			break
   12570 		}
   12571 		x := v.Args[0]
   12572 		v.reset(OpCopy)
   12573 		v.Type = x.Type
   12574 		v.AddArg(x)
   12575 		return true
   12576 	}
   12577 	return false
   12578 }
   12579 func rewriteValue386_Op386ROLLconst_0(v *Value) bool {
   12580 	// match: (ROLLconst [c] (ROLLconst [d] x))
   12581 	// cond:
   12582 	// result: (ROLLconst [(c+d)&31] x)
   12583 	for {
   12584 		c := v.AuxInt
   12585 		v_0 := v.Args[0]
   12586 		if v_0.Op != Op386ROLLconst {
   12587 			break
   12588 		}
   12589 		d := v_0.AuxInt
   12590 		x := v_0.Args[0]
   12591 		v.reset(Op386ROLLconst)
   12592 		v.AuxInt = (c + d) & 31
   12593 		v.AddArg(x)
   12594 		return true
   12595 	}
   12596 	// match: (ROLLconst [0] x)
   12597 	// cond:
   12598 	// result: x
   12599 	for {
   12600 		if v.AuxInt != 0 {
   12601 			break
   12602 		}
   12603 		x := v.Args[0]
   12604 		v.reset(OpCopy)
   12605 		v.Type = x.Type
   12606 		v.AddArg(x)
   12607 		return true
   12608 	}
   12609 	return false
   12610 }
   12611 func rewriteValue386_Op386ROLWconst_0(v *Value) bool {
   12612 	// match: (ROLWconst [c] (ROLWconst [d] x))
   12613 	// cond:
   12614 	// result: (ROLWconst [(c+d)&15] x)
   12615 	for {
   12616 		c := v.AuxInt
   12617 		v_0 := v.Args[0]
   12618 		if v_0.Op != Op386ROLWconst {
   12619 			break
   12620 		}
   12621 		d := v_0.AuxInt
   12622 		x := v_0.Args[0]
   12623 		v.reset(Op386ROLWconst)
   12624 		v.AuxInt = (c + d) & 15
   12625 		v.AddArg(x)
   12626 		return true
   12627 	}
   12628 	// match: (ROLWconst [0] x)
   12629 	// cond:
   12630 	// result: x
   12631 	for {
   12632 		if v.AuxInt != 0 {
   12633 			break
   12634 		}
   12635 		x := v.Args[0]
   12636 		v.reset(OpCopy)
   12637 		v.Type = x.Type
   12638 		v.AddArg(x)
   12639 		return true
   12640 	}
   12641 	return false
   12642 }
   12643 func rewriteValue386_Op386SARB_0(v *Value) bool {
   12644 	// match: (SARB x (MOVLconst [c]))
   12645 	// cond:
   12646 	// result: (SARBconst [min(c&31,7)] x)
   12647 	for {
   12648 		_ = v.Args[1]
   12649 		x := v.Args[0]
   12650 		v_1 := v.Args[1]
   12651 		if v_1.Op != Op386MOVLconst {
   12652 			break
   12653 		}
   12654 		c := v_1.AuxInt
   12655 		v.reset(Op386SARBconst)
   12656 		v.AuxInt = min(c&31, 7)
   12657 		v.AddArg(x)
   12658 		return true
   12659 	}
   12660 	return false
   12661 }
   12662 func rewriteValue386_Op386SARBconst_0(v *Value) bool {
   12663 	// match: (SARBconst x [0])
   12664 	// cond:
   12665 	// result: x
   12666 	for {
   12667 		if v.AuxInt != 0 {
   12668 			break
   12669 		}
   12670 		x := v.Args[0]
   12671 		v.reset(OpCopy)
   12672 		v.Type = x.Type
   12673 		v.AddArg(x)
   12674 		return true
   12675 	}
   12676 	// match: (SARBconst [c] (MOVLconst [d]))
   12677 	// cond:
   12678 	// result: (MOVLconst [d>>uint64(c)])
   12679 	for {
   12680 		c := v.AuxInt
   12681 		v_0 := v.Args[0]
   12682 		if v_0.Op != Op386MOVLconst {
   12683 			break
   12684 		}
   12685 		d := v_0.AuxInt
   12686 		v.reset(Op386MOVLconst)
   12687 		v.AuxInt = d >> uint64(c)
   12688 		return true
   12689 	}
   12690 	return false
   12691 }
   12692 func rewriteValue386_Op386SARL_0(v *Value) bool {
   12693 	// match: (SARL x (MOVLconst [c]))
   12694 	// cond:
   12695 	// result: (SARLconst [c&31] x)
   12696 	for {
   12697 		_ = v.Args[1]
   12698 		x := v.Args[0]
   12699 		v_1 := v.Args[1]
   12700 		if v_1.Op != Op386MOVLconst {
   12701 			break
   12702 		}
   12703 		c := v_1.AuxInt
   12704 		v.reset(Op386SARLconst)
   12705 		v.AuxInt = c & 31
   12706 		v.AddArg(x)
   12707 		return true
   12708 	}
   12709 	// match: (SARL x (ANDLconst [31] y))
   12710 	// cond:
   12711 	// result: (SARL x y)
   12712 	for {
   12713 		_ = v.Args[1]
   12714 		x := v.Args[0]
   12715 		v_1 := v.Args[1]
   12716 		if v_1.Op != Op386ANDLconst {
   12717 			break
   12718 		}
   12719 		if v_1.AuxInt != 31 {
   12720 			break
   12721 		}
   12722 		y := v_1.Args[0]
   12723 		v.reset(Op386SARL)
   12724 		v.AddArg(x)
   12725 		v.AddArg(y)
   12726 		return true
   12727 	}
   12728 	return false
   12729 }
   12730 func rewriteValue386_Op386SARLconst_0(v *Value) bool {
   12731 	// match: (SARLconst x [0])
   12732 	// cond:
   12733 	// result: x
   12734 	for {
   12735 		if v.AuxInt != 0 {
   12736 			break
   12737 		}
   12738 		x := v.Args[0]
   12739 		v.reset(OpCopy)
   12740 		v.Type = x.Type
   12741 		v.AddArg(x)
   12742 		return true
   12743 	}
   12744 	// match: (SARLconst [c] (MOVLconst [d]))
   12745 	// cond:
   12746 	// result: (MOVLconst [d>>uint64(c)])
   12747 	for {
   12748 		c := v.AuxInt
   12749 		v_0 := v.Args[0]
   12750 		if v_0.Op != Op386MOVLconst {
   12751 			break
   12752 		}
   12753 		d := v_0.AuxInt
   12754 		v.reset(Op386MOVLconst)
   12755 		v.AuxInt = d >> uint64(c)
   12756 		return true
   12757 	}
   12758 	return false
   12759 }
   12760 func rewriteValue386_Op386SARW_0(v *Value) bool {
   12761 	// match: (SARW x (MOVLconst [c]))
   12762 	// cond:
   12763 	// result: (SARWconst [min(c&31,15)] x)
   12764 	for {
   12765 		_ = v.Args[1]
   12766 		x := v.Args[0]
   12767 		v_1 := v.Args[1]
   12768 		if v_1.Op != Op386MOVLconst {
   12769 			break
   12770 		}
   12771 		c := v_1.AuxInt
   12772 		v.reset(Op386SARWconst)
   12773 		v.AuxInt = min(c&31, 15)
   12774 		v.AddArg(x)
   12775 		return true
   12776 	}
   12777 	return false
   12778 }
   12779 func rewriteValue386_Op386SARWconst_0(v *Value) bool {
   12780 	// match: (SARWconst x [0])
   12781 	// cond:
   12782 	// result: x
   12783 	for {
   12784 		if v.AuxInt != 0 {
   12785 			break
   12786 		}
   12787 		x := v.Args[0]
   12788 		v.reset(OpCopy)
   12789 		v.Type = x.Type
   12790 		v.AddArg(x)
   12791 		return true
   12792 	}
   12793 	// match: (SARWconst [c] (MOVLconst [d]))
   12794 	// cond:
   12795 	// result: (MOVLconst [d>>uint64(c)])
   12796 	for {
   12797 		c := v.AuxInt
   12798 		v_0 := v.Args[0]
   12799 		if v_0.Op != Op386MOVLconst {
   12800 			break
   12801 		}
   12802 		d := v_0.AuxInt
   12803 		v.reset(Op386MOVLconst)
   12804 		v.AuxInt = d >> uint64(c)
   12805 		return true
   12806 	}
   12807 	return false
   12808 }
   12809 func rewriteValue386_Op386SBBL_0(v *Value) bool {
   12810 	// match: (SBBL x (MOVLconst [c]) f)
   12811 	// cond:
   12812 	// result: (SBBLconst [c] x f)
   12813 	for {
   12814 		_ = v.Args[2]
   12815 		x := v.Args[0]
   12816 		v_1 := v.Args[1]
   12817 		if v_1.Op != Op386MOVLconst {
   12818 			break
   12819 		}
   12820 		c := v_1.AuxInt
   12821 		f := v.Args[2]
   12822 		v.reset(Op386SBBLconst)
   12823 		v.AuxInt = c
   12824 		v.AddArg(x)
   12825 		v.AddArg(f)
   12826 		return true
   12827 	}
   12828 	return false
   12829 }
   12830 func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool {
   12831 	// match: (SBBLcarrymask (FlagEQ))
   12832 	// cond:
   12833 	// result: (MOVLconst [0])
   12834 	for {
   12835 		v_0 := v.Args[0]
   12836 		if v_0.Op != Op386FlagEQ {
   12837 			break
   12838 		}
   12839 		v.reset(Op386MOVLconst)
   12840 		v.AuxInt = 0
   12841 		return true
   12842 	}
   12843 	// match: (SBBLcarrymask (FlagLT_ULT))
   12844 	// cond:
   12845 	// result: (MOVLconst [-1])
   12846 	for {
   12847 		v_0 := v.Args[0]
   12848 		if v_0.Op != Op386FlagLT_ULT {
   12849 			break
   12850 		}
   12851 		v.reset(Op386MOVLconst)
   12852 		v.AuxInt = -1
   12853 		return true
   12854 	}
   12855 	// match: (SBBLcarrymask (FlagLT_UGT))
   12856 	// cond:
   12857 	// result: (MOVLconst [0])
   12858 	for {
   12859 		v_0 := v.Args[0]
   12860 		if v_0.Op != Op386FlagLT_UGT {
   12861 			break
   12862 		}
   12863 		v.reset(Op386MOVLconst)
   12864 		v.AuxInt = 0
   12865 		return true
   12866 	}
   12867 	// match: (SBBLcarrymask (FlagGT_ULT))
   12868 	// cond:
   12869 	// result: (MOVLconst [-1])
   12870 	for {
   12871 		v_0 := v.Args[0]
   12872 		if v_0.Op != Op386FlagGT_ULT {
   12873 			break
   12874 		}
   12875 		v.reset(Op386MOVLconst)
   12876 		v.AuxInt = -1
   12877 		return true
   12878 	}
   12879 	// match: (SBBLcarrymask (FlagGT_UGT))
   12880 	// cond:
   12881 	// result: (MOVLconst [0])
   12882 	for {
   12883 		v_0 := v.Args[0]
   12884 		if v_0.Op != Op386FlagGT_UGT {
   12885 			break
   12886 		}
   12887 		v.reset(Op386MOVLconst)
   12888 		v.AuxInt = 0
   12889 		return true
   12890 	}
   12891 	return false
   12892 }
   12893 func rewriteValue386_Op386SETA_0(v *Value) bool {
   12894 	// match: (SETA (InvertFlags x))
   12895 	// cond:
   12896 	// result: (SETB x)
   12897 	for {
   12898 		v_0 := v.Args[0]
   12899 		if v_0.Op != Op386InvertFlags {
   12900 			break
   12901 		}
   12902 		x := v_0.Args[0]
   12903 		v.reset(Op386SETB)
   12904 		v.AddArg(x)
   12905 		return true
   12906 	}
   12907 	// match: (SETA (FlagEQ))
   12908 	// cond:
   12909 	// result: (MOVLconst [0])
   12910 	for {
   12911 		v_0 := v.Args[0]
   12912 		if v_0.Op != Op386FlagEQ {
   12913 			break
   12914 		}
   12915 		v.reset(Op386MOVLconst)
   12916 		v.AuxInt = 0
   12917 		return true
   12918 	}
   12919 	// match: (SETA (FlagLT_ULT))
   12920 	// cond:
   12921 	// result: (MOVLconst [0])
   12922 	for {
   12923 		v_0 := v.Args[0]
   12924 		if v_0.Op != Op386FlagLT_ULT {
   12925 			break
   12926 		}
   12927 		v.reset(Op386MOVLconst)
   12928 		v.AuxInt = 0
   12929 		return true
   12930 	}
   12931 	// match: (SETA (FlagLT_UGT))
   12932 	// cond:
   12933 	// result: (MOVLconst [1])
   12934 	for {
   12935 		v_0 := v.Args[0]
   12936 		if v_0.Op != Op386FlagLT_UGT {
   12937 			break
   12938 		}
   12939 		v.reset(Op386MOVLconst)
   12940 		v.AuxInt = 1
   12941 		return true
   12942 	}
   12943 	// match: (SETA (FlagGT_ULT))
   12944 	// cond:
   12945 	// result: (MOVLconst [0])
   12946 	for {
   12947 		v_0 := v.Args[0]
   12948 		if v_0.Op != Op386FlagGT_ULT {
   12949 			break
   12950 		}
   12951 		v.reset(Op386MOVLconst)
   12952 		v.AuxInt = 0
   12953 		return true
   12954 	}
   12955 	// match: (SETA (FlagGT_UGT))
   12956 	// cond:
   12957 	// result: (MOVLconst [1])
   12958 	for {
   12959 		v_0 := v.Args[0]
   12960 		if v_0.Op != Op386FlagGT_UGT {
   12961 			break
   12962 		}
   12963 		v.reset(Op386MOVLconst)
   12964 		v.AuxInt = 1
   12965 		return true
   12966 	}
   12967 	return false
   12968 }
   12969 func rewriteValue386_Op386SETAE_0(v *Value) bool {
   12970 	// match: (SETAE (InvertFlags x))
   12971 	// cond:
   12972 	// result: (SETBE x)
   12973 	for {
   12974 		v_0 := v.Args[0]
   12975 		if v_0.Op != Op386InvertFlags {
   12976 			break
   12977 		}
   12978 		x := v_0.Args[0]
   12979 		v.reset(Op386SETBE)
   12980 		v.AddArg(x)
   12981 		return true
   12982 	}
   12983 	// match: (SETAE (FlagEQ))
   12984 	// cond:
   12985 	// result: (MOVLconst [1])
   12986 	for {
   12987 		v_0 := v.Args[0]
   12988 		if v_0.Op != Op386FlagEQ {
   12989 			break
   12990 		}
   12991 		v.reset(Op386MOVLconst)
   12992 		v.AuxInt = 1
   12993 		return true
   12994 	}
   12995 	// match: (SETAE (FlagLT_ULT))
   12996 	// cond:
   12997 	// result: (MOVLconst [0])
   12998 	for {
   12999 		v_0 := v.Args[0]
   13000 		if v_0.Op != Op386FlagLT_ULT {
   13001 			break
   13002 		}
   13003 		v.reset(Op386MOVLconst)
   13004 		v.AuxInt = 0
   13005 		return true
   13006 	}
   13007 	// match: (SETAE (FlagLT_UGT))
   13008 	// cond:
   13009 	// result: (MOVLconst [1])
   13010 	for {
   13011 		v_0 := v.Args[0]
   13012 		if v_0.Op != Op386FlagLT_UGT {
   13013 			break
   13014 		}
   13015 		v.reset(Op386MOVLconst)
   13016 		v.AuxInt = 1
   13017 		return true
   13018 	}
   13019 	// match: (SETAE (FlagGT_ULT))
   13020 	// cond:
   13021 	// result: (MOVLconst [0])
   13022 	for {
   13023 		v_0 := v.Args[0]
   13024 		if v_0.Op != Op386FlagGT_ULT {
   13025 			break
   13026 		}
   13027 		v.reset(Op386MOVLconst)
   13028 		v.AuxInt = 0
   13029 		return true
   13030 	}
   13031 	// match: (SETAE (FlagGT_UGT))
   13032 	// cond:
   13033 	// result: (MOVLconst [1])
   13034 	for {
   13035 		v_0 := v.Args[0]
   13036 		if v_0.Op != Op386FlagGT_UGT {
   13037 			break
   13038 		}
   13039 		v.reset(Op386MOVLconst)
   13040 		v.AuxInt = 1
   13041 		return true
   13042 	}
   13043 	return false
   13044 }
   13045 func rewriteValue386_Op386SETB_0(v *Value) bool {
   13046 	// match: (SETB (InvertFlags x))
   13047 	// cond:
   13048 	// result: (SETA x)
   13049 	for {
   13050 		v_0 := v.Args[0]
   13051 		if v_0.Op != Op386InvertFlags {
   13052 			break
   13053 		}
   13054 		x := v_0.Args[0]
   13055 		v.reset(Op386SETA)
   13056 		v.AddArg(x)
   13057 		return true
   13058 	}
   13059 	// match: (SETB (FlagEQ))
   13060 	// cond:
   13061 	// result: (MOVLconst [0])
   13062 	for {
   13063 		v_0 := v.Args[0]
   13064 		if v_0.Op != Op386FlagEQ {
   13065 			break
   13066 		}
   13067 		v.reset(Op386MOVLconst)
   13068 		v.AuxInt = 0
   13069 		return true
   13070 	}
   13071 	// match: (SETB (FlagLT_ULT))
   13072 	// cond:
   13073 	// result: (MOVLconst [1])
   13074 	for {
   13075 		v_0 := v.Args[0]
   13076 		if v_0.Op != Op386FlagLT_ULT {
   13077 			break
   13078 		}
   13079 		v.reset(Op386MOVLconst)
   13080 		v.AuxInt = 1
   13081 		return true
   13082 	}
   13083 	// match: (SETB (FlagLT_UGT))
   13084 	// cond:
   13085 	// result: (MOVLconst [0])
   13086 	for {
   13087 		v_0 := v.Args[0]
   13088 		if v_0.Op != Op386FlagLT_UGT {
   13089 			break
   13090 		}
   13091 		v.reset(Op386MOVLconst)
   13092 		v.AuxInt = 0
   13093 		return true
   13094 	}
   13095 	// match: (SETB (FlagGT_ULT))
   13096 	// cond:
   13097 	// result: (MOVLconst [1])
   13098 	for {
   13099 		v_0 := v.Args[0]
   13100 		if v_0.Op != Op386FlagGT_ULT {
   13101 			break
   13102 		}
   13103 		v.reset(Op386MOVLconst)
   13104 		v.AuxInt = 1
   13105 		return true
   13106 	}
   13107 	// match: (SETB (FlagGT_UGT))
   13108 	// cond:
   13109 	// result: (MOVLconst [0])
   13110 	for {
   13111 		v_0 := v.Args[0]
   13112 		if v_0.Op != Op386FlagGT_UGT {
   13113 			break
   13114 		}
   13115 		v.reset(Op386MOVLconst)
   13116 		v.AuxInt = 0
   13117 		return true
   13118 	}
   13119 	return false
   13120 }
   13121 func rewriteValue386_Op386SETBE_0(v *Value) bool {
   13122 	// match: (SETBE (InvertFlags x))
   13123 	// cond:
   13124 	// result: (SETAE x)
   13125 	for {
   13126 		v_0 := v.Args[0]
   13127 		if v_0.Op != Op386InvertFlags {
   13128 			break
   13129 		}
   13130 		x := v_0.Args[0]
   13131 		v.reset(Op386SETAE)
   13132 		v.AddArg(x)
   13133 		return true
   13134 	}
   13135 	// match: (SETBE (FlagEQ))
   13136 	// cond:
   13137 	// result: (MOVLconst [1])
   13138 	for {
   13139 		v_0 := v.Args[0]
   13140 		if v_0.Op != Op386FlagEQ {
   13141 			break
   13142 		}
   13143 		v.reset(Op386MOVLconst)
   13144 		v.AuxInt = 1
   13145 		return true
   13146 	}
   13147 	// match: (SETBE (FlagLT_ULT))
   13148 	// cond:
   13149 	// result: (MOVLconst [1])
   13150 	for {
   13151 		v_0 := v.Args[0]
   13152 		if v_0.Op != Op386FlagLT_ULT {
   13153 			break
   13154 		}
   13155 		v.reset(Op386MOVLconst)
   13156 		v.AuxInt = 1
   13157 		return true
   13158 	}
   13159 	// match: (SETBE (FlagLT_UGT))
   13160 	// cond:
   13161 	// result: (MOVLconst [0])
   13162 	for {
   13163 		v_0 := v.Args[0]
   13164 		if v_0.Op != Op386FlagLT_UGT {
   13165 			break
   13166 		}
   13167 		v.reset(Op386MOVLconst)
   13168 		v.AuxInt = 0
   13169 		return true
   13170 	}
   13171 	// match: (SETBE (FlagGT_ULT))
   13172 	// cond:
   13173 	// result: (MOVLconst [1])
   13174 	for {
   13175 		v_0 := v.Args[0]
   13176 		if v_0.Op != Op386FlagGT_ULT {
   13177 			break
   13178 		}
   13179 		v.reset(Op386MOVLconst)
   13180 		v.AuxInt = 1
   13181 		return true
   13182 	}
   13183 	// match: (SETBE (FlagGT_UGT))
   13184 	// cond:
   13185 	// result: (MOVLconst [0])
   13186 	for {
   13187 		v_0 := v.Args[0]
   13188 		if v_0.Op != Op386FlagGT_UGT {
   13189 			break
   13190 		}
   13191 		v.reset(Op386MOVLconst)
   13192 		v.AuxInt = 0
   13193 		return true
   13194 	}
   13195 	return false
   13196 }
   13197 func rewriteValue386_Op386SETEQ_0(v *Value) bool {
   13198 	// match: (SETEQ (InvertFlags x))
   13199 	// cond:
   13200 	// result: (SETEQ x)
   13201 	for {
   13202 		v_0 := v.Args[0]
   13203 		if v_0.Op != Op386InvertFlags {
   13204 			break
   13205 		}
   13206 		x := v_0.Args[0]
   13207 		v.reset(Op386SETEQ)
   13208 		v.AddArg(x)
   13209 		return true
   13210 	}
   13211 	// match: (SETEQ (FlagEQ))
   13212 	// cond:
   13213 	// result: (MOVLconst [1])
   13214 	for {
   13215 		v_0 := v.Args[0]
   13216 		if v_0.Op != Op386FlagEQ {
   13217 			break
   13218 		}
   13219 		v.reset(Op386MOVLconst)
   13220 		v.AuxInt = 1
   13221 		return true
   13222 	}
   13223 	// match: (SETEQ (FlagLT_ULT))
   13224 	// cond:
   13225 	// result: (MOVLconst [0])
   13226 	for {
   13227 		v_0 := v.Args[0]
   13228 		if v_0.Op != Op386FlagLT_ULT {
   13229 			break
   13230 		}
   13231 		v.reset(Op386MOVLconst)
   13232 		v.AuxInt = 0
   13233 		return true
   13234 	}
   13235 	// match: (SETEQ (FlagLT_UGT))
   13236 	// cond:
   13237 	// result: (MOVLconst [0])
   13238 	for {
   13239 		v_0 := v.Args[0]
   13240 		if v_0.Op != Op386FlagLT_UGT {
   13241 			break
   13242 		}
   13243 		v.reset(Op386MOVLconst)
   13244 		v.AuxInt = 0
   13245 		return true
   13246 	}
   13247 	// match: (SETEQ (FlagGT_ULT))
   13248 	// cond:
   13249 	// result: (MOVLconst [0])
   13250 	for {
   13251 		v_0 := v.Args[0]
   13252 		if v_0.Op != Op386FlagGT_ULT {
   13253 			break
   13254 		}
   13255 		v.reset(Op386MOVLconst)
   13256 		v.AuxInt = 0
   13257 		return true
   13258 	}
   13259 	// match: (SETEQ (FlagGT_UGT))
   13260 	// cond:
   13261 	// result: (MOVLconst [0])
   13262 	for {
   13263 		v_0 := v.Args[0]
   13264 		if v_0.Op != Op386FlagGT_UGT {
   13265 			break
   13266 		}
   13267 		v.reset(Op386MOVLconst)
   13268 		v.AuxInt = 0
   13269 		return true
   13270 	}
   13271 	return false
   13272 }
   13273 func rewriteValue386_Op386SETG_0(v *Value) bool {
   13274 	// match: (SETG (InvertFlags x))
   13275 	// cond:
   13276 	// result: (SETL x)
   13277 	for {
   13278 		v_0 := v.Args[0]
   13279 		if v_0.Op != Op386InvertFlags {
   13280 			break
   13281 		}
   13282 		x := v_0.Args[0]
   13283 		v.reset(Op386SETL)
   13284 		v.AddArg(x)
   13285 		return true
   13286 	}
   13287 	// match: (SETG (FlagEQ))
   13288 	// cond:
   13289 	// result: (MOVLconst [0])
   13290 	for {
   13291 		v_0 := v.Args[0]
   13292 		if v_0.Op != Op386FlagEQ {
   13293 			break
   13294 		}
   13295 		v.reset(Op386MOVLconst)
   13296 		v.AuxInt = 0
   13297 		return true
   13298 	}
   13299 	// match: (SETG (FlagLT_ULT))
   13300 	// cond:
   13301 	// result: (MOVLconst [0])
   13302 	for {
   13303 		v_0 := v.Args[0]
   13304 		if v_0.Op != Op386FlagLT_ULT {
   13305 			break
   13306 		}
   13307 		v.reset(Op386MOVLconst)
   13308 		v.AuxInt = 0
   13309 		return true
   13310 	}
   13311 	// match: (SETG (FlagLT_UGT))
   13312 	// cond:
   13313 	// result: (MOVLconst [0])
   13314 	for {
   13315 		v_0 := v.Args[0]
   13316 		if v_0.Op != Op386FlagLT_UGT {
   13317 			break
   13318 		}
   13319 		v.reset(Op386MOVLconst)
   13320 		v.AuxInt = 0
   13321 		return true
   13322 	}
   13323 	// match: (SETG (FlagGT_ULT))
   13324 	// cond:
   13325 	// result: (MOVLconst [1])
   13326 	for {
   13327 		v_0 := v.Args[0]
   13328 		if v_0.Op != Op386FlagGT_ULT {
   13329 			break
   13330 		}
   13331 		v.reset(Op386MOVLconst)
   13332 		v.AuxInt = 1
   13333 		return true
   13334 	}
   13335 	// match: (SETG (FlagGT_UGT))
   13336 	// cond:
   13337 	// result: (MOVLconst [1])
   13338 	for {
   13339 		v_0 := v.Args[0]
   13340 		if v_0.Op != Op386FlagGT_UGT {
   13341 			break
   13342 		}
   13343 		v.reset(Op386MOVLconst)
   13344 		v.AuxInt = 1
   13345 		return true
   13346 	}
   13347 	return false
   13348 }
   13349 func rewriteValue386_Op386SETGE_0(v *Value) bool {
   13350 	// match: (SETGE (InvertFlags x))
   13351 	// cond:
   13352 	// result: (SETLE x)
   13353 	for {
   13354 		v_0 := v.Args[0]
   13355 		if v_0.Op != Op386InvertFlags {
   13356 			break
   13357 		}
   13358 		x := v_0.Args[0]
   13359 		v.reset(Op386SETLE)
   13360 		v.AddArg(x)
   13361 		return true
   13362 	}
   13363 	// match: (SETGE (FlagEQ))
   13364 	// cond:
   13365 	// result: (MOVLconst [1])
   13366 	for {
   13367 		v_0 := v.Args[0]
   13368 		if v_0.Op != Op386FlagEQ {
   13369 			break
   13370 		}
   13371 		v.reset(Op386MOVLconst)
   13372 		v.AuxInt = 1
   13373 		return true
   13374 	}
   13375 	// match: (SETGE (FlagLT_ULT))
   13376 	// cond:
   13377 	// result: (MOVLconst [0])
   13378 	for {
   13379 		v_0 := v.Args[0]
   13380 		if v_0.Op != Op386FlagLT_ULT {
   13381 			break
   13382 		}
   13383 		v.reset(Op386MOVLconst)
   13384 		v.AuxInt = 0
   13385 		return true
   13386 	}
   13387 	// match: (SETGE (FlagLT_UGT))
   13388 	// cond:
   13389 	// result: (MOVLconst [0])
   13390 	for {
   13391 		v_0 := v.Args[0]
   13392 		if v_0.Op != Op386FlagLT_UGT {
   13393 			break
   13394 		}
   13395 		v.reset(Op386MOVLconst)
   13396 		v.AuxInt = 0
   13397 		return true
   13398 	}
   13399 	// match: (SETGE (FlagGT_ULT))
   13400 	// cond:
   13401 	// result: (MOVLconst [1])
   13402 	for {
   13403 		v_0 := v.Args[0]
   13404 		if v_0.Op != Op386FlagGT_ULT {
   13405 			break
   13406 		}
   13407 		v.reset(Op386MOVLconst)
   13408 		v.AuxInt = 1
   13409 		return true
   13410 	}
   13411 	// match: (SETGE (FlagGT_UGT))
   13412 	// cond:
   13413 	// result: (MOVLconst [1])
   13414 	for {
   13415 		v_0 := v.Args[0]
   13416 		if v_0.Op != Op386FlagGT_UGT {
   13417 			break
   13418 		}
   13419 		v.reset(Op386MOVLconst)
   13420 		v.AuxInt = 1
   13421 		return true
   13422 	}
   13423 	return false
   13424 }
   13425 func rewriteValue386_Op386SETL_0(v *Value) bool {
   13426 	// match: (SETL (InvertFlags x))
   13427 	// cond:
   13428 	// result: (SETG x)
   13429 	for {
   13430 		v_0 := v.Args[0]
   13431 		if v_0.Op != Op386InvertFlags {
   13432 			break
   13433 		}
   13434 		x := v_0.Args[0]
   13435 		v.reset(Op386SETG)
   13436 		v.AddArg(x)
   13437 		return true
   13438 	}
   13439 	// match: (SETL (FlagEQ))
   13440 	// cond:
   13441 	// result: (MOVLconst [0])
   13442 	for {
   13443 		v_0 := v.Args[0]
   13444 		if v_0.Op != Op386FlagEQ {
   13445 			break
   13446 		}
   13447 		v.reset(Op386MOVLconst)
   13448 		v.AuxInt = 0
   13449 		return true
   13450 	}
   13451 	// match: (SETL (FlagLT_ULT))
   13452 	// cond:
   13453 	// result: (MOVLconst [1])
   13454 	for {
   13455 		v_0 := v.Args[0]
   13456 		if v_0.Op != Op386FlagLT_ULT {
   13457 			break
   13458 		}
   13459 		v.reset(Op386MOVLconst)
   13460 		v.AuxInt = 1
   13461 		return true
   13462 	}
   13463 	// match: (SETL (FlagLT_UGT))
   13464 	// cond:
   13465 	// result: (MOVLconst [1])
   13466 	for {
   13467 		v_0 := v.Args[0]
   13468 		if v_0.Op != Op386FlagLT_UGT {
   13469 			break
   13470 		}
   13471 		v.reset(Op386MOVLconst)
   13472 		v.AuxInt = 1
   13473 		return true
   13474 	}
   13475 	// match: (SETL (FlagGT_ULT))
   13476 	// cond:
   13477 	// result: (MOVLconst [0])
   13478 	for {
   13479 		v_0 := v.Args[0]
   13480 		if v_0.Op != Op386FlagGT_ULT {
   13481 			break
   13482 		}
   13483 		v.reset(Op386MOVLconst)
   13484 		v.AuxInt = 0
   13485 		return true
   13486 	}
   13487 	// match: (SETL (FlagGT_UGT))
   13488 	// cond:
   13489 	// result: (MOVLconst [0])
   13490 	for {
   13491 		v_0 := v.Args[0]
   13492 		if v_0.Op != Op386FlagGT_UGT {
   13493 			break
   13494 		}
   13495 		v.reset(Op386MOVLconst)
   13496 		v.AuxInt = 0
   13497 		return true
   13498 	}
   13499 	return false
   13500 }
   13501 func rewriteValue386_Op386SETLE_0(v *Value) bool {
   13502 	// match: (SETLE (InvertFlags x))
   13503 	// cond:
   13504 	// result: (SETGE x)
   13505 	for {
   13506 		v_0 := v.Args[0]
   13507 		if v_0.Op != Op386InvertFlags {
   13508 			break
   13509 		}
   13510 		x := v_0.Args[0]
   13511 		v.reset(Op386SETGE)
   13512 		v.AddArg(x)
   13513 		return true
   13514 	}
   13515 	// match: (SETLE (FlagEQ))
   13516 	// cond:
   13517 	// result: (MOVLconst [1])
   13518 	for {
   13519 		v_0 := v.Args[0]
   13520 		if v_0.Op != Op386FlagEQ {
   13521 			break
   13522 		}
   13523 		v.reset(Op386MOVLconst)
   13524 		v.AuxInt = 1
   13525 		return true
   13526 	}
   13527 	// match: (SETLE (FlagLT_ULT))
   13528 	// cond:
   13529 	// result: (MOVLconst [1])
   13530 	for {
   13531 		v_0 := v.Args[0]
   13532 		if v_0.Op != Op386FlagLT_ULT {
   13533 			break
   13534 		}
   13535 		v.reset(Op386MOVLconst)
   13536 		v.AuxInt = 1
   13537 		return true
   13538 	}
   13539 	// match: (SETLE (FlagLT_UGT))
   13540 	// cond:
   13541 	// result: (MOVLconst [1])
   13542 	for {
   13543 		v_0 := v.Args[0]
   13544 		if v_0.Op != Op386FlagLT_UGT {
   13545 			break
   13546 		}
   13547 		v.reset(Op386MOVLconst)
   13548 		v.AuxInt = 1
   13549 		return true
   13550 	}
   13551 	// match: (SETLE (FlagGT_ULT))
   13552 	// cond:
   13553 	// result: (MOVLconst [0])
   13554 	for {
   13555 		v_0 := v.Args[0]
   13556 		if v_0.Op != Op386FlagGT_ULT {
   13557 			break
   13558 		}
   13559 		v.reset(Op386MOVLconst)
   13560 		v.AuxInt = 0
   13561 		return true
   13562 	}
   13563 	// match: (SETLE (FlagGT_UGT))
   13564 	// cond:
   13565 	// result: (MOVLconst [0])
   13566 	for {
   13567 		v_0 := v.Args[0]
   13568 		if v_0.Op != Op386FlagGT_UGT {
   13569 			break
   13570 		}
   13571 		v.reset(Op386MOVLconst)
   13572 		v.AuxInt = 0
   13573 		return true
   13574 	}
   13575 	return false
   13576 }
   13577 func rewriteValue386_Op386SETNE_0(v *Value) bool {
   13578 	// match: (SETNE (InvertFlags x))
   13579 	// cond:
   13580 	// result: (SETNE x)
   13581 	for {
   13582 		v_0 := v.Args[0]
   13583 		if v_0.Op != Op386InvertFlags {
   13584 			break
   13585 		}
   13586 		x := v_0.Args[0]
   13587 		v.reset(Op386SETNE)
   13588 		v.AddArg(x)
   13589 		return true
   13590 	}
   13591 	// match: (SETNE (FlagEQ))
   13592 	// cond:
   13593 	// result: (MOVLconst [0])
   13594 	for {
   13595 		v_0 := v.Args[0]
   13596 		if v_0.Op != Op386FlagEQ {
   13597 			break
   13598 		}
   13599 		v.reset(Op386MOVLconst)
   13600 		v.AuxInt = 0
   13601 		return true
   13602 	}
   13603 	// match: (SETNE (FlagLT_ULT))
   13604 	// cond:
   13605 	// result: (MOVLconst [1])
   13606 	for {
   13607 		v_0 := v.Args[0]
   13608 		if v_0.Op != Op386FlagLT_ULT {
   13609 			break
   13610 		}
   13611 		v.reset(Op386MOVLconst)
   13612 		v.AuxInt = 1
   13613 		return true
   13614 	}
   13615 	// match: (SETNE (FlagLT_UGT))
   13616 	// cond:
   13617 	// result: (MOVLconst [1])
   13618 	for {
   13619 		v_0 := v.Args[0]
   13620 		if v_0.Op != Op386FlagLT_UGT {
   13621 			break
   13622 		}
   13623 		v.reset(Op386MOVLconst)
   13624 		v.AuxInt = 1
   13625 		return true
   13626 	}
   13627 	// match: (SETNE (FlagGT_ULT))
   13628 	// cond:
   13629 	// result: (MOVLconst [1])
   13630 	for {
   13631 		v_0 := v.Args[0]
   13632 		if v_0.Op != Op386FlagGT_ULT {
   13633 			break
   13634 		}
   13635 		v.reset(Op386MOVLconst)
   13636 		v.AuxInt = 1
   13637 		return true
   13638 	}
   13639 	// match: (SETNE (FlagGT_UGT))
   13640 	// cond:
   13641 	// result: (MOVLconst [1])
   13642 	for {
   13643 		v_0 := v.Args[0]
   13644 		if v_0.Op != Op386FlagGT_UGT {
   13645 			break
   13646 		}
   13647 		v.reset(Op386MOVLconst)
   13648 		v.AuxInt = 1
   13649 		return true
   13650 	}
   13651 	return false
   13652 }
   13653 func rewriteValue386_Op386SHLL_0(v *Value) bool {
   13654 	// match: (SHLL x (MOVLconst [c]))
   13655 	// cond:
   13656 	// result: (SHLLconst [c&31] x)
   13657 	for {
   13658 		_ = v.Args[1]
   13659 		x := v.Args[0]
   13660 		v_1 := v.Args[1]
   13661 		if v_1.Op != Op386MOVLconst {
   13662 			break
   13663 		}
   13664 		c := v_1.AuxInt
   13665 		v.reset(Op386SHLLconst)
   13666 		v.AuxInt = c & 31
   13667 		v.AddArg(x)
   13668 		return true
   13669 	}
   13670 	// match: (SHLL x (ANDLconst [31] y))
   13671 	// cond:
   13672 	// result: (SHLL x y)
   13673 	for {
   13674 		_ = v.Args[1]
   13675 		x := v.Args[0]
   13676 		v_1 := v.Args[1]
   13677 		if v_1.Op != Op386ANDLconst {
   13678 			break
   13679 		}
   13680 		if v_1.AuxInt != 31 {
   13681 			break
   13682 		}
   13683 		y := v_1.Args[0]
   13684 		v.reset(Op386SHLL)
   13685 		v.AddArg(x)
   13686 		v.AddArg(y)
   13687 		return true
   13688 	}
   13689 	return false
   13690 }
   13691 func rewriteValue386_Op386SHLLconst_0(v *Value) bool {
   13692 	// match: (SHLLconst x [0])
   13693 	// cond:
   13694 	// result: x
   13695 	for {
   13696 		if v.AuxInt != 0 {
   13697 			break
   13698 		}
   13699 		x := v.Args[0]
   13700 		v.reset(OpCopy)
   13701 		v.Type = x.Type
   13702 		v.AddArg(x)
   13703 		return true
   13704 	}
   13705 	return false
   13706 }
   13707 func rewriteValue386_Op386SHRB_0(v *Value) bool {
   13708 	// match: (SHRB x (MOVLconst [c]))
   13709 	// cond: c&31 < 8
   13710 	// result: (SHRBconst [c&31] x)
   13711 	for {
   13712 		_ = v.Args[1]
   13713 		x := v.Args[0]
   13714 		v_1 := v.Args[1]
   13715 		if v_1.Op != Op386MOVLconst {
   13716 			break
   13717 		}
   13718 		c := v_1.AuxInt
   13719 		if !(c&31 < 8) {
   13720 			break
   13721 		}
   13722 		v.reset(Op386SHRBconst)
   13723 		v.AuxInt = c & 31
   13724 		v.AddArg(x)
   13725 		return true
   13726 	}
   13727 	// match: (SHRB _ (MOVLconst [c]))
   13728 	// cond: c&31 >= 8
   13729 	// result: (MOVLconst [0])
   13730 	for {
   13731 		_ = v.Args[1]
   13732 		v_1 := v.Args[1]
   13733 		if v_1.Op != Op386MOVLconst {
   13734 			break
   13735 		}
   13736 		c := v_1.AuxInt
   13737 		if !(c&31 >= 8) {
   13738 			break
   13739 		}
   13740 		v.reset(Op386MOVLconst)
   13741 		v.AuxInt = 0
   13742 		return true
   13743 	}
   13744 	return false
   13745 }
   13746 func rewriteValue386_Op386SHRBconst_0(v *Value) bool {
   13747 	// match: (SHRBconst x [0])
   13748 	// cond:
   13749 	// result: x
   13750 	for {
   13751 		if v.AuxInt != 0 {
   13752 			break
   13753 		}
   13754 		x := v.Args[0]
   13755 		v.reset(OpCopy)
   13756 		v.Type = x.Type
   13757 		v.AddArg(x)
   13758 		return true
   13759 	}
   13760 	return false
   13761 }
   13762 func rewriteValue386_Op386SHRL_0(v *Value) bool {
   13763 	// match: (SHRL x (MOVLconst [c]))
   13764 	// cond:
   13765 	// result: (SHRLconst [c&31] x)
   13766 	for {
   13767 		_ = v.Args[1]
   13768 		x := v.Args[0]
   13769 		v_1 := v.Args[1]
   13770 		if v_1.Op != Op386MOVLconst {
   13771 			break
   13772 		}
   13773 		c := v_1.AuxInt
   13774 		v.reset(Op386SHRLconst)
   13775 		v.AuxInt = c & 31
   13776 		v.AddArg(x)
   13777 		return true
   13778 	}
   13779 	// match: (SHRL x (ANDLconst [31] y))
   13780 	// cond:
   13781 	// result: (SHRL x y)
   13782 	for {
   13783 		_ = v.Args[1]
   13784 		x := v.Args[0]
   13785 		v_1 := v.Args[1]
   13786 		if v_1.Op != Op386ANDLconst {
   13787 			break
   13788 		}
   13789 		if v_1.AuxInt != 31 {
   13790 			break
   13791 		}
   13792 		y := v_1.Args[0]
   13793 		v.reset(Op386SHRL)
   13794 		v.AddArg(x)
   13795 		v.AddArg(y)
   13796 		return true
   13797 	}
   13798 	return false
   13799 }
   13800 func rewriteValue386_Op386SHRLconst_0(v *Value) bool {
   13801 	// match: (SHRLconst x [0])
   13802 	// cond:
   13803 	// result: x
   13804 	for {
   13805 		if v.AuxInt != 0 {
   13806 			break
   13807 		}
   13808 		x := v.Args[0]
   13809 		v.reset(OpCopy)
   13810 		v.Type = x.Type
   13811 		v.AddArg(x)
   13812 		return true
   13813 	}
   13814 	return false
   13815 }
   13816 func rewriteValue386_Op386SHRW_0(v *Value) bool {
   13817 	// match: (SHRW x (MOVLconst [c]))
   13818 	// cond: c&31 < 16
   13819 	// result: (SHRWconst [c&31] x)
   13820 	for {
   13821 		_ = v.Args[1]
   13822 		x := v.Args[0]
   13823 		v_1 := v.Args[1]
   13824 		if v_1.Op != Op386MOVLconst {
   13825 			break
   13826 		}
   13827 		c := v_1.AuxInt
   13828 		if !(c&31 < 16) {
   13829 			break
   13830 		}
   13831 		v.reset(Op386SHRWconst)
   13832 		v.AuxInt = c & 31
   13833 		v.AddArg(x)
   13834 		return true
   13835 	}
   13836 	// match: (SHRW _ (MOVLconst [c]))
   13837 	// cond: c&31 >= 16
   13838 	// result: (MOVLconst [0])
   13839 	for {
   13840 		_ = v.Args[1]
   13841 		v_1 := v.Args[1]
   13842 		if v_1.Op != Op386MOVLconst {
   13843 			break
   13844 		}
   13845 		c := v_1.AuxInt
   13846 		if !(c&31 >= 16) {
   13847 			break
   13848 		}
   13849 		v.reset(Op386MOVLconst)
   13850 		v.AuxInt = 0
   13851 		return true
   13852 	}
   13853 	return false
   13854 }
   13855 func rewriteValue386_Op386SHRWconst_0(v *Value) bool {
   13856 	// match: (SHRWconst x [0])
   13857 	// cond:
   13858 	// result: x
   13859 	for {
   13860 		if v.AuxInt != 0 {
   13861 			break
   13862 		}
   13863 		x := v.Args[0]
   13864 		v.reset(OpCopy)
   13865 		v.Type = x.Type
   13866 		v.AddArg(x)
   13867 		return true
   13868 	}
   13869 	return false
   13870 }
   13871 func rewriteValue386_Op386SUBL_0(v *Value) bool {
   13872 	b := v.Block
   13873 	_ = b
   13874 	// match: (SUBL x (MOVLconst [c]))
   13875 	// cond:
   13876 	// result: (SUBLconst x [c])
   13877 	for {
   13878 		_ = v.Args[1]
   13879 		x := v.Args[0]
   13880 		v_1 := v.Args[1]
   13881 		if v_1.Op != Op386MOVLconst {
   13882 			break
   13883 		}
   13884 		c := v_1.AuxInt
   13885 		v.reset(Op386SUBLconst)
   13886 		v.AuxInt = c
   13887 		v.AddArg(x)
   13888 		return true
   13889 	}
   13890 	// match: (SUBL (MOVLconst [c]) x)
   13891 	// cond:
   13892 	// result: (NEGL (SUBLconst <v.Type> x [c]))
   13893 	for {
   13894 		_ = v.Args[1]
   13895 		v_0 := v.Args[0]
   13896 		if v_0.Op != Op386MOVLconst {
   13897 			break
   13898 		}
   13899 		c := v_0.AuxInt
   13900 		x := v.Args[1]
   13901 		v.reset(Op386NEGL)
   13902 		v0 := b.NewValue0(v.Pos, Op386SUBLconst, v.Type)
   13903 		v0.AuxInt = c
   13904 		v0.AddArg(x)
   13905 		v.AddArg(v0)
   13906 		return true
   13907 	}
   13908 	// match: (SUBL x x)
   13909 	// cond:
   13910 	// result: (MOVLconst [0])
   13911 	for {
   13912 		_ = v.Args[1]
   13913 		x := v.Args[0]
   13914 		if x != v.Args[1] {
   13915 			break
   13916 		}
   13917 		v.reset(Op386MOVLconst)
   13918 		v.AuxInt = 0
   13919 		return true
   13920 	}
   13921 	return false
   13922 }
   13923 func rewriteValue386_Op386SUBLcarry_0(v *Value) bool {
   13924 	// match: (SUBLcarry x (MOVLconst [c]))
   13925 	// cond:
   13926 	// result: (SUBLconstcarry [c] x)
   13927 	for {
   13928 		_ = v.Args[1]
   13929 		x := v.Args[0]
   13930 		v_1 := v.Args[1]
   13931 		if v_1.Op != Op386MOVLconst {
   13932 			break
   13933 		}
   13934 		c := v_1.AuxInt
   13935 		v.reset(Op386SUBLconstcarry)
   13936 		v.AuxInt = c
   13937 		v.AddArg(x)
   13938 		return true
   13939 	}
   13940 	return false
   13941 }
   13942 func rewriteValue386_Op386SUBLconst_0(v *Value) bool {
   13943 	// match: (SUBLconst [c] x)
   13944 	// cond: int32(c) == 0
   13945 	// result: x
   13946 	for {
   13947 		c := v.AuxInt
   13948 		x := v.Args[0]
   13949 		if !(int32(c) == 0) {
   13950 			break
   13951 		}
   13952 		v.reset(OpCopy)
   13953 		v.Type = x.Type
   13954 		v.AddArg(x)
   13955 		return true
   13956 	}
   13957 	// match: (SUBLconst [c] x)
   13958 	// cond:
   13959 	// result: (ADDLconst [int64(int32(-c))] x)
   13960 	for {
   13961 		c := v.AuxInt
   13962 		x := v.Args[0]
   13963 		v.reset(Op386ADDLconst)
   13964 		v.AuxInt = int64(int32(-c))
   13965 		v.AddArg(x)
   13966 		return true
   13967 	}
   13968 }
   13969 func rewriteValue386_Op386XORL_0(v *Value) bool {
   13970 	// match: (XORL x (MOVLconst [c]))
   13971 	// cond:
   13972 	// result: (XORLconst [c] x)
   13973 	for {
   13974 		_ = v.Args[1]
   13975 		x := v.Args[0]
   13976 		v_1 := v.Args[1]
   13977 		if v_1.Op != Op386MOVLconst {
   13978 			break
   13979 		}
   13980 		c := v_1.AuxInt
   13981 		v.reset(Op386XORLconst)
   13982 		v.AuxInt = c
   13983 		v.AddArg(x)
   13984 		return true
   13985 	}
   13986 	// match: (XORL (MOVLconst [c]) x)
   13987 	// cond:
   13988 	// result: (XORLconst [c] x)
   13989 	for {
   13990 		_ = v.Args[1]
   13991 		v_0 := v.Args[0]
   13992 		if v_0.Op != Op386MOVLconst {
   13993 			break
   13994 		}
   13995 		c := v_0.AuxInt
   13996 		x := v.Args[1]
   13997 		v.reset(Op386XORLconst)
   13998 		v.AuxInt = c
   13999 		v.AddArg(x)
   14000 		return true
   14001 	}
   14002 	// match: (XORL (SHLLconst [c] x) (SHRLconst [d] x))
   14003 	// cond: d == 32-c
   14004 	// result: (ROLLconst [c] x)
   14005 	for {
   14006 		_ = v.Args[1]
   14007 		v_0 := v.Args[0]
   14008 		if v_0.Op != Op386SHLLconst {
   14009 			break
   14010 		}
   14011 		c := v_0.AuxInt
   14012 		x := v_0.Args[0]
   14013 		v_1 := v.Args[1]
   14014 		if v_1.Op != Op386SHRLconst {
   14015 			break
   14016 		}
   14017 		d := v_1.AuxInt
   14018 		if x != v_1.Args[0] {
   14019 			break
   14020 		}
   14021 		if !(d == 32-c) {
   14022 			break
   14023 		}
   14024 		v.reset(Op386ROLLconst)
   14025 		v.AuxInt = c
   14026 		v.AddArg(x)
   14027 		return true
   14028 	}
   14029 	// match: (XORL (SHRLconst [d] x) (SHLLconst [c] x))
   14030 	// cond: d == 32-c
   14031 	// result: (ROLLconst [c] x)
   14032 	for {
   14033 		_ = v.Args[1]
   14034 		v_0 := v.Args[0]
   14035 		if v_0.Op != Op386SHRLconst {
   14036 			break
   14037 		}
   14038 		d := v_0.AuxInt
   14039 		x := v_0.Args[0]
   14040 		v_1 := v.Args[1]
   14041 		if v_1.Op != Op386SHLLconst {
   14042 			break
   14043 		}
   14044 		c := v_1.AuxInt
   14045 		if x != v_1.Args[0] {
   14046 			break
   14047 		}
   14048 		if !(d == 32-c) {
   14049 			break
   14050 		}
   14051 		v.reset(Op386ROLLconst)
   14052 		v.AuxInt = c
   14053 		v.AddArg(x)
   14054 		return true
   14055 	}
   14056 	// match: (XORL <t> (SHLLconst x [c]) (SHRWconst x [d]))
   14057 	// cond: c < 16 && d == 16-c && t.Size() == 2
   14058 	// result: (ROLWconst x [c])
   14059 	for {
   14060 		t := v.Type
   14061 		_ = v.Args[1]
   14062 		v_0 := v.Args[0]
   14063 		if v_0.Op != Op386SHLLconst {
   14064 			break
   14065 		}
   14066 		c := v_0.AuxInt
   14067 		x := v_0.Args[0]
   14068 		v_1 := v.Args[1]
   14069 		if v_1.Op != Op386SHRWconst {
   14070 			break
   14071 		}
   14072 		d := v_1.AuxInt
   14073 		if x != v_1.Args[0] {
   14074 			break
   14075 		}
   14076 		if !(c < 16 && d == 16-c && t.Size() == 2) {
   14077 			break
   14078 		}
   14079 		v.reset(Op386ROLWconst)
   14080 		v.AuxInt = c
   14081 		v.AddArg(x)
   14082 		return true
   14083 	}
   14084 	// match: (XORL <t> (SHRWconst x [d]) (SHLLconst x [c]))
   14085 	// cond: c < 16 && d == 16-c && t.Size() == 2
   14086 	// result: (ROLWconst x [c])
   14087 	for {
   14088 		t := v.Type
   14089 		_ = v.Args[1]
   14090 		v_0 := v.Args[0]
   14091 		if v_0.Op != Op386SHRWconst {
   14092 			break
   14093 		}
   14094 		d := v_0.AuxInt
   14095 		x := v_0.Args[0]
   14096 		v_1 := v.Args[1]
   14097 		if v_1.Op != Op386SHLLconst {
   14098 			break
   14099 		}
   14100 		c := v_1.AuxInt
   14101 		if x != v_1.Args[0] {
   14102 			break
   14103 		}
   14104 		if !(c < 16 && d == 16-c && t.Size() == 2) {
   14105 			break
   14106 		}
   14107 		v.reset(Op386ROLWconst)
   14108 		v.AuxInt = c
   14109 		v.AddArg(x)
   14110 		return true
   14111 	}
   14112 	// match: (XORL <t> (SHLLconst x [c]) (SHRBconst x [d]))
   14113 	// cond: c < 8 && d == 8-c && t.Size() == 1
   14114 	// result: (ROLBconst x [c])
   14115 	for {
   14116 		t := v.Type
   14117 		_ = v.Args[1]
   14118 		v_0 := v.Args[0]
   14119 		if v_0.Op != Op386SHLLconst {
   14120 			break
   14121 		}
   14122 		c := v_0.AuxInt
   14123 		x := v_0.Args[0]
   14124 		v_1 := v.Args[1]
   14125 		if v_1.Op != Op386SHRBconst {
   14126 			break
   14127 		}
   14128 		d := v_1.AuxInt
   14129 		if x != v_1.Args[0] {
   14130 			break
   14131 		}
   14132 		if !(c < 8 && d == 8-c && t.Size() == 1) {
   14133 			break
   14134 		}
   14135 		v.reset(Op386ROLBconst)
   14136 		v.AuxInt = c
   14137 		v.AddArg(x)
   14138 		return true
   14139 	}
   14140 	// match: (XORL <t> (SHRBconst x [d]) (SHLLconst x [c]))
   14141 	// cond: c < 8 && d == 8-c && t.Size() == 1
   14142 	// result: (ROLBconst x [c])
   14143 	for {
   14144 		t := v.Type
   14145 		_ = v.Args[1]
   14146 		v_0 := v.Args[0]
   14147 		if v_0.Op != Op386SHRBconst {
   14148 			break
   14149 		}
   14150 		d := v_0.AuxInt
   14151 		x := v_0.Args[0]
   14152 		v_1 := v.Args[1]
   14153 		if v_1.Op != Op386SHLLconst {
   14154 			break
   14155 		}
   14156 		c := v_1.AuxInt
   14157 		if x != v_1.Args[0] {
   14158 			break
   14159 		}
   14160 		if !(c < 8 && d == 8-c && t.Size() == 1) {
   14161 			break
   14162 		}
   14163 		v.reset(Op386ROLBconst)
   14164 		v.AuxInt = c
   14165 		v.AddArg(x)
   14166 		return true
   14167 	}
   14168 	// match: (XORL x x)
   14169 	// cond:
   14170 	// result: (MOVLconst [0])
   14171 	for {
   14172 		_ = v.Args[1]
   14173 		x := v.Args[0]
   14174 		if x != v.Args[1] {
   14175 			break
   14176 		}
   14177 		v.reset(Op386MOVLconst)
   14178 		v.AuxInt = 0
   14179 		return true
   14180 	}
   14181 	return false
   14182 }
   14183 func rewriteValue386_Op386XORLconst_0(v *Value) bool {
   14184 	// match: (XORLconst [c] (XORLconst [d] x))
   14185 	// cond:
   14186 	// result: (XORLconst [c ^ d] x)
   14187 	for {
   14188 		c := v.AuxInt
   14189 		v_0 := v.Args[0]
   14190 		if v_0.Op != Op386XORLconst {
   14191 			break
   14192 		}
   14193 		d := v_0.AuxInt
   14194 		x := v_0.Args[0]
   14195 		v.reset(Op386XORLconst)
   14196 		v.AuxInt = c ^ d
   14197 		v.AddArg(x)
   14198 		return true
   14199 	}
   14200 	// match: (XORLconst [c] x)
   14201 	// cond: int32(c)==0
   14202 	// result: x
   14203 	for {
   14204 		c := v.AuxInt
   14205 		x := v.Args[0]
   14206 		if !(int32(c) == 0) {
   14207 			break
   14208 		}
   14209 		v.reset(OpCopy)
   14210 		v.Type = x.Type
   14211 		v.AddArg(x)
   14212 		return true
   14213 	}
   14214 	// match: (XORLconst [c] (MOVLconst [d]))
   14215 	// cond:
   14216 	// result: (MOVLconst [c^d])
   14217 	for {
   14218 		c := v.AuxInt
   14219 		v_0 := v.Args[0]
   14220 		if v_0.Op != Op386MOVLconst {
   14221 			break
   14222 		}
   14223 		d := v_0.AuxInt
   14224 		v.reset(Op386MOVLconst)
   14225 		v.AuxInt = c ^ d
   14226 		return true
   14227 	}
   14228 	return false
   14229 }
   14230 func rewriteValue386_OpAdd16_0(v *Value) bool {
   14231 	// match: (Add16 x y)
   14232 	// cond:
   14233 	// result: (ADDL  x y)
   14234 	for {
   14235 		_ = v.Args[1]
   14236 		x := v.Args[0]
   14237 		y := v.Args[1]
   14238 		v.reset(Op386ADDL)
   14239 		v.AddArg(x)
   14240 		v.AddArg(y)
   14241 		return true
   14242 	}
   14243 }
   14244 func rewriteValue386_OpAdd32_0(v *Value) bool {
   14245 	// match: (Add32 x y)
   14246 	// cond:
   14247 	// result: (ADDL  x y)
   14248 	for {
   14249 		_ = v.Args[1]
   14250 		x := v.Args[0]
   14251 		y := v.Args[1]
   14252 		v.reset(Op386ADDL)
   14253 		v.AddArg(x)
   14254 		v.AddArg(y)
   14255 		return true
   14256 	}
   14257 }
   14258 func rewriteValue386_OpAdd32F_0(v *Value) bool {
   14259 	// match: (Add32F x y)
   14260 	// cond:
   14261 	// result: (ADDSS x y)
   14262 	for {
   14263 		_ = v.Args[1]
   14264 		x := v.Args[0]
   14265 		y := v.Args[1]
   14266 		v.reset(Op386ADDSS)
   14267 		v.AddArg(x)
   14268 		v.AddArg(y)
   14269 		return true
   14270 	}
   14271 }
   14272 func rewriteValue386_OpAdd32carry_0(v *Value) bool {
   14273 	// match: (Add32carry x y)
   14274 	// cond:
   14275 	// result: (ADDLcarry x y)
   14276 	for {
   14277 		_ = v.Args[1]
   14278 		x := v.Args[0]
   14279 		y := v.Args[1]
   14280 		v.reset(Op386ADDLcarry)
   14281 		v.AddArg(x)
   14282 		v.AddArg(y)
   14283 		return true
   14284 	}
   14285 }
   14286 func rewriteValue386_OpAdd32withcarry_0(v *Value) bool {
   14287 	// match: (Add32withcarry x y c)
   14288 	// cond:
   14289 	// result: (ADCL x y c)
   14290 	for {
   14291 		_ = v.Args[2]
   14292 		x := v.Args[0]
   14293 		y := v.Args[1]
   14294 		c := v.Args[2]
   14295 		v.reset(Op386ADCL)
   14296 		v.AddArg(x)
   14297 		v.AddArg(y)
   14298 		v.AddArg(c)
   14299 		return true
   14300 	}
   14301 }
   14302 func rewriteValue386_OpAdd64F_0(v *Value) bool {
   14303 	// match: (Add64F x y)
   14304 	// cond:
   14305 	// result: (ADDSD x y)
   14306 	for {
   14307 		_ = v.Args[1]
   14308 		x := v.Args[0]
   14309 		y := v.Args[1]
   14310 		v.reset(Op386ADDSD)
   14311 		v.AddArg(x)
   14312 		v.AddArg(y)
   14313 		return true
   14314 	}
   14315 }
   14316 func rewriteValue386_OpAdd8_0(v *Value) bool {
   14317 	// match: (Add8 x y)
   14318 	// cond:
   14319 	// result: (ADDL  x y)
   14320 	for {
   14321 		_ = v.Args[1]
   14322 		x := v.Args[0]
   14323 		y := v.Args[1]
   14324 		v.reset(Op386ADDL)
   14325 		v.AddArg(x)
   14326 		v.AddArg(y)
   14327 		return true
   14328 	}
   14329 }
   14330 func rewriteValue386_OpAddPtr_0(v *Value) bool {
   14331 	// match: (AddPtr x y)
   14332 	// cond:
   14333 	// result: (ADDL  x y)
   14334 	for {
   14335 		_ = v.Args[1]
   14336 		x := v.Args[0]
   14337 		y := v.Args[1]
   14338 		v.reset(Op386ADDL)
   14339 		v.AddArg(x)
   14340 		v.AddArg(y)
   14341 		return true
   14342 	}
   14343 }
   14344 func rewriteValue386_OpAddr_0(v *Value) bool {
   14345 	// match: (Addr {sym} base)
   14346 	// cond:
   14347 	// result: (LEAL {sym} base)
   14348 	for {
   14349 		sym := v.Aux
   14350 		base := v.Args[0]
   14351 		v.reset(Op386LEAL)
   14352 		v.Aux = sym
   14353 		v.AddArg(base)
   14354 		return true
   14355 	}
   14356 }
   14357 func rewriteValue386_OpAnd16_0(v *Value) bool {
   14358 	// match: (And16 x y)
   14359 	// cond:
   14360 	// result: (ANDL x y)
   14361 	for {
   14362 		_ = v.Args[1]
   14363 		x := v.Args[0]
   14364 		y := v.Args[1]
   14365 		v.reset(Op386ANDL)
   14366 		v.AddArg(x)
   14367 		v.AddArg(y)
   14368 		return true
   14369 	}
   14370 }
   14371 func rewriteValue386_OpAnd32_0(v *Value) bool {
   14372 	// match: (And32 x y)
   14373 	// cond:
   14374 	// result: (ANDL x y)
   14375 	for {
   14376 		_ = v.Args[1]
   14377 		x := v.Args[0]
   14378 		y := v.Args[1]
   14379 		v.reset(Op386ANDL)
   14380 		v.AddArg(x)
   14381 		v.AddArg(y)
   14382 		return true
   14383 	}
   14384 }
   14385 func rewriteValue386_OpAnd8_0(v *Value) bool {
   14386 	// match: (And8 x y)
   14387 	// cond:
   14388 	// result: (ANDL x y)
   14389 	for {
   14390 		_ = v.Args[1]
   14391 		x := v.Args[0]
   14392 		y := v.Args[1]
   14393 		v.reset(Op386ANDL)
   14394 		v.AddArg(x)
   14395 		v.AddArg(y)
   14396 		return true
   14397 	}
   14398 }
   14399 func rewriteValue386_OpAndB_0(v *Value) bool {
   14400 	// match: (AndB x y)
   14401 	// cond:
   14402 	// result: (ANDL x y)
   14403 	for {
   14404 		_ = v.Args[1]
   14405 		x := v.Args[0]
   14406 		y := v.Args[1]
   14407 		v.reset(Op386ANDL)
   14408 		v.AddArg(x)
   14409 		v.AddArg(y)
   14410 		return true
   14411 	}
   14412 }
   14413 func rewriteValue386_OpAvg32u_0(v *Value) bool {
   14414 	// match: (Avg32u x y)
   14415 	// cond:
   14416 	// result: (AVGLU x y)
   14417 	for {
   14418 		_ = v.Args[1]
   14419 		x := v.Args[0]
   14420 		y := v.Args[1]
   14421 		v.reset(Op386AVGLU)
   14422 		v.AddArg(x)
   14423 		v.AddArg(y)
   14424 		return true
   14425 	}
   14426 }
   14427 func rewriteValue386_OpBswap32_0(v *Value) bool {
   14428 	// match: (Bswap32 x)
   14429 	// cond:
   14430 	// result: (BSWAPL x)
   14431 	for {
   14432 		x := v.Args[0]
   14433 		v.reset(Op386BSWAPL)
   14434 		v.AddArg(x)
   14435 		return true
   14436 	}
   14437 }
   14438 func rewriteValue386_OpClosureCall_0(v *Value) bool {
   14439 	// match: (ClosureCall [argwid] entry closure mem)
   14440 	// cond:
   14441 	// result: (CALLclosure [argwid] entry closure mem)
   14442 	for {
   14443 		argwid := v.AuxInt
   14444 		_ = v.Args[2]
   14445 		entry := v.Args[0]
   14446 		closure := v.Args[1]
   14447 		mem := v.Args[2]
   14448 		v.reset(Op386CALLclosure)
   14449 		v.AuxInt = argwid
   14450 		v.AddArg(entry)
   14451 		v.AddArg(closure)
   14452 		v.AddArg(mem)
   14453 		return true
   14454 	}
   14455 }
   14456 func rewriteValue386_OpCom16_0(v *Value) bool {
   14457 	// match: (Com16 x)
   14458 	// cond:
   14459 	// result: (NOTL x)
   14460 	for {
   14461 		x := v.Args[0]
   14462 		v.reset(Op386NOTL)
   14463 		v.AddArg(x)
   14464 		return true
   14465 	}
   14466 }
   14467 func rewriteValue386_OpCom32_0(v *Value) bool {
   14468 	// match: (Com32 x)
   14469 	// cond:
   14470 	// result: (NOTL x)
   14471 	for {
   14472 		x := v.Args[0]
   14473 		v.reset(Op386NOTL)
   14474 		v.AddArg(x)
   14475 		return true
   14476 	}
   14477 }
   14478 func rewriteValue386_OpCom8_0(v *Value) bool {
   14479 	// match: (Com8 x)
   14480 	// cond:
   14481 	// result: (NOTL x)
   14482 	for {
   14483 		x := v.Args[0]
   14484 		v.reset(Op386NOTL)
   14485 		v.AddArg(x)
   14486 		return true
   14487 	}
   14488 }
   14489 func rewriteValue386_OpConst16_0(v *Value) bool {
   14490 	// match: (Const16 [val])
   14491 	// cond:
   14492 	// result: (MOVLconst [val])
   14493 	for {
   14494 		val := v.AuxInt
   14495 		v.reset(Op386MOVLconst)
   14496 		v.AuxInt = val
   14497 		return true
   14498 	}
   14499 }
   14500 func rewriteValue386_OpConst32_0(v *Value) bool {
   14501 	// match: (Const32 [val])
   14502 	// cond:
   14503 	// result: (MOVLconst [val])
   14504 	for {
   14505 		val := v.AuxInt
   14506 		v.reset(Op386MOVLconst)
   14507 		v.AuxInt = val
   14508 		return true
   14509 	}
   14510 }
   14511 func rewriteValue386_OpConst32F_0(v *Value) bool {
   14512 	// match: (Const32F [val])
   14513 	// cond:
   14514 	// result: (MOVSSconst [val])
   14515 	for {
   14516 		val := v.AuxInt
   14517 		v.reset(Op386MOVSSconst)
   14518 		v.AuxInt = val
   14519 		return true
   14520 	}
   14521 }
   14522 func rewriteValue386_OpConst64F_0(v *Value) bool {
   14523 	// match: (Const64F [val])
   14524 	// cond:
   14525 	// result: (MOVSDconst [val])
   14526 	for {
   14527 		val := v.AuxInt
   14528 		v.reset(Op386MOVSDconst)
   14529 		v.AuxInt = val
   14530 		return true
   14531 	}
   14532 }
   14533 func rewriteValue386_OpConst8_0(v *Value) bool {
   14534 	// match: (Const8 [val])
   14535 	// cond:
   14536 	// result: (MOVLconst [val])
   14537 	for {
   14538 		val := v.AuxInt
   14539 		v.reset(Op386MOVLconst)
   14540 		v.AuxInt = val
   14541 		return true
   14542 	}
   14543 }
   14544 func rewriteValue386_OpConstBool_0(v *Value) bool {
   14545 	// match: (ConstBool [b])
   14546 	// cond:
   14547 	// result: (MOVLconst [b])
   14548 	for {
   14549 		b := v.AuxInt
   14550 		v.reset(Op386MOVLconst)
   14551 		v.AuxInt = b
   14552 		return true
   14553 	}
   14554 }
   14555 func rewriteValue386_OpConstNil_0(v *Value) bool {
   14556 	// match: (ConstNil)
   14557 	// cond:
   14558 	// result: (MOVLconst [0])
   14559 	for {
   14560 		v.reset(Op386MOVLconst)
   14561 		v.AuxInt = 0
   14562 		return true
   14563 	}
   14564 }
   14565 func rewriteValue386_OpConvert_0(v *Value) bool {
   14566 	// match: (Convert <t> x mem)
   14567 	// cond:
   14568 	// result: (MOVLconvert <t> x mem)
   14569 	for {
   14570 		t := v.Type
   14571 		_ = v.Args[1]
   14572 		x := v.Args[0]
   14573 		mem := v.Args[1]
   14574 		v.reset(Op386MOVLconvert)
   14575 		v.Type = t
   14576 		v.AddArg(x)
   14577 		v.AddArg(mem)
   14578 		return true
   14579 	}
   14580 }
   14581 func rewriteValue386_OpCvt32Fto32_0(v *Value) bool {
   14582 	// match: (Cvt32Fto32 x)
   14583 	// cond:
   14584 	// result: (CVTTSS2SL x)
   14585 	for {
   14586 		x := v.Args[0]
   14587 		v.reset(Op386CVTTSS2SL)
   14588 		v.AddArg(x)
   14589 		return true
   14590 	}
   14591 }
   14592 func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool {
   14593 	// match: (Cvt32Fto64F x)
   14594 	// cond:
   14595 	// result: (CVTSS2SD x)
   14596 	for {
   14597 		x := v.Args[0]
   14598 		v.reset(Op386CVTSS2SD)
   14599 		v.AddArg(x)
   14600 		return true
   14601 	}
   14602 }
   14603 func rewriteValue386_OpCvt32to32F_0(v *Value) bool {
   14604 	// match: (Cvt32to32F x)
   14605 	// cond:
   14606 	// result: (CVTSL2SS x)
   14607 	for {
   14608 		x := v.Args[0]
   14609 		v.reset(Op386CVTSL2SS)
   14610 		v.AddArg(x)
   14611 		return true
   14612 	}
   14613 }
   14614 func rewriteValue386_OpCvt32to64F_0(v *Value) bool {
   14615 	// match: (Cvt32to64F x)
   14616 	// cond:
   14617 	// result: (CVTSL2SD x)
   14618 	for {
   14619 		x := v.Args[0]
   14620 		v.reset(Op386CVTSL2SD)
   14621 		v.AddArg(x)
   14622 		return true
   14623 	}
   14624 }
   14625 func rewriteValue386_OpCvt64Fto32_0(v *Value) bool {
   14626 	// match: (Cvt64Fto32 x)
   14627 	// cond:
   14628 	// result: (CVTTSD2SL x)
   14629 	for {
   14630 		x := v.Args[0]
   14631 		v.reset(Op386CVTTSD2SL)
   14632 		v.AddArg(x)
   14633 		return true
   14634 	}
   14635 }
   14636 func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool {
   14637 	// match: (Cvt64Fto32F x)
   14638 	// cond:
   14639 	// result: (CVTSD2SS x)
   14640 	for {
   14641 		x := v.Args[0]
   14642 		v.reset(Op386CVTSD2SS)
   14643 		v.AddArg(x)
   14644 		return true
   14645 	}
   14646 }
   14647 func rewriteValue386_OpDiv16_0(v *Value) bool {
   14648 	// match: (Div16 x y)
   14649 	// cond:
   14650 	// result: (DIVW  x y)
   14651 	for {
   14652 		_ = v.Args[1]
   14653 		x := v.Args[0]
   14654 		y := v.Args[1]
   14655 		v.reset(Op386DIVW)
   14656 		v.AddArg(x)
   14657 		v.AddArg(y)
   14658 		return true
   14659 	}
   14660 }
   14661 func rewriteValue386_OpDiv16u_0(v *Value) bool {
   14662 	// match: (Div16u x y)
   14663 	// cond:
   14664 	// result: (DIVWU x y)
   14665 	for {
   14666 		_ = v.Args[1]
   14667 		x := v.Args[0]
   14668 		y := v.Args[1]
   14669 		v.reset(Op386DIVWU)
   14670 		v.AddArg(x)
   14671 		v.AddArg(y)
   14672 		return true
   14673 	}
   14674 }
   14675 func rewriteValue386_OpDiv32_0(v *Value) bool {
   14676 	// match: (Div32 x y)
   14677 	// cond:
   14678 	// result: (DIVL  x y)
   14679 	for {
   14680 		_ = v.Args[1]
   14681 		x := v.Args[0]
   14682 		y := v.Args[1]
   14683 		v.reset(Op386DIVL)
   14684 		v.AddArg(x)
   14685 		v.AddArg(y)
   14686 		return true
   14687 	}
   14688 }
   14689 func rewriteValue386_OpDiv32F_0(v *Value) bool {
   14690 	// match: (Div32F x y)
   14691 	// cond:
   14692 	// result: (DIVSS x y)
   14693 	for {
   14694 		_ = v.Args[1]
   14695 		x := v.Args[0]
   14696 		y := v.Args[1]
   14697 		v.reset(Op386DIVSS)
   14698 		v.AddArg(x)
   14699 		v.AddArg(y)
   14700 		return true
   14701 	}
   14702 }
   14703 func rewriteValue386_OpDiv32u_0(v *Value) bool {
   14704 	// match: (Div32u x y)
   14705 	// cond:
   14706 	// result: (DIVLU x y)
   14707 	for {
   14708 		_ = v.Args[1]
   14709 		x := v.Args[0]
   14710 		y := v.Args[1]
   14711 		v.reset(Op386DIVLU)
   14712 		v.AddArg(x)
   14713 		v.AddArg(y)
   14714 		return true
   14715 	}
   14716 }
   14717 func rewriteValue386_OpDiv64F_0(v *Value) bool {
   14718 	// match: (Div64F x y)
   14719 	// cond:
   14720 	// result: (DIVSD x y)
   14721 	for {
   14722 		_ = v.Args[1]
   14723 		x := v.Args[0]
   14724 		y := v.Args[1]
   14725 		v.reset(Op386DIVSD)
   14726 		v.AddArg(x)
   14727 		v.AddArg(y)
   14728 		return true
   14729 	}
   14730 }
   14731 func rewriteValue386_OpDiv8_0(v *Value) bool {
   14732 	b := v.Block
   14733 	_ = b
   14734 	typ := &b.Func.Config.Types
   14735 	_ = typ
   14736 	// match: (Div8 x y)
   14737 	// cond:
   14738 	// result: (DIVW  (SignExt8to16 x) (SignExt8to16 y))
   14739 	for {
   14740 		_ = v.Args[1]
   14741 		x := v.Args[0]
   14742 		y := v.Args[1]
   14743 		v.reset(Op386DIVW)
   14744 		v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
   14745 		v0.AddArg(x)
   14746 		v.AddArg(v0)
   14747 		v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
   14748 		v1.AddArg(y)
   14749 		v.AddArg(v1)
   14750 		return true
   14751 	}
   14752 }
   14753 func rewriteValue386_OpDiv8u_0(v *Value) bool {
   14754 	b := v.Block
   14755 	_ = b
   14756 	typ := &b.Func.Config.Types
   14757 	_ = typ
   14758 	// match: (Div8u x y)
   14759 	// cond:
   14760 	// result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))
   14761 	for {
   14762 		_ = v.Args[1]
   14763 		x := v.Args[0]
   14764 		y := v.Args[1]
   14765 		v.reset(Op386DIVWU)
   14766 		v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
   14767 		v0.AddArg(x)
   14768 		v.AddArg(v0)
   14769 		v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
   14770 		v1.AddArg(y)
   14771 		v.AddArg(v1)
   14772 		return true
   14773 	}
   14774 }
   14775 func rewriteValue386_OpEq16_0(v *Value) bool {
   14776 	b := v.Block
   14777 	_ = b
   14778 	// match: (Eq16 x y)
   14779 	// cond:
   14780 	// result: (SETEQ (CMPW x y))
   14781 	for {
   14782 		_ = v.Args[1]
   14783 		x := v.Args[0]
   14784 		y := v.Args[1]
   14785 		v.reset(Op386SETEQ)
   14786 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   14787 		v0.AddArg(x)
   14788 		v0.AddArg(y)
   14789 		v.AddArg(v0)
   14790 		return true
   14791 	}
   14792 }
   14793 func rewriteValue386_OpEq32_0(v *Value) bool {
   14794 	b := v.Block
   14795 	_ = b
   14796 	// match: (Eq32 x y)
   14797 	// cond:
   14798 	// result: (SETEQ (CMPL x y))
   14799 	for {
   14800 		_ = v.Args[1]
   14801 		x := v.Args[0]
   14802 		y := v.Args[1]
   14803 		v.reset(Op386SETEQ)
   14804 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   14805 		v0.AddArg(x)
   14806 		v0.AddArg(y)
   14807 		v.AddArg(v0)
   14808 		return true
   14809 	}
   14810 }
   14811 func rewriteValue386_OpEq32F_0(v *Value) bool {
   14812 	b := v.Block
   14813 	_ = b
   14814 	// match: (Eq32F x y)
   14815 	// cond:
   14816 	// result: (SETEQF (UCOMISS x y))
   14817 	for {
   14818 		_ = v.Args[1]
   14819 		x := v.Args[0]
   14820 		y := v.Args[1]
   14821 		v.reset(Op386SETEQF)
   14822 		v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
   14823 		v0.AddArg(x)
   14824 		v0.AddArg(y)
   14825 		v.AddArg(v0)
   14826 		return true
   14827 	}
   14828 }
   14829 func rewriteValue386_OpEq64F_0(v *Value) bool {
   14830 	b := v.Block
   14831 	_ = b
   14832 	// match: (Eq64F x y)
   14833 	// cond:
   14834 	// result: (SETEQF (UCOMISD x y))
   14835 	for {
   14836 		_ = v.Args[1]
   14837 		x := v.Args[0]
   14838 		y := v.Args[1]
   14839 		v.reset(Op386SETEQF)
   14840 		v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
   14841 		v0.AddArg(x)
   14842 		v0.AddArg(y)
   14843 		v.AddArg(v0)
   14844 		return true
   14845 	}
   14846 }
   14847 func rewriteValue386_OpEq8_0(v *Value) bool {
   14848 	b := v.Block
   14849 	_ = b
   14850 	// match: (Eq8 x y)
   14851 	// cond:
   14852 	// result: (SETEQ (CMPB x y))
   14853 	for {
   14854 		_ = v.Args[1]
   14855 		x := v.Args[0]
   14856 		y := v.Args[1]
   14857 		v.reset(Op386SETEQ)
   14858 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   14859 		v0.AddArg(x)
   14860 		v0.AddArg(y)
   14861 		v.AddArg(v0)
   14862 		return true
   14863 	}
   14864 }
   14865 func rewriteValue386_OpEqB_0(v *Value) bool {
   14866 	b := v.Block
   14867 	_ = b
   14868 	// match: (EqB x y)
   14869 	// cond:
   14870 	// result: (SETEQ (CMPB x y))
   14871 	for {
   14872 		_ = v.Args[1]
   14873 		x := v.Args[0]
   14874 		y := v.Args[1]
   14875 		v.reset(Op386SETEQ)
   14876 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   14877 		v0.AddArg(x)
   14878 		v0.AddArg(y)
   14879 		v.AddArg(v0)
   14880 		return true
   14881 	}
   14882 }
   14883 func rewriteValue386_OpEqPtr_0(v *Value) bool {
   14884 	b := v.Block
   14885 	_ = b
   14886 	// match: (EqPtr x y)
   14887 	// cond:
   14888 	// result: (SETEQ (CMPL x y))
   14889 	for {
   14890 		_ = v.Args[1]
   14891 		x := v.Args[0]
   14892 		y := v.Args[1]
   14893 		v.reset(Op386SETEQ)
   14894 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   14895 		v0.AddArg(x)
   14896 		v0.AddArg(y)
   14897 		v.AddArg(v0)
   14898 		return true
   14899 	}
   14900 }
   14901 func rewriteValue386_OpGeq16_0(v *Value) bool {
   14902 	b := v.Block
   14903 	_ = b
   14904 	// match: (Geq16 x y)
   14905 	// cond:
   14906 	// result: (SETGE (CMPW x y))
   14907 	for {
   14908 		_ = v.Args[1]
   14909 		x := v.Args[0]
   14910 		y := v.Args[1]
   14911 		v.reset(Op386SETGE)
   14912 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   14913 		v0.AddArg(x)
   14914 		v0.AddArg(y)
   14915 		v.AddArg(v0)
   14916 		return true
   14917 	}
   14918 }
   14919 func rewriteValue386_OpGeq16U_0(v *Value) bool {
   14920 	b := v.Block
   14921 	_ = b
   14922 	// match: (Geq16U x y)
   14923 	// cond:
   14924 	// result: (SETAE (CMPW x y))
   14925 	for {
   14926 		_ = v.Args[1]
   14927 		x := v.Args[0]
   14928 		y := v.Args[1]
   14929 		v.reset(Op386SETAE)
   14930 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   14931 		v0.AddArg(x)
   14932 		v0.AddArg(y)
   14933 		v.AddArg(v0)
   14934 		return true
   14935 	}
   14936 }
   14937 func rewriteValue386_OpGeq32_0(v *Value) bool {
   14938 	b := v.Block
   14939 	_ = b
   14940 	// match: (Geq32 x y)
   14941 	// cond:
   14942 	// result: (SETGE (CMPL x y))
   14943 	for {
   14944 		_ = v.Args[1]
   14945 		x := v.Args[0]
   14946 		y := v.Args[1]
   14947 		v.reset(Op386SETGE)
   14948 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   14949 		v0.AddArg(x)
   14950 		v0.AddArg(y)
   14951 		v.AddArg(v0)
   14952 		return true
   14953 	}
   14954 }
   14955 func rewriteValue386_OpGeq32F_0(v *Value) bool {
   14956 	b := v.Block
   14957 	_ = b
   14958 	// match: (Geq32F x y)
   14959 	// cond:
   14960 	// result: (SETGEF (UCOMISS x y))
   14961 	for {
   14962 		_ = v.Args[1]
   14963 		x := v.Args[0]
   14964 		y := v.Args[1]
   14965 		v.reset(Op386SETGEF)
   14966 		v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
   14967 		v0.AddArg(x)
   14968 		v0.AddArg(y)
   14969 		v.AddArg(v0)
   14970 		return true
   14971 	}
   14972 }
   14973 func rewriteValue386_OpGeq32U_0(v *Value) bool {
   14974 	b := v.Block
   14975 	_ = b
   14976 	// match: (Geq32U x y)
   14977 	// cond:
   14978 	// result: (SETAE (CMPL x y))
   14979 	for {
   14980 		_ = v.Args[1]
   14981 		x := v.Args[0]
   14982 		y := v.Args[1]
   14983 		v.reset(Op386SETAE)
   14984 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   14985 		v0.AddArg(x)
   14986 		v0.AddArg(y)
   14987 		v.AddArg(v0)
   14988 		return true
   14989 	}
   14990 }
   14991 func rewriteValue386_OpGeq64F_0(v *Value) bool {
   14992 	b := v.Block
   14993 	_ = b
   14994 	// match: (Geq64F x y)
   14995 	// cond:
   14996 	// result: (SETGEF (UCOMISD x y))
   14997 	for {
   14998 		_ = v.Args[1]
   14999 		x := v.Args[0]
   15000 		y := v.Args[1]
   15001 		v.reset(Op386SETGEF)
   15002 		v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
   15003 		v0.AddArg(x)
   15004 		v0.AddArg(y)
   15005 		v.AddArg(v0)
   15006 		return true
   15007 	}
   15008 }
   15009 func rewriteValue386_OpGeq8_0(v *Value) bool {
   15010 	b := v.Block
   15011 	_ = b
   15012 	// match: (Geq8 x y)
   15013 	// cond:
   15014 	// result: (SETGE (CMPB x y))
   15015 	for {
   15016 		_ = v.Args[1]
   15017 		x := v.Args[0]
   15018 		y := v.Args[1]
   15019 		v.reset(Op386SETGE)
   15020 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15021 		v0.AddArg(x)
   15022 		v0.AddArg(y)
   15023 		v.AddArg(v0)
   15024 		return true
   15025 	}
   15026 }
   15027 func rewriteValue386_OpGeq8U_0(v *Value) bool {
   15028 	b := v.Block
   15029 	_ = b
   15030 	// match: (Geq8U x y)
   15031 	// cond:
   15032 	// result: (SETAE (CMPB x y))
   15033 	for {
   15034 		_ = v.Args[1]
   15035 		x := v.Args[0]
   15036 		y := v.Args[1]
   15037 		v.reset(Op386SETAE)
   15038 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15039 		v0.AddArg(x)
   15040 		v0.AddArg(y)
   15041 		v.AddArg(v0)
   15042 		return true
   15043 	}
   15044 }
   15045 func rewriteValue386_OpGetCallerPC_0(v *Value) bool {
   15046 	// match: (GetCallerPC)
   15047 	// cond:
   15048 	// result: (LoweredGetCallerPC)
   15049 	for {
   15050 		v.reset(Op386LoweredGetCallerPC)
   15051 		return true
   15052 	}
   15053 }
   15054 func rewriteValue386_OpGetCallerSP_0(v *Value) bool {
   15055 	// match: (GetCallerSP)
   15056 	// cond:
   15057 	// result: (LoweredGetCallerSP)
   15058 	for {
   15059 		v.reset(Op386LoweredGetCallerSP)
   15060 		return true
   15061 	}
   15062 }
   15063 func rewriteValue386_OpGetClosurePtr_0(v *Value) bool {
   15064 	// match: (GetClosurePtr)
   15065 	// cond:
   15066 	// result: (LoweredGetClosurePtr)
   15067 	for {
   15068 		v.reset(Op386LoweredGetClosurePtr)
   15069 		return true
   15070 	}
   15071 }
   15072 func rewriteValue386_OpGetG_0(v *Value) bool {
   15073 	// match: (GetG mem)
   15074 	// cond:
   15075 	// result: (LoweredGetG mem)
   15076 	for {
   15077 		mem := v.Args[0]
   15078 		v.reset(Op386LoweredGetG)
   15079 		v.AddArg(mem)
   15080 		return true
   15081 	}
   15082 }
   15083 func rewriteValue386_OpGreater16_0(v *Value) bool {
   15084 	b := v.Block
   15085 	_ = b
   15086 	// match: (Greater16 x y)
   15087 	// cond:
   15088 	// result: (SETG (CMPW x y))
   15089 	for {
   15090 		_ = v.Args[1]
   15091 		x := v.Args[0]
   15092 		y := v.Args[1]
   15093 		v.reset(Op386SETG)
   15094 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   15095 		v0.AddArg(x)
   15096 		v0.AddArg(y)
   15097 		v.AddArg(v0)
   15098 		return true
   15099 	}
   15100 }
   15101 func rewriteValue386_OpGreater16U_0(v *Value) bool {
   15102 	b := v.Block
   15103 	_ = b
   15104 	// match: (Greater16U x y)
   15105 	// cond:
   15106 	// result: (SETA (CMPW x y))
   15107 	for {
   15108 		_ = v.Args[1]
   15109 		x := v.Args[0]
   15110 		y := v.Args[1]
   15111 		v.reset(Op386SETA)
   15112 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   15113 		v0.AddArg(x)
   15114 		v0.AddArg(y)
   15115 		v.AddArg(v0)
   15116 		return true
   15117 	}
   15118 }
   15119 func rewriteValue386_OpGreater32_0(v *Value) bool {
   15120 	b := v.Block
   15121 	_ = b
   15122 	// match: (Greater32 x y)
   15123 	// cond:
   15124 	// result: (SETG (CMPL x y))
   15125 	for {
   15126 		_ = v.Args[1]
   15127 		x := v.Args[0]
   15128 		y := v.Args[1]
   15129 		v.reset(Op386SETG)
   15130 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15131 		v0.AddArg(x)
   15132 		v0.AddArg(y)
   15133 		v.AddArg(v0)
   15134 		return true
   15135 	}
   15136 }
   15137 func rewriteValue386_OpGreater32F_0(v *Value) bool {
   15138 	b := v.Block
   15139 	_ = b
   15140 	// match: (Greater32F x y)
   15141 	// cond:
   15142 	// result: (SETGF (UCOMISS x y))
   15143 	for {
   15144 		_ = v.Args[1]
   15145 		x := v.Args[0]
   15146 		y := v.Args[1]
   15147 		v.reset(Op386SETGF)
   15148 		v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
   15149 		v0.AddArg(x)
   15150 		v0.AddArg(y)
   15151 		v.AddArg(v0)
   15152 		return true
   15153 	}
   15154 }
   15155 func rewriteValue386_OpGreater32U_0(v *Value) bool {
   15156 	b := v.Block
   15157 	_ = b
   15158 	// match: (Greater32U x y)
   15159 	// cond:
   15160 	// result: (SETA (CMPL x y))
   15161 	for {
   15162 		_ = v.Args[1]
   15163 		x := v.Args[0]
   15164 		y := v.Args[1]
   15165 		v.reset(Op386SETA)
   15166 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15167 		v0.AddArg(x)
   15168 		v0.AddArg(y)
   15169 		v.AddArg(v0)
   15170 		return true
   15171 	}
   15172 }
   15173 func rewriteValue386_OpGreater64F_0(v *Value) bool {
   15174 	b := v.Block
   15175 	_ = b
   15176 	// match: (Greater64F x y)
   15177 	// cond:
   15178 	// result: (SETGF (UCOMISD x y))
   15179 	for {
   15180 		_ = v.Args[1]
   15181 		x := v.Args[0]
   15182 		y := v.Args[1]
   15183 		v.reset(Op386SETGF)
   15184 		v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
   15185 		v0.AddArg(x)
   15186 		v0.AddArg(y)
   15187 		v.AddArg(v0)
   15188 		return true
   15189 	}
   15190 }
   15191 func rewriteValue386_OpGreater8_0(v *Value) bool {
   15192 	b := v.Block
   15193 	_ = b
   15194 	// match: (Greater8 x y)
   15195 	// cond:
   15196 	// result: (SETG (CMPB x y))
   15197 	for {
   15198 		_ = v.Args[1]
   15199 		x := v.Args[0]
   15200 		y := v.Args[1]
   15201 		v.reset(Op386SETG)
   15202 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15203 		v0.AddArg(x)
   15204 		v0.AddArg(y)
   15205 		v.AddArg(v0)
   15206 		return true
   15207 	}
   15208 }
   15209 func rewriteValue386_OpGreater8U_0(v *Value) bool {
   15210 	b := v.Block
   15211 	_ = b
   15212 	// match: (Greater8U x y)
   15213 	// cond:
   15214 	// result: (SETA (CMPB x y))
   15215 	for {
   15216 		_ = v.Args[1]
   15217 		x := v.Args[0]
   15218 		y := v.Args[1]
   15219 		v.reset(Op386SETA)
   15220 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15221 		v0.AddArg(x)
   15222 		v0.AddArg(y)
   15223 		v.AddArg(v0)
   15224 		return true
   15225 	}
   15226 }
   15227 func rewriteValue386_OpHmul32_0(v *Value) bool {
   15228 	// match: (Hmul32 x y)
   15229 	// cond:
   15230 	// result: (HMULL  x y)
   15231 	for {
   15232 		_ = v.Args[1]
   15233 		x := v.Args[0]
   15234 		y := v.Args[1]
   15235 		v.reset(Op386HMULL)
   15236 		v.AddArg(x)
   15237 		v.AddArg(y)
   15238 		return true
   15239 	}
   15240 }
   15241 func rewriteValue386_OpHmul32u_0(v *Value) bool {
   15242 	// match: (Hmul32u x y)
   15243 	// cond:
   15244 	// result: (HMULLU x y)
   15245 	for {
   15246 		_ = v.Args[1]
   15247 		x := v.Args[0]
   15248 		y := v.Args[1]
   15249 		v.reset(Op386HMULLU)
   15250 		v.AddArg(x)
   15251 		v.AddArg(y)
   15252 		return true
   15253 	}
   15254 }
   15255 func rewriteValue386_OpInterCall_0(v *Value) bool {
   15256 	// match: (InterCall [argwid] entry mem)
   15257 	// cond:
   15258 	// result: (CALLinter [argwid] entry mem)
   15259 	for {
   15260 		argwid := v.AuxInt
   15261 		_ = v.Args[1]
   15262 		entry := v.Args[0]
   15263 		mem := v.Args[1]
   15264 		v.reset(Op386CALLinter)
   15265 		v.AuxInt = argwid
   15266 		v.AddArg(entry)
   15267 		v.AddArg(mem)
   15268 		return true
   15269 	}
   15270 }
   15271 func rewriteValue386_OpIsInBounds_0(v *Value) bool {
   15272 	b := v.Block
   15273 	_ = b
   15274 	// match: (IsInBounds idx len)
   15275 	// cond:
   15276 	// result: (SETB (CMPL idx len))
   15277 	for {
   15278 		_ = v.Args[1]
   15279 		idx := v.Args[0]
   15280 		len := v.Args[1]
   15281 		v.reset(Op386SETB)
   15282 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15283 		v0.AddArg(idx)
   15284 		v0.AddArg(len)
   15285 		v.AddArg(v0)
   15286 		return true
   15287 	}
   15288 }
   15289 func rewriteValue386_OpIsNonNil_0(v *Value) bool {
   15290 	b := v.Block
   15291 	_ = b
   15292 	// match: (IsNonNil p)
   15293 	// cond:
   15294 	// result: (SETNE (TESTL p p))
   15295 	for {
   15296 		p := v.Args[0]
   15297 		v.reset(Op386SETNE)
   15298 		v0 := b.NewValue0(v.Pos, Op386TESTL, types.TypeFlags)
   15299 		v0.AddArg(p)
   15300 		v0.AddArg(p)
   15301 		v.AddArg(v0)
   15302 		return true
   15303 	}
   15304 }
   15305 func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool {
   15306 	b := v.Block
   15307 	_ = b
   15308 	// match: (IsSliceInBounds idx len)
   15309 	// cond:
   15310 	// result: (SETBE (CMPL idx len))
   15311 	for {
   15312 		_ = v.Args[1]
   15313 		idx := v.Args[0]
   15314 		len := v.Args[1]
   15315 		v.reset(Op386SETBE)
   15316 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15317 		v0.AddArg(idx)
   15318 		v0.AddArg(len)
   15319 		v.AddArg(v0)
   15320 		return true
   15321 	}
   15322 }
   15323 func rewriteValue386_OpLeq16_0(v *Value) bool {
   15324 	b := v.Block
   15325 	_ = b
   15326 	// match: (Leq16 x y)
   15327 	// cond:
   15328 	// result: (SETLE (CMPW x y))
   15329 	for {
   15330 		_ = v.Args[1]
   15331 		x := v.Args[0]
   15332 		y := v.Args[1]
   15333 		v.reset(Op386SETLE)
   15334 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   15335 		v0.AddArg(x)
   15336 		v0.AddArg(y)
   15337 		v.AddArg(v0)
   15338 		return true
   15339 	}
   15340 }
   15341 func rewriteValue386_OpLeq16U_0(v *Value) bool {
   15342 	b := v.Block
   15343 	_ = b
   15344 	// match: (Leq16U x y)
   15345 	// cond:
   15346 	// result: (SETBE (CMPW x y))
   15347 	for {
   15348 		_ = v.Args[1]
   15349 		x := v.Args[0]
   15350 		y := v.Args[1]
   15351 		v.reset(Op386SETBE)
   15352 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   15353 		v0.AddArg(x)
   15354 		v0.AddArg(y)
   15355 		v.AddArg(v0)
   15356 		return true
   15357 	}
   15358 }
   15359 func rewriteValue386_OpLeq32_0(v *Value) bool {
   15360 	b := v.Block
   15361 	_ = b
   15362 	// match: (Leq32 x y)
   15363 	// cond:
   15364 	// result: (SETLE (CMPL x y))
   15365 	for {
   15366 		_ = v.Args[1]
   15367 		x := v.Args[0]
   15368 		y := v.Args[1]
   15369 		v.reset(Op386SETLE)
   15370 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15371 		v0.AddArg(x)
   15372 		v0.AddArg(y)
   15373 		v.AddArg(v0)
   15374 		return true
   15375 	}
   15376 }
   15377 func rewriteValue386_OpLeq32F_0(v *Value) bool {
   15378 	b := v.Block
   15379 	_ = b
   15380 	// match: (Leq32F x y)
   15381 	// cond:
   15382 	// result: (SETGEF (UCOMISS y x))
   15383 	for {
   15384 		_ = v.Args[1]
   15385 		x := v.Args[0]
   15386 		y := v.Args[1]
   15387 		v.reset(Op386SETGEF)
   15388 		v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
   15389 		v0.AddArg(y)
   15390 		v0.AddArg(x)
   15391 		v.AddArg(v0)
   15392 		return true
   15393 	}
   15394 }
   15395 func rewriteValue386_OpLeq32U_0(v *Value) bool {
   15396 	b := v.Block
   15397 	_ = b
   15398 	// match: (Leq32U x y)
   15399 	// cond:
   15400 	// result: (SETBE (CMPL x y))
   15401 	for {
   15402 		_ = v.Args[1]
   15403 		x := v.Args[0]
   15404 		y := v.Args[1]
   15405 		v.reset(Op386SETBE)
   15406 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15407 		v0.AddArg(x)
   15408 		v0.AddArg(y)
   15409 		v.AddArg(v0)
   15410 		return true
   15411 	}
   15412 }
   15413 func rewriteValue386_OpLeq64F_0(v *Value) bool {
   15414 	b := v.Block
   15415 	_ = b
   15416 	// match: (Leq64F x y)
   15417 	// cond:
   15418 	// result: (SETGEF (UCOMISD y x))
   15419 	for {
   15420 		_ = v.Args[1]
   15421 		x := v.Args[0]
   15422 		y := v.Args[1]
   15423 		v.reset(Op386SETGEF)
   15424 		v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
   15425 		v0.AddArg(y)
   15426 		v0.AddArg(x)
   15427 		v.AddArg(v0)
   15428 		return true
   15429 	}
   15430 }
   15431 func rewriteValue386_OpLeq8_0(v *Value) bool {
   15432 	b := v.Block
   15433 	_ = b
   15434 	// match: (Leq8 x y)
   15435 	// cond:
   15436 	// result: (SETLE (CMPB x y))
   15437 	for {
   15438 		_ = v.Args[1]
   15439 		x := v.Args[0]
   15440 		y := v.Args[1]
   15441 		v.reset(Op386SETLE)
   15442 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15443 		v0.AddArg(x)
   15444 		v0.AddArg(y)
   15445 		v.AddArg(v0)
   15446 		return true
   15447 	}
   15448 }
   15449 func rewriteValue386_OpLeq8U_0(v *Value) bool {
   15450 	b := v.Block
   15451 	_ = b
   15452 	// match: (Leq8U x y)
   15453 	// cond:
   15454 	// result: (SETBE (CMPB x y))
   15455 	for {
   15456 		_ = v.Args[1]
   15457 		x := v.Args[0]
   15458 		y := v.Args[1]
   15459 		v.reset(Op386SETBE)
   15460 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15461 		v0.AddArg(x)
   15462 		v0.AddArg(y)
   15463 		v.AddArg(v0)
   15464 		return true
   15465 	}
   15466 }
   15467 func rewriteValue386_OpLess16_0(v *Value) bool {
   15468 	b := v.Block
   15469 	_ = b
   15470 	// match: (Less16 x y)
   15471 	// cond:
   15472 	// result: (SETL (CMPW x y))
   15473 	for {
   15474 		_ = v.Args[1]
   15475 		x := v.Args[0]
   15476 		y := v.Args[1]
   15477 		v.reset(Op386SETL)
   15478 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   15479 		v0.AddArg(x)
   15480 		v0.AddArg(y)
   15481 		v.AddArg(v0)
   15482 		return true
   15483 	}
   15484 }
   15485 func rewriteValue386_OpLess16U_0(v *Value) bool {
   15486 	b := v.Block
   15487 	_ = b
   15488 	// match: (Less16U x y)
   15489 	// cond:
   15490 	// result: (SETB (CMPW x y))
   15491 	for {
   15492 		_ = v.Args[1]
   15493 		x := v.Args[0]
   15494 		y := v.Args[1]
   15495 		v.reset(Op386SETB)
   15496 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   15497 		v0.AddArg(x)
   15498 		v0.AddArg(y)
   15499 		v.AddArg(v0)
   15500 		return true
   15501 	}
   15502 }
   15503 func rewriteValue386_OpLess32_0(v *Value) bool {
   15504 	b := v.Block
   15505 	_ = b
   15506 	// match: (Less32 x y)
   15507 	// cond:
   15508 	// result: (SETL (CMPL x y))
   15509 	for {
   15510 		_ = v.Args[1]
   15511 		x := v.Args[0]
   15512 		y := v.Args[1]
   15513 		v.reset(Op386SETL)
   15514 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15515 		v0.AddArg(x)
   15516 		v0.AddArg(y)
   15517 		v.AddArg(v0)
   15518 		return true
   15519 	}
   15520 }
   15521 func rewriteValue386_OpLess32F_0(v *Value) bool {
   15522 	b := v.Block
   15523 	_ = b
   15524 	// match: (Less32F x y)
   15525 	// cond:
   15526 	// result: (SETGF (UCOMISS y x))
   15527 	for {
   15528 		_ = v.Args[1]
   15529 		x := v.Args[0]
   15530 		y := v.Args[1]
   15531 		v.reset(Op386SETGF)
   15532 		v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
   15533 		v0.AddArg(y)
   15534 		v0.AddArg(x)
   15535 		v.AddArg(v0)
   15536 		return true
   15537 	}
   15538 }
   15539 func rewriteValue386_OpLess32U_0(v *Value) bool {
   15540 	b := v.Block
   15541 	_ = b
   15542 	// match: (Less32U x y)
   15543 	// cond:
   15544 	// result: (SETB (CMPL x y))
   15545 	for {
   15546 		_ = v.Args[1]
   15547 		x := v.Args[0]
   15548 		y := v.Args[1]
   15549 		v.reset(Op386SETB)
   15550 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   15551 		v0.AddArg(x)
   15552 		v0.AddArg(y)
   15553 		v.AddArg(v0)
   15554 		return true
   15555 	}
   15556 }
   15557 func rewriteValue386_OpLess64F_0(v *Value) bool {
   15558 	b := v.Block
   15559 	_ = b
   15560 	// match: (Less64F x y)
   15561 	// cond:
   15562 	// result: (SETGF (UCOMISD y x))
   15563 	for {
   15564 		_ = v.Args[1]
   15565 		x := v.Args[0]
   15566 		y := v.Args[1]
   15567 		v.reset(Op386SETGF)
   15568 		v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
   15569 		v0.AddArg(y)
   15570 		v0.AddArg(x)
   15571 		v.AddArg(v0)
   15572 		return true
   15573 	}
   15574 }
   15575 func rewriteValue386_OpLess8_0(v *Value) bool {
   15576 	b := v.Block
   15577 	_ = b
   15578 	// match: (Less8 x y)
   15579 	// cond:
   15580 	// result: (SETL (CMPB x y))
   15581 	for {
   15582 		_ = v.Args[1]
   15583 		x := v.Args[0]
   15584 		y := v.Args[1]
   15585 		v.reset(Op386SETL)
   15586 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15587 		v0.AddArg(x)
   15588 		v0.AddArg(y)
   15589 		v.AddArg(v0)
   15590 		return true
   15591 	}
   15592 }
   15593 func rewriteValue386_OpLess8U_0(v *Value) bool {
   15594 	b := v.Block
   15595 	_ = b
   15596 	// match: (Less8U x y)
   15597 	// cond:
   15598 	// result: (SETB (CMPB x y))
   15599 	for {
   15600 		_ = v.Args[1]
   15601 		x := v.Args[0]
   15602 		y := v.Args[1]
   15603 		v.reset(Op386SETB)
   15604 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   15605 		v0.AddArg(x)
   15606 		v0.AddArg(y)
   15607 		v.AddArg(v0)
   15608 		return true
   15609 	}
   15610 }
   15611 func rewriteValue386_OpLoad_0(v *Value) bool {
   15612 	// match: (Load <t> ptr mem)
   15613 	// cond: (is32BitInt(t) || isPtr(t))
   15614 	// result: (MOVLload ptr mem)
   15615 	for {
   15616 		t := v.Type
   15617 		_ = v.Args[1]
   15618 		ptr := v.Args[0]
   15619 		mem := v.Args[1]
   15620 		if !(is32BitInt(t) || isPtr(t)) {
   15621 			break
   15622 		}
   15623 		v.reset(Op386MOVLload)
   15624 		v.AddArg(ptr)
   15625 		v.AddArg(mem)
   15626 		return true
   15627 	}
   15628 	// match: (Load <t> ptr mem)
   15629 	// cond: is16BitInt(t)
   15630 	// result: (MOVWload ptr mem)
   15631 	for {
   15632 		t := v.Type
   15633 		_ = v.Args[1]
   15634 		ptr := v.Args[0]
   15635 		mem := v.Args[1]
   15636 		if !(is16BitInt(t)) {
   15637 			break
   15638 		}
   15639 		v.reset(Op386MOVWload)
   15640 		v.AddArg(ptr)
   15641 		v.AddArg(mem)
   15642 		return true
   15643 	}
   15644 	// match: (Load <t> ptr mem)
   15645 	// cond: (t.IsBoolean() || is8BitInt(t))
   15646 	// result: (MOVBload ptr mem)
   15647 	for {
   15648 		t := v.Type
   15649 		_ = v.Args[1]
   15650 		ptr := v.Args[0]
   15651 		mem := v.Args[1]
   15652 		if !(t.IsBoolean() || is8BitInt(t)) {
   15653 			break
   15654 		}
   15655 		v.reset(Op386MOVBload)
   15656 		v.AddArg(ptr)
   15657 		v.AddArg(mem)
   15658 		return true
   15659 	}
   15660 	// match: (Load <t> ptr mem)
   15661 	// cond: is32BitFloat(t)
   15662 	// result: (MOVSSload ptr mem)
   15663 	for {
   15664 		t := v.Type
   15665 		_ = v.Args[1]
   15666 		ptr := v.Args[0]
   15667 		mem := v.Args[1]
   15668 		if !(is32BitFloat(t)) {
   15669 			break
   15670 		}
   15671 		v.reset(Op386MOVSSload)
   15672 		v.AddArg(ptr)
   15673 		v.AddArg(mem)
   15674 		return true
   15675 	}
   15676 	// match: (Load <t> ptr mem)
   15677 	// cond: is64BitFloat(t)
   15678 	// result: (MOVSDload ptr mem)
   15679 	for {
   15680 		t := v.Type
   15681 		_ = v.Args[1]
   15682 		ptr := v.Args[0]
   15683 		mem := v.Args[1]
   15684 		if !(is64BitFloat(t)) {
   15685 			break
   15686 		}
   15687 		v.reset(Op386MOVSDload)
   15688 		v.AddArg(ptr)
   15689 		v.AddArg(mem)
   15690 		return true
   15691 	}
   15692 	return false
   15693 }
   15694 func rewriteValue386_OpLsh16x16_0(v *Value) bool {
   15695 	b := v.Block
   15696 	_ = b
   15697 	// match: (Lsh16x16 <t> x y)
   15698 	// cond:
   15699 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
   15700 	for {
   15701 		t := v.Type
   15702 		_ = v.Args[1]
   15703 		x := v.Args[0]
   15704 		y := v.Args[1]
   15705 		v.reset(Op386ANDL)
   15706 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15707 		v0.AddArg(x)
   15708 		v0.AddArg(y)
   15709 		v.AddArg(v0)
   15710 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15711 		v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   15712 		v2.AuxInt = 32
   15713 		v2.AddArg(y)
   15714 		v1.AddArg(v2)
   15715 		v.AddArg(v1)
   15716 		return true
   15717 	}
   15718 }
   15719 func rewriteValue386_OpLsh16x32_0(v *Value) bool {
   15720 	b := v.Block
   15721 	_ = b
   15722 	// match: (Lsh16x32 <t> x y)
   15723 	// cond:
   15724 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
   15725 	for {
   15726 		t := v.Type
   15727 		_ = v.Args[1]
   15728 		x := v.Args[0]
   15729 		y := v.Args[1]
   15730 		v.reset(Op386ANDL)
   15731 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15732 		v0.AddArg(x)
   15733 		v0.AddArg(y)
   15734 		v.AddArg(v0)
   15735 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15736 		v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   15737 		v2.AuxInt = 32
   15738 		v2.AddArg(y)
   15739 		v1.AddArg(v2)
   15740 		v.AddArg(v1)
   15741 		return true
   15742 	}
   15743 }
   15744 func rewriteValue386_OpLsh16x64_0(v *Value) bool {
   15745 	// match: (Lsh16x64 x (Const64 [c]))
   15746 	// cond: uint64(c) < 16
   15747 	// result: (SHLLconst x [c])
   15748 	for {
   15749 		_ = v.Args[1]
   15750 		x := v.Args[0]
   15751 		v_1 := v.Args[1]
   15752 		if v_1.Op != OpConst64 {
   15753 			break
   15754 		}
   15755 		c := v_1.AuxInt
   15756 		if !(uint64(c) < 16) {
   15757 			break
   15758 		}
   15759 		v.reset(Op386SHLLconst)
   15760 		v.AuxInt = c
   15761 		v.AddArg(x)
   15762 		return true
   15763 	}
   15764 	// match: (Lsh16x64 _ (Const64 [c]))
   15765 	// cond: uint64(c) >= 16
   15766 	// result: (Const16 [0])
   15767 	for {
   15768 		_ = v.Args[1]
   15769 		v_1 := v.Args[1]
   15770 		if v_1.Op != OpConst64 {
   15771 			break
   15772 		}
   15773 		c := v_1.AuxInt
   15774 		if !(uint64(c) >= 16) {
   15775 			break
   15776 		}
   15777 		v.reset(OpConst16)
   15778 		v.AuxInt = 0
   15779 		return true
   15780 	}
   15781 	return false
   15782 }
   15783 func rewriteValue386_OpLsh16x8_0(v *Value) bool {
   15784 	b := v.Block
   15785 	_ = b
   15786 	// match: (Lsh16x8 <t> x y)
   15787 	// cond:
   15788 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
   15789 	for {
   15790 		t := v.Type
   15791 		_ = v.Args[1]
   15792 		x := v.Args[0]
   15793 		y := v.Args[1]
   15794 		v.reset(Op386ANDL)
   15795 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15796 		v0.AddArg(x)
   15797 		v0.AddArg(y)
   15798 		v.AddArg(v0)
   15799 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15800 		v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   15801 		v2.AuxInt = 32
   15802 		v2.AddArg(y)
   15803 		v1.AddArg(v2)
   15804 		v.AddArg(v1)
   15805 		return true
   15806 	}
   15807 }
   15808 func rewriteValue386_OpLsh32x16_0(v *Value) bool {
   15809 	b := v.Block
   15810 	_ = b
   15811 	// match: (Lsh32x16 <t> x y)
   15812 	// cond:
   15813 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
   15814 	for {
   15815 		t := v.Type
   15816 		_ = v.Args[1]
   15817 		x := v.Args[0]
   15818 		y := v.Args[1]
   15819 		v.reset(Op386ANDL)
   15820 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15821 		v0.AddArg(x)
   15822 		v0.AddArg(y)
   15823 		v.AddArg(v0)
   15824 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15825 		v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   15826 		v2.AuxInt = 32
   15827 		v2.AddArg(y)
   15828 		v1.AddArg(v2)
   15829 		v.AddArg(v1)
   15830 		return true
   15831 	}
   15832 }
   15833 func rewriteValue386_OpLsh32x32_0(v *Value) bool {
   15834 	b := v.Block
   15835 	_ = b
   15836 	// match: (Lsh32x32 <t> x y)
   15837 	// cond:
   15838 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
   15839 	for {
   15840 		t := v.Type
   15841 		_ = v.Args[1]
   15842 		x := v.Args[0]
   15843 		y := v.Args[1]
   15844 		v.reset(Op386ANDL)
   15845 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15846 		v0.AddArg(x)
   15847 		v0.AddArg(y)
   15848 		v.AddArg(v0)
   15849 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15850 		v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   15851 		v2.AuxInt = 32
   15852 		v2.AddArg(y)
   15853 		v1.AddArg(v2)
   15854 		v.AddArg(v1)
   15855 		return true
   15856 	}
   15857 }
   15858 func rewriteValue386_OpLsh32x64_0(v *Value) bool {
   15859 	// match: (Lsh32x64 x (Const64 [c]))
   15860 	// cond: uint64(c) < 32
   15861 	// result: (SHLLconst x [c])
   15862 	for {
   15863 		_ = v.Args[1]
   15864 		x := v.Args[0]
   15865 		v_1 := v.Args[1]
   15866 		if v_1.Op != OpConst64 {
   15867 			break
   15868 		}
   15869 		c := v_1.AuxInt
   15870 		if !(uint64(c) < 32) {
   15871 			break
   15872 		}
   15873 		v.reset(Op386SHLLconst)
   15874 		v.AuxInt = c
   15875 		v.AddArg(x)
   15876 		return true
   15877 	}
   15878 	// match: (Lsh32x64 _ (Const64 [c]))
   15879 	// cond: uint64(c) >= 32
   15880 	// result: (Const32 [0])
   15881 	for {
   15882 		_ = v.Args[1]
   15883 		v_1 := v.Args[1]
   15884 		if v_1.Op != OpConst64 {
   15885 			break
   15886 		}
   15887 		c := v_1.AuxInt
   15888 		if !(uint64(c) >= 32) {
   15889 			break
   15890 		}
   15891 		v.reset(OpConst32)
   15892 		v.AuxInt = 0
   15893 		return true
   15894 	}
   15895 	return false
   15896 }
   15897 func rewriteValue386_OpLsh32x8_0(v *Value) bool {
   15898 	b := v.Block
   15899 	_ = b
   15900 	// match: (Lsh32x8 <t> x y)
   15901 	// cond:
   15902 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
   15903 	for {
   15904 		t := v.Type
   15905 		_ = v.Args[1]
   15906 		x := v.Args[0]
   15907 		y := v.Args[1]
   15908 		v.reset(Op386ANDL)
   15909 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15910 		v0.AddArg(x)
   15911 		v0.AddArg(y)
   15912 		v.AddArg(v0)
   15913 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15914 		v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   15915 		v2.AuxInt = 32
   15916 		v2.AddArg(y)
   15917 		v1.AddArg(v2)
   15918 		v.AddArg(v1)
   15919 		return true
   15920 	}
   15921 }
   15922 func rewriteValue386_OpLsh8x16_0(v *Value) bool {
   15923 	b := v.Block
   15924 	_ = b
   15925 	// match: (Lsh8x16 <t> x y)
   15926 	// cond:
   15927 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
   15928 	for {
   15929 		t := v.Type
   15930 		_ = v.Args[1]
   15931 		x := v.Args[0]
   15932 		y := v.Args[1]
   15933 		v.reset(Op386ANDL)
   15934 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15935 		v0.AddArg(x)
   15936 		v0.AddArg(y)
   15937 		v.AddArg(v0)
   15938 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15939 		v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   15940 		v2.AuxInt = 32
   15941 		v2.AddArg(y)
   15942 		v1.AddArg(v2)
   15943 		v.AddArg(v1)
   15944 		return true
   15945 	}
   15946 }
   15947 func rewriteValue386_OpLsh8x32_0(v *Value) bool {
   15948 	b := v.Block
   15949 	_ = b
   15950 	// match: (Lsh8x32 <t> x y)
   15951 	// cond:
   15952 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
   15953 	for {
   15954 		t := v.Type
   15955 		_ = v.Args[1]
   15956 		x := v.Args[0]
   15957 		y := v.Args[1]
   15958 		v.reset(Op386ANDL)
   15959 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   15960 		v0.AddArg(x)
   15961 		v0.AddArg(y)
   15962 		v.AddArg(v0)
   15963 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   15964 		v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   15965 		v2.AuxInt = 32
   15966 		v2.AddArg(y)
   15967 		v1.AddArg(v2)
   15968 		v.AddArg(v1)
   15969 		return true
   15970 	}
   15971 }
   15972 func rewriteValue386_OpLsh8x64_0(v *Value) bool {
   15973 	// match: (Lsh8x64 x (Const64 [c]))
   15974 	// cond: uint64(c) < 8
   15975 	// result: (SHLLconst x [c])
   15976 	for {
   15977 		_ = v.Args[1]
   15978 		x := v.Args[0]
   15979 		v_1 := v.Args[1]
   15980 		if v_1.Op != OpConst64 {
   15981 			break
   15982 		}
   15983 		c := v_1.AuxInt
   15984 		if !(uint64(c) < 8) {
   15985 			break
   15986 		}
   15987 		v.reset(Op386SHLLconst)
   15988 		v.AuxInt = c
   15989 		v.AddArg(x)
   15990 		return true
   15991 	}
   15992 	// match: (Lsh8x64 _ (Const64 [c]))
   15993 	// cond: uint64(c) >= 8
   15994 	// result: (Const8 [0])
   15995 	for {
   15996 		_ = v.Args[1]
   15997 		v_1 := v.Args[1]
   15998 		if v_1.Op != OpConst64 {
   15999 			break
   16000 		}
   16001 		c := v_1.AuxInt
   16002 		if !(uint64(c) >= 8) {
   16003 			break
   16004 		}
   16005 		v.reset(OpConst8)
   16006 		v.AuxInt = 0
   16007 		return true
   16008 	}
   16009 	return false
   16010 }
   16011 func rewriteValue386_OpLsh8x8_0(v *Value) bool {
   16012 	b := v.Block
   16013 	_ = b
   16014 	// match: (Lsh8x8 <t> x y)
   16015 	// cond:
   16016 	// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
   16017 	for {
   16018 		t := v.Type
   16019 		_ = v.Args[1]
   16020 		x := v.Args[0]
   16021 		y := v.Args[1]
   16022 		v.reset(Op386ANDL)
   16023 		v0 := b.NewValue0(v.Pos, Op386SHLL, t)
   16024 		v0.AddArg(x)
   16025 		v0.AddArg(y)
   16026 		v.AddArg(v0)
   16027 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   16028 		v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   16029 		v2.AuxInt = 32
   16030 		v2.AddArg(y)
   16031 		v1.AddArg(v2)
   16032 		v.AddArg(v1)
   16033 		return true
   16034 	}
   16035 }
   16036 func rewriteValue386_OpMod16_0(v *Value) bool {
   16037 	// match: (Mod16 x y)
   16038 	// cond:
   16039 	// result: (MODW  x y)
   16040 	for {
   16041 		_ = v.Args[1]
   16042 		x := v.Args[0]
   16043 		y := v.Args[1]
   16044 		v.reset(Op386MODW)
   16045 		v.AddArg(x)
   16046 		v.AddArg(y)
   16047 		return true
   16048 	}
   16049 }
   16050 func rewriteValue386_OpMod16u_0(v *Value) bool {
   16051 	// match: (Mod16u x y)
   16052 	// cond:
   16053 	// result: (MODWU x y)
   16054 	for {
   16055 		_ = v.Args[1]
   16056 		x := v.Args[0]
   16057 		y := v.Args[1]
   16058 		v.reset(Op386MODWU)
   16059 		v.AddArg(x)
   16060 		v.AddArg(y)
   16061 		return true
   16062 	}
   16063 }
   16064 func rewriteValue386_OpMod32_0(v *Value) bool {
   16065 	// match: (Mod32 x y)
   16066 	// cond:
   16067 	// result: (MODL  x y)
   16068 	for {
   16069 		_ = v.Args[1]
   16070 		x := v.Args[0]
   16071 		y := v.Args[1]
   16072 		v.reset(Op386MODL)
   16073 		v.AddArg(x)
   16074 		v.AddArg(y)
   16075 		return true
   16076 	}
   16077 }
   16078 func rewriteValue386_OpMod32u_0(v *Value) bool {
   16079 	// match: (Mod32u x y)
   16080 	// cond:
   16081 	// result: (MODLU x y)
   16082 	for {
   16083 		_ = v.Args[1]
   16084 		x := v.Args[0]
   16085 		y := v.Args[1]
   16086 		v.reset(Op386MODLU)
   16087 		v.AddArg(x)
   16088 		v.AddArg(y)
   16089 		return true
   16090 	}
   16091 }
   16092 func rewriteValue386_OpMod8_0(v *Value) bool {
   16093 	b := v.Block
   16094 	_ = b
   16095 	typ := &b.Func.Config.Types
   16096 	_ = typ
   16097 	// match: (Mod8 x y)
   16098 	// cond:
   16099 	// result: (MODW  (SignExt8to16 x) (SignExt8to16 y))
   16100 	for {
   16101 		_ = v.Args[1]
   16102 		x := v.Args[0]
   16103 		y := v.Args[1]
   16104 		v.reset(Op386MODW)
   16105 		v0 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
   16106 		v0.AddArg(x)
   16107 		v.AddArg(v0)
   16108 		v1 := b.NewValue0(v.Pos, OpSignExt8to16, typ.Int16)
   16109 		v1.AddArg(y)
   16110 		v.AddArg(v1)
   16111 		return true
   16112 	}
   16113 }
   16114 func rewriteValue386_OpMod8u_0(v *Value) bool {
   16115 	b := v.Block
   16116 	_ = b
   16117 	typ := &b.Func.Config.Types
   16118 	_ = typ
   16119 	// match: (Mod8u x y)
   16120 	// cond:
   16121 	// result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y))
   16122 	for {
   16123 		_ = v.Args[1]
   16124 		x := v.Args[0]
   16125 		y := v.Args[1]
   16126 		v.reset(Op386MODWU)
   16127 		v0 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
   16128 		v0.AddArg(x)
   16129 		v.AddArg(v0)
   16130 		v1 := b.NewValue0(v.Pos, OpZeroExt8to16, typ.UInt16)
   16131 		v1.AddArg(y)
   16132 		v.AddArg(v1)
   16133 		return true
   16134 	}
   16135 }
   16136 func rewriteValue386_OpMove_0(v *Value) bool {
   16137 	b := v.Block
   16138 	_ = b
   16139 	typ := &b.Func.Config.Types
   16140 	_ = typ
   16141 	// match: (Move [0] _ _ mem)
   16142 	// cond:
   16143 	// result: mem
   16144 	for {
   16145 		if v.AuxInt != 0 {
   16146 			break
   16147 		}
   16148 		_ = v.Args[2]
   16149 		mem := v.Args[2]
   16150 		v.reset(OpCopy)
   16151 		v.Type = mem.Type
   16152 		v.AddArg(mem)
   16153 		return true
   16154 	}
   16155 	// match: (Move [1] dst src mem)
   16156 	// cond:
   16157 	// result: (MOVBstore dst (MOVBload src mem) mem)
   16158 	for {
   16159 		if v.AuxInt != 1 {
   16160 			break
   16161 		}
   16162 		_ = v.Args[2]
   16163 		dst := v.Args[0]
   16164 		src := v.Args[1]
   16165 		mem := v.Args[2]
   16166 		v.reset(Op386MOVBstore)
   16167 		v.AddArg(dst)
   16168 		v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
   16169 		v0.AddArg(src)
   16170 		v0.AddArg(mem)
   16171 		v.AddArg(v0)
   16172 		v.AddArg(mem)
   16173 		return true
   16174 	}
   16175 	// match: (Move [2] dst src mem)
   16176 	// cond:
   16177 	// result: (MOVWstore dst (MOVWload src mem) mem)
   16178 	for {
   16179 		if v.AuxInt != 2 {
   16180 			break
   16181 		}
   16182 		_ = v.Args[2]
   16183 		dst := v.Args[0]
   16184 		src := v.Args[1]
   16185 		mem := v.Args[2]
   16186 		v.reset(Op386MOVWstore)
   16187 		v.AddArg(dst)
   16188 		v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   16189 		v0.AddArg(src)
   16190 		v0.AddArg(mem)
   16191 		v.AddArg(v0)
   16192 		v.AddArg(mem)
   16193 		return true
   16194 	}
   16195 	// match: (Move [4] dst src mem)
   16196 	// cond:
   16197 	// result: (MOVLstore dst (MOVLload src mem) mem)
   16198 	for {
   16199 		if v.AuxInt != 4 {
   16200 			break
   16201 		}
   16202 		_ = v.Args[2]
   16203 		dst := v.Args[0]
   16204 		src := v.Args[1]
   16205 		mem := v.Args[2]
   16206 		v.reset(Op386MOVLstore)
   16207 		v.AddArg(dst)
   16208 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16209 		v0.AddArg(src)
   16210 		v0.AddArg(mem)
   16211 		v.AddArg(v0)
   16212 		v.AddArg(mem)
   16213 		return true
   16214 	}
   16215 	// match: (Move [3] dst src mem)
   16216 	// cond:
   16217 	// result: (MOVBstore [2] dst (MOVBload [2] src mem) 		(MOVWstore dst (MOVWload src mem) mem))
   16218 	for {
   16219 		if v.AuxInt != 3 {
   16220 			break
   16221 		}
   16222 		_ = v.Args[2]
   16223 		dst := v.Args[0]
   16224 		src := v.Args[1]
   16225 		mem := v.Args[2]
   16226 		v.reset(Op386MOVBstore)
   16227 		v.AuxInt = 2
   16228 		v.AddArg(dst)
   16229 		v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
   16230 		v0.AuxInt = 2
   16231 		v0.AddArg(src)
   16232 		v0.AddArg(mem)
   16233 		v.AddArg(v0)
   16234 		v1 := b.NewValue0(v.Pos, Op386MOVWstore, types.TypeMem)
   16235 		v1.AddArg(dst)
   16236 		v2 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   16237 		v2.AddArg(src)
   16238 		v2.AddArg(mem)
   16239 		v1.AddArg(v2)
   16240 		v1.AddArg(mem)
   16241 		v.AddArg(v1)
   16242 		return true
   16243 	}
   16244 	// match: (Move [5] dst src mem)
   16245 	// cond:
   16246 	// result: (MOVBstore [4] dst (MOVBload [4] src mem) 		(MOVLstore dst (MOVLload src mem) mem))
   16247 	for {
   16248 		if v.AuxInt != 5 {
   16249 			break
   16250 		}
   16251 		_ = v.Args[2]
   16252 		dst := v.Args[0]
   16253 		src := v.Args[1]
   16254 		mem := v.Args[2]
   16255 		v.reset(Op386MOVBstore)
   16256 		v.AuxInt = 4
   16257 		v.AddArg(dst)
   16258 		v0 := b.NewValue0(v.Pos, Op386MOVBload, typ.UInt8)
   16259 		v0.AuxInt = 4
   16260 		v0.AddArg(src)
   16261 		v0.AddArg(mem)
   16262 		v.AddArg(v0)
   16263 		v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
   16264 		v1.AddArg(dst)
   16265 		v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16266 		v2.AddArg(src)
   16267 		v2.AddArg(mem)
   16268 		v1.AddArg(v2)
   16269 		v1.AddArg(mem)
   16270 		v.AddArg(v1)
   16271 		return true
   16272 	}
   16273 	// match: (Move [6] dst src mem)
   16274 	// cond:
   16275 	// result: (MOVWstore [4] dst (MOVWload [4] src mem) 		(MOVLstore dst (MOVLload src mem) mem))
   16276 	for {
   16277 		if v.AuxInt != 6 {
   16278 			break
   16279 		}
   16280 		_ = v.Args[2]
   16281 		dst := v.Args[0]
   16282 		src := v.Args[1]
   16283 		mem := v.Args[2]
   16284 		v.reset(Op386MOVWstore)
   16285 		v.AuxInt = 4
   16286 		v.AddArg(dst)
   16287 		v0 := b.NewValue0(v.Pos, Op386MOVWload, typ.UInt16)
   16288 		v0.AuxInt = 4
   16289 		v0.AddArg(src)
   16290 		v0.AddArg(mem)
   16291 		v.AddArg(v0)
   16292 		v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
   16293 		v1.AddArg(dst)
   16294 		v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16295 		v2.AddArg(src)
   16296 		v2.AddArg(mem)
   16297 		v1.AddArg(v2)
   16298 		v1.AddArg(mem)
   16299 		v.AddArg(v1)
   16300 		return true
   16301 	}
   16302 	// match: (Move [7] dst src mem)
   16303 	// cond:
   16304 	// result: (MOVLstore [3] dst (MOVLload [3] src mem) 		(MOVLstore dst (MOVLload src mem) mem))
   16305 	for {
   16306 		if v.AuxInt != 7 {
   16307 			break
   16308 		}
   16309 		_ = v.Args[2]
   16310 		dst := v.Args[0]
   16311 		src := v.Args[1]
   16312 		mem := v.Args[2]
   16313 		v.reset(Op386MOVLstore)
   16314 		v.AuxInt = 3
   16315 		v.AddArg(dst)
   16316 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16317 		v0.AuxInt = 3
   16318 		v0.AddArg(src)
   16319 		v0.AddArg(mem)
   16320 		v.AddArg(v0)
   16321 		v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
   16322 		v1.AddArg(dst)
   16323 		v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16324 		v2.AddArg(src)
   16325 		v2.AddArg(mem)
   16326 		v1.AddArg(v2)
   16327 		v1.AddArg(mem)
   16328 		v.AddArg(v1)
   16329 		return true
   16330 	}
   16331 	// match: (Move [8] dst src mem)
   16332 	// cond:
   16333 	// result: (MOVLstore [4] dst (MOVLload [4] src mem) 		(MOVLstore dst (MOVLload src mem) mem))
   16334 	for {
   16335 		if v.AuxInt != 8 {
   16336 			break
   16337 		}
   16338 		_ = v.Args[2]
   16339 		dst := v.Args[0]
   16340 		src := v.Args[1]
   16341 		mem := v.Args[2]
   16342 		v.reset(Op386MOVLstore)
   16343 		v.AuxInt = 4
   16344 		v.AddArg(dst)
   16345 		v0 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16346 		v0.AuxInt = 4
   16347 		v0.AddArg(src)
   16348 		v0.AddArg(mem)
   16349 		v.AddArg(v0)
   16350 		v1 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
   16351 		v1.AddArg(dst)
   16352 		v2 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16353 		v2.AddArg(src)
   16354 		v2.AddArg(mem)
   16355 		v1.AddArg(v2)
   16356 		v1.AddArg(mem)
   16357 		v.AddArg(v1)
   16358 		return true
   16359 	}
   16360 	// match: (Move [s] dst src mem)
   16361 	// cond: s > 8 && s%4 != 0
   16362 	// result: (Move [s-s%4] 		(ADDLconst <dst.Type> dst [s%4]) 		(ADDLconst <src.Type> src [s%4]) 		(MOVLstore dst (MOVLload src mem) mem))
   16363 	for {
   16364 		s := v.AuxInt
   16365 		_ = v.Args[2]
   16366 		dst := v.Args[0]
   16367 		src := v.Args[1]
   16368 		mem := v.Args[2]
   16369 		if !(s > 8 && s%4 != 0) {
   16370 			break
   16371 		}
   16372 		v.reset(OpMove)
   16373 		v.AuxInt = s - s%4
   16374 		v0 := b.NewValue0(v.Pos, Op386ADDLconst, dst.Type)
   16375 		v0.AuxInt = s % 4
   16376 		v0.AddArg(dst)
   16377 		v.AddArg(v0)
   16378 		v1 := b.NewValue0(v.Pos, Op386ADDLconst, src.Type)
   16379 		v1.AuxInt = s % 4
   16380 		v1.AddArg(src)
   16381 		v.AddArg(v1)
   16382 		v2 := b.NewValue0(v.Pos, Op386MOVLstore, types.TypeMem)
   16383 		v2.AddArg(dst)
   16384 		v3 := b.NewValue0(v.Pos, Op386MOVLload, typ.UInt32)
   16385 		v3.AddArg(src)
   16386 		v3.AddArg(mem)
   16387 		v2.AddArg(v3)
   16388 		v2.AddArg(mem)
   16389 		v.AddArg(v2)
   16390 		return true
   16391 	}
   16392 	return false
   16393 }
   16394 func rewriteValue386_OpMove_10(v *Value) bool {
   16395 	b := v.Block
   16396 	_ = b
   16397 	config := b.Func.Config
   16398 	_ = config
   16399 	typ := &b.Func.Config.Types
   16400 	_ = typ
   16401 	// match: (Move [s] dst src mem)
   16402 	// cond: s > 8 && s <= 4*128 && s%4 == 0 	&& !config.noDuffDevice
   16403 	// result: (DUFFCOPY [10*(128-s/4)] dst src mem)
   16404 	for {
   16405 		s := v.AuxInt
   16406 		_ = v.Args[2]
   16407 		dst := v.Args[0]
   16408 		src := v.Args[1]
   16409 		mem := v.Args[2]
   16410 		if !(s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) {
   16411 			break
   16412 		}
   16413 		v.reset(Op386DUFFCOPY)
   16414 		v.AuxInt = 10 * (128 - s/4)
   16415 		v.AddArg(dst)
   16416 		v.AddArg(src)
   16417 		v.AddArg(mem)
   16418 		return true
   16419 	}
   16420 	// match: (Move [s] dst src mem)
   16421 	// cond: (s > 4*128 || config.noDuffDevice) && s%4 == 0
   16422 	// result: (REPMOVSL dst src (MOVLconst [s/4]) mem)
   16423 	for {
   16424 		s := v.AuxInt
   16425 		_ = v.Args[2]
   16426 		dst := v.Args[0]
   16427 		src := v.Args[1]
   16428 		mem := v.Args[2]
   16429 		if !((s > 4*128 || config.noDuffDevice) && s%4 == 0) {
   16430 			break
   16431 		}
   16432 		v.reset(Op386REPMOVSL)
   16433 		v.AddArg(dst)
   16434 		v.AddArg(src)
   16435 		v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
   16436 		v0.AuxInt = s / 4
   16437 		v.AddArg(v0)
   16438 		v.AddArg(mem)
   16439 		return true
   16440 	}
   16441 	return false
   16442 }
   16443 func rewriteValue386_OpMul16_0(v *Value) bool {
   16444 	// match: (Mul16 x y)
   16445 	// cond:
   16446 	// result: (MULL  x y)
   16447 	for {
   16448 		_ = v.Args[1]
   16449 		x := v.Args[0]
   16450 		y := v.Args[1]
   16451 		v.reset(Op386MULL)
   16452 		v.AddArg(x)
   16453 		v.AddArg(y)
   16454 		return true
   16455 	}
   16456 }
   16457 func rewriteValue386_OpMul32_0(v *Value) bool {
   16458 	// match: (Mul32 x y)
   16459 	// cond:
   16460 	// result: (MULL  x y)
   16461 	for {
   16462 		_ = v.Args[1]
   16463 		x := v.Args[0]
   16464 		y := v.Args[1]
   16465 		v.reset(Op386MULL)
   16466 		v.AddArg(x)
   16467 		v.AddArg(y)
   16468 		return true
   16469 	}
   16470 }
   16471 func rewriteValue386_OpMul32F_0(v *Value) bool {
   16472 	// match: (Mul32F x y)
   16473 	// cond:
   16474 	// result: (MULSS x y)
   16475 	for {
   16476 		_ = v.Args[1]
   16477 		x := v.Args[0]
   16478 		y := v.Args[1]
   16479 		v.reset(Op386MULSS)
   16480 		v.AddArg(x)
   16481 		v.AddArg(y)
   16482 		return true
   16483 	}
   16484 }
   16485 func rewriteValue386_OpMul32uhilo_0(v *Value) bool {
   16486 	// match: (Mul32uhilo x y)
   16487 	// cond:
   16488 	// result: (MULLQU x y)
   16489 	for {
   16490 		_ = v.Args[1]
   16491 		x := v.Args[0]
   16492 		y := v.Args[1]
   16493 		v.reset(Op386MULLQU)
   16494 		v.AddArg(x)
   16495 		v.AddArg(y)
   16496 		return true
   16497 	}
   16498 }
   16499 func rewriteValue386_OpMul64F_0(v *Value) bool {
   16500 	// match: (Mul64F x y)
   16501 	// cond:
   16502 	// result: (MULSD x y)
   16503 	for {
   16504 		_ = v.Args[1]
   16505 		x := v.Args[0]
   16506 		y := v.Args[1]
   16507 		v.reset(Op386MULSD)
   16508 		v.AddArg(x)
   16509 		v.AddArg(y)
   16510 		return true
   16511 	}
   16512 }
   16513 func rewriteValue386_OpMul8_0(v *Value) bool {
   16514 	// match: (Mul8 x y)
   16515 	// cond:
   16516 	// result: (MULL  x y)
   16517 	for {
   16518 		_ = v.Args[1]
   16519 		x := v.Args[0]
   16520 		y := v.Args[1]
   16521 		v.reset(Op386MULL)
   16522 		v.AddArg(x)
   16523 		v.AddArg(y)
   16524 		return true
   16525 	}
   16526 }
   16527 func rewriteValue386_OpNeg16_0(v *Value) bool {
   16528 	// match: (Neg16 x)
   16529 	// cond:
   16530 	// result: (NEGL x)
   16531 	for {
   16532 		x := v.Args[0]
   16533 		v.reset(Op386NEGL)
   16534 		v.AddArg(x)
   16535 		return true
   16536 	}
   16537 }
   16538 func rewriteValue386_OpNeg32_0(v *Value) bool {
   16539 	// match: (Neg32 x)
   16540 	// cond:
   16541 	// result: (NEGL x)
   16542 	for {
   16543 		x := v.Args[0]
   16544 		v.reset(Op386NEGL)
   16545 		v.AddArg(x)
   16546 		return true
   16547 	}
   16548 }
   16549 func rewriteValue386_OpNeg32F_0(v *Value) bool {
   16550 	b := v.Block
   16551 	_ = b
   16552 	config := b.Func.Config
   16553 	_ = config
   16554 	typ := &b.Func.Config.Types
   16555 	_ = typ
   16556 	// match: (Neg32F x)
   16557 	// cond: !config.use387
   16558 	// result: (PXOR x (MOVSSconst <typ.Float32> [f2i(math.Copysign(0, -1))]))
   16559 	for {
   16560 		x := v.Args[0]
   16561 		if !(!config.use387) {
   16562 			break
   16563 		}
   16564 		v.reset(Op386PXOR)
   16565 		v.AddArg(x)
   16566 		v0 := b.NewValue0(v.Pos, Op386MOVSSconst, typ.Float32)
   16567 		v0.AuxInt = f2i(math.Copysign(0, -1))
   16568 		v.AddArg(v0)
   16569 		return true
   16570 	}
   16571 	// match: (Neg32F x)
   16572 	// cond: config.use387
   16573 	// result: (FCHS x)
   16574 	for {
   16575 		x := v.Args[0]
   16576 		if !(config.use387) {
   16577 			break
   16578 		}
   16579 		v.reset(Op386FCHS)
   16580 		v.AddArg(x)
   16581 		return true
   16582 	}
   16583 	return false
   16584 }
   16585 func rewriteValue386_OpNeg64F_0(v *Value) bool {
   16586 	b := v.Block
   16587 	_ = b
   16588 	config := b.Func.Config
   16589 	_ = config
   16590 	typ := &b.Func.Config.Types
   16591 	_ = typ
   16592 	// match: (Neg64F x)
   16593 	// cond: !config.use387
   16594 	// result: (PXOR x (MOVSDconst <typ.Float64> [f2i(math.Copysign(0, -1))]))
   16595 	for {
   16596 		x := v.Args[0]
   16597 		if !(!config.use387) {
   16598 			break
   16599 		}
   16600 		v.reset(Op386PXOR)
   16601 		v.AddArg(x)
   16602 		v0 := b.NewValue0(v.Pos, Op386MOVSDconst, typ.Float64)
   16603 		v0.AuxInt = f2i(math.Copysign(0, -1))
   16604 		v.AddArg(v0)
   16605 		return true
   16606 	}
   16607 	// match: (Neg64F x)
   16608 	// cond: config.use387
   16609 	// result: (FCHS x)
   16610 	for {
   16611 		x := v.Args[0]
   16612 		if !(config.use387) {
   16613 			break
   16614 		}
   16615 		v.reset(Op386FCHS)
   16616 		v.AddArg(x)
   16617 		return true
   16618 	}
   16619 	return false
   16620 }
   16621 func rewriteValue386_OpNeg8_0(v *Value) bool {
   16622 	// match: (Neg8 x)
   16623 	// cond:
   16624 	// result: (NEGL x)
   16625 	for {
   16626 		x := v.Args[0]
   16627 		v.reset(Op386NEGL)
   16628 		v.AddArg(x)
   16629 		return true
   16630 	}
   16631 }
   16632 func rewriteValue386_OpNeq16_0(v *Value) bool {
   16633 	b := v.Block
   16634 	_ = b
   16635 	// match: (Neq16 x y)
   16636 	// cond:
   16637 	// result: (SETNE (CMPW x y))
   16638 	for {
   16639 		_ = v.Args[1]
   16640 		x := v.Args[0]
   16641 		y := v.Args[1]
   16642 		v.reset(Op386SETNE)
   16643 		v0 := b.NewValue0(v.Pos, Op386CMPW, types.TypeFlags)
   16644 		v0.AddArg(x)
   16645 		v0.AddArg(y)
   16646 		v.AddArg(v0)
   16647 		return true
   16648 	}
   16649 }
   16650 func rewriteValue386_OpNeq32_0(v *Value) bool {
   16651 	b := v.Block
   16652 	_ = b
   16653 	// match: (Neq32 x y)
   16654 	// cond:
   16655 	// result: (SETNE (CMPL x y))
   16656 	for {
   16657 		_ = v.Args[1]
   16658 		x := v.Args[0]
   16659 		y := v.Args[1]
   16660 		v.reset(Op386SETNE)
   16661 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   16662 		v0.AddArg(x)
   16663 		v0.AddArg(y)
   16664 		v.AddArg(v0)
   16665 		return true
   16666 	}
   16667 }
   16668 func rewriteValue386_OpNeq32F_0(v *Value) bool {
   16669 	b := v.Block
   16670 	_ = b
   16671 	// match: (Neq32F x y)
   16672 	// cond:
   16673 	// result: (SETNEF (UCOMISS x y))
   16674 	for {
   16675 		_ = v.Args[1]
   16676 		x := v.Args[0]
   16677 		y := v.Args[1]
   16678 		v.reset(Op386SETNEF)
   16679 		v0 := b.NewValue0(v.Pos, Op386UCOMISS, types.TypeFlags)
   16680 		v0.AddArg(x)
   16681 		v0.AddArg(y)
   16682 		v.AddArg(v0)
   16683 		return true
   16684 	}
   16685 }
   16686 func rewriteValue386_OpNeq64F_0(v *Value) bool {
   16687 	b := v.Block
   16688 	_ = b
   16689 	// match: (Neq64F x y)
   16690 	// cond:
   16691 	// result: (SETNEF (UCOMISD x y))
   16692 	for {
   16693 		_ = v.Args[1]
   16694 		x := v.Args[0]
   16695 		y := v.Args[1]
   16696 		v.reset(Op386SETNEF)
   16697 		v0 := b.NewValue0(v.Pos, Op386UCOMISD, types.TypeFlags)
   16698 		v0.AddArg(x)
   16699 		v0.AddArg(y)
   16700 		v.AddArg(v0)
   16701 		return true
   16702 	}
   16703 }
   16704 func rewriteValue386_OpNeq8_0(v *Value) bool {
   16705 	b := v.Block
   16706 	_ = b
   16707 	// match: (Neq8 x y)
   16708 	// cond:
   16709 	// result: (SETNE (CMPB x y))
   16710 	for {
   16711 		_ = v.Args[1]
   16712 		x := v.Args[0]
   16713 		y := v.Args[1]
   16714 		v.reset(Op386SETNE)
   16715 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   16716 		v0.AddArg(x)
   16717 		v0.AddArg(y)
   16718 		v.AddArg(v0)
   16719 		return true
   16720 	}
   16721 }
   16722 func rewriteValue386_OpNeqB_0(v *Value) bool {
   16723 	b := v.Block
   16724 	_ = b
   16725 	// match: (NeqB x y)
   16726 	// cond:
   16727 	// result: (SETNE (CMPB x y))
   16728 	for {
   16729 		_ = v.Args[1]
   16730 		x := v.Args[0]
   16731 		y := v.Args[1]
   16732 		v.reset(Op386SETNE)
   16733 		v0 := b.NewValue0(v.Pos, Op386CMPB, types.TypeFlags)
   16734 		v0.AddArg(x)
   16735 		v0.AddArg(y)
   16736 		v.AddArg(v0)
   16737 		return true
   16738 	}
   16739 }
   16740 func rewriteValue386_OpNeqPtr_0(v *Value) bool {
   16741 	b := v.Block
   16742 	_ = b
   16743 	// match: (NeqPtr x y)
   16744 	// cond:
   16745 	// result: (SETNE (CMPL x y))
   16746 	for {
   16747 		_ = v.Args[1]
   16748 		x := v.Args[0]
   16749 		y := v.Args[1]
   16750 		v.reset(Op386SETNE)
   16751 		v0 := b.NewValue0(v.Pos, Op386CMPL, types.TypeFlags)
   16752 		v0.AddArg(x)
   16753 		v0.AddArg(y)
   16754 		v.AddArg(v0)
   16755 		return true
   16756 	}
   16757 }
   16758 func rewriteValue386_OpNilCheck_0(v *Value) bool {
   16759 	// match: (NilCheck ptr mem)
   16760 	// cond:
   16761 	// result: (LoweredNilCheck ptr mem)
   16762 	for {
   16763 		_ = v.Args[1]
   16764 		ptr := v.Args[0]
   16765 		mem := v.Args[1]
   16766 		v.reset(Op386LoweredNilCheck)
   16767 		v.AddArg(ptr)
   16768 		v.AddArg(mem)
   16769 		return true
   16770 	}
   16771 }
   16772 func rewriteValue386_OpNot_0(v *Value) bool {
   16773 	// match: (Not x)
   16774 	// cond:
   16775 	// result: (XORLconst [1] x)
   16776 	for {
   16777 		x := v.Args[0]
   16778 		v.reset(Op386XORLconst)
   16779 		v.AuxInt = 1
   16780 		v.AddArg(x)
   16781 		return true
   16782 	}
   16783 }
   16784 func rewriteValue386_OpOffPtr_0(v *Value) bool {
   16785 	// match: (OffPtr [off] ptr)
   16786 	// cond:
   16787 	// result: (ADDLconst [off] ptr)
   16788 	for {
   16789 		off := v.AuxInt
   16790 		ptr := v.Args[0]
   16791 		v.reset(Op386ADDLconst)
   16792 		v.AuxInt = off
   16793 		v.AddArg(ptr)
   16794 		return true
   16795 	}
   16796 }
   16797 func rewriteValue386_OpOr16_0(v *Value) bool {
   16798 	// match: (Or16 x y)
   16799 	// cond:
   16800 	// result: (ORL x y)
   16801 	for {
   16802 		_ = v.Args[1]
   16803 		x := v.Args[0]
   16804 		y := v.Args[1]
   16805 		v.reset(Op386ORL)
   16806 		v.AddArg(x)
   16807 		v.AddArg(y)
   16808 		return true
   16809 	}
   16810 }
   16811 func rewriteValue386_OpOr32_0(v *Value) bool {
   16812 	// match: (Or32 x y)
   16813 	// cond:
   16814 	// result: (ORL x y)
   16815 	for {
   16816 		_ = v.Args[1]
   16817 		x := v.Args[0]
   16818 		y := v.Args[1]
   16819 		v.reset(Op386ORL)
   16820 		v.AddArg(x)
   16821 		v.AddArg(y)
   16822 		return true
   16823 	}
   16824 }
   16825 func rewriteValue386_OpOr8_0(v *Value) bool {
   16826 	// match: (Or8 x y)
   16827 	// cond:
   16828 	// result: (ORL x y)
   16829 	for {
   16830 		_ = v.Args[1]
   16831 		x := v.Args[0]
   16832 		y := v.Args[1]
   16833 		v.reset(Op386ORL)
   16834 		v.AddArg(x)
   16835 		v.AddArg(y)
   16836 		return true
   16837 	}
   16838 }
   16839 func rewriteValue386_OpOrB_0(v *Value) bool {
   16840 	// match: (OrB x y)
   16841 	// cond:
   16842 	// result: (ORL x y)
   16843 	for {
   16844 		_ = v.Args[1]
   16845 		x := v.Args[0]
   16846 		y := v.Args[1]
   16847 		v.reset(Op386ORL)
   16848 		v.AddArg(x)
   16849 		v.AddArg(y)
   16850 		return true
   16851 	}
   16852 }
   16853 func rewriteValue386_OpRound32F_0(v *Value) bool {
   16854 	// match: (Round32F x)
   16855 	// cond:
   16856 	// result: x
   16857 	for {
   16858 		x := v.Args[0]
   16859 		v.reset(OpCopy)
   16860 		v.Type = x.Type
   16861 		v.AddArg(x)
   16862 		return true
   16863 	}
   16864 }
   16865 func rewriteValue386_OpRound64F_0(v *Value) bool {
   16866 	// match: (Round64F x)
   16867 	// cond:
   16868 	// result: x
   16869 	for {
   16870 		x := v.Args[0]
   16871 		v.reset(OpCopy)
   16872 		v.Type = x.Type
   16873 		v.AddArg(x)
   16874 		return true
   16875 	}
   16876 }
   16877 func rewriteValue386_OpRsh16Ux16_0(v *Value) bool {
   16878 	b := v.Block
   16879 	_ = b
   16880 	// match: (Rsh16Ux16 <t> x y)
   16881 	// cond:
   16882 	// result: (ANDL (SHRW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
   16883 	for {
   16884 		t := v.Type
   16885 		_ = v.Args[1]
   16886 		x := v.Args[0]
   16887 		y := v.Args[1]
   16888 		v.reset(Op386ANDL)
   16889 		v0 := b.NewValue0(v.Pos, Op386SHRW, t)
   16890 		v0.AddArg(x)
   16891 		v0.AddArg(y)
   16892 		v.AddArg(v0)
   16893 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   16894 		v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   16895 		v2.AuxInt = 16
   16896 		v2.AddArg(y)
   16897 		v1.AddArg(v2)
   16898 		v.AddArg(v1)
   16899 		return true
   16900 	}
   16901 }
   16902 func rewriteValue386_OpRsh16Ux32_0(v *Value) bool {
   16903 	b := v.Block
   16904 	_ = b
   16905 	// match: (Rsh16Ux32 <t> x y)
   16906 	// cond:
   16907 	// result: (ANDL (SHRW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
   16908 	for {
   16909 		t := v.Type
   16910 		_ = v.Args[1]
   16911 		x := v.Args[0]
   16912 		y := v.Args[1]
   16913 		v.reset(Op386ANDL)
   16914 		v0 := b.NewValue0(v.Pos, Op386SHRW, t)
   16915 		v0.AddArg(x)
   16916 		v0.AddArg(y)
   16917 		v.AddArg(v0)
   16918 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   16919 		v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   16920 		v2.AuxInt = 16
   16921 		v2.AddArg(y)
   16922 		v1.AddArg(v2)
   16923 		v.AddArg(v1)
   16924 		return true
   16925 	}
   16926 }
   16927 func rewriteValue386_OpRsh16Ux64_0(v *Value) bool {
   16928 	// match: (Rsh16Ux64 x (Const64 [c]))
   16929 	// cond: uint64(c) < 16
   16930 	// result: (SHRWconst x [c])
   16931 	for {
   16932 		_ = v.Args[1]
   16933 		x := v.Args[0]
   16934 		v_1 := v.Args[1]
   16935 		if v_1.Op != OpConst64 {
   16936 			break
   16937 		}
   16938 		c := v_1.AuxInt
   16939 		if !(uint64(c) < 16) {
   16940 			break
   16941 		}
   16942 		v.reset(Op386SHRWconst)
   16943 		v.AuxInt = c
   16944 		v.AddArg(x)
   16945 		return true
   16946 	}
   16947 	// match: (Rsh16Ux64 _ (Const64 [c]))
   16948 	// cond: uint64(c) >= 16
   16949 	// result: (Const16 [0])
   16950 	for {
   16951 		_ = v.Args[1]
   16952 		v_1 := v.Args[1]
   16953 		if v_1.Op != OpConst64 {
   16954 			break
   16955 		}
   16956 		c := v_1.AuxInt
   16957 		if !(uint64(c) >= 16) {
   16958 			break
   16959 		}
   16960 		v.reset(OpConst16)
   16961 		v.AuxInt = 0
   16962 		return true
   16963 	}
   16964 	return false
   16965 }
   16966 func rewriteValue386_OpRsh16Ux8_0(v *Value) bool {
   16967 	b := v.Block
   16968 	_ = b
   16969 	// match: (Rsh16Ux8 <t> x y)
   16970 	// cond:
   16971 	// result: (ANDL (SHRW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
   16972 	for {
   16973 		t := v.Type
   16974 		_ = v.Args[1]
   16975 		x := v.Args[0]
   16976 		y := v.Args[1]
   16977 		v.reset(Op386ANDL)
   16978 		v0 := b.NewValue0(v.Pos, Op386SHRW, t)
   16979 		v0.AddArg(x)
   16980 		v0.AddArg(y)
   16981 		v.AddArg(v0)
   16982 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   16983 		v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   16984 		v2.AuxInt = 16
   16985 		v2.AddArg(y)
   16986 		v1.AddArg(v2)
   16987 		v.AddArg(v1)
   16988 		return true
   16989 	}
   16990 }
   16991 func rewriteValue386_OpRsh16x16_0(v *Value) bool {
   16992 	b := v.Block
   16993 	_ = b
   16994 	// match: (Rsh16x16 <t> x y)
   16995 	// cond:
   16996 	// result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [16])))))
   16997 	for {
   16998 		t := v.Type
   16999 		_ = v.Args[1]
   17000 		x := v.Args[0]
   17001 		y := v.Args[1]
   17002 		v.reset(Op386SARW)
   17003 		v.Type = t
   17004 		v.AddArg(x)
   17005 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17006 		v0.AddArg(y)
   17007 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17008 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17009 		v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   17010 		v3.AuxInt = 16
   17011 		v3.AddArg(y)
   17012 		v2.AddArg(v3)
   17013 		v1.AddArg(v2)
   17014 		v0.AddArg(v1)
   17015 		v.AddArg(v0)
   17016 		return true
   17017 	}
   17018 }
   17019 func rewriteValue386_OpRsh16x32_0(v *Value) bool {
   17020 	b := v.Block
   17021 	_ = b
   17022 	// match: (Rsh16x32 <t> x y)
   17023 	// cond:
   17024 	// result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [16])))))
   17025 	for {
   17026 		t := v.Type
   17027 		_ = v.Args[1]
   17028 		x := v.Args[0]
   17029 		y := v.Args[1]
   17030 		v.reset(Op386SARW)
   17031 		v.Type = t
   17032 		v.AddArg(x)
   17033 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17034 		v0.AddArg(y)
   17035 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17036 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17037 		v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   17038 		v3.AuxInt = 16
   17039 		v3.AddArg(y)
   17040 		v2.AddArg(v3)
   17041 		v1.AddArg(v2)
   17042 		v0.AddArg(v1)
   17043 		v.AddArg(v0)
   17044 		return true
   17045 	}
   17046 }
   17047 func rewriteValue386_OpRsh16x64_0(v *Value) bool {
   17048 	// match: (Rsh16x64 x (Const64 [c]))
   17049 	// cond: uint64(c) < 16
   17050 	// result: (SARWconst x [c])
   17051 	for {
   17052 		_ = v.Args[1]
   17053 		x := v.Args[0]
   17054 		v_1 := v.Args[1]
   17055 		if v_1.Op != OpConst64 {
   17056 			break
   17057 		}
   17058 		c := v_1.AuxInt
   17059 		if !(uint64(c) < 16) {
   17060 			break
   17061 		}
   17062 		v.reset(Op386SARWconst)
   17063 		v.AuxInt = c
   17064 		v.AddArg(x)
   17065 		return true
   17066 	}
   17067 	// match: (Rsh16x64 x (Const64 [c]))
   17068 	// cond: uint64(c) >= 16
   17069 	// result: (SARWconst x [15])
   17070 	for {
   17071 		_ = v.Args[1]
   17072 		x := v.Args[0]
   17073 		v_1 := v.Args[1]
   17074 		if v_1.Op != OpConst64 {
   17075 			break
   17076 		}
   17077 		c := v_1.AuxInt
   17078 		if !(uint64(c) >= 16) {
   17079 			break
   17080 		}
   17081 		v.reset(Op386SARWconst)
   17082 		v.AuxInt = 15
   17083 		v.AddArg(x)
   17084 		return true
   17085 	}
   17086 	return false
   17087 }
   17088 func rewriteValue386_OpRsh16x8_0(v *Value) bool {
   17089 	b := v.Block
   17090 	_ = b
   17091 	// match: (Rsh16x8 <t> x y)
   17092 	// cond:
   17093 	// result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [16])))))
   17094 	for {
   17095 		t := v.Type
   17096 		_ = v.Args[1]
   17097 		x := v.Args[0]
   17098 		y := v.Args[1]
   17099 		v.reset(Op386SARW)
   17100 		v.Type = t
   17101 		v.AddArg(x)
   17102 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17103 		v0.AddArg(y)
   17104 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17105 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17106 		v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   17107 		v3.AuxInt = 16
   17108 		v3.AddArg(y)
   17109 		v2.AddArg(v3)
   17110 		v1.AddArg(v2)
   17111 		v0.AddArg(v1)
   17112 		v.AddArg(v0)
   17113 		return true
   17114 	}
   17115 }
   17116 func rewriteValue386_OpRsh32Ux16_0(v *Value) bool {
   17117 	b := v.Block
   17118 	_ = b
   17119 	// match: (Rsh32Ux16 <t> x y)
   17120 	// cond:
   17121 	// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
   17122 	for {
   17123 		t := v.Type
   17124 		_ = v.Args[1]
   17125 		x := v.Args[0]
   17126 		y := v.Args[1]
   17127 		v.reset(Op386ANDL)
   17128 		v0 := b.NewValue0(v.Pos, Op386SHRL, t)
   17129 		v0.AddArg(x)
   17130 		v0.AddArg(y)
   17131 		v.AddArg(v0)
   17132 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   17133 		v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   17134 		v2.AuxInt = 32
   17135 		v2.AddArg(y)
   17136 		v1.AddArg(v2)
   17137 		v.AddArg(v1)
   17138 		return true
   17139 	}
   17140 }
   17141 func rewriteValue386_OpRsh32Ux32_0(v *Value) bool {
   17142 	b := v.Block
   17143 	_ = b
   17144 	// match: (Rsh32Ux32 <t> x y)
   17145 	// cond:
   17146 	// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
   17147 	for {
   17148 		t := v.Type
   17149 		_ = v.Args[1]
   17150 		x := v.Args[0]
   17151 		y := v.Args[1]
   17152 		v.reset(Op386ANDL)
   17153 		v0 := b.NewValue0(v.Pos, Op386SHRL, t)
   17154 		v0.AddArg(x)
   17155 		v0.AddArg(y)
   17156 		v.AddArg(v0)
   17157 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   17158 		v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   17159 		v2.AuxInt = 32
   17160 		v2.AddArg(y)
   17161 		v1.AddArg(v2)
   17162 		v.AddArg(v1)
   17163 		return true
   17164 	}
   17165 }
   17166 func rewriteValue386_OpRsh32Ux64_0(v *Value) bool {
   17167 	// match: (Rsh32Ux64 x (Const64 [c]))
   17168 	// cond: uint64(c) < 32
   17169 	// result: (SHRLconst x [c])
   17170 	for {
   17171 		_ = v.Args[1]
   17172 		x := v.Args[0]
   17173 		v_1 := v.Args[1]
   17174 		if v_1.Op != OpConst64 {
   17175 			break
   17176 		}
   17177 		c := v_1.AuxInt
   17178 		if !(uint64(c) < 32) {
   17179 			break
   17180 		}
   17181 		v.reset(Op386SHRLconst)
   17182 		v.AuxInt = c
   17183 		v.AddArg(x)
   17184 		return true
   17185 	}
   17186 	// match: (Rsh32Ux64 _ (Const64 [c]))
   17187 	// cond: uint64(c) >= 32
   17188 	// result: (Const32 [0])
   17189 	for {
   17190 		_ = v.Args[1]
   17191 		v_1 := v.Args[1]
   17192 		if v_1.Op != OpConst64 {
   17193 			break
   17194 		}
   17195 		c := v_1.AuxInt
   17196 		if !(uint64(c) >= 32) {
   17197 			break
   17198 		}
   17199 		v.reset(OpConst32)
   17200 		v.AuxInt = 0
   17201 		return true
   17202 	}
   17203 	return false
   17204 }
   17205 func rewriteValue386_OpRsh32Ux8_0(v *Value) bool {
   17206 	b := v.Block
   17207 	_ = b
   17208 	// match: (Rsh32Ux8 <t> x y)
   17209 	// cond:
   17210 	// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
   17211 	for {
   17212 		t := v.Type
   17213 		_ = v.Args[1]
   17214 		x := v.Args[0]
   17215 		y := v.Args[1]
   17216 		v.reset(Op386ANDL)
   17217 		v0 := b.NewValue0(v.Pos, Op386SHRL, t)
   17218 		v0.AddArg(x)
   17219 		v0.AddArg(y)
   17220 		v.AddArg(v0)
   17221 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   17222 		v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   17223 		v2.AuxInt = 32
   17224 		v2.AddArg(y)
   17225 		v1.AddArg(v2)
   17226 		v.AddArg(v1)
   17227 		return true
   17228 	}
   17229 }
   17230 func rewriteValue386_OpRsh32x16_0(v *Value) bool {
   17231 	b := v.Block
   17232 	_ = b
   17233 	// match: (Rsh32x16 <t> x y)
   17234 	// cond:
   17235 	// result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [32])))))
   17236 	for {
   17237 		t := v.Type
   17238 		_ = v.Args[1]
   17239 		x := v.Args[0]
   17240 		y := v.Args[1]
   17241 		v.reset(Op386SARL)
   17242 		v.Type = t
   17243 		v.AddArg(x)
   17244 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17245 		v0.AddArg(y)
   17246 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17247 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17248 		v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   17249 		v3.AuxInt = 32
   17250 		v3.AddArg(y)
   17251 		v2.AddArg(v3)
   17252 		v1.AddArg(v2)
   17253 		v0.AddArg(v1)
   17254 		v.AddArg(v0)
   17255 		return true
   17256 	}
   17257 }
   17258 func rewriteValue386_OpRsh32x32_0(v *Value) bool {
   17259 	b := v.Block
   17260 	_ = b
   17261 	// match: (Rsh32x32 <t> x y)
   17262 	// cond:
   17263 	// result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [32])))))
   17264 	for {
   17265 		t := v.Type
   17266 		_ = v.Args[1]
   17267 		x := v.Args[0]
   17268 		y := v.Args[1]
   17269 		v.reset(Op386SARL)
   17270 		v.Type = t
   17271 		v.AddArg(x)
   17272 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17273 		v0.AddArg(y)
   17274 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17275 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17276 		v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   17277 		v3.AuxInt = 32
   17278 		v3.AddArg(y)
   17279 		v2.AddArg(v3)
   17280 		v1.AddArg(v2)
   17281 		v0.AddArg(v1)
   17282 		v.AddArg(v0)
   17283 		return true
   17284 	}
   17285 }
   17286 func rewriteValue386_OpRsh32x64_0(v *Value) bool {
   17287 	// match: (Rsh32x64 x (Const64 [c]))
   17288 	// cond: uint64(c) < 32
   17289 	// result: (SARLconst x [c])
   17290 	for {
   17291 		_ = v.Args[1]
   17292 		x := v.Args[0]
   17293 		v_1 := v.Args[1]
   17294 		if v_1.Op != OpConst64 {
   17295 			break
   17296 		}
   17297 		c := v_1.AuxInt
   17298 		if !(uint64(c) < 32) {
   17299 			break
   17300 		}
   17301 		v.reset(Op386SARLconst)
   17302 		v.AuxInt = c
   17303 		v.AddArg(x)
   17304 		return true
   17305 	}
   17306 	// match: (Rsh32x64 x (Const64 [c]))
   17307 	// cond: uint64(c) >= 32
   17308 	// result: (SARLconst x [31])
   17309 	for {
   17310 		_ = v.Args[1]
   17311 		x := v.Args[0]
   17312 		v_1 := v.Args[1]
   17313 		if v_1.Op != OpConst64 {
   17314 			break
   17315 		}
   17316 		c := v_1.AuxInt
   17317 		if !(uint64(c) >= 32) {
   17318 			break
   17319 		}
   17320 		v.reset(Op386SARLconst)
   17321 		v.AuxInt = 31
   17322 		v.AddArg(x)
   17323 		return true
   17324 	}
   17325 	return false
   17326 }
   17327 func rewriteValue386_OpRsh32x8_0(v *Value) bool {
   17328 	b := v.Block
   17329 	_ = b
   17330 	// match: (Rsh32x8 <t> x y)
   17331 	// cond:
   17332 	// result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [32])))))
   17333 	for {
   17334 		t := v.Type
   17335 		_ = v.Args[1]
   17336 		x := v.Args[0]
   17337 		y := v.Args[1]
   17338 		v.reset(Op386SARL)
   17339 		v.Type = t
   17340 		v.AddArg(x)
   17341 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17342 		v0.AddArg(y)
   17343 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17344 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17345 		v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   17346 		v3.AuxInt = 32
   17347 		v3.AddArg(y)
   17348 		v2.AddArg(v3)
   17349 		v1.AddArg(v2)
   17350 		v0.AddArg(v1)
   17351 		v.AddArg(v0)
   17352 		return true
   17353 	}
   17354 }
   17355 func rewriteValue386_OpRsh8Ux16_0(v *Value) bool {
   17356 	b := v.Block
   17357 	_ = b
   17358 	// match: (Rsh8Ux16 <t> x y)
   17359 	// cond:
   17360 	// result: (ANDL (SHRB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
   17361 	for {
   17362 		t := v.Type
   17363 		_ = v.Args[1]
   17364 		x := v.Args[0]
   17365 		y := v.Args[1]
   17366 		v.reset(Op386ANDL)
   17367 		v0 := b.NewValue0(v.Pos, Op386SHRB, t)
   17368 		v0.AddArg(x)
   17369 		v0.AddArg(y)
   17370 		v.AddArg(v0)
   17371 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   17372 		v2 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   17373 		v2.AuxInt = 8
   17374 		v2.AddArg(y)
   17375 		v1.AddArg(v2)
   17376 		v.AddArg(v1)
   17377 		return true
   17378 	}
   17379 }
   17380 func rewriteValue386_OpRsh8Ux32_0(v *Value) bool {
   17381 	b := v.Block
   17382 	_ = b
   17383 	// match: (Rsh8Ux32 <t> x y)
   17384 	// cond:
   17385 	// result: (ANDL (SHRB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
   17386 	for {
   17387 		t := v.Type
   17388 		_ = v.Args[1]
   17389 		x := v.Args[0]
   17390 		y := v.Args[1]
   17391 		v.reset(Op386ANDL)
   17392 		v0 := b.NewValue0(v.Pos, Op386SHRB, t)
   17393 		v0.AddArg(x)
   17394 		v0.AddArg(y)
   17395 		v.AddArg(v0)
   17396 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   17397 		v2 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   17398 		v2.AuxInt = 8
   17399 		v2.AddArg(y)
   17400 		v1.AddArg(v2)
   17401 		v.AddArg(v1)
   17402 		return true
   17403 	}
   17404 }
   17405 func rewriteValue386_OpRsh8Ux64_0(v *Value) bool {
   17406 	// match: (Rsh8Ux64 x (Const64 [c]))
   17407 	// cond: uint64(c) < 8
   17408 	// result: (SHRBconst x [c])
   17409 	for {
   17410 		_ = v.Args[1]
   17411 		x := v.Args[0]
   17412 		v_1 := v.Args[1]
   17413 		if v_1.Op != OpConst64 {
   17414 			break
   17415 		}
   17416 		c := v_1.AuxInt
   17417 		if !(uint64(c) < 8) {
   17418 			break
   17419 		}
   17420 		v.reset(Op386SHRBconst)
   17421 		v.AuxInt = c
   17422 		v.AddArg(x)
   17423 		return true
   17424 	}
   17425 	// match: (Rsh8Ux64 _ (Const64 [c]))
   17426 	// cond: uint64(c) >= 8
   17427 	// result: (Const8 [0])
   17428 	for {
   17429 		_ = v.Args[1]
   17430 		v_1 := v.Args[1]
   17431 		if v_1.Op != OpConst64 {
   17432 			break
   17433 		}
   17434 		c := v_1.AuxInt
   17435 		if !(uint64(c) >= 8) {
   17436 			break
   17437 		}
   17438 		v.reset(OpConst8)
   17439 		v.AuxInt = 0
   17440 		return true
   17441 	}
   17442 	return false
   17443 }
   17444 func rewriteValue386_OpRsh8Ux8_0(v *Value) bool {
   17445 	b := v.Block
   17446 	_ = b
   17447 	// match: (Rsh8Ux8 <t> x y)
   17448 	// cond:
   17449 	// result: (ANDL (SHRB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
   17450 	for {
   17451 		t := v.Type
   17452 		_ = v.Args[1]
   17453 		x := v.Args[0]
   17454 		y := v.Args[1]
   17455 		v.reset(Op386ANDL)
   17456 		v0 := b.NewValue0(v.Pos, Op386SHRB, t)
   17457 		v0.AddArg(x)
   17458 		v0.AddArg(y)
   17459 		v.AddArg(v0)
   17460 		v1 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   17461 		v2 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   17462 		v2.AuxInt = 8
   17463 		v2.AddArg(y)
   17464 		v1.AddArg(v2)
   17465 		v.AddArg(v1)
   17466 		return true
   17467 	}
   17468 }
   17469 func rewriteValue386_OpRsh8x16_0(v *Value) bool {
   17470 	b := v.Block
   17471 	_ = b
   17472 	// match: (Rsh8x16 <t> x y)
   17473 	// cond:
   17474 	// result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [8])))))
   17475 	for {
   17476 		t := v.Type
   17477 		_ = v.Args[1]
   17478 		x := v.Args[0]
   17479 		y := v.Args[1]
   17480 		v.reset(Op386SARB)
   17481 		v.Type = t
   17482 		v.AddArg(x)
   17483 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17484 		v0.AddArg(y)
   17485 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17486 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17487 		v3 := b.NewValue0(v.Pos, Op386CMPWconst, types.TypeFlags)
   17488 		v3.AuxInt = 8
   17489 		v3.AddArg(y)
   17490 		v2.AddArg(v3)
   17491 		v1.AddArg(v2)
   17492 		v0.AddArg(v1)
   17493 		v.AddArg(v0)
   17494 		return true
   17495 	}
   17496 }
   17497 func rewriteValue386_OpRsh8x32_0(v *Value) bool {
   17498 	b := v.Block
   17499 	_ = b
   17500 	// match: (Rsh8x32 <t> x y)
   17501 	// cond:
   17502 	// result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [8])))))
   17503 	for {
   17504 		t := v.Type
   17505 		_ = v.Args[1]
   17506 		x := v.Args[0]
   17507 		y := v.Args[1]
   17508 		v.reset(Op386SARB)
   17509 		v.Type = t
   17510 		v.AddArg(x)
   17511 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17512 		v0.AddArg(y)
   17513 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17514 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17515 		v3 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   17516 		v3.AuxInt = 8
   17517 		v3.AddArg(y)
   17518 		v2.AddArg(v3)
   17519 		v1.AddArg(v2)
   17520 		v0.AddArg(v1)
   17521 		v.AddArg(v0)
   17522 		return true
   17523 	}
   17524 }
   17525 func rewriteValue386_OpRsh8x64_0(v *Value) bool {
   17526 	// match: (Rsh8x64 x (Const64 [c]))
   17527 	// cond: uint64(c) < 8
   17528 	// result: (SARBconst x [c])
   17529 	for {
   17530 		_ = v.Args[1]
   17531 		x := v.Args[0]
   17532 		v_1 := v.Args[1]
   17533 		if v_1.Op != OpConst64 {
   17534 			break
   17535 		}
   17536 		c := v_1.AuxInt
   17537 		if !(uint64(c) < 8) {
   17538 			break
   17539 		}
   17540 		v.reset(Op386SARBconst)
   17541 		v.AuxInt = c
   17542 		v.AddArg(x)
   17543 		return true
   17544 	}
   17545 	// match: (Rsh8x64 x (Const64 [c]))
   17546 	// cond: uint64(c) >= 8
   17547 	// result: (SARBconst x [7])
   17548 	for {
   17549 		_ = v.Args[1]
   17550 		x := v.Args[0]
   17551 		v_1 := v.Args[1]
   17552 		if v_1.Op != OpConst64 {
   17553 			break
   17554 		}
   17555 		c := v_1.AuxInt
   17556 		if !(uint64(c) >= 8) {
   17557 			break
   17558 		}
   17559 		v.reset(Op386SARBconst)
   17560 		v.AuxInt = 7
   17561 		v.AddArg(x)
   17562 		return true
   17563 	}
   17564 	return false
   17565 }
   17566 func rewriteValue386_OpRsh8x8_0(v *Value) bool {
   17567 	b := v.Block
   17568 	_ = b
   17569 	// match: (Rsh8x8 <t> x y)
   17570 	// cond:
   17571 	// result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [8])))))
   17572 	for {
   17573 		t := v.Type
   17574 		_ = v.Args[1]
   17575 		x := v.Args[0]
   17576 		y := v.Args[1]
   17577 		v.reset(Op386SARB)
   17578 		v.Type = t
   17579 		v.AddArg(x)
   17580 		v0 := b.NewValue0(v.Pos, Op386ORL, y.Type)
   17581 		v0.AddArg(y)
   17582 		v1 := b.NewValue0(v.Pos, Op386NOTL, y.Type)
   17583 		v2 := b.NewValue0(v.Pos, Op386SBBLcarrymask, y.Type)
   17584 		v3 := b.NewValue0(v.Pos, Op386CMPBconst, types.TypeFlags)
   17585 		v3.AuxInt = 8
   17586 		v3.AddArg(y)
   17587 		v2.AddArg(v3)
   17588 		v1.AddArg(v2)
   17589 		v0.AddArg(v1)
   17590 		v.AddArg(v0)
   17591 		return true
   17592 	}
   17593 }
   17594 func rewriteValue386_OpSignExt16to32_0(v *Value) bool {
   17595 	// match: (SignExt16to32 x)
   17596 	// cond:
   17597 	// result: (MOVWLSX x)
   17598 	for {
   17599 		x := v.Args[0]
   17600 		v.reset(Op386MOVWLSX)
   17601 		v.AddArg(x)
   17602 		return true
   17603 	}
   17604 }
   17605 func rewriteValue386_OpSignExt8to16_0(v *Value) bool {
   17606 	// match: (SignExt8to16 x)
   17607 	// cond:
   17608 	// result: (MOVBLSX x)
   17609 	for {
   17610 		x := v.Args[0]
   17611 		v.reset(Op386MOVBLSX)
   17612 		v.AddArg(x)
   17613 		return true
   17614 	}
   17615 }
   17616 func rewriteValue386_OpSignExt8to32_0(v *Value) bool {
   17617 	// match: (SignExt8to32 x)
   17618 	// cond:
   17619 	// result: (MOVBLSX x)
   17620 	for {
   17621 		x := v.Args[0]
   17622 		v.reset(Op386MOVBLSX)
   17623 		v.AddArg(x)
   17624 		return true
   17625 	}
   17626 }
   17627 func rewriteValue386_OpSignmask_0(v *Value) bool {
   17628 	// match: (Signmask x)
   17629 	// cond:
   17630 	// result: (SARLconst x [31])
   17631 	for {
   17632 		x := v.Args[0]
   17633 		v.reset(Op386SARLconst)
   17634 		v.AuxInt = 31
   17635 		v.AddArg(x)
   17636 		return true
   17637 	}
   17638 }
   17639 func rewriteValue386_OpSlicemask_0(v *Value) bool {
   17640 	b := v.Block
   17641 	_ = b
   17642 	// match: (Slicemask <t> x)
   17643 	// cond:
   17644 	// result: (SARLconst (NEGL <t> x) [31])
   17645 	for {
   17646 		t := v.Type
   17647 		x := v.Args[0]
   17648 		v.reset(Op386SARLconst)
   17649 		v.AuxInt = 31
   17650 		v0 := b.NewValue0(v.Pos, Op386NEGL, t)
   17651 		v0.AddArg(x)
   17652 		v.AddArg(v0)
   17653 		return true
   17654 	}
   17655 }
   17656 func rewriteValue386_OpSqrt_0(v *Value) bool {
   17657 	// match: (Sqrt x)
   17658 	// cond:
   17659 	// result: (SQRTSD x)
   17660 	for {
   17661 		x := v.Args[0]
   17662 		v.reset(Op386SQRTSD)
   17663 		v.AddArg(x)
   17664 		return true
   17665 	}
   17666 }
   17667 func rewriteValue386_OpStaticCall_0(v *Value) bool {
   17668 	// match: (StaticCall [argwid] {target} mem)
   17669 	// cond:
   17670 	// result: (CALLstatic [argwid] {target} mem)
   17671 	for {
   17672 		argwid := v.AuxInt
   17673 		target := v.Aux
   17674 		mem := v.Args[0]
   17675 		v.reset(Op386CALLstatic)
   17676 		v.AuxInt = argwid
   17677 		v.Aux = target
   17678 		v.AddArg(mem)
   17679 		return true
   17680 	}
   17681 }
   17682 func rewriteValue386_OpStore_0(v *Value) bool {
   17683 	// match: (Store {t} ptr val mem)
   17684 	// cond: t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)
   17685 	// result: (MOVSDstore ptr val mem)
   17686 	for {
   17687 		t := v.Aux
   17688 		_ = v.Args[2]
   17689 		ptr := v.Args[0]
   17690 		val := v.Args[1]
   17691 		mem := v.Args[2]
   17692 		if !(t.(*types.Type).Size() == 8 && is64BitFloat(val.Type)) {
   17693 			break
   17694 		}
   17695 		v.reset(Op386MOVSDstore)
   17696 		v.AddArg(ptr)
   17697 		v.AddArg(val)
   17698 		v.AddArg(mem)
   17699 		return true
   17700 	}
   17701 	// match: (Store {t} ptr val mem)
   17702 	// cond: t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)
   17703 	// result: (MOVSSstore ptr val mem)
   17704 	for {
   17705 		t := v.Aux
   17706 		_ = v.Args[2]
   17707 		ptr := v.Args[0]
   17708 		val := v.Args[1]
   17709 		mem := v.Args[2]
   17710 		if !(t.(*types.Type).Size() == 4 && is32BitFloat(val.Type)) {
   17711 			break
   17712 		}
   17713 		v.reset(Op386MOVSSstore)
   17714 		v.AddArg(ptr)
   17715 		v.AddArg(val)
   17716 		v.AddArg(mem)
   17717 		return true
   17718 	}
   17719 	// match: (Store {t} ptr val mem)
   17720 	// cond: t.(*types.Type).Size() == 4
   17721 	// result: (MOVLstore ptr val mem)
   17722 	for {
   17723 		t := v.Aux
   17724 		_ = v.Args[2]
   17725 		ptr := v.Args[0]
   17726 		val := v.Args[1]
   17727 		mem := v.Args[2]
   17728 		if !(t.(*types.Type).Size() == 4) {
   17729 			break
   17730 		}
   17731 		v.reset(Op386MOVLstore)
   17732 		v.AddArg(ptr)
   17733 		v.AddArg(val)
   17734 		v.AddArg(mem)
   17735 		return true
   17736 	}
   17737 	// match: (Store {t} ptr val mem)
   17738 	// cond: t.(*types.Type).Size() == 2
   17739 	// result: (MOVWstore ptr val mem)
   17740 	for {
   17741 		t := v.Aux
   17742 		_ = v.Args[2]
   17743 		ptr := v.Args[0]
   17744 		val := v.Args[1]
   17745 		mem := v.Args[2]
   17746 		if !(t.(*types.Type).Size() == 2) {
   17747 			break
   17748 		}
   17749 		v.reset(Op386MOVWstore)
   17750 		v.AddArg(ptr)
   17751 		v.AddArg(val)
   17752 		v.AddArg(mem)
   17753 		return true
   17754 	}
   17755 	// match: (Store {t} ptr val mem)
   17756 	// cond: t.(*types.Type).Size() == 1
   17757 	// result: (MOVBstore ptr val mem)
   17758 	for {
   17759 		t := v.Aux
   17760 		_ = v.Args[2]
   17761 		ptr := v.Args[0]
   17762 		val := v.Args[1]
   17763 		mem := v.Args[2]
   17764 		if !(t.(*types.Type).Size() == 1) {
   17765 			break
   17766 		}
   17767 		v.reset(Op386MOVBstore)
   17768 		v.AddArg(ptr)
   17769 		v.AddArg(val)
   17770 		v.AddArg(mem)
   17771 		return true
   17772 	}
   17773 	return false
   17774 }
   17775 func rewriteValue386_OpSub16_0(v *Value) bool {
   17776 	// match: (Sub16 x y)
   17777 	// cond:
   17778 	// result: (SUBL  x y)
   17779 	for {
   17780 		_ = v.Args[1]
   17781 		x := v.Args[0]
   17782 		y := v.Args[1]
   17783 		v.reset(Op386SUBL)
   17784 		v.AddArg(x)
   17785 		v.AddArg(y)
   17786 		return true
   17787 	}
   17788 }
   17789 func rewriteValue386_OpSub32_0(v *Value) bool {
   17790 	// match: (Sub32 x y)
   17791 	// cond:
   17792 	// result: (SUBL  x y)
   17793 	for {
   17794 		_ = v.Args[1]
   17795 		x := v.Args[0]
   17796 		y := v.Args[1]
   17797 		v.reset(Op386SUBL)
   17798 		v.AddArg(x)
   17799 		v.AddArg(y)
   17800 		return true
   17801 	}
   17802 }
   17803 func rewriteValue386_OpSub32F_0(v *Value) bool {
   17804 	// match: (Sub32F x y)
   17805 	// cond:
   17806 	// result: (SUBSS x y)
   17807 	for {
   17808 		_ = v.Args[1]
   17809 		x := v.Args[0]
   17810 		y := v.Args[1]
   17811 		v.reset(Op386SUBSS)
   17812 		v.AddArg(x)
   17813 		v.AddArg(y)
   17814 		return true
   17815 	}
   17816 }
   17817 func rewriteValue386_OpSub32carry_0(v *Value) bool {
   17818 	// match: (Sub32carry x y)
   17819 	// cond:
   17820 	// result: (SUBLcarry x y)
   17821 	for {
   17822 		_ = v.Args[1]
   17823 		x := v.Args[0]
   17824 		y := v.Args[1]
   17825 		v.reset(Op386SUBLcarry)
   17826 		v.AddArg(x)
   17827 		v.AddArg(y)
   17828 		return true
   17829 	}
   17830 }
   17831 func rewriteValue386_OpSub32withcarry_0(v *Value) bool {
   17832 	// match: (Sub32withcarry x y c)
   17833 	// cond:
   17834 	// result: (SBBL x y c)
   17835 	for {
   17836 		_ = v.Args[2]
   17837 		x := v.Args[0]
   17838 		y := v.Args[1]
   17839 		c := v.Args[2]
   17840 		v.reset(Op386SBBL)
   17841 		v.AddArg(x)
   17842 		v.AddArg(y)
   17843 		v.AddArg(c)
   17844 		return true
   17845 	}
   17846 }
   17847 func rewriteValue386_OpSub64F_0(v *Value) bool {
   17848 	// match: (Sub64F x y)
   17849 	// cond:
   17850 	// result: (SUBSD x y)
   17851 	for {
   17852 		_ = v.Args[1]
   17853 		x := v.Args[0]
   17854 		y := v.Args[1]
   17855 		v.reset(Op386SUBSD)
   17856 		v.AddArg(x)
   17857 		v.AddArg(y)
   17858 		return true
   17859 	}
   17860 }
   17861 func rewriteValue386_OpSub8_0(v *Value) bool {
   17862 	// match: (Sub8 x y)
   17863 	// cond:
   17864 	// result: (SUBL  x y)
   17865 	for {
   17866 		_ = v.Args[1]
   17867 		x := v.Args[0]
   17868 		y := v.Args[1]
   17869 		v.reset(Op386SUBL)
   17870 		v.AddArg(x)
   17871 		v.AddArg(y)
   17872 		return true
   17873 	}
   17874 }
   17875 func rewriteValue386_OpSubPtr_0(v *Value) bool {
   17876 	// match: (SubPtr x y)
   17877 	// cond:
   17878 	// result: (SUBL  x y)
   17879 	for {
   17880 		_ = v.Args[1]
   17881 		x := v.Args[0]
   17882 		y := v.Args[1]
   17883 		v.reset(Op386SUBL)
   17884 		v.AddArg(x)
   17885 		v.AddArg(y)
   17886 		return true
   17887 	}
   17888 }
   17889 func rewriteValue386_OpTrunc16to8_0(v *Value) bool {
   17890 	// match: (Trunc16to8 x)
   17891 	// cond:
   17892 	// result: x
   17893 	for {
   17894 		x := v.Args[0]
   17895 		v.reset(OpCopy)
   17896 		v.Type = x.Type
   17897 		v.AddArg(x)
   17898 		return true
   17899 	}
   17900 }
   17901 func rewriteValue386_OpTrunc32to16_0(v *Value) bool {
   17902 	// match: (Trunc32to16 x)
   17903 	// cond:
   17904 	// result: x
   17905 	for {
   17906 		x := v.Args[0]
   17907 		v.reset(OpCopy)
   17908 		v.Type = x.Type
   17909 		v.AddArg(x)
   17910 		return true
   17911 	}
   17912 }
   17913 func rewriteValue386_OpTrunc32to8_0(v *Value) bool {
   17914 	// match: (Trunc32to8 x)
   17915 	// cond:
   17916 	// result: x
   17917 	for {
   17918 		x := v.Args[0]
   17919 		v.reset(OpCopy)
   17920 		v.Type = x.Type
   17921 		v.AddArg(x)
   17922 		return true
   17923 	}
   17924 }
   17925 func rewriteValue386_OpXor16_0(v *Value) bool {
   17926 	// match: (Xor16 x y)
   17927 	// cond:
   17928 	// result: (XORL x y)
   17929 	for {
   17930 		_ = v.Args[1]
   17931 		x := v.Args[0]
   17932 		y := v.Args[1]
   17933 		v.reset(Op386XORL)
   17934 		v.AddArg(x)
   17935 		v.AddArg(y)
   17936 		return true
   17937 	}
   17938 }
   17939 func rewriteValue386_OpXor32_0(v *Value) bool {
   17940 	// match: (Xor32 x y)
   17941 	// cond:
   17942 	// result: (XORL x y)
   17943 	for {
   17944 		_ = v.Args[1]
   17945 		x := v.Args[0]
   17946 		y := v.Args[1]
   17947 		v.reset(Op386XORL)
   17948 		v.AddArg(x)
   17949 		v.AddArg(y)
   17950 		return true
   17951 	}
   17952 }
   17953 func rewriteValue386_OpXor8_0(v *Value) bool {
   17954 	// match: (Xor8 x y)
   17955 	// cond:
   17956 	// result: (XORL x y)
   17957 	for {
   17958 		_ = v.Args[1]
   17959 		x := v.Args[0]
   17960 		y := v.Args[1]
   17961 		v.reset(Op386XORL)
   17962 		v.AddArg(x)
   17963 		v.AddArg(y)
   17964 		return true
   17965 	}
   17966 }
   17967 func rewriteValue386_OpZero_0(v *Value) bool {
   17968 	b := v.Block
   17969 	_ = b
   17970 	typ := &b.Func.Config.Types
   17971 	_ = typ
   17972 	// match: (Zero [0] _ mem)
   17973 	// cond:
   17974 	// result: mem
   17975 	for {
   17976 		if v.AuxInt != 0 {
   17977 			break
   17978 		}
   17979 		_ = v.Args[1]
   17980 		mem := v.Args[1]
   17981 		v.reset(OpCopy)
   17982 		v.Type = mem.Type
   17983 		v.AddArg(mem)
   17984 		return true
   17985 	}
   17986 	// match: (Zero [1] destptr mem)
   17987 	// cond:
   17988 	// result: (MOVBstoreconst [0] destptr mem)
   17989 	for {
   17990 		if v.AuxInt != 1 {
   17991 			break
   17992 		}
   17993 		_ = v.Args[1]
   17994 		destptr := v.Args[0]
   17995 		mem := v.Args[1]
   17996 		v.reset(Op386MOVBstoreconst)
   17997 		v.AuxInt = 0
   17998 		v.AddArg(destptr)
   17999 		v.AddArg(mem)
   18000 		return true
   18001 	}
   18002 	// match: (Zero [2] destptr mem)
   18003 	// cond:
   18004 	// result: (MOVWstoreconst [0] destptr mem)
   18005 	for {
   18006 		if v.AuxInt != 2 {
   18007 			break
   18008 		}
   18009 		_ = v.Args[1]
   18010 		destptr := v.Args[0]
   18011 		mem := v.Args[1]
   18012 		v.reset(Op386MOVWstoreconst)
   18013 		v.AuxInt = 0
   18014 		v.AddArg(destptr)
   18015 		v.AddArg(mem)
   18016 		return true
   18017 	}
   18018 	// match: (Zero [4] destptr mem)
   18019 	// cond:
   18020 	// result: (MOVLstoreconst [0] destptr mem)
   18021 	for {
   18022 		if v.AuxInt != 4 {
   18023 			break
   18024 		}
   18025 		_ = v.Args[1]
   18026 		destptr := v.Args[0]
   18027 		mem := v.Args[1]
   18028 		v.reset(Op386MOVLstoreconst)
   18029 		v.AuxInt = 0
   18030 		v.AddArg(destptr)
   18031 		v.AddArg(mem)
   18032 		return true
   18033 	}
   18034 	// match: (Zero [3] destptr mem)
   18035 	// cond:
   18036 	// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr 		(MOVWstoreconst [0] destptr mem))
   18037 	for {
   18038 		if v.AuxInt != 3 {
   18039 			break
   18040 		}
   18041 		_ = v.Args[1]
   18042 		destptr := v.Args[0]
   18043 		mem := v.Args[1]
   18044 		v.reset(Op386MOVBstoreconst)
   18045 		v.AuxInt = makeValAndOff(0, 2)
   18046 		v.AddArg(destptr)
   18047 		v0 := b.NewValue0(v.Pos, Op386MOVWstoreconst, types.TypeMem)
   18048 		v0.AuxInt = 0
   18049 		v0.AddArg(destptr)
   18050 		v0.AddArg(mem)
   18051 		v.AddArg(v0)
   18052 		return true
   18053 	}
   18054 	// match: (Zero [5] destptr mem)
   18055 	// cond:
   18056 	// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr 		(MOVLstoreconst [0] destptr mem))
   18057 	for {
   18058 		if v.AuxInt != 5 {
   18059 			break
   18060 		}
   18061 		_ = v.Args[1]
   18062 		destptr := v.Args[0]
   18063 		mem := v.Args[1]
   18064 		v.reset(Op386MOVBstoreconst)
   18065 		v.AuxInt = makeValAndOff(0, 4)
   18066 		v.AddArg(destptr)
   18067 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18068 		v0.AuxInt = 0
   18069 		v0.AddArg(destptr)
   18070 		v0.AddArg(mem)
   18071 		v.AddArg(v0)
   18072 		return true
   18073 	}
   18074 	// match: (Zero [6] destptr mem)
   18075 	// cond:
   18076 	// result: (MOVWstoreconst [makeValAndOff(0,4)] destptr 		(MOVLstoreconst [0] destptr mem))
   18077 	for {
   18078 		if v.AuxInt != 6 {
   18079 			break
   18080 		}
   18081 		_ = v.Args[1]
   18082 		destptr := v.Args[0]
   18083 		mem := v.Args[1]
   18084 		v.reset(Op386MOVWstoreconst)
   18085 		v.AuxInt = makeValAndOff(0, 4)
   18086 		v.AddArg(destptr)
   18087 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18088 		v0.AuxInt = 0
   18089 		v0.AddArg(destptr)
   18090 		v0.AddArg(mem)
   18091 		v.AddArg(v0)
   18092 		return true
   18093 	}
   18094 	// match: (Zero [7] destptr mem)
   18095 	// cond:
   18096 	// result: (MOVLstoreconst [makeValAndOff(0,3)] destptr 		(MOVLstoreconst [0] destptr mem))
   18097 	for {
   18098 		if v.AuxInt != 7 {
   18099 			break
   18100 		}
   18101 		_ = v.Args[1]
   18102 		destptr := v.Args[0]
   18103 		mem := v.Args[1]
   18104 		v.reset(Op386MOVLstoreconst)
   18105 		v.AuxInt = makeValAndOff(0, 3)
   18106 		v.AddArg(destptr)
   18107 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18108 		v0.AuxInt = 0
   18109 		v0.AddArg(destptr)
   18110 		v0.AddArg(mem)
   18111 		v.AddArg(v0)
   18112 		return true
   18113 	}
   18114 	// match: (Zero [s] destptr mem)
   18115 	// cond: s%4 != 0 && s > 4
   18116 	// result: (Zero [s-s%4] (ADDLconst destptr [s%4]) 		(MOVLstoreconst [0] destptr mem))
   18117 	for {
   18118 		s := v.AuxInt
   18119 		_ = v.Args[1]
   18120 		destptr := v.Args[0]
   18121 		mem := v.Args[1]
   18122 		if !(s%4 != 0 && s > 4) {
   18123 			break
   18124 		}
   18125 		v.reset(OpZero)
   18126 		v.AuxInt = s - s%4
   18127 		v0 := b.NewValue0(v.Pos, Op386ADDLconst, typ.UInt32)
   18128 		v0.AuxInt = s % 4
   18129 		v0.AddArg(destptr)
   18130 		v.AddArg(v0)
   18131 		v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18132 		v1.AuxInt = 0
   18133 		v1.AddArg(destptr)
   18134 		v1.AddArg(mem)
   18135 		v.AddArg(v1)
   18136 		return true
   18137 	}
   18138 	// match: (Zero [8] destptr mem)
   18139 	// cond:
   18140 	// result: (MOVLstoreconst [makeValAndOff(0,4)] destptr 		(MOVLstoreconst [0] destptr mem))
   18141 	for {
   18142 		if v.AuxInt != 8 {
   18143 			break
   18144 		}
   18145 		_ = v.Args[1]
   18146 		destptr := v.Args[0]
   18147 		mem := v.Args[1]
   18148 		v.reset(Op386MOVLstoreconst)
   18149 		v.AuxInt = makeValAndOff(0, 4)
   18150 		v.AddArg(destptr)
   18151 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18152 		v0.AuxInt = 0
   18153 		v0.AddArg(destptr)
   18154 		v0.AddArg(mem)
   18155 		v.AddArg(v0)
   18156 		return true
   18157 	}
   18158 	return false
   18159 }
   18160 func rewriteValue386_OpZero_10(v *Value) bool {
   18161 	b := v.Block
   18162 	_ = b
   18163 	config := b.Func.Config
   18164 	_ = config
   18165 	typ := &b.Func.Config.Types
   18166 	_ = typ
   18167 	// match: (Zero [12] destptr mem)
   18168 	// cond:
   18169 	// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr 		(MOVLstoreconst [makeValAndOff(0,4)] destptr 			(MOVLstoreconst [0] destptr mem)))
   18170 	for {
   18171 		if v.AuxInt != 12 {
   18172 			break
   18173 		}
   18174 		_ = v.Args[1]
   18175 		destptr := v.Args[0]
   18176 		mem := v.Args[1]
   18177 		v.reset(Op386MOVLstoreconst)
   18178 		v.AuxInt = makeValAndOff(0, 8)
   18179 		v.AddArg(destptr)
   18180 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18181 		v0.AuxInt = makeValAndOff(0, 4)
   18182 		v0.AddArg(destptr)
   18183 		v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18184 		v1.AuxInt = 0
   18185 		v1.AddArg(destptr)
   18186 		v1.AddArg(mem)
   18187 		v0.AddArg(v1)
   18188 		v.AddArg(v0)
   18189 		return true
   18190 	}
   18191 	// match: (Zero [16] destptr mem)
   18192 	// cond:
   18193 	// result: (MOVLstoreconst [makeValAndOff(0,12)] destptr 		(MOVLstoreconst [makeValAndOff(0,8)] destptr 			(MOVLstoreconst [makeValAndOff(0,4)] destptr 				(MOVLstoreconst [0] destptr mem))))
   18194 	for {
   18195 		if v.AuxInt != 16 {
   18196 			break
   18197 		}
   18198 		_ = v.Args[1]
   18199 		destptr := v.Args[0]
   18200 		mem := v.Args[1]
   18201 		v.reset(Op386MOVLstoreconst)
   18202 		v.AuxInt = makeValAndOff(0, 12)
   18203 		v.AddArg(destptr)
   18204 		v0 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18205 		v0.AuxInt = makeValAndOff(0, 8)
   18206 		v0.AddArg(destptr)
   18207 		v1 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18208 		v1.AuxInt = makeValAndOff(0, 4)
   18209 		v1.AddArg(destptr)
   18210 		v2 := b.NewValue0(v.Pos, Op386MOVLstoreconst, types.TypeMem)
   18211 		v2.AuxInt = 0
   18212 		v2.AddArg(destptr)
   18213 		v2.AddArg(mem)
   18214 		v1.AddArg(v2)
   18215 		v0.AddArg(v1)
   18216 		v.AddArg(v0)
   18217 		return true
   18218 	}
   18219 	// match: (Zero [s] destptr mem)
   18220 	// cond: s > 16 && s <= 4*128 && s%4 == 0   && !config.noDuffDevice
   18221 	// result: (DUFFZERO [1*(128-s/4)] destptr (MOVLconst [0]) mem)
   18222 	for {
   18223 		s := v.AuxInt
   18224 		_ = v.Args[1]
   18225 		destptr := v.Args[0]
   18226 		mem := v.Args[1]
   18227 		if !(s > 16 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice) {
   18228 			break
   18229 		}
   18230 		v.reset(Op386DUFFZERO)
   18231 		v.AuxInt = 1 * (128 - s/4)
   18232 		v.AddArg(destptr)
   18233 		v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
   18234 		v0.AuxInt = 0
   18235 		v.AddArg(v0)
   18236 		v.AddArg(mem)
   18237 		return true
   18238 	}
   18239 	// match: (Zero [s] destptr mem)
   18240 	// cond: (s > 4*128 || (config.noDuffDevice && s > 16))   && s%4 == 0
   18241 	// result: (REPSTOSL destptr (MOVLconst [s/4]) (MOVLconst [0]) mem)
   18242 	for {
   18243 		s := v.AuxInt
   18244 		_ = v.Args[1]
   18245 		destptr := v.Args[0]
   18246 		mem := v.Args[1]
   18247 		if !((s > 4*128 || (config.noDuffDevice && s > 16)) && s%4 == 0) {
   18248 			break
   18249 		}
   18250 		v.reset(Op386REPSTOSL)
   18251 		v.AddArg(destptr)
   18252 		v0 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
   18253 		v0.AuxInt = s / 4
   18254 		v.AddArg(v0)
   18255 		v1 := b.NewValue0(v.Pos, Op386MOVLconst, typ.UInt32)
   18256 		v1.AuxInt = 0
   18257 		v.AddArg(v1)
   18258 		v.AddArg(mem)
   18259 		return true
   18260 	}
   18261 	return false
   18262 }
   18263 func rewriteValue386_OpZeroExt16to32_0(v *Value) bool {
   18264 	// match: (ZeroExt16to32 x)
   18265 	// cond:
   18266 	// result: (MOVWLZX x)
   18267 	for {
   18268 		x := v.Args[0]
   18269 		v.reset(Op386MOVWLZX)
   18270 		v.AddArg(x)
   18271 		return true
   18272 	}
   18273 }
   18274 func rewriteValue386_OpZeroExt8to16_0(v *Value) bool {
   18275 	// match: (ZeroExt8to16 x)
   18276 	// cond:
   18277 	// result: (MOVBLZX x)
   18278 	for {
   18279 		x := v.Args[0]
   18280 		v.reset(Op386MOVBLZX)
   18281 		v.AddArg(x)
   18282 		return true
   18283 	}
   18284 }
   18285 func rewriteValue386_OpZeroExt8to32_0(v *Value) bool {
   18286 	// match: (ZeroExt8to32 x)
   18287 	// cond:
   18288 	// result: (MOVBLZX x)
   18289 	for {
   18290 		x := v.Args[0]
   18291 		v.reset(Op386MOVBLZX)
   18292 		v.AddArg(x)
   18293 		return true
   18294 	}
   18295 }
   18296 func rewriteValue386_OpZeromask_0(v *Value) bool {
   18297 	b := v.Block
   18298 	_ = b
   18299 	// match: (Zeromask <t> x)
   18300 	// cond:
   18301 	// result: (XORLconst [-1] (SBBLcarrymask <t> (CMPLconst x [1])))
   18302 	for {
   18303 		t := v.Type
   18304 		x := v.Args[0]
   18305 		v.reset(Op386XORLconst)
   18306 		v.AuxInt = -1
   18307 		v0 := b.NewValue0(v.Pos, Op386SBBLcarrymask, t)
   18308 		v1 := b.NewValue0(v.Pos, Op386CMPLconst, types.TypeFlags)
   18309 		v1.AuxInt = 1
   18310 		v1.AddArg(x)
   18311 		v0.AddArg(v1)
   18312 		v.AddArg(v0)
   18313 		return true
   18314 	}
   18315 }
   18316 func rewriteBlock386(b *Block) bool {
   18317 	config := b.Func.Config
   18318 	_ = config
   18319 	fe := b.Func.fe
   18320 	_ = fe
   18321 	typ := &config.Types
   18322 	_ = typ
   18323 	switch b.Kind {
   18324 	case Block386EQ:
   18325 		// match: (EQ (InvertFlags cmp) yes no)
   18326 		// cond:
   18327 		// result: (EQ cmp yes no)
   18328 		for {
   18329 			v := b.Control
   18330 			if v.Op != Op386InvertFlags {
   18331 				break
   18332 			}
   18333 			cmp := v.Args[0]
   18334 			b.Kind = Block386EQ
   18335 			b.SetControl(cmp)
   18336 			b.Aux = nil
   18337 			return true
   18338 		}
   18339 		// match: (EQ (FlagEQ) yes no)
   18340 		// cond:
   18341 		// result: (First nil yes no)
   18342 		for {
   18343 			v := b.Control
   18344 			if v.Op != Op386FlagEQ {
   18345 				break
   18346 			}
   18347 			b.Kind = BlockFirst
   18348 			b.SetControl(nil)
   18349 			b.Aux = nil
   18350 			return true
   18351 		}
   18352 		// match: (EQ (FlagLT_ULT) yes no)
   18353 		// cond:
   18354 		// result: (First nil no yes)
   18355 		for {
   18356 			v := b.Control
   18357 			if v.Op != Op386FlagLT_ULT {
   18358 				break
   18359 			}
   18360 			b.Kind = BlockFirst
   18361 			b.SetControl(nil)
   18362 			b.Aux = nil
   18363 			b.swapSuccessors()
   18364 			return true
   18365 		}
   18366 		// match: (EQ (FlagLT_UGT) yes no)
   18367 		// cond:
   18368 		// result: (First nil no yes)
   18369 		for {
   18370 			v := b.Control
   18371 			if v.Op != Op386FlagLT_UGT {
   18372 				break
   18373 			}
   18374 			b.Kind = BlockFirst
   18375 			b.SetControl(nil)
   18376 			b.Aux = nil
   18377 			b.swapSuccessors()
   18378 			return true
   18379 		}
   18380 		// match: (EQ (FlagGT_ULT) yes no)
   18381 		// cond:
   18382 		// result: (First nil no yes)
   18383 		for {
   18384 			v := b.Control
   18385 			if v.Op != Op386FlagGT_ULT {
   18386 				break
   18387 			}
   18388 			b.Kind = BlockFirst
   18389 			b.SetControl(nil)
   18390 			b.Aux = nil
   18391 			b.swapSuccessors()
   18392 			return true
   18393 		}
   18394 		// match: (EQ (FlagGT_UGT) yes no)
   18395 		// cond:
   18396 		// result: (First nil no yes)
   18397 		for {
   18398 			v := b.Control
   18399 			if v.Op != Op386FlagGT_UGT {
   18400 				break
   18401 			}
   18402 			b.Kind = BlockFirst
   18403 			b.SetControl(nil)
   18404 			b.Aux = nil
   18405 			b.swapSuccessors()
   18406 			return true
   18407 		}
   18408 	case Block386GE:
   18409 		// match: (GE (InvertFlags cmp) yes no)
   18410 		// cond:
   18411 		// result: (LE cmp yes no)
   18412 		for {
   18413 			v := b.Control
   18414 			if v.Op != Op386InvertFlags {
   18415 				break
   18416 			}
   18417 			cmp := v.Args[0]
   18418 			b.Kind = Block386LE
   18419 			b.SetControl(cmp)
   18420 			b.Aux = nil
   18421 			return true
   18422 		}
   18423 		// match: (GE (FlagEQ) yes no)
   18424 		// cond:
   18425 		// result: (First nil yes no)
   18426 		for {
   18427 			v := b.Control
   18428 			if v.Op != Op386FlagEQ {
   18429 				break
   18430 			}
   18431 			b.Kind = BlockFirst
   18432 			b.SetControl(nil)
   18433 			b.Aux = nil
   18434 			return true
   18435 		}
   18436 		// match: (GE (FlagLT_ULT) yes no)
   18437 		// cond:
   18438 		// result: (First nil no yes)
   18439 		for {
   18440 			v := b.Control
   18441 			if v.Op != Op386FlagLT_ULT {
   18442 				break
   18443 			}
   18444 			b.Kind = BlockFirst
   18445 			b.SetControl(nil)
   18446 			b.Aux = nil
   18447 			b.swapSuccessors()
   18448 			return true
   18449 		}
   18450 		// match: (GE (FlagLT_UGT) yes no)
   18451 		// cond:
   18452 		// result: (First nil no yes)
   18453 		for {
   18454 			v := b.Control
   18455 			if v.Op != Op386FlagLT_UGT {
   18456 				break
   18457 			}
   18458 			b.Kind = BlockFirst
   18459 			b.SetControl(nil)
   18460 			b.Aux = nil
   18461 			b.swapSuccessors()
   18462 			return true
   18463 		}
   18464 		// match: (GE (FlagGT_ULT) yes no)
   18465 		// cond:
   18466 		// result: (First nil yes no)
   18467 		for {
   18468 			v := b.Control
   18469 			if v.Op != Op386FlagGT_ULT {
   18470 				break
   18471 			}
   18472 			b.Kind = BlockFirst
   18473 			b.SetControl(nil)
   18474 			b.Aux = nil
   18475 			return true
   18476 		}
   18477 		// match: (GE (FlagGT_UGT) yes no)
   18478 		// cond:
   18479 		// result: (First nil yes no)
   18480 		for {
   18481 			v := b.Control
   18482 			if v.Op != Op386FlagGT_UGT {
   18483 				break
   18484 			}
   18485 			b.Kind = BlockFirst
   18486 			b.SetControl(nil)
   18487 			b.Aux = nil
   18488 			return true
   18489 		}
   18490 	case Block386GT:
   18491 		// match: (GT (InvertFlags cmp) yes no)
   18492 		// cond:
   18493 		// result: (LT cmp yes no)
   18494 		for {
   18495 			v := b.Control
   18496 			if v.Op != Op386InvertFlags {
   18497 				break
   18498 			}
   18499 			cmp := v.Args[0]
   18500 			b.Kind = Block386LT
   18501 			b.SetControl(cmp)
   18502 			b.Aux = nil
   18503 			return true
   18504 		}
   18505 		// match: (GT (FlagEQ) yes no)
   18506 		// cond:
   18507 		// result: (First nil no yes)
   18508 		for {
   18509 			v := b.Control
   18510 			if v.Op != Op386FlagEQ {
   18511 				break
   18512 			}
   18513 			b.Kind = BlockFirst
   18514 			b.SetControl(nil)
   18515 			b.Aux = nil
   18516 			b.swapSuccessors()
   18517 			return true
   18518 		}
   18519 		// match: (GT (FlagLT_ULT) yes no)
   18520 		// cond:
   18521 		// result: (First nil no yes)
   18522 		for {
   18523 			v := b.Control
   18524 			if v.Op != Op386FlagLT_ULT {
   18525 				break
   18526 			}
   18527 			b.Kind = BlockFirst
   18528 			b.SetControl(nil)
   18529 			b.Aux = nil
   18530 			b.swapSuccessors()
   18531 			return true
   18532 		}
   18533 		// match: (GT (FlagLT_UGT) yes no)
   18534 		// cond:
   18535 		// result: (First nil no yes)
   18536 		for {
   18537 			v := b.Control
   18538 			if v.Op != Op386FlagLT_UGT {
   18539 				break
   18540 			}
   18541 			b.Kind = BlockFirst
   18542 			b.SetControl(nil)
   18543 			b.Aux = nil
   18544 			b.swapSuccessors()
   18545 			return true
   18546 		}
   18547 		// match: (GT (FlagGT_ULT) yes no)
   18548 		// cond:
   18549 		// result: (First nil yes no)
   18550 		for {
   18551 			v := b.Control
   18552 			if v.Op != Op386FlagGT_ULT {
   18553 				break
   18554 			}
   18555 			b.Kind = BlockFirst
   18556 			b.SetControl(nil)
   18557 			b.Aux = nil
   18558 			return true
   18559 		}
   18560 		// match: (GT (FlagGT_UGT) yes no)
   18561 		// cond:
   18562 		// result: (First nil yes no)
   18563 		for {
   18564 			v := b.Control
   18565 			if v.Op != Op386FlagGT_UGT {
   18566 				break
   18567 			}
   18568 			b.Kind = BlockFirst
   18569 			b.SetControl(nil)
   18570 			b.Aux = nil
   18571 			return true
   18572 		}
   18573 	case BlockIf:
   18574 		// match: (If (SETL cmp) yes no)
   18575 		// cond:
   18576 		// result: (LT  cmp yes no)
   18577 		for {
   18578 			v := b.Control
   18579 			if v.Op != Op386SETL {
   18580 				break
   18581 			}
   18582 			cmp := v.Args[0]
   18583 			b.Kind = Block386LT
   18584 			b.SetControl(cmp)
   18585 			b.Aux = nil
   18586 			return true
   18587 		}
   18588 		// match: (If (SETLE cmp) yes no)
   18589 		// cond:
   18590 		// result: (LE  cmp yes no)
   18591 		for {
   18592 			v := b.Control
   18593 			if v.Op != Op386SETLE {
   18594 				break
   18595 			}
   18596 			cmp := v.Args[0]
   18597 			b.Kind = Block386LE
   18598 			b.SetControl(cmp)
   18599 			b.Aux = nil
   18600 			return true
   18601 		}
   18602 		// match: (If (SETG cmp) yes no)
   18603 		// cond:
   18604 		// result: (GT  cmp yes no)
   18605 		for {
   18606 			v := b.Control
   18607 			if v.Op != Op386SETG {
   18608 				break
   18609 			}
   18610 			cmp := v.Args[0]
   18611 			b.Kind = Block386GT
   18612 			b.SetControl(cmp)
   18613 			b.Aux = nil
   18614 			return true
   18615 		}
   18616 		// match: (If (SETGE cmp) yes no)
   18617 		// cond:
   18618 		// result: (GE  cmp yes no)
   18619 		for {
   18620 			v := b.Control
   18621 			if v.Op != Op386SETGE {
   18622 				break
   18623 			}
   18624 			cmp := v.Args[0]
   18625 			b.Kind = Block386GE
   18626 			b.SetControl(cmp)
   18627 			b.Aux = nil
   18628 			return true
   18629 		}
   18630 		// match: (If (SETEQ cmp) yes no)
   18631 		// cond:
   18632 		// result: (EQ  cmp yes no)
   18633 		for {
   18634 			v := b.Control
   18635 			if v.Op != Op386SETEQ {
   18636 				break
   18637 			}
   18638 			cmp := v.Args[0]
   18639 			b.Kind = Block386EQ
   18640 			b.SetControl(cmp)
   18641 			b.Aux = nil
   18642 			return true
   18643 		}
   18644 		// match: (If (SETNE cmp) yes no)
   18645 		// cond:
   18646 		// result: (NE  cmp yes no)
   18647 		for {
   18648 			v := b.Control
   18649 			if v.Op != Op386SETNE {
   18650 				break
   18651 			}
   18652 			cmp := v.Args[0]
   18653 			b.Kind = Block386NE
   18654 			b.SetControl(cmp)
   18655 			b.Aux = nil
   18656 			return true
   18657 		}
   18658 		// match: (If (SETB cmp) yes no)
   18659 		// cond:
   18660 		// result: (ULT cmp yes no)
   18661 		for {
   18662 			v := b.Control
   18663 			if v.Op != Op386SETB {
   18664 				break
   18665 			}
   18666 			cmp := v.Args[0]
   18667 			b.Kind = Block386ULT
   18668 			b.SetControl(cmp)
   18669 			b.Aux = nil
   18670 			return true
   18671 		}
   18672 		// match: (If (SETBE cmp) yes no)
   18673 		// cond:
   18674 		// result: (ULE cmp yes no)
   18675 		for {
   18676 			v := b.Control
   18677 			if v.Op != Op386SETBE {
   18678 				break
   18679 			}
   18680 			cmp := v.Args[0]
   18681 			b.Kind = Block386ULE
   18682 			b.SetControl(cmp)
   18683 			b.Aux = nil
   18684 			return true
   18685 		}
   18686 		// match: (If (SETA cmp) yes no)
   18687 		// cond:
   18688 		// result: (UGT cmp yes no)
   18689 		for {
   18690 			v := b.Control
   18691 			if v.Op != Op386SETA {
   18692 				break
   18693 			}
   18694 			cmp := v.Args[0]
   18695 			b.Kind = Block386UGT
   18696 			b.SetControl(cmp)
   18697 			b.Aux = nil
   18698 			return true
   18699 		}
   18700 		// match: (If (SETAE cmp) yes no)
   18701 		// cond:
   18702 		// result: (UGE cmp yes no)
   18703 		for {
   18704 			v := b.Control
   18705 			if v.Op != Op386SETAE {
   18706 				break
   18707 			}
   18708 			cmp := v.Args[0]
   18709 			b.Kind = Block386UGE
   18710 			b.SetControl(cmp)
   18711 			b.Aux = nil
   18712 			return true
   18713 		}
   18714 		// match: (If (SETGF cmp) yes no)
   18715 		// cond:
   18716 		// result: (UGT  cmp yes no)
   18717 		for {
   18718 			v := b.Control
   18719 			if v.Op != Op386SETGF {
   18720 				break
   18721 			}
   18722 			cmp := v.Args[0]
   18723 			b.Kind = Block386UGT
   18724 			b.SetControl(cmp)
   18725 			b.Aux = nil
   18726 			return true
   18727 		}
   18728 		// match: (If (SETGEF cmp) yes no)
   18729 		// cond:
   18730 		// result: (UGE  cmp yes no)
   18731 		for {
   18732 			v := b.Control
   18733 			if v.Op != Op386SETGEF {
   18734 				break
   18735 			}
   18736 			cmp := v.Args[0]
   18737 			b.Kind = Block386UGE
   18738 			b.SetControl(cmp)
   18739 			b.Aux = nil
   18740 			return true
   18741 		}
   18742 		// match: (If (SETEQF cmp) yes no)
   18743 		// cond:
   18744 		// result: (EQF  cmp yes no)
   18745 		for {
   18746 			v := b.Control
   18747 			if v.Op != Op386SETEQF {
   18748 				break
   18749 			}
   18750 			cmp := v.Args[0]
   18751 			b.Kind = Block386EQF
   18752 			b.SetControl(cmp)
   18753 			b.Aux = nil
   18754 			return true
   18755 		}
   18756 		// match: (If (SETNEF cmp) yes no)
   18757 		// cond:
   18758 		// result: (NEF  cmp yes no)
   18759 		for {
   18760 			v := b.Control
   18761 			if v.Op != Op386SETNEF {
   18762 				break
   18763 			}
   18764 			cmp := v.Args[0]
   18765 			b.Kind = Block386NEF
   18766 			b.SetControl(cmp)
   18767 			b.Aux = nil
   18768 			return true
   18769 		}
   18770 		// match: (If cond yes no)
   18771 		// cond:
   18772 		// result: (NE (TESTB cond cond) yes no)
   18773 		for {
   18774 			v := b.Control
   18775 			_ = v
   18776 			cond := b.Control
   18777 			b.Kind = Block386NE
   18778 			v0 := b.NewValue0(v.Pos, Op386TESTB, types.TypeFlags)
   18779 			v0.AddArg(cond)
   18780 			v0.AddArg(cond)
   18781 			b.SetControl(v0)
   18782 			b.Aux = nil
   18783 			return true
   18784 		}
   18785 	case Block386LE:
   18786 		// match: (LE (InvertFlags cmp) yes no)
   18787 		// cond:
   18788 		// result: (GE cmp yes no)
   18789 		for {
   18790 			v := b.Control
   18791 			if v.Op != Op386InvertFlags {
   18792 				break
   18793 			}
   18794 			cmp := v.Args[0]
   18795 			b.Kind = Block386GE
   18796 			b.SetControl(cmp)
   18797 			b.Aux = nil
   18798 			return true
   18799 		}
   18800 		// match: (LE (FlagEQ) yes no)
   18801 		// cond:
   18802 		// result: (First nil yes no)
   18803 		for {
   18804 			v := b.Control
   18805 			if v.Op != Op386FlagEQ {
   18806 				break
   18807 			}
   18808 			b.Kind = BlockFirst
   18809 			b.SetControl(nil)
   18810 			b.Aux = nil
   18811 			return true
   18812 		}
   18813 		// match: (LE (FlagLT_ULT) yes no)
   18814 		// cond:
   18815 		// result: (First nil yes no)
   18816 		for {
   18817 			v := b.Control
   18818 			if v.Op != Op386FlagLT_ULT {
   18819 				break
   18820 			}
   18821 			b.Kind = BlockFirst
   18822 			b.SetControl(nil)
   18823 			b.Aux = nil
   18824 			return true
   18825 		}
   18826 		// match: (LE (FlagLT_UGT) yes no)
   18827 		// cond:
   18828 		// result: (First nil yes no)
   18829 		for {
   18830 			v := b.Control
   18831 			if v.Op != Op386FlagLT_UGT {
   18832 				break
   18833 			}
   18834 			b.Kind = BlockFirst
   18835 			b.SetControl(nil)
   18836 			b.Aux = nil
   18837 			return true
   18838 		}
   18839 		// match: (LE (FlagGT_ULT) yes no)
   18840 		// cond:
   18841 		// result: (First nil no yes)
   18842 		for {
   18843 			v := b.Control
   18844 			if v.Op != Op386FlagGT_ULT {
   18845 				break
   18846 			}
   18847 			b.Kind = BlockFirst
   18848 			b.SetControl(nil)
   18849 			b.Aux = nil
   18850 			b.swapSuccessors()
   18851 			return true
   18852 		}
   18853 		// match: (LE (FlagGT_UGT) yes no)
   18854 		// cond:
   18855 		// result: (First nil no yes)
   18856 		for {
   18857 			v := b.Control
   18858 			if v.Op != Op386FlagGT_UGT {
   18859 				break
   18860 			}
   18861 			b.Kind = BlockFirst
   18862 			b.SetControl(nil)
   18863 			b.Aux = nil
   18864 			b.swapSuccessors()
   18865 			return true
   18866 		}
   18867 	case Block386LT:
   18868 		// match: (LT (InvertFlags cmp) yes no)
   18869 		// cond:
   18870 		// result: (GT cmp yes no)
   18871 		for {
   18872 			v := b.Control
   18873 			if v.Op != Op386InvertFlags {
   18874 				break
   18875 			}
   18876 			cmp := v.Args[0]
   18877 			b.Kind = Block386GT
   18878 			b.SetControl(cmp)
   18879 			b.Aux = nil
   18880 			return true
   18881 		}
   18882 		// match: (LT (FlagEQ) yes no)
   18883 		// cond:
   18884 		// result: (First nil no yes)
   18885 		for {
   18886 			v := b.Control
   18887 			if v.Op != Op386FlagEQ {
   18888 				break
   18889 			}
   18890 			b.Kind = BlockFirst
   18891 			b.SetControl(nil)
   18892 			b.Aux = nil
   18893 			b.swapSuccessors()
   18894 			return true
   18895 		}
   18896 		// match: (LT (FlagLT_ULT) yes no)
   18897 		// cond:
   18898 		// result: (First nil yes no)
   18899 		for {
   18900 			v := b.Control
   18901 			if v.Op != Op386FlagLT_ULT {
   18902 				break
   18903 			}
   18904 			b.Kind = BlockFirst
   18905 			b.SetControl(nil)
   18906 			b.Aux = nil
   18907 			return true
   18908 		}
   18909 		// match: (LT (FlagLT_UGT) yes no)
   18910 		// cond:
   18911 		// result: (First nil yes no)
   18912 		for {
   18913 			v := b.Control
   18914 			if v.Op != Op386FlagLT_UGT {
   18915 				break
   18916 			}
   18917 			b.Kind = BlockFirst
   18918 			b.SetControl(nil)
   18919 			b.Aux = nil
   18920 			return true
   18921 		}
   18922 		// match: (LT (FlagGT_ULT) yes no)
   18923 		// cond:
   18924 		// result: (First nil no yes)
   18925 		for {
   18926 			v := b.Control
   18927 			if v.Op != Op386FlagGT_ULT {
   18928 				break
   18929 			}
   18930 			b.Kind = BlockFirst
   18931 			b.SetControl(nil)
   18932 			b.Aux = nil
   18933 			b.swapSuccessors()
   18934 			return true
   18935 		}
   18936 		// match: (LT (FlagGT_UGT) yes no)
   18937 		// cond:
   18938 		// result: (First nil no yes)
   18939 		for {
   18940 			v := b.Control
   18941 			if v.Op != Op386FlagGT_UGT {
   18942 				break
   18943 			}
   18944 			b.Kind = BlockFirst
   18945 			b.SetControl(nil)
   18946 			b.Aux = nil
   18947 			b.swapSuccessors()
   18948 			return true
   18949 		}
   18950 	case Block386NE:
   18951 		// match: (NE (TESTB (SETL cmp) (SETL cmp)) yes no)
   18952 		// cond:
   18953 		// result: (LT  cmp yes no)
   18954 		for {
   18955 			v := b.Control
   18956 			if v.Op != Op386TESTB {
   18957 				break
   18958 			}
   18959 			_ = v.Args[1]
   18960 			v_0 := v.Args[0]
   18961 			if v_0.Op != Op386SETL {
   18962 				break
   18963 			}
   18964 			cmp := v_0.Args[0]
   18965 			v_1 := v.Args[1]
   18966 			if v_1.Op != Op386SETL {
   18967 				break
   18968 			}
   18969 			if cmp != v_1.Args[0] {
   18970 				break
   18971 			}
   18972 			b.Kind = Block386LT
   18973 			b.SetControl(cmp)
   18974 			b.Aux = nil
   18975 			return true
   18976 		}
   18977 		// match: (NE (TESTB (SETL cmp) (SETL cmp)) yes no)
   18978 		// cond:
   18979 		// result: (LT  cmp yes no)
   18980 		for {
   18981 			v := b.Control
   18982 			if v.Op != Op386TESTB {
   18983 				break
   18984 			}
   18985 			_ = v.Args[1]
   18986 			v_0 := v.Args[0]
   18987 			if v_0.Op != Op386SETL {
   18988 				break
   18989 			}
   18990 			cmp := v_0.Args[0]
   18991 			v_1 := v.Args[1]
   18992 			if v_1.Op != Op386SETL {
   18993 				break
   18994 			}
   18995 			if cmp != v_1.Args[0] {
   18996 				break
   18997 			}
   18998 			b.Kind = Block386LT
   18999 			b.SetControl(cmp)
   19000 			b.Aux = nil
   19001 			return true
   19002 		}
   19003 		// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
   19004 		// cond:
   19005 		// result: (LE  cmp yes no)
   19006 		for {
   19007 			v := b.Control
   19008 			if v.Op != Op386TESTB {
   19009 				break
   19010 			}
   19011 			_ = v.Args[1]
   19012 			v_0 := v.Args[0]
   19013 			if v_0.Op != Op386SETLE {
   19014 				break
   19015 			}
   19016 			cmp := v_0.Args[0]
   19017 			v_1 := v.Args[1]
   19018 			if v_1.Op != Op386SETLE {
   19019 				break
   19020 			}
   19021 			if cmp != v_1.Args[0] {
   19022 				break
   19023 			}
   19024 			b.Kind = Block386LE
   19025 			b.SetControl(cmp)
   19026 			b.Aux = nil
   19027 			return true
   19028 		}
   19029 		// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
   19030 		// cond:
   19031 		// result: (LE  cmp yes no)
   19032 		for {
   19033 			v := b.Control
   19034 			if v.Op != Op386TESTB {
   19035 				break
   19036 			}
   19037 			_ = v.Args[1]
   19038 			v_0 := v.Args[0]
   19039 			if v_0.Op != Op386SETLE {
   19040 				break
   19041 			}
   19042 			cmp := v_0.Args[0]
   19043 			v_1 := v.Args[1]
   19044 			if v_1.Op != Op386SETLE {
   19045 				break
   19046 			}
   19047 			if cmp != v_1.Args[0] {
   19048 				break
   19049 			}
   19050 			b.Kind = Block386LE
   19051 			b.SetControl(cmp)
   19052 			b.Aux = nil
   19053 			return true
   19054 		}
   19055 		// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
   19056 		// cond:
   19057 		// result: (GT  cmp yes no)
   19058 		for {
   19059 			v := b.Control
   19060 			if v.Op != Op386TESTB {
   19061 				break
   19062 			}
   19063 			_ = v.Args[1]
   19064 			v_0 := v.Args[0]
   19065 			if v_0.Op != Op386SETG {
   19066 				break
   19067 			}
   19068 			cmp := v_0.Args[0]
   19069 			v_1 := v.Args[1]
   19070 			if v_1.Op != Op386SETG {
   19071 				break
   19072 			}
   19073 			if cmp != v_1.Args[0] {
   19074 				break
   19075 			}
   19076 			b.Kind = Block386GT
   19077 			b.SetControl(cmp)
   19078 			b.Aux = nil
   19079 			return true
   19080 		}
   19081 		// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
   19082 		// cond:
   19083 		// result: (GT  cmp yes no)
   19084 		for {
   19085 			v := b.Control
   19086 			if v.Op != Op386TESTB {
   19087 				break
   19088 			}
   19089 			_ = v.Args[1]
   19090 			v_0 := v.Args[0]
   19091 			if v_0.Op != Op386SETG {
   19092 				break
   19093 			}
   19094 			cmp := v_0.Args[0]
   19095 			v_1 := v.Args[1]
   19096 			if v_1.Op != Op386SETG {
   19097 				break
   19098 			}
   19099 			if cmp != v_1.Args[0] {
   19100 				break
   19101 			}
   19102 			b.Kind = Block386GT
   19103 			b.SetControl(cmp)
   19104 			b.Aux = nil
   19105 			return true
   19106 		}
   19107 		// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
   19108 		// cond:
   19109 		// result: (GE  cmp yes no)
   19110 		for {
   19111 			v := b.Control
   19112 			if v.Op != Op386TESTB {
   19113 				break
   19114 			}
   19115 			_ = v.Args[1]
   19116 			v_0 := v.Args[0]
   19117 			if v_0.Op != Op386SETGE {
   19118 				break
   19119 			}
   19120 			cmp := v_0.Args[0]
   19121 			v_1 := v.Args[1]
   19122 			if v_1.Op != Op386SETGE {
   19123 				break
   19124 			}
   19125 			if cmp != v_1.Args[0] {
   19126 				break
   19127 			}
   19128 			b.Kind = Block386GE
   19129 			b.SetControl(cmp)
   19130 			b.Aux = nil
   19131 			return true
   19132 		}
   19133 		// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
   19134 		// cond:
   19135 		// result: (GE  cmp yes no)
   19136 		for {
   19137 			v := b.Control
   19138 			if v.Op != Op386TESTB {
   19139 				break
   19140 			}
   19141 			_ = v.Args[1]
   19142 			v_0 := v.Args[0]
   19143 			if v_0.Op != Op386SETGE {
   19144 				break
   19145 			}
   19146 			cmp := v_0.Args[0]
   19147 			v_1 := v.Args[1]
   19148 			if v_1.Op != Op386SETGE {
   19149 				break
   19150 			}
   19151 			if cmp != v_1.Args[0] {
   19152 				break
   19153 			}
   19154 			b.Kind = Block386GE
   19155 			b.SetControl(cmp)
   19156 			b.Aux = nil
   19157 			return true
   19158 		}
   19159 		// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
   19160 		// cond:
   19161 		// result: (EQ  cmp yes no)
   19162 		for {
   19163 			v := b.Control
   19164 			if v.Op != Op386TESTB {
   19165 				break
   19166 			}
   19167 			_ = v.Args[1]
   19168 			v_0 := v.Args[0]
   19169 			if v_0.Op != Op386SETEQ {
   19170 				break
   19171 			}
   19172 			cmp := v_0.Args[0]
   19173 			v_1 := v.Args[1]
   19174 			if v_1.Op != Op386SETEQ {
   19175 				break
   19176 			}
   19177 			if cmp != v_1.Args[0] {
   19178 				break
   19179 			}
   19180 			b.Kind = Block386EQ
   19181 			b.SetControl(cmp)
   19182 			b.Aux = nil
   19183 			return true
   19184 		}
   19185 		// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
   19186 		// cond:
   19187 		// result: (EQ  cmp yes no)
   19188 		for {
   19189 			v := b.Control
   19190 			if v.Op != Op386TESTB {
   19191 				break
   19192 			}
   19193 			_ = v.Args[1]
   19194 			v_0 := v.Args[0]
   19195 			if v_0.Op != Op386SETEQ {
   19196 				break
   19197 			}
   19198 			cmp := v_0.Args[0]
   19199 			v_1 := v.Args[1]
   19200 			if v_1.Op != Op386SETEQ {
   19201 				break
   19202 			}
   19203 			if cmp != v_1.Args[0] {
   19204 				break
   19205 			}
   19206 			b.Kind = Block386EQ
   19207 			b.SetControl(cmp)
   19208 			b.Aux = nil
   19209 			return true
   19210 		}
   19211 		// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
   19212 		// cond:
   19213 		// result: (NE  cmp yes no)
   19214 		for {
   19215 			v := b.Control
   19216 			if v.Op != Op386TESTB {
   19217 				break
   19218 			}
   19219 			_ = v.Args[1]
   19220 			v_0 := v.Args[0]
   19221 			if v_0.Op != Op386SETNE {
   19222 				break
   19223 			}
   19224 			cmp := v_0.Args[0]
   19225 			v_1 := v.Args[1]
   19226 			if v_1.Op != Op386SETNE {
   19227 				break
   19228 			}
   19229 			if cmp != v_1.Args[0] {
   19230 				break
   19231 			}
   19232 			b.Kind = Block386NE
   19233 			b.SetControl(cmp)
   19234 			b.Aux = nil
   19235 			return true
   19236 		}
   19237 		// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
   19238 		// cond:
   19239 		// result: (NE  cmp yes no)
   19240 		for {
   19241 			v := b.Control
   19242 			if v.Op != Op386TESTB {
   19243 				break
   19244 			}
   19245 			_ = v.Args[1]
   19246 			v_0 := v.Args[0]
   19247 			if v_0.Op != Op386SETNE {
   19248 				break
   19249 			}
   19250 			cmp := v_0.Args[0]
   19251 			v_1 := v.Args[1]
   19252 			if v_1.Op != Op386SETNE {
   19253 				break
   19254 			}
   19255 			if cmp != v_1.Args[0] {
   19256 				break
   19257 			}
   19258 			b.Kind = Block386NE
   19259 			b.SetControl(cmp)
   19260 			b.Aux = nil
   19261 			return true
   19262 		}
   19263 		// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
   19264 		// cond:
   19265 		// result: (ULT cmp yes no)
   19266 		for {
   19267 			v := b.Control
   19268 			if v.Op != Op386TESTB {
   19269 				break
   19270 			}
   19271 			_ = v.Args[1]
   19272 			v_0 := v.Args[0]
   19273 			if v_0.Op != Op386SETB {
   19274 				break
   19275 			}
   19276 			cmp := v_0.Args[0]
   19277 			v_1 := v.Args[1]
   19278 			if v_1.Op != Op386SETB {
   19279 				break
   19280 			}
   19281 			if cmp != v_1.Args[0] {
   19282 				break
   19283 			}
   19284 			b.Kind = Block386ULT
   19285 			b.SetControl(cmp)
   19286 			b.Aux = nil
   19287 			return true
   19288 		}
   19289 		// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
   19290 		// cond:
   19291 		// result: (ULT cmp yes no)
   19292 		for {
   19293 			v := b.Control
   19294 			if v.Op != Op386TESTB {
   19295 				break
   19296 			}
   19297 			_ = v.Args[1]
   19298 			v_0 := v.Args[0]
   19299 			if v_0.Op != Op386SETB {
   19300 				break
   19301 			}
   19302 			cmp := v_0.Args[0]
   19303 			v_1 := v.Args[1]
   19304 			if v_1.Op != Op386SETB {
   19305 				break
   19306 			}
   19307 			if cmp != v_1.Args[0] {
   19308 				break
   19309 			}
   19310 			b.Kind = Block386ULT
   19311 			b.SetControl(cmp)
   19312 			b.Aux = nil
   19313 			return true
   19314 		}
   19315 		// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
   19316 		// cond:
   19317 		// result: (ULE cmp yes no)
   19318 		for {
   19319 			v := b.Control
   19320 			if v.Op != Op386TESTB {
   19321 				break
   19322 			}
   19323 			_ = v.Args[1]
   19324 			v_0 := v.Args[0]
   19325 			if v_0.Op != Op386SETBE {
   19326 				break
   19327 			}
   19328 			cmp := v_0.Args[0]
   19329 			v_1 := v.Args[1]
   19330 			if v_1.Op != Op386SETBE {
   19331 				break
   19332 			}
   19333 			if cmp != v_1.Args[0] {
   19334 				break
   19335 			}
   19336 			b.Kind = Block386ULE
   19337 			b.SetControl(cmp)
   19338 			b.Aux = nil
   19339 			return true
   19340 		}
   19341 		// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
   19342 		// cond:
   19343 		// result: (ULE cmp yes no)
   19344 		for {
   19345 			v := b.Control
   19346 			if v.Op != Op386TESTB {
   19347 				break
   19348 			}
   19349 			_ = v.Args[1]
   19350 			v_0 := v.Args[0]
   19351 			if v_0.Op != Op386SETBE {
   19352 				break
   19353 			}
   19354 			cmp := v_0.Args[0]
   19355 			v_1 := v.Args[1]
   19356 			if v_1.Op != Op386SETBE {
   19357 				break
   19358 			}
   19359 			if cmp != v_1.Args[0] {
   19360 				break
   19361 			}
   19362 			b.Kind = Block386ULE
   19363 			b.SetControl(cmp)
   19364 			b.Aux = nil
   19365 			return true
   19366 		}
   19367 		// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
   19368 		// cond:
   19369 		// result: (UGT cmp yes no)
   19370 		for {
   19371 			v := b.Control
   19372 			if v.Op != Op386TESTB {
   19373 				break
   19374 			}
   19375 			_ = v.Args[1]
   19376 			v_0 := v.Args[0]
   19377 			if v_0.Op != Op386SETA {
   19378 				break
   19379 			}
   19380 			cmp := v_0.Args[0]
   19381 			v_1 := v.Args[1]
   19382 			if v_1.Op != Op386SETA {
   19383 				break
   19384 			}
   19385 			if cmp != v_1.Args[0] {
   19386 				break
   19387 			}
   19388 			b.Kind = Block386UGT
   19389 			b.SetControl(cmp)
   19390 			b.Aux = nil
   19391 			return true
   19392 		}
   19393 		// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
   19394 		// cond:
   19395 		// result: (UGT cmp yes no)
   19396 		for {
   19397 			v := b.Control
   19398 			if v.Op != Op386TESTB {
   19399 				break
   19400 			}
   19401 			_ = v.Args[1]
   19402 			v_0 := v.Args[0]
   19403 			if v_0.Op != Op386SETA {
   19404 				break
   19405 			}
   19406 			cmp := v_0.Args[0]
   19407 			v_1 := v.Args[1]
   19408 			if v_1.Op != Op386SETA {
   19409 				break
   19410 			}
   19411 			if cmp != v_1.Args[0] {
   19412 				break
   19413 			}
   19414 			b.Kind = Block386UGT
   19415 			b.SetControl(cmp)
   19416 			b.Aux = nil
   19417 			return true
   19418 		}
   19419 		// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
   19420 		// cond:
   19421 		// result: (UGE cmp yes no)
   19422 		for {
   19423 			v := b.Control
   19424 			if v.Op != Op386TESTB {
   19425 				break
   19426 			}
   19427 			_ = v.Args[1]
   19428 			v_0 := v.Args[0]
   19429 			if v_0.Op != Op386SETAE {
   19430 				break
   19431 			}
   19432 			cmp := v_0.Args[0]
   19433 			v_1 := v.Args[1]
   19434 			if v_1.Op != Op386SETAE {
   19435 				break
   19436 			}
   19437 			if cmp != v_1.Args[0] {
   19438 				break
   19439 			}
   19440 			b.Kind = Block386UGE
   19441 			b.SetControl(cmp)
   19442 			b.Aux = nil
   19443 			return true
   19444 		}
   19445 		// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
   19446 		// cond:
   19447 		// result: (UGE cmp yes no)
   19448 		for {
   19449 			v := b.Control
   19450 			if v.Op != Op386TESTB {
   19451 				break
   19452 			}
   19453 			_ = v.Args[1]
   19454 			v_0 := v.Args[0]
   19455 			if v_0.Op != Op386SETAE {
   19456 				break
   19457 			}
   19458 			cmp := v_0.Args[0]
   19459 			v_1 := v.Args[1]
   19460 			if v_1.Op != Op386SETAE {
   19461 				break
   19462 			}
   19463 			if cmp != v_1.Args[0] {
   19464 				break
   19465 			}
   19466 			b.Kind = Block386UGE
   19467 			b.SetControl(cmp)
   19468 			b.Aux = nil
   19469 			return true
   19470 		}
   19471 		// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
   19472 		// cond:
   19473 		// result: (UGT  cmp yes no)
   19474 		for {
   19475 			v := b.Control
   19476 			if v.Op != Op386TESTB {
   19477 				break
   19478 			}
   19479 			_ = v.Args[1]
   19480 			v_0 := v.Args[0]
   19481 			if v_0.Op != Op386SETGF {
   19482 				break
   19483 			}
   19484 			cmp := v_0.Args[0]
   19485 			v_1 := v.Args[1]
   19486 			if v_1.Op != Op386SETGF {
   19487 				break
   19488 			}
   19489 			if cmp != v_1.Args[0] {
   19490 				break
   19491 			}
   19492 			b.Kind = Block386UGT
   19493 			b.SetControl(cmp)
   19494 			b.Aux = nil
   19495 			return true
   19496 		}
   19497 		// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
   19498 		// cond:
   19499 		// result: (UGT  cmp yes no)
   19500 		for {
   19501 			v := b.Control
   19502 			if v.Op != Op386TESTB {
   19503 				break
   19504 			}
   19505 			_ = v.Args[1]
   19506 			v_0 := v.Args[0]
   19507 			if v_0.Op != Op386SETGF {
   19508 				break
   19509 			}
   19510 			cmp := v_0.Args[0]
   19511 			v_1 := v.Args[1]
   19512 			if v_1.Op != Op386SETGF {
   19513 				break
   19514 			}
   19515 			if cmp != v_1.Args[0] {
   19516 				break
   19517 			}
   19518 			b.Kind = Block386UGT
   19519 			b.SetControl(cmp)
   19520 			b.Aux = nil
   19521 			return true
   19522 		}
   19523 		// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
   19524 		// cond:
   19525 		// result: (UGE  cmp yes no)
   19526 		for {
   19527 			v := b.Control
   19528 			if v.Op != Op386TESTB {
   19529 				break
   19530 			}
   19531 			_ = v.Args[1]
   19532 			v_0 := v.Args[0]
   19533 			if v_0.Op != Op386SETGEF {
   19534 				break
   19535 			}
   19536 			cmp := v_0.Args[0]
   19537 			v_1 := v.Args[1]
   19538 			if v_1.Op != Op386SETGEF {
   19539 				break
   19540 			}
   19541 			if cmp != v_1.Args[0] {
   19542 				break
   19543 			}
   19544 			b.Kind = Block386UGE
   19545 			b.SetControl(cmp)
   19546 			b.Aux = nil
   19547 			return true
   19548 		}
   19549 		// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
   19550 		// cond:
   19551 		// result: (UGE  cmp yes no)
   19552 		for {
   19553 			v := b.Control
   19554 			if v.Op != Op386TESTB {
   19555 				break
   19556 			}
   19557 			_ = v.Args[1]
   19558 			v_0 := v.Args[0]
   19559 			if v_0.Op != Op386SETGEF {
   19560 				break
   19561 			}
   19562 			cmp := v_0.Args[0]
   19563 			v_1 := v.Args[1]
   19564 			if v_1.Op != Op386SETGEF {
   19565 				break
   19566 			}
   19567 			if cmp != v_1.Args[0] {
   19568 				break
   19569 			}
   19570 			b.Kind = Block386UGE
   19571 			b.SetControl(cmp)
   19572 			b.Aux = nil
   19573 			return true
   19574 		}
   19575 		// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
   19576 		// cond:
   19577 		// result: (EQF  cmp yes no)
   19578 		for {
   19579 			v := b.Control
   19580 			if v.Op != Op386TESTB {
   19581 				break
   19582 			}
   19583 			_ = v.Args[1]
   19584 			v_0 := v.Args[0]
   19585 			if v_0.Op != Op386SETEQF {
   19586 				break
   19587 			}
   19588 			cmp := v_0.Args[0]
   19589 			v_1 := v.Args[1]
   19590 			if v_1.Op != Op386SETEQF {
   19591 				break
   19592 			}
   19593 			if cmp != v_1.Args[0] {
   19594 				break
   19595 			}
   19596 			b.Kind = Block386EQF
   19597 			b.SetControl(cmp)
   19598 			b.Aux = nil
   19599 			return true
   19600 		}
   19601 		// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
   19602 		// cond:
   19603 		// result: (EQF  cmp yes no)
   19604 		for {
   19605 			v := b.Control
   19606 			if v.Op != Op386TESTB {
   19607 				break
   19608 			}
   19609 			_ = v.Args[1]
   19610 			v_0 := v.Args[0]
   19611 			if v_0.Op != Op386SETEQF {
   19612 				break
   19613 			}
   19614 			cmp := v_0.Args[0]
   19615 			v_1 := v.Args[1]
   19616 			if v_1.Op != Op386SETEQF {
   19617 				break
   19618 			}
   19619 			if cmp != v_1.Args[0] {
   19620 				break
   19621 			}
   19622 			b.Kind = Block386EQF
   19623 			b.SetControl(cmp)
   19624 			b.Aux = nil
   19625 			return true
   19626 		}
   19627 		// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
   19628 		// cond:
   19629 		// result: (NEF  cmp yes no)
   19630 		for {
   19631 			v := b.Control
   19632 			if v.Op != Op386TESTB {
   19633 				break
   19634 			}
   19635 			_ = v.Args[1]
   19636 			v_0 := v.Args[0]
   19637 			if v_0.Op != Op386SETNEF {
   19638 				break
   19639 			}
   19640 			cmp := v_0.Args[0]
   19641 			v_1 := v.Args[1]
   19642 			if v_1.Op != Op386SETNEF {
   19643 				break
   19644 			}
   19645 			if cmp != v_1.Args[0] {
   19646 				break
   19647 			}
   19648 			b.Kind = Block386NEF
   19649 			b.SetControl(cmp)
   19650 			b.Aux = nil
   19651 			return true
   19652 		}
   19653 		// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
   19654 		// cond:
   19655 		// result: (NEF  cmp yes no)
   19656 		for {
   19657 			v := b.Control
   19658 			if v.Op != Op386TESTB {
   19659 				break
   19660 			}
   19661 			_ = v.Args[1]
   19662 			v_0 := v.Args[0]
   19663 			if v_0.Op != Op386SETNEF {
   19664 				break
   19665 			}
   19666 			cmp := v_0.Args[0]
   19667 			v_1 := v.Args[1]
   19668 			if v_1.Op != Op386SETNEF {
   19669 				break
   19670 			}
   19671 			if cmp != v_1.Args[0] {
   19672 				break
   19673 			}
   19674 			b.Kind = Block386NEF
   19675 			b.SetControl(cmp)
   19676 			b.Aux = nil
   19677 			return true
   19678 		}
   19679 		// match: (NE (InvertFlags cmp) yes no)
   19680 		// cond:
   19681 		// result: (NE cmp yes no)
   19682 		for {
   19683 			v := b.Control
   19684 			if v.Op != Op386InvertFlags {
   19685 				break
   19686 			}
   19687 			cmp := v.Args[0]
   19688 			b.Kind = Block386NE
   19689 			b.SetControl(cmp)
   19690 			b.Aux = nil
   19691 			return true
   19692 		}
   19693 		// match: (NE (FlagEQ) yes no)
   19694 		// cond:
   19695 		// result: (First nil no yes)
   19696 		for {
   19697 			v := b.Control
   19698 			if v.Op != Op386FlagEQ {
   19699 				break
   19700 			}
   19701 			b.Kind = BlockFirst
   19702 			b.SetControl(nil)
   19703 			b.Aux = nil
   19704 			b.swapSuccessors()
   19705 			return true
   19706 		}
   19707 		// match: (NE (FlagLT_ULT) yes no)
   19708 		// cond:
   19709 		// result: (First nil yes no)
   19710 		for {
   19711 			v := b.Control
   19712 			if v.Op != Op386FlagLT_ULT {
   19713 				break
   19714 			}
   19715 			b.Kind = BlockFirst
   19716 			b.SetControl(nil)
   19717 			b.Aux = nil
   19718 			return true
   19719 		}
   19720 		// match: (NE (FlagLT_UGT) yes no)
   19721 		// cond:
   19722 		// result: (First nil yes no)
   19723 		for {
   19724 			v := b.Control
   19725 			if v.Op != Op386FlagLT_UGT {
   19726 				break
   19727 			}
   19728 			b.Kind = BlockFirst
   19729 			b.SetControl(nil)
   19730 			b.Aux = nil
   19731 			return true
   19732 		}
   19733 		// match: (NE (FlagGT_ULT) yes no)
   19734 		// cond:
   19735 		// result: (First nil yes no)
   19736 		for {
   19737 			v := b.Control
   19738 			if v.Op != Op386FlagGT_ULT {
   19739 				break
   19740 			}
   19741 			b.Kind = BlockFirst
   19742 			b.SetControl(nil)
   19743 			b.Aux = nil
   19744 			return true
   19745 		}
   19746 		// match: (NE (FlagGT_UGT) yes no)
   19747 		// cond:
   19748 		// result: (First nil yes no)
   19749 		for {
   19750 			v := b.Control
   19751 			if v.Op != Op386FlagGT_UGT {
   19752 				break
   19753 			}
   19754 			b.Kind = BlockFirst
   19755 			b.SetControl(nil)
   19756 			b.Aux = nil
   19757 			return true
   19758 		}
   19759 	case Block386UGE:
   19760 		// match: (UGE (InvertFlags cmp) yes no)
   19761 		// cond:
   19762 		// result: (ULE cmp yes no)
   19763 		for {
   19764 			v := b.Control
   19765 			if v.Op != Op386InvertFlags {
   19766 				break
   19767 			}
   19768 			cmp := v.Args[0]
   19769 			b.Kind = Block386ULE
   19770 			b.SetControl(cmp)
   19771 			b.Aux = nil
   19772 			return true
   19773 		}
   19774 		// match: (UGE (FlagEQ) yes no)
   19775 		// cond:
   19776 		// result: (First nil yes no)
   19777 		for {
   19778 			v := b.Control
   19779 			if v.Op != Op386FlagEQ {
   19780 				break
   19781 			}
   19782 			b.Kind = BlockFirst
   19783 			b.SetControl(nil)
   19784 			b.Aux = nil
   19785 			return true
   19786 		}
   19787 		// match: (UGE (FlagLT_ULT) yes no)
   19788 		// cond:
   19789 		// result: (First nil no yes)
   19790 		for {
   19791 			v := b.Control
   19792 			if v.Op != Op386FlagLT_ULT {
   19793 				break
   19794 			}
   19795 			b.Kind = BlockFirst
   19796 			b.SetControl(nil)
   19797 			b.Aux = nil
   19798 			b.swapSuccessors()
   19799 			return true
   19800 		}
   19801 		// match: (UGE (FlagLT_UGT) yes no)
   19802 		// cond:
   19803 		// result: (First nil yes no)
   19804 		for {
   19805 			v := b.Control
   19806 			if v.Op != Op386FlagLT_UGT {
   19807 				break
   19808 			}
   19809 			b.Kind = BlockFirst
   19810 			b.SetControl(nil)
   19811 			b.Aux = nil
   19812 			return true
   19813 		}
   19814 		// match: (UGE (FlagGT_ULT) yes no)
   19815 		// cond:
   19816 		// result: (First nil no yes)
   19817 		for {
   19818 			v := b.Control
   19819 			if v.Op != Op386FlagGT_ULT {
   19820 				break
   19821 			}
   19822 			b.Kind = BlockFirst
   19823 			b.SetControl(nil)
   19824 			b.Aux = nil
   19825 			b.swapSuccessors()
   19826 			return true
   19827 		}
   19828 		// match: (UGE (FlagGT_UGT) yes no)
   19829 		// cond:
   19830 		// result: (First nil yes no)
   19831 		for {
   19832 			v := b.Control
   19833 			if v.Op != Op386FlagGT_UGT {
   19834 				break
   19835 			}
   19836 			b.Kind = BlockFirst
   19837 			b.SetControl(nil)
   19838 			b.Aux = nil
   19839 			return true
   19840 		}
   19841 	case Block386UGT:
   19842 		// match: (UGT (InvertFlags cmp) yes no)
   19843 		// cond:
   19844 		// result: (ULT cmp yes no)
   19845 		for {
   19846 			v := b.Control
   19847 			if v.Op != Op386InvertFlags {
   19848 				break
   19849 			}
   19850 			cmp := v.Args[0]
   19851 			b.Kind = Block386ULT
   19852 			b.SetControl(cmp)
   19853 			b.Aux = nil
   19854 			return true
   19855 		}
   19856 		// match: (UGT (FlagEQ) yes no)
   19857 		// cond:
   19858 		// result: (First nil no yes)
   19859 		for {
   19860 			v := b.Control
   19861 			if v.Op != Op386FlagEQ {
   19862 				break
   19863 			}
   19864 			b.Kind = BlockFirst
   19865 			b.SetControl(nil)
   19866 			b.Aux = nil
   19867 			b.swapSuccessors()
   19868 			return true
   19869 		}
   19870 		// match: (UGT (FlagLT_ULT) yes no)
   19871 		// cond:
   19872 		// result: (First nil no yes)
   19873 		for {
   19874 			v := b.Control
   19875 			if v.Op != Op386FlagLT_ULT {
   19876 				break
   19877 			}
   19878 			b.Kind = BlockFirst
   19879 			b.SetControl(nil)
   19880 			b.Aux = nil
   19881 			b.swapSuccessors()
   19882 			return true
   19883 		}
   19884 		// match: (UGT (FlagLT_UGT) yes no)
   19885 		// cond:
   19886 		// result: (First nil yes no)
   19887 		for {
   19888 			v := b.Control
   19889 			if v.Op != Op386FlagLT_UGT {
   19890 				break
   19891 			}
   19892 			b.Kind = BlockFirst
   19893 			b.SetControl(nil)
   19894 			b.Aux = nil
   19895 			return true
   19896 		}
   19897 		// match: (UGT (FlagGT_ULT) yes no)
   19898 		// cond:
   19899 		// result: (First nil no yes)
   19900 		for {
   19901 			v := b.Control
   19902 			if v.Op != Op386FlagGT_ULT {
   19903 				break
   19904 			}
   19905 			b.Kind = BlockFirst
   19906 			b.SetControl(nil)
   19907 			b.Aux = nil
   19908 			b.swapSuccessors()
   19909 			return true
   19910 		}
   19911 		// match: (UGT (FlagGT_UGT) yes no)
   19912 		// cond:
   19913 		// result: (First nil yes no)
   19914 		for {
   19915 			v := b.Control
   19916 			if v.Op != Op386FlagGT_UGT {
   19917 				break
   19918 			}
   19919 			b.Kind = BlockFirst
   19920 			b.SetControl(nil)
   19921 			b.Aux = nil
   19922 			return true
   19923 		}
   19924 	case Block386ULE:
   19925 		// match: (ULE (InvertFlags cmp) yes no)
   19926 		// cond:
   19927 		// result: (UGE cmp yes no)
   19928 		for {
   19929 			v := b.Control
   19930 			if v.Op != Op386InvertFlags {
   19931 				break
   19932 			}
   19933 			cmp := v.Args[0]
   19934 			b.Kind = Block386UGE
   19935 			b.SetControl(cmp)
   19936 			b.Aux = nil
   19937 			return true
   19938 		}
   19939 		// match: (ULE (FlagEQ) yes no)
   19940 		// cond:
   19941 		// result: (First nil yes no)
   19942 		for {
   19943 			v := b.Control
   19944 			if v.Op != Op386FlagEQ {
   19945 				break
   19946 			}
   19947 			b.Kind = BlockFirst
   19948 			b.SetControl(nil)
   19949 			b.Aux = nil
   19950 			return true
   19951 		}
   19952 		// match: (ULE (FlagLT_ULT) yes no)
   19953 		// cond:
   19954 		// result: (First nil yes no)
   19955 		for {
   19956 			v := b.Control
   19957 			if v.Op != Op386FlagLT_ULT {
   19958 				break
   19959 			}
   19960 			b.Kind = BlockFirst
   19961 			b.SetControl(nil)
   19962 			b.Aux = nil
   19963 			return true
   19964 		}
   19965 		// match: (ULE (FlagLT_UGT) yes no)
   19966 		// cond:
   19967 		// result: (First nil no yes)
   19968 		for {
   19969 			v := b.Control
   19970 			if v.Op != Op386FlagLT_UGT {
   19971 				break
   19972 			}
   19973 			b.Kind = BlockFirst
   19974 			b.SetControl(nil)
   19975 			b.Aux = nil
   19976 			b.swapSuccessors()
   19977 			return true
   19978 		}
   19979 		// match: (ULE (FlagGT_ULT) yes no)
   19980 		// cond:
   19981 		// result: (First nil yes no)
   19982 		for {
   19983 			v := b.Control
   19984 			if v.Op != Op386FlagGT_ULT {
   19985 				break
   19986 			}
   19987 			b.Kind = BlockFirst
   19988 			b.SetControl(nil)
   19989 			b.Aux = nil
   19990 			return true
   19991 		}
   19992 		// match: (ULE (FlagGT_UGT) yes no)
   19993 		// cond:
   19994 		// result: (First nil no yes)
   19995 		for {
   19996 			v := b.Control
   19997 			if v.Op != Op386FlagGT_UGT {
   19998 				break
   19999 			}
   20000 			b.Kind = BlockFirst
   20001 			b.SetControl(nil)
   20002 			b.Aux = nil
   20003 			b.swapSuccessors()
   20004 			return true
   20005 		}
   20006 	case Block386ULT:
   20007 		// match: (ULT (InvertFlags cmp) yes no)
   20008 		// cond:
   20009 		// result: (UGT cmp yes no)
   20010 		for {
   20011 			v := b.Control
   20012 			if v.Op != Op386InvertFlags {
   20013 				break
   20014 			}
   20015 			cmp := v.Args[0]
   20016 			b.Kind = Block386UGT
   20017 			b.SetControl(cmp)
   20018 			b.Aux = nil
   20019 			return true
   20020 		}
   20021 		// match: (ULT (FlagEQ) yes no)
   20022 		// cond:
   20023 		// result: (First nil no yes)
   20024 		for {
   20025 			v := b.Control
   20026 			if v.Op != Op386FlagEQ {
   20027 				break
   20028 			}
   20029 			b.Kind = BlockFirst
   20030 			b.SetControl(nil)
   20031 			b.Aux = nil
   20032 			b.swapSuccessors()
   20033 			return true
   20034 		}
   20035 		// match: (ULT (FlagLT_ULT) yes no)
   20036 		// cond:
   20037 		// result: (First nil yes no)
   20038 		for {
   20039 			v := b.Control
   20040 			if v.Op != Op386FlagLT_ULT {
   20041 				break
   20042 			}
   20043 			b.Kind = BlockFirst
   20044 			b.SetControl(nil)
   20045 			b.Aux = nil
   20046 			return true
   20047 		}
   20048 		// match: (ULT (FlagLT_UGT) yes no)
   20049 		// cond:
   20050 		// result: (First nil no yes)
   20051 		for {
   20052 			v := b.Control
   20053 			if v.Op != Op386FlagLT_UGT {
   20054 				break
   20055 			}
   20056 			b.Kind = BlockFirst
   20057 			b.SetControl(nil)
   20058 			b.Aux = nil
   20059 			b.swapSuccessors()
   20060 			return true
   20061 		}
   20062 		// match: (ULT (FlagGT_ULT) yes no)
   20063 		// cond:
   20064 		// result: (First nil yes no)
   20065 		for {
   20066 			v := b.Control
   20067 			if v.Op != Op386FlagGT_ULT {
   20068 				break
   20069 			}
   20070 			b.Kind = BlockFirst
   20071 			b.SetControl(nil)
   20072 			b.Aux = nil
   20073 			return true
   20074 		}
   20075 		// match: (ULT (FlagGT_UGT) yes no)
   20076 		// cond:
   20077 		// result: (First nil no yes)
   20078 		for {
   20079 			v := b.Control
   20080 			if v.Op != Op386FlagGT_UGT {
   20081 				break
   20082 			}
   20083 			b.Kind = BlockFirst
   20084 			b.SetControl(nil)
   20085 			b.Aux = nil
   20086 			b.swapSuccessors()
   20087 			return true
   20088 		}
   20089 	}
   20090 	return false
   20091 }
   20092